mirror of
https://git.naxdy.org/Mirror/Ryujinx.git
synced 2025-03-14 22:40:18 +00:00
Merge remote-tracking branch 'gdkchan/skyline' into zandm7
# Conflicts: # ARMeilleure/Translation/IntervalTree.cs # Ryujinx.HLE/Switch.cs
This commit is contained in:
commit
026fb907e8
32 changed files with 1340 additions and 942 deletions
|
@ -25,6 +25,7 @@ namespace Ryujinx.Cpu
|
||||||
|
|
||||||
private const int PointerTagBit = 62;
|
private const int PointerTagBit = 62;
|
||||||
|
|
||||||
|
private readonly MemoryBlock _backingMemory;
|
||||||
private readonly InvalidAccessHandler _invalidAccessHandler;
|
private readonly InvalidAccessHandler _invalidAccessHandler;
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
@ -50,10 +51,12 @@ namespace Ryujinx.Cpu
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Creates a new instance of the memory manager.
|
/// Creates a new instance of the memory manager.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
|
/// <param name="backingMemory">Physical backing memory where virtual memory will be mapped to</param>
|
||||||
/// <param name="addressSpaceSize">Size of the address space</param>
|
/// <param name="addressSpaceSize">Size of the address space</param>
|
||||||
/// <param name="invalidAccessHandler">Optional function to handle invalid memory accesses</param>
|
/// <param name="invalidAccessHandler">Optional function to handle invalid memory accesses</param>
|
||||||
public MemoryManager(ulong addressSpaceSize, InvalidAccessHandler invalidAccessHandler = null)
|
public MemoryManager(MemoryBlock backingMemory, ulong addressSpaceSize, InvalidAccessHandler invalidAccessHandler = null)
|
||||||
{
|
{
|
||||||
|
_backingMemory = backingMemory;
|
||||||
_invalidAccessHandler = invalidAccessHandler;
|
_invalidAccessHandler = invalidAccessHandler;
|
||||||
|
|
||||||
ulong asSize = PageSize;
|
ulong asSize = PageSize;
|
||||||
|
@ -73,18 +76,19 @@ namespace Ryujinx.Cpu
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public void Map(ulong va, nuint hostAddress, ulong size)
|
public void Map(ulong va, ulong pa, ulong size)
|
||||||
{
|
{
|
||||||
AssertValidAddressAndSize(va, size);
|
AssertValidAddressAndSize(va, size);
|
||||||
|
|
||||||
ulong remainingSize = size;
|
ulong remainingSize = size;
|
||||||
ulong oVa = va;
|
ulong oVa = va;
|
||||||
|
ulong oPa = pa;
|
||||||
while (remainingSize != 0)
|
while (remainingSize != 0)
|
||||||
{
|
{
|
||||||
_pageTable.Write((va / PageSize) * PteSize, hostAddress);
|
_pageTable.Write((va / PageSize) * PteSize, PaToPte(pa));
|
||||||
|
|
||||||
va += PageSize;
|
va += PageSize;
|
||||||
hostAddress += PageSize;
|
pa += PageSize;
|
||||||
remainingSize -= PageSize;
|
remainingSize -= PageSize;
|
||||||
}
|
}
|
||||||
Tracking.Map(oVa, size);
|
Tracking.Map(oVa, size);
|
||||||
|
@ -107,7 +111,7 @@ namespace Ryujinx.Cpu
|
||||||
ulong remainingSize = size;
|
ulong remainingSize = size;
|
||||||
while (remainingSize != 0)
|
while (remainingSize != 0)
|
||||||
{
|
{
|
||||||
_pageTable.Write((va / PageSize) * PteSize, (nuint)0);
|
_pageTable.Write((va / PageSize) * PteSize, 0UL);
|
||||||
|
|
||||||
va += PageSize;
|
va += PageSize;
|
||||||
remainingSize -= PageSize;
|
remainingSize -= PageSize;
|
||||||
|
@ -122,9 +126,22 @@ namespace Ryujinx.Cpu
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public T ReadTracked<T>(ulong va) where T : unmanaged
|
public T ReadTracked<T>(ulong va) where T : unmanaged
|
||||||
|
{
|
||||||
|
try
|
||||||
{
|
{
|
||||||
SignalMemoryTracking(va, (ulong)Unsafe.SizeOf<T>(), false);
|
SignalMemoryTracking(va, (ulong)Unsafe.SizeOf<T>(), false);
|
||||||
return MemoryMarshal.Cast<byte, T>(GetSpan(va, Unsafe.SizeOf<T>()))[0];
|
|
||||||
|
return Read<T>(va);
|
||||||
|
}
|
||||||
|
catch (InvalidMemoryRegionException)
|
||||||
|
{
|
||||||
|
if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
|
||||||
|
{
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
|
||||||
|
return default;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
|
@ -177,7 +194,7 @@ namespace Ryujinx.Cpu
|
||||||
|
|
||||||
if (IsContiguousAndMapped(va, data.Length))
|
if (IsContiguousAndMapped(va, data.Length))
|
||||||
{
|
{
|
||||||
data.CopyTo(GetHostSpanContiguous(va, data.Length));
|
data.CopyTo(_backingMemory.GetSpan(GetPhysicalAddressInternal(va), data.Length));
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -185,18 +202,22 @@ namespace Ryujinx.Cpu
|
||||||
|
|
||||||
if ((va & PageMask) != 0)
|
if ((va & PageMask) != 0)
|
||||||
{
|
{
|
||||||
|
ulong pa = GetPhysicalAddressInternal(va);
|
||||||
|
|
||||||
size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
|
size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
|
||||||
|
|
||||||
data.Slice(0, size).CopyTo(GetHostSpanContiguous(va, size));
|
data.Slice(0, size).CopyTo(_backingMemory.GetSpan(pa, size));
|
||||||
|
|
||||||
offset += size;
|
offset += size;
|
||||||
}
|
}
|
||||||
|
|
||||||
for (; offset < data.Length; offset += size)
|
for (; offset < data.Length; offset += size)
|
||||||
{
|
{
|
||||||
|
ulong pa = GetPhysicalAddressInternal(va + (ulong)offset);
|
||||||
|
|
||||||
size = Math.Min(data.Length - offset, PageSize);
|
size = Math.Min(data.Length - offset, PageSize);
|
||||||
|
|
||||||
data.Slice(offset, size).CopyTo(GetHostSpanContiguous(va + (ulong)offset, size));
|
data.Slice(offset, size).CopyTo(_backingMemory.GetSpan(pa, size));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -224,7 +245,7 @@ namespace Ryujinx.Cpu
|
||||||
|
|
||||||
if (IsContiguousAndMapped(va, size))
|
if (IsContiguousAndMapped(va, size))
|
||||||
{
|
{
|
||||||
return GetHostSpanContiguous(va, size);
|
return _backingMemory.GetSpan(GetPhysicalAddressInternal(va), size);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -251,7 +272,7 @@ namespace Ryujinx.Cpu
|
||||||
SignalMemoryTracking(va, (ulong)size, true);
|
SignalMemoryTracking(va, (ulong)size, true);
|
||||||
}
|
}
|
||||||
|
|
||||||
return new WritableRegion(null, va, new NativeMemoryManager<byte>((byte*)GetHostAddress(va), size).Memory);
|
return new WritableRegion(null, va, _backingMemory.GetMemory(GetPhysicalAddressInternal(va), size));
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -264,7 +285,7 @@ namespace Ryujinx.Cpu
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public unsafe ref T GetRef<T>(ulong va) where T : unmanaged
|
public ref T GetRef<T>(ulong va) where T : unmanaged
|
||||||
{
|
{
|
||||||
if (!IsContiguous(va, Unsafe.SizeOf<T>()))
|
if (!IsContiguous(va, Unsafe.SizeOf<T>()))
|
||||||
{
|
{
|
||||||
|
@ -273,7 +294,7 @@ namespace Ryujinx.Cpu
|
||||||
|
|
||||||
SignalMemoryTracking(va, (ulong)Unsafe.SizeOf<T>(), true);
|
SignalMemoryTracking(va, (ulong)Unsafe.SizeOf<T>(), true);
|
||||||
|
|
||||||
return ref *(T*)GetHostAddress(va);
|
return ref _backingMemory.GetRef<T>(GetPhysicalAddressInternal(va));
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
@ -293,7 +314,7 @@ namespace Ryujinx.Cpu
|
||||||
return (int)(vaSpan / PageSize);
|
return (int)(vaSpan / PageSize);
|
||||||
}
|
}
|
||||||
|
|
||||||
private void ThrowMemoryNotContiguous() => throw new MemoryNotContiguousException();
|
private static void ThrowMemoryNotContiguous() => throw new MemoryNotContiguousException();
|
||||||
|
|
||||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||||
private bool IsContiguousAndMapped(ulong va, int size) => IsContiguous(va, size) && IsMapped(va);
|
private bool IsContiguousAndMapped(ulong va, int size) => IsContiguous(va, size) && IsMapped(va);
|
||||||
|
@ -315,7 +336,7 @@ namespace Ryujinx.Cpu
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (GetHostAddress(va) + PageSize != GetHostAddress(va + PageSize))
|
if (GetPhysicalAddressInternal(va) + PageSize != GetPhysicalAddressInternal(va + PageSize))
|
||||||
{
|
{
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
@ -327,11 +348,11 @@ namespace Ryujinx.Cpu
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public IEnumerable<HostMemoryRange> GetPhysicalRegions(ulong va, ulong size)
|
public IEnumerable<MemoryRange> GetPhysicalRegions(ulong va, ulong size)
|
||||||
{
|
{
|
||||||
if (size == 0)
|
if (size == 0)
|
||||||
{
|
{
|
||||||
return Enumerable.Empty<HostMemoryRange>();
|
return Enumerable.Empty<MemoryRange>();
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!ValidateAddress(va) || !ValidateAddressAndSize(va, size))
|
if (!ValidateAddress(va) || !ValidateAddressAndSize(va, size))
|
||||||
|
@ -341,9 +362,9 @@ namespace Ryujinx.Cpu
|
||||||
|
|
||||||
int pages = GetPagesCount(va, (uint)size, out va);
|
int pages = GetPagesCount(va, (uint)size, out va);
|
||||||
|
|
||||||
var regions = new List<HostMemoryRange>();
|
var regions = new List<MemoryRange>();
|
||||||
|
|
||||||
nuint regionStart = GetHostAddress(va);
|
ulong regionStart = GetPhysicalAddressInternal(va);
|
||||||
ulong regionSize = PageSize;
|
ulong regionSize = PageSize;
|
||||||
|
|
||||||
for (int page = 0; page < pages - 1; page++)
|
for (int page = 0; page < pages - 1; page++)
|
||||||
|
@ -353,12 +374,12 @@ namespace Ryujinx.Cpu
|
||||||
return null;
|
return null;
|
||||||
}
|
}
|
||||||
|
|
||||||
nuint newHostAddress = GetHostAddress(va + PageSize);
|
ulong newPa = GetPhysicalAddressInternal(va + PageSize);
|
||||||
|
|
||||||
if (GetHostAddress(va) + PageSize != newHostAddress)
|
if (GetPhysicalAddressInternal(va) + PageSize != newPa)
|
||||||
{
|
{
|
||||||
regions.Add(new HostMemoryRange(regionStart, regionSize));
|
regions.Add(new MemoryRange(regionStart, regionSize));
|
||||||
regionStart = newHostAddress;
|
regionStart = newPa;
|
||||||
regionSize = 0;
|
regionSize = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -366,7 +387,7 @@ namespace Ryujinx.Cpu
|
||||||
regionSize += PageSize;
|
regionSize += PageSize;
|
||||||
}
|
}
|
||||||
|
|
||||||
regions.Add(new HostMemoryRange(regionStart, regionSize));
|
regions.Add(new MemoryRange(regionStart, regionSize));
|
||||||
|
|
||||||
return regions;
|
return regions;
|
||||||
}
|
}
|
||||||
|
@ -386,18 +407,22 @@ namespace Ryujinx.Cpu
|
||||||
|
|
||||||
if ((va & PageMask) != 0)
|
if ((va & PageMask) != 0)
|
||||||
{
|
{
|
||||||
|
ulong pa = GetPhysicalAddressInternal(va);
|
||||||
|
|
||||||
size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
|
size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
|
||||||
|
|
||||||
GetHostSpanContiguous(va, size).CopyTo(data.Slice(0, size));
|
_backingMemory.GetSpan(pa, size).CopyTo(data.Slice(0, size));
|
||||||
|
|
||||||
offset += size;
|
offset += size;
|
||||||
}
|
}
|
||||||
|
|
||||||
for (; offset < data.Length; offset += size)
|
for (; offset < data.Length; offset += size)
|
||||||
{
|
{
|
||||||
|
ulong pa = GetPhysicalAddressInternal(va + (ulong)offset);
|
||||||
|
|
||||||
size = Math.Min(data.Length - offset, PageSize);
|
size = Math.Min(data.Length - offset, PageSize);
|
||||||
|
|
||||||
GetHostSpanContiguous(va + (ulong)offset, size).CopyTo(data.Slice(offset, size));
|
_backingMemory.GetSpan(pa, size).CopyTo(data.Slice(offset, size));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
catch (InvalidMemoryRegionException)
|
catch (InvalidMemoryRegionException)
|
||||||
|
@ -446,7 +471,7 @@ namespace Ryujinx.Cpu
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
return _pageTable.Read<nuint>((va / PageSize) * PteSize) != 0;
|
return _pageTable.Read<ulong>((va / PageSize) * PteSize) != 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
private bool ValidateAddress(ulong va)
|
private bool ValidateAddress(ulong va)
|
||||||
|
@ -480,37 +505,20 @@ namespace Ryujinx.Cpu
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
private ulong GetPhysicalAddress(ulong va)
|
||||||
/// Get a span representing the given virtual address and size range in host memory.
|
|
||||||
/// This function assumes that the requested virtual memory region is contiguous.
|
|
||||||
/// </summary>
|
|
||||||
/// <param name="va">Virtual address of the range</param>
|
|
||||||
/// <param name="size">Size of the range in bytes</param>
|
|
||||||
/// <returns>A span representing the given virtual range in host memory</returns>
|
|
||||||
/// <exception cref="InvalidMemoryRegionException">Throw when the base virtual address is not mapped</exception>
|
|
||||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
||||||
private unsafe Span<byte> GetHostSpanContiguous(ulong va, int size)
|
|
||||||
{
|
{
|
||||||
return new Span<byte>((void*)GetHostAddress(va), size);
|
// We return -1L if the virtual address is invalid or unmapped.
|
||||||
|
if (!ValidateAddress(va) || !IsMapped(va))
|
||||||
|
{
|
||||||
|
return ulong.MaxValue;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
return GetPhysicalAddressInternal(va);
|
||||||
/// Get the host address for a given virtual address, using the page table.
|
|
||||||
/// </summary>
|
|
||||||
/// <param name="va">Virtual address</param>
|
|
||||||
/// <returns>The corresponding host address for the given virtual address</returns>
|
|
||||||
/// <exception cref="InvalidMemoryRegionException">Throw when the virtual address is not mapped</exception>
|
|
||||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
||||||
private nuint GetHostAddress(ulong va)
|
|
||||||
{
|
|
||||||
nuint pageBase = _pageTable.Read<nuint>((va / PageSize) * PteSize) & unchecked((nuint)0xffff_ffff_ffffUL);
|
|
||||||
|
|
||||||
if (pageBase == 0)
|
|
||||||
{
|
|
||||||
ThrowInvalidMemoryRegionException($"Not mapped: va=0x{va:X16}");
|
|
||||||
}
|
}
|
||||||
|
|
||||||
return pageBase + (nuint)(va & PageMask);
|
private ulong GetPhysicalAddressInternal(ulong va)
|
||||||
|
{
|
||||||
|
return PteToPa(_pageTable.Read<ulong>((va / PageSize) * PteSize) & ~(0xffffUL << 48)) + (va & PageMask);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
|
@ -604,6 +612,16 @@ namespace Ryujinx.Cpu
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
private ulong PaToPte(ulong pa)
|
||||||
|
{
|
||||||
|
return (ulong)_backingMemory.GetPointer(pa, PageSize);
|
||||||
|
}
|
||||||
|
|
||||||
|
private ulong PteToPa(ulong pte)
|
||||||
|
{
|
||||||
|
return (ulong)((long)pte - _backingMemory.Pointer.ToInt64());
|
||||||
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Disposes of resources used by the memory manager.
|
/// Disposes of resources used by the memory manager.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
|
|
|
@ -7,6 +7,7 @@ using System;
|
||||||
using System.Collections.Generic;
|
using System.Collections.Generic;
|
||||||
using System.Linq;
|
using System.Linq;
|
||||||
using System.Runtime.CompilerServices;
|
using System.Runtime.CompilerServices;
|
||||||
|
using System.Runtime.InteropServices;
|
||||||
using System.Threading;
|
using System.Threading;
|
||||||
|
|
||||||
namespace Ryujinx.Cpu
|
namespace Ryujinx.Cpu
|
||||||
|
@ -14,7 +15,7 @@ namespace Ryujinx.Cpu
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Represents a CPU memory manager which maps guest virtual memory directly onto a host virtual region.
|
/// Represents a CPU memory manager which maps guest virtual memory directly onto a host virtual region.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
public class MemoryManagerHostMapped : MemoryManagerBase, IMemoryManager, IVirtualMemoryManagerTracked
|
public class MemoryManagerHostMapped : MemoryManagerBase, IMemoryManager, IVirtualMemoryManagerTracked, IWritableBlock
|
||||||
{
|
{
|
||||||
public const int PageBits = 12;
|
public const int PageBits = 12;
|
||||||
public const int PageSize = 1 << PageBits;
|
public const int PageSize = 1 << PageBits;
|
||||||
|
@ -39,12 +40,14 @@ namespace Ryujinx.Cpu
|
||||||
private readonly bool _unsafeMode;
|
private readonly bool _unsafeMode;
|
||||||
|
|
||||||
private readonly MemoryBlock _addressSpace;
|
private readonly MemoryBlock _addressSpace;
|
||||||
private readonly MemoryBlock _addressSpaceMirror;
|
|
||||||
private readonly ulong _addressSpaceSize;
|
private readonly ulong _addressSpaceSize;
|
||||||
|
|
||||||
|
private readonly MemoryBlock _backingMemory;
|
||||||
|
private readonly PageTable<ulong> _pageTable;
|
||||||
|
|
||||||
private readonly MemoryEhMeilleure _memoryEh;
|
private readonly MemoryEhMeilleure _memoryEh;
|
||||||
|
|
||||||
private ulong[] _pageTable;
|
private readonly ulong[] _pageBitmap;
|
||||||
|
|
||||||
public int AddressSpaceBits { get; }
|
public int AddressSpaceBits { get; }
|
||||||
|
|
||||||
|
@ -59,11 +62,14 @@ namespace Ryujinx.Cpu
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Creates a new instance of the host mapped memory manager.
|
/// Creates a new instance of the host mapped memory manager.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
|
/// <param name="backingMemory">Physical backing memory where virtual memory will be mapped to</param>
|
||||||
/// <param name="addressSpaceSize">Size of the address space</param>
|
/// <param name="addressSpaceSize">Size of the address space</param>
|
||||||
/// <param name="unsafeMode">True if unmanaged access should not be masked (unsafe), false otherwise.</param>
|
/// <param name="unsafeMode">True if unmanaged access should not be masked (unsafe), false otherwise.</param>
|
||||||
/// <param name="invalidAccessHandler">Optional function to handle invalid memory accesses</param>
|
/// <param name="invalidAccessHandler">Optional function to handle invalid memory accesses</param>
|
||||||
public MemoryManagerHostMapped(ulong addressSpaceSize, bool unsafeMode, InvalidAccessHandler invalidAccessHandler = null)
|
public MemoryManagerHostMapped(MemoryBlock backingMemory, ulong addressSpaceSize, bool unsafeMode, InvalidAccessHandler invalidAccessHandler = null)
|
||||||
{
|
{
|
||||||
|
_backingMemory = backingMemory;
|
||||||
|
_pageTable = new PageTable<ulong>();
|
||||||
_invalidAccessHandler = invalidAccessHandler;
|
_invalidAccessHandler = invalidAccessHandler;
|
||||||
_unsafeMode = unsafeMode;
|
_unsafeMode = unsafeMode;
|
||||||
_addressSpaceSize = addressSpaceSize;
|
_addressSpaceSize = addressSpaceSize;
|
||||||
|
@ -79,9 +85,8 @@ namespace Ryujinx.Cpu
|
||||||
|
|
||||||
AddressSpaceBits = asBits;
|
AddressSpaceBits = asBits;
|
||||||
|
|
||||||
_pageTable = new ulong[1 << (AddressSpaceBits - (PageBits + PageToPteShift))];
|
_pageBitmap = new ulong[1 << (AddressSpaceBits - (PageBits + PageToPteShift))];
|
||||||
_addressSpace = new MemoryBlock(asSize, MemoryAllocationFlags.Reserve | MemoryAllocationFlags.Mirrorable);
|
_addressSpace = new MemoryBlock(asSize, MemoryAllocationFlags.Reserve | MemoryAllocationFlags.ViewCompatible);
|
||||||
_addressSpaceMirror = _addressSpace.CreateMirror();
|
|
||||||
Tracking = new MemoryTracking(this, PageSize, invalidAccessHandler);
|
Tracking = new MemoryTracking(this, PageSize, invalidAccessHandler);
|
||||||
_memoryEh = new MemoryEhMeilleure(_addressSpace, Tracking);
|
_memoryEh = new MemoryEhMeilleure(_addressSpace, Tracking);
|
||||||
}
|
}
|
||||||
|
@ -136,16 +141,29 @@ namespace Ryujinx.Cpu
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public void Map(ulong va, nuint hostAddress, ulong size)
|
public void Map(ulong va, ulong pa, ulong size)
|
||||||
{
|
{
|
||||||
AssertValidAddressAndSize(va, size);
|
AssertValidAddressAndSize(va, size);
|
||||||
|
|
||||||
_addressSpace.Commit(va, size);
|
PtMap(va, pa, size);
|
||||||
|
_addressSpace.MapView(_backingMemory, pa, va, size);
|
||||||
AddMapping(va, size);
|
AddMapping(va, size);
|
||||||
|
|
||||||
Tracking.Map(va, size);
|
Tracking.Map(va, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
private void PtMap(ulong va, ulong pa, ulong size)
|
||||||
|
{
|
||||||
|
while (size != 0)
|
||||||
|
{
|
||||||
|
_pageTable.Map(va, pa);
|
||||||
|
|
||||||
|
va += PageSize;
|
||||||
|
pa += PageSize;
|
||||||
|
size -= PageSize;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public void Unmap(ulong va, ulong size)
|
public void Unmap(ulong va, ulong size)
|
||||||
{
|
{
|
||||||
|
@ -155,27 +173,25 @@ namespace Ryujinx.Cpu
|
||||||
Tracking.Unmap(va, size);
|
Tracking.Unmap(va, size);
|
||||||
|
|
||||||
RemoveMapping(va, size);
|
RemoveMapping(va, size);
|
||||||
_addressSpace.Decommit(va, size);
|
_addressSpace.UnmapView(va, size);
|
||||||
|
PtUnmap(va, size);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void PtUnmap(ulong va, ulong size)
|
||||||
|
{
|
||||||
|
while (size != 0)
|
||||||
|
{
|
||||||
|
_pageTable.Unmap(va);
|
||||||
|
|
||||||
|
va += PageSize;
|
||||||
|
size -= PageSize;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public T Read<T>(ulong va) where T : unmanaged
|
public T Read<T>(ulong va) where T : unmanaged
|
||||||
{
|
{
|
||||||
try
|
return MemoryMarshal.Cast<byte, T>(GetSpan(va, Unsafe.SizeOf<T>()))[0];
|
||||||
{
|
|
||||||
AssertMapped(va, (ulong)Unsafe.SizeOf<T>());
|
|
||||||
|
|
||||||
return _addressSpaceMirror.Read<T>(va);
|
|
||||||
}
|
|
||||||
catch (InvalidMemoryRegionException)
|
|
||||||
{
|
|
||||||
if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
|
|
||||||
{
|
|
||||||
throw;
|
|
||||||
}
|
|
||||||
|
|
||||||
return default;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
|
@ -201,64 +217,73 @@ namespace Ryujinx.Cpu
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public void Read(ulong va, Span<byte> data)
|
public void Read(ulong va, Span<byte> data)
|
||||||
{
|
{
|
||||||
try
|
ReadImpl(va, data);
|
||||||
{
|
|
||||||
AssertMapped(va, (ulong)data.Length);
|
|
||||||
|
|
||||||
_addressSpaceMirror.Read(va, data);
|
|
||||||
}
|
|
||||||
catch (InvalidMemoryRegionException)
|
|
||||||
{
|
|
||||||
if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
|
|
||||||
{
|
|
||||||
throw;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public void Write<T>(ulong va, T value) where T : unmanaged
|
public void Write<T>(ulong va, T value) where T : unmanaged
|
||||||
{
|
{
|
||||||
try
|
Write(va, MemoryMarshal.Cast<T, byte>(MemoryMarshal.CreateSpan(ref value, 1)));
|
||||||
{
|
|
||||||
SignalMemoryTracking(va, (ulong)Unsafe.SizeOf<T>(), write: true);
|
|
||||||
|
|
||||||
_addressSpaceMirror.Write(va, value);
|
|
||||||
}
|
|
||||||
catch (InvalidMemoryRegionException)
|
|
||||||
{
|
|
||||||
if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
|
|
||||||
{
|
|
||||||
throw;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public void Write(ulong va, ReadOnlySpan<byte> data)
|
public void Write(ulong va, ReadOnlySpan<byte> data)
|
||||||
{
|
{
|
||||||
try {
|
if (data.Length == 0)
|
||||||
SignalMemoryTracking(va, (ulong)data.Length, write: true);
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
_addressSpaceMirror.Write(va, data);
|
SignalMemoryTracking(va, (ulong)data.Length, true);
|
||||||
}
|
|
||||||
catch (InvalidMemoryRegionException)
|
WriteImpl(va, data);
|
||||||
{
|
|
||||||
if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
|
|
||||||
{
|
|
||||||
throw;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public void WriteUntracked(ulong va, ReadOnlySpan<byte> data)
|
public void WriteUntracked(ulong va, ReadOnlySpan<byte> data)
|
||||||
|
{
|
||||||
|
if (data.Length == 0)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
WriteImpl(va, data);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void WriteImpl(ulong va, ReadOnlySpan<byte> data)
|
||||||
{
|
{
|
||||||
try
|
try
|
||||||
{
|
{
|
||||||
AssertMapped(va, (ulong)data.Length);
|
AssertValidAddressAndSize(va, (ulong)data.Length);
|
||||||
|
|
||||||
_addressSpaceMirror.Write(va, data);
|
if (IsContiguousAndMapped(va, data.Length))
|
||||||
|
{
|
||||||
|
data.CopyTo(_backingMemory.GetSpan(GetPhysicalAddressInternal(va), data.Length));
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
int offset = 0, size;
|
||||||
|
|
||||||
|
if ((va & PageMask) != 0)
|
||||||
|
{
|
||||||
|
ulong pa = GetPhysicalAddressInternal(va);
|
||||||
|
|
||||||
|
size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
|
||||||
|
|
||||||
|
data.Slice(0, size).CopyTo(_backingMemory.GetSpan(pa, size));
|
||||||
|
|
||||||
|
offset += size;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (; offset < data.Length; offset += size)
|
||||||
|
{
|
||||||
|
ulong pa = GetPhysicalAddressInternal(va + (ulong)offset);
|
||||||
|
|
||||||
|
size = Math.Min(data.Length - offset, PageSize);
|
||||||
|
|
||||||
|
data.Slice(offset, size).CopyTo(_backingMemory.GetSpan(pa, size));
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
catch (InvalidMemoryRegionException)
|
catch (InvalidMemoryRegionException)
|
||||||
{
|
{
|
||||||
|
@ -267,44 +292,71 @@ namespace Ryujinx.Cpu
|
||||||
throw;
|
throw;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public ReadOnlySpan<byte> GetSpan(ulong va, int size, bool tracked = false)
|
public ReadOnlySpan<byte> GetSpan(ulong va, int size, bool tracked = false)
|
||||||
{
|
{
|
||||||
|
if (size == 0)
|
||||||
|
{
|
||||||
|
return ReadOnlySpan<byte>.Empty;
|
||||||
|
}
|
||||||
|
|
||||||
if (tracked)
|
if (tracked)
|
||||||
{
|
{
|
||||||
SignalMemoryTracking(va, (ulong)size, write: false);
|
SignalMemoryTracking(va, (ulong)size, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (IsContiguousAndMapped(va, size))
|
||||||
|
{
|
||||||
|
return _backingMemory.GetSpan(GetPhysicalAddressInternal(va), size);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
AssertMapped(va, (ulong)size);
|
Span<byte> data = new byte[size];
|
||||||
}
|
|
||||||
|
|
||||||
return _addressSpaceMirror.GetSpan(va, size);
|
ReadImpl(va, data);
|
||||||
|
|
||||||
|
return data;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public WritableRegion GetWritableRegion(ulong va, int size, bool tracked = false)
|
public WritableRegion GetWritableRegion(ulong va, int size, bool tracked = false)
|
||||||
{
|
{
|
||||||
|
if (size == 0)
|
||||||
|
{
|
||||||
|
return new WritableRegion(null, va, Memory<byte>.Empty);
|
||||||
|
}
|
||||||
|
|
||||||
if (tracked)
|
if (tracked)
|
||||||
{
|
{
|
||||||
SignalMemoryTracking(va, (ulong)size, true);
|
SignalMemoryTracking(va, (ulong)size, true);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if (IsContiguousAndMapped(va, size))
|
||||||
|
{
|
||||||
|
return new WritableRegion(null, va, _backingMemory.GetMemory(GetPhysicalAddressInternal(va), size));
|
||||||
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
AssertMapped(va, (ulong)size);
|
Memory<byte> memory = new byte[size];
|
||||||
}
|
|
||||||
|
|
||||||
return _addressSpaceMirror.GetWritableRegion(va, size);
|
ReadImpl(va, memory.Span);
|
||||||
|
|
||||||
|
return new WritableRegion(this, va, memory);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public ref T GetRef<T>(ulong va) where T : unmanaged
|
public ref T GetRef<T>(ulong va) where T : unmanaged
|
||||||
{
|
{
|
||||||
SignalMemoryTracking(va, (ulong)Unsafe.SizeOf<T>(), true);
|
if (!IsContiguous(va, Unsafe.SizeOf<T>()))
|
||||||
|
{
|
||||||
|
ThrowMemoryNotContiguous();
|
||||||
|
}
|
||||||
|
|
||||||
return ref _addressSpaceMirror.GetRef<T>(va);
|
return ref _backingMemory.GetRef<T>(GetPhysicalAddressInternal(va));
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
|
@ -322,7 +374,7 @@ namespace Ryujinx.Cpu
|
||||||
int bit = (int)((page & 31) << 1);
|
int bit = (int)((page & 31) << 1);
|
||||||
|
|
||||||
int pageIndex = (int)(page >> PageToPteShift);
|
int pageIndex = (int)(page >> PageToPteShift);
|
||||||
ref ulong pageRef = ref _pageTable[pageIndex];
|
ref ulong pageRef = ref _pageBitmap[pageIndex];
|
||||||
|
|
||||||
ulong pte = Volatile.Read(ref pageRef);
|
ulong pte = Volatile.Read(ref pageRef);
|
||||||
|
|
||||||
|
@ -373,7 +425,7 @@ namespace Ryujinx.Cpu
|
||||||
mask &= endMask;
|
mask &= endMask;
|
||||||
}
|
}
|
||||||
|
|
||||||
ref ulong pageRef = ref _pageTable[pageIndex++];
|
ref ulong pageRef = ref _pageBitmap[pageIndex++];
|
||||||
ulong pte = Volatile.Read(ref pageRef);
|
ulong pte = Volatile.Read(ref pageRef);
|
||||||
|
|
||||||
pte |= pte >> 1;
|
pte |= pte >> 1;
|
||||||
|
@ -388,17 +440,124 @@ namespace Ryujinx.Cpu
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
private static void ThrowMemoryNotContiguous() => throw new MemoryNotContiguousException();
|
||||||
|
|
||||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||||
|
private bool IsContiguousAndMapped(ulong va, int size) => IsContiguous(va, size) && IsMapped(va);
|
||||||
|
|
||||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||||
|
private bool IsContiguous(ulong va, int size)
|
||||||
|
{
|
||||||
|
if (!ValidateAddress(va) || !ValidateAddressAndSize(va, (ulong)size))
|
||||||
|
{
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
int pages = GetPagesCount(va, (uint)size, out va);
|
||||||
|
|
||||||
|
for (int page = 0; page < pages - 1; page++)
|
||||||
|
{
|
||||||
|
if (!ValidateAddress(va + PageSize))
|
||||||
|
{
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (GetPhysicalAddressInternal(va) + PageSize != GetPhysicalAddressInternal(va + PageSize))
|
||||||
|
{
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
va += PageSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
public IEnumerable<HostMemoryRange> GetPhysicalRegions(ulong va, ulong size)
|
public IEnumerable<MemoryRange> GetPhysicalRegions(ulong va, ulong size)
|
||||||
{
|
{
|
||||||
if (size == 0)
|
if (size == 0)
|
||||||
{
|
{
|
||||||
return Enumerable.Empty<HostMemoryRange>();
|
return Enumerable.Empty<MemoryRange>();
|
||||||
}
|
}
|
||||||
|
|
||||||
AssertMapped(va, size);
|
if (!ValidateAddress(va) || !ValidateAddressAndSize(va, size))
|
||||||
|
{
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
return new HostMemoryRange[] { new HostMemoryRange(_addressSpaceMirror.GetPointer(va, size), size) };
|
int pages = GetPagesCount(va, (uint)size, out va);
|
||||||
|
|
||||||
|
var regions = new List<MemoryRange>();
|
||||||
|
|
||||||
|
ulong regionStart = GetPhysicalAddressInternal(va);
|
||||||
|
ulong regionSize = PageSize;
|
||||||
|
|
||||||
|
for (int page = 0; page < pages - 1; page++)
|
||||||
|
{
|
||||||
|
if (!ValidateAddress(va + PageSize))
|
||||||
|
{
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
ulong newPa = GetPhysicalAddressInternal(va + PageSize);
|
||||||
|
|
||||||
|
if (GetPhysicalAddressInternal(va) + PageSize != newPa)
|
||||||
|
{
|
||||||
|
regions.Add(new MemoryRange(regionStart, regionSize));
|
||||||
|
regionStart = newPa;
|
||||||
|
regionSize = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
va += PageSize;
|
||||||
|
regionSize += PageSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
regions.Add(new MemoryRange(regionStart, regionSize));
|
||||||
|
|
||||||
|
return regions;
|
||||||
|
}
|
||||||
|
|
||||||
|
private void ReadImpl(ulong va, Span<byte> data)
|
||||||
|
{
|
||||||
|
if (data.Length == 0)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
AssertValidAddressAndSize(va, (ulong)data.Length);
|
||||||
|
|
||||||
|
int offset = 0, size;
|
||||||
|
|
||||||
|
if ((va & PageMask) != 0)
|
||||||
|
{
|
||||||
|
ulong pa = GetPhysicalAddressInternal(va);
|
||||||
|
|
||||||
|
size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
|
||||||
|
|
||||||
|
_backingMemory.GetSpan(pa, size).CopyTo(data.Slice(0, size));
|
||||||
|
|
||||||
|
offset += size;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (; offset < data.Length; offset += size)
|
||||||
|
{
|
||||||
|
ulong pa = GetPhysicalAddressInternal(va + (ulong)offset);
|
||||||
|
|
||||||
|
size = Math.Min(data.Length - offset, PageSize);
|
||||||
|
|
||||||
|
_backingMemory.GetSpan(pa, size).CopyTo(data.Slice(offset, size));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (InvalidMemoryRegionException)
|
||||||
|
{
|
||||||
|
if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
|
||||||
|
{
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
|
@ -427,7 +586,7 @@ namespace Ryujinx.Cpu
|
||||||
int bit = (int)((pageStart & 31) << 1);
|
int bit = (int)((pageStart & 31) << 1);
|
||||||
|
|
||||||
int pageIndex = (int)(pageStart >> PageToPteShift);
|
int pageIndex = (int)(pageStart >> PageToPteShift);
|
||||||
ref ulong pageRef = ref _pageTable[pageIndex];
|
ref ulong pageRef = ref _pageBitmap[pageIndex];
|
||||||
|
|
||||||
ulong pte = Volatile.Read(ref pageRef);
|
ulong pte = Volatile.Read(ref pageRef);
|
||||||
ulong state = ((pte >> bit) & 3);
|
ulong state = ((pte >> bit) & 3);
|
||||||
|
@ -459,7 +618,7 @@ namespace Ryujinx.Cpu
|
||||||
mask &= endMask;
|
mask &= endMask;
|
||||||
}
|
}
|
||||||
|
|
||||||
ref ulong pageRef = ref _pageTable[pageIndex++];
|
ref ulong pageRef = ref _pageBitmap[pageIndex++];
|
||||||
|
|
||||||
ulong pte = Volatile.Read(ref pageRef);
|
ulong pte = Volatile.Read(ref pageRef);
|
||||||
ulong mappedMask = mask & BlockMappedMask;
|
ulong mappedMask = mask & BlockMappedMask;
|
||||||
|
@ -530,7 +689,7 @@ namespace Ryujinx.Cpu
|
||||||
ulong tag = protTag << bit;
|
ulong tag = protTag << bit;
|
||||||
|
|
||||||
int pageIndex = (int)(pageStart >> PageToPteShift);
|
int pageIndex = (int)(pageStart >> PageToPteShift);
|
||||||
ref ulong pageRef = ref _pageTable[pageIndex];
|
ref ulong pageRef = ref _pageBitmap[pageIndex];
|
||||||
|
|
||||||
ulong pte;
|
ulong pte;
|
||||||
|
|
||||||
|
@ -562,7 +721,7 @@ namespace Ryujinx.Cpu
|
||||||
mask &= endMask;
|
mask &= endMask;
|
||||||
}
|
}
|
||||||
|
|
||||||
ref ulong pageRef = ref _pageTable[pageIndex++];
|
ref ulong pageRef = ref _pageBitmap[pageIndex++];
|
||||||
|
|
||||||
ulong pte;
|
ulong pte;
|
||||||
ulong mappedMask;
|
ulong mappedMask;
|
||||||
|
@ -632,7 +791,7 @@ namespace Ryujinx.Cpu
|
||||||
mask &= endMask;
|
mask &= endMask;
|
||||||
}
|
}
|
||||||
|
|
||||||
ref ulong pageRef = ref _pageTable[pageIndex++];
|
ref ulong pageRef = ref _pageBitmap[pageIndex++];
|
||||||
|
|
||||||
ulong pte;
|
ulong pte;
|
||||||
ulong mappedMask;
|
ulong mappedMask;
|
||||||
|
@ -677,7 +836,7 @@ namespace Ryujinx.Cpu
|
||||||
mask |= endMask;
|
mask |= endMask;
|
||||||
}
|
}
|
||||||
|
|
||||||
ref ulong pageRef = ref _pageTable[pageIndex++];
|
ref ulong pageRef = ref _pageBitmap[pageIndex++];
|
||||||
ulong pte;
|
ulong pte;
|
||||||
|
|
||||||
do
|
do
|
||||||
|
@ -690,16 +849,20 @@ namespace Ryujinx.Cpu
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
private ulong GetPhysicalAddressInternal(ulong va)
|
||||||
|
{
|
||||||
|
return _pageTable.Read(va) + (va & PageMask);
|
||||||
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Disposes of resources used by the memory manager.
|
/// Disposes of resources used by the memory manager.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
protected override void Destroy()
|
protected override void Destroy()
|
||||||
{
|
{
|
||||||
_addressSpaceMirror.Dispose();
|
|
||||||
_addressSpace.Dispose();
|
_addressSpace.Dispose();
|
||||||
_memoryEh.Dispose();
|
_memoryEh.Dispose();
|
||||||
}
|
}
|
||||||
|
|
||||||
private void ThrowInvalidMemoryRegionException(string message) => throw new InvalidMemoryRegionException(message);
|
private static void ThrowInvalidMemoryRegionException(string message) => throw new InvalidMemoryRegionException(message);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -17,6 +17,7 @@ using Ryujinx.Common.Logging;
|
||||||
using Ryujinx.HLE.FileSystem;
|
using Ryujinx.HLE.FileSystem;
|
||||||
using Ryujinx.HLE.HOS.Kernel.Process;
|
using Ryujinx.HLE.HOS.Kernel.Process;
|
||||||
using Ryujinx.HLE.Loaders.Executables;
|
using Ryujinx.HLE.Loaders.Executables;
|
||||||
|
using Ryujinx.Memory;
|
||||||
using System;
|
using System;
|
||||||
using System.Collections.Generic;
|
using System.Collections.Generic;
|
||||||
using System.Globalization;
|
using System.Globalization;
|
||||||
|
@ -561,7 +562,14 @@ namespace Ryujinx.HLE.HOS
|
||||||
Graphics.Gpu.GraphicsConfig.TitleId = TitleIdText;
|
Graphics.Gpu.GraphicsConfig.TitleId = TitleIdText;
|
||||||
_device.Gpu.HostInitalized.Set();
|
_device.Gpu.HostInitalized.Set();
|
||||||
|
|
||||||
Ptc.Initialize(TitleIdText, DisplayVersion, usePtc, _device.Configuration.MemoryManagerMode);
|
MemoryManagerMode memoryManagerMode = _device.Configuration.MemoryManagerMode;
|
||||||
|
|
||||||
|
if (!MemoryBlock.SupportsFlags(MemoryAllocationFlags.ViewCompatible))
|
||||||
|
{
|
||||||
|
memoryManagerMode = MemoryManagerMode.SoftwarePageTable;
|
||||||
|
}
|
||||||
|
|
||||||
|
Ptc.Initialize(TitleIdText, DisplayVersion, usePtc, memoryManagerMode);
|
||||||
|
|
||||||
metaData.GetNpdm(out Npdm npdm).ThrowIfFailure();
|
metaData.GetNpdm(out Npdm npdm).ThrowIfFailure();
|
||||||
ProgramLoader.LoadNsos(_device.System.KernelContext, out ProcessTamperInfo tamperInfo, metaData, new ProgramInfo(in npdm), executables: programs);
|
ProgramLoader.LoadNsos(_device.System.KernelContext, out ProcessTamperInfo tamperInfo, metaData, new ProgramInfo(in npdm), executables: programs);
|
||||||
|
|
|
@ -21,15 +21,20 @@ namespace Ryujinx.HLE.HOS
|
||||||
{
|
{
|
||||||
MemoryManagerMode mode = context.Device.Configuration.MemoryManagerMode;
|
MemoryManagerMode mode = context.Device.Configuration.MemoryManagerMode;
|
||||||
|
|
||||||
|
if (!MemoryBlock.SupportsFlags(MemoryAllocationFlags.ViewCompatible))
|
||||||
|
{
|
||||||
|
mode = MemoryManagerMode.SoftwarePageTable;
|
||||||
|
}
|
||||||
|
|
||||||
switch (mode)
|
switch (mode)
|
||||||
{
|
{
|
||||||
case MemoryManagerMode.SoftwarePageTable:
|
case MemoryManagerMode.SoftwarePageTable:
|
||||||
return new ArmProcessContext<MemoryManager>(pid, _gpu, new MemoryManager(addressSpaceSize, invalidAccessHandler), for64Bit);
|
return new ArmProcessContext<MemoryManager>(pid, _gpu, new MemoryManager(context.Memory, addressSpaceSize, invalidAccessHandler), for64Bit);
|
||||||
|
|
||||||
case MemoryManagerMode.HostMapped:
|
case MemoryManagerMode.HostMapped:
|
||||||
case MemoryManagerMode.HostMappedUnsafe:
|
case MemoryManagerMode.HostMappedUnsafe:
|
||||||
bool unsafeMode = mode == MemoryManagerMode.HostMappedUnsafe;
|
bool unsafeMode = mode == MemoryManagerMode.HostMappedUnsafe;
|
||||||
return new ArmProcessContext<MemoryManagerHostMapped>(pid, _gpu, new MemoryManagerHostMapped(addressSpaceSize, unsafeMode, invalidAccessHandler), for64Bit);
|
return new ArmProcessContext<MemoryManagerHostMapped>(pid, _gpu, new MemoryManagerHostMapped(context.Memory, addressSpaceSize, unsafeMode, invalidAccessHandler), for64Bit);
|
||||||
|
|
||||||
default:
|
default:
|
||||||
throw new ArgumentOutOfRangeException();
|
throw new ArgumentOutOfRangeException();
|
||||||
|
|
|
@ -59,5 +59,15 @@ namespace Ryujinx.HLE.HOS.Kernel
|
||||||
{
|
{
|
||||||
return GetCurrentThread().Owner;
|
return GetCurrentThread().Owner;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
internal static KProcess GetProcessByPid(long pid)
|
||||||
|
{
|
||||||
|
if (Context.Processes.TryGetValue(pid, out KProcess process))
|
||||||
|
{
|
||||||
|
return process;
|
||||||
|
}
|
||||||
|
|
||||||
|
return null;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
170
Ryujinx.HLE/HOS/Kernel/Memory/KCodeMemory.cs
Normal file
170
Ryujinx.HLE/HOS/Kernel/Memory/KCodeMemory.cs
Normal file
|
@ -0,0 +1,170 @@
|
||||||
|
using Ryujinx.Common;
|
||||||
|
using Ryujinx.HLE.HOS.Kernel.Common;
|
||||||
|
using Ryujinx.HLE.HOS.Kernel.Process;
|
||||||
|
using System;
|
||||||
|
using System.Diagnostics;
|
||||||
|
|
||||||
|
namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
|
{
|
||||||
|
class KCodeMemory : KAutoObject
|
||||||
|
{
|
||||||
|
public KProcess Owner { get; private set; }
|
||||||
|
private readonly KPageList _pageList;
|
||||||
|
private readonly object _lock;
|
||||||
|
private ulong _address;
|
||||||
|
private bool _isInitialized;
|
||||||
|
private bool _isOwnerMapped;
|
||||||
|
private bool _isMapped;
|
||||||
|
|
||||||
|
public KCodeMemory(KernelContext context) : base(context)
|
||||||
|
{
|
||||||
|
_pageList = new KPageList();
|
||||||
|
_lock = new object();
|
||||||
|
}
|
||||||
|
|
||||||
|
public KernelResult Initialize(ulong address, ulong size)
|
||||||
|
{
|
||||||
|
Owner = KernelStatic.GetCurrentProcess();
|
||||||
|
|
||||||
|
KernelResult result = Owner.MemoryManager.BorrowCodeMemory(_pageList, address, size);
|
||||||
|
|
||||||
|
if (result != KernelResult.Success)
|
||||||
|
{
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
Owner.CpuMemory.Fill(address, size, 0xff);
|
||||||
|
Owner.IncrementReferenceCount();
|
||||||
|
|
||||||
|
_address = address;
|
||||||
|
_isInitialized = true;
|
||||||
|
_isMapped = false;
|
||||||
|
_isOwnerMapped = false;
|
||||||
|
|
||||||
|
return KernelResult.Success;
|
||||||
|
}
|
||||||
|
|
||||||
|
public KernelResult Map(ulong address, ulong size, KMemoryPermission perm)
|
||||||
|
{
|
||||||
|
if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
if (_isMapped)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidState;
|
||||||
|
}
|
||||||
|
|
||||||
|
KProcess process = KernelStatic.GetCurrentProcess();
|
||||||
|
|
||||||
|
KernelResult result = process.MemoryManager.MapPages(address, _pageList, MemoryState.CodeWritable, KMemoryPermission.ReadAndWrite);
|
||||||
|
|
||||||
|
if (result != KernelResult.Success)
|
||||||
|
{
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
_isMapped = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
return KernelResult.Success;
|
||||||
|
}
|
||||||
|
|
||||||
|
public KernelResult MapToOwner(ulong address, ulong size, KMemoryPermission permission)
|
||||||
|
{
|
||||||
|
if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
if (_isOwnerMapped)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidState;
|
||||||
|
}
|
||||||
|
|
||||||
|
Debug.Assert(permission == KMemoryPermission.Read || permission == KMemoryPermission.ReadAndExecute);
|
||||||
|
|
||||||
|
KernelResult result = Owner.MemoryManager.MapPages(address, _pageList, MemoryState.CodeReadOnly, permission);
|
||||||
|
|
||||||
|
if (result != KernelResult.Success)
|
||||||
|
{
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
_isOwnerMapped = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
return KernelResult.Success;
|
||||||
|
}
|
||||||
|
|
||||||
|
public KernelResult Unmap(ulong address, ulong size)
|
||||||
|
{
|
||||||
|
if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
KProcess process = KernelStatic.GetCurrentProcess();
|
||||||
|
|
||||||
|
KernelResult result = process.MemoryManager.UnmapPages(address, _pageList, MemoryState.CodeWritable);
|
||||||
|
|
||||||
|
if (result != KernelResult.Success)
|
||||||
|
{
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
Debug.Assert(_isMapped);
|
||||||
|
|
||||||
|
_isMapped = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
return KernelResult.Success;
|
||||||
|
}
|
||||||
|
|
||||||
|
public KernelResult UnmapFromOwner(ulong address, ulong size)
|
||||||
|
{
|
||||||
|
if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
KernelResult result = Owner.MemoryManager.UnmapPages(address, _pageList, MemoryState.CodeReadOnly);
|
||||||
|
|
||||||
|
if (result != KernelResult.Success)
|
||||||
|
{
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
Debug.Assert(_isOwnerMapped);
|
||||||
|
|
||||||
|
_isOwnerMapped = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
return KernelResult.Success;
|
||||||
|
}
|
||||||
|
|
||||||
|
protected override void Destroy()
|
||||||
|
{
|
||||||
|
if (!_isMapped && !_isOwnerMapped)
|
||||||
|
{
|
||||||
|
ulong size = _pageList.GetPagesCount() * KPageTableBase.PageSize;
|
||||||
|
|
||||||
|
if (Owner.MemoryManager.UnborrowCodeMemory(_address, size, _pageList) != KernelResult.Success)
|
||||||
|
{
|
||||||
|
throw new InvalidOperationException("Unexpected failure restoring transfer memory attributes.");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Owner.DecrementReferenceCount();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
|
@ -1,10 +1,7 @@
|
||||||
using Ryujinx.HLE.HOS.Kernel.Common;
|
using Ryujinx.HLE.HOS.Kernel.Common;
|
||||||
using Ryujinx.Memory;
|
using Ryujinx.Memory;
|
||||||
using Ryujinx.Memory.Range;
|
|
||||||
using System;
|
using System;
|
||||||
using System.Collections.Generic;
|
|
||||||
using System.Diagnostics;
|
using System.Diagnostics;
|
||||||
using System.Linq;
|
|
||||||
|
|
||||||
namespace Ryujinx.HLE.HOS.Kernel.Memory
|
namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
{
|
{
|
||||||
|
@ -12,17 +9,19 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
{
|
{
|
||||||
private readonly IVirtualMemoryManager _cpuMemory;
|
private readonly IVirtualMemoryManager _cpuMemory;
|
||||||
|
|
||||||
public override bool SupportsMemoryAliasing => true;
|
|
||||||
|
|
||||||
public KPageTable(KernelContext context, IVirtualMemoryManager cpuMemory) : base(context)
|
public KPageTable(KernelContext context, IVirtualMemoryManager cpuMemory) : base(context)
|
||||||
{
|
{
|
||||||
_cpuMemory = cpuMemory;
|
_cpuMemory = cpuMemory;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
protected override IEnumerable<HostMemoryRange> GetPhysicalRegions(ulong va, ulong size)
|
protected override void GetPhysicalRegions(ulong va, ulong size, KPageList pageList)
|
||||||
{
|
{
|
||||||
return _cpuMemory.GetPhysicalRegions(va, size);
|
var ranges = _cpuMemory.GetPhysicalRegions(va, size);
|
||||||
|
foreach (var range in ranges)
|
||||||
|
{
|
||||||
|
pageList.AddRange(range.Address + DramMemoryMap.DramBase, range.Size / PageSize);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
|
@ -34,7 +33,8 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
protected override KernelResult MapMemory(ulong src, ulong dst, ulong pagesCount, KMemoryPermission oldSrcPermission, KMemoryPermission newDstPermission)
|
protected override KernelResult MapMemory(ulong src, ulong dst, ulong pagesCount, KMemoryPermission oldSrcPermission, KMemoryPermission newDstPermission)
|
||||||
{
|
{
|
||||||
var srcRanges = GetPhysicalRegions(src, pagesCount * PageSize);
|
KPageList pageList = new KPageList();
|
||||||
|
GetPhysicalRegions(src, pagesCount * PageSize, pageList);
|
||||||
|
|
||||||
KernelResult result = Reprotect(src, pagesCount, KMemoryPermission.None);
|
KernelResult result = Reprotect(src, pagesCount, KMemoryPermission.None);
|
||||||
|
|
||||||
|
@ -43,7 +43,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
result = MapPages(dst, srcRanges, newDstPermission);
|
result = MapPages(dst, pageList, newDstPermission, false, 0);
|
||||||
|
|
||||||
if (result != KernelResult.Success)
|
if (result != KernelResult.Success)
|
||||||
{
|
{
|
||||||
|
@ -59,10 +59,13 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
{
|
{
|
||||||
ulong size = pagesCount * PageSize;
|
ulong size = pagesCount * PageSize;
|
||||||
|
|
||||||
var srcRanges = GetPhysicalRegions(src, size);
|
KPageList srcPageList = new KPageList();
|
||||||
var dstRanges = GetPhysicalRegions(dst, size);
|
KPageList dstPageList = new KPageList();
|
||||||
|
|
||||||
if (!dstRanges.SequenceEqual(srcRanges))
|
GetPhysicalRegions(src, size, srcPageList);
|
||||||
|
GetPhysicalRegions(dst, size, dstPageList);
|
||||||
|
|
||||||
|
if (!dstPageList.IsEqual(srcPageList))
|
||||||
{
|
{
|
||||||
return KernelResult.InvalidMemRange;
|
return KernelResult.InvalidMemRange;
|
||||||
}
|
}
|
||||||
|
@ -78,7 +81,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
|
|
||||||
if (result != KernelResult.Success)
|
if (result != KernelResult.Success)
|
||||||
{
|
{
|
||||||
KernelResult mapResult = MapPages(dst, dstRanges, oldDstPermission);
|
KernelResult mapResult = MapPages(dst, dstPageList, oldDstPermission, false, 0);
|
||||||
Debug.Assert(mapResult == KernelResult.Success);
|
Debug.Assert(mapResult == KernelResult.Success);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -92,7 +95,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
|
|
||||||
Context.Memory.Commit(srcPa - DramMemoryMap.DramBase, size);
|
Context.Memory.Commit(srcPa - DramMemoryMap.DramBase, size);
|
||||||
|
|
||||||
_cpuMemory.Map(dstVa, Context.Memory.GetPointer(srcPa - DramMemoryMap.DramBase, size), size);
|
_cpuMemory.Map(dstVa, srcPa - DramMemoryMap.DramBase, size);
|
||||||
|
|
||||||
if (DramMemoryMap.IsHeapPhysicalAddress(srcPa))
|
if (DramMemoryMap.IsHeapPhysicalAddress(srcPa))
|
||||||
{
|
{
|
||||||
|
@ -121,7 +124,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
|
|
||||||
Context.Memory.Commit(addr, size);
|
Context.Memory.Commit(addr, size);
|
||||||
|
|
||||||
_cpuMemory.Map(currentVa, Context.Memory.GetPointer(addr, size), size);
|
_cpuMemory.Map(currentVa, addr, size);
|
||||||
|
|
||||||
if (shouldFillPages)
|
if (shouldFillPages)
|
||||||
{
|
{
|
||||||
|
@ -136,33 +139,6 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
return KernelResult.Success;
|
return KernelResult.Success;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <inheritdoc/>
|
|
||||||
protected override KernelResult MapPages(ulong address, IEnumerable<HostMemoryRange> ranges, KMemoryPermission permission)
|
|
||||||
{
|
|
||||||
ulong currentVa = address;
|
|
||||||
|
|
||||||
foreach (var range in ranges)
|
|
||||||
{
|
|
||||||
ulong size = range.Size;
|
|
||||||
|
|
||||||
ulong pa = GetDramAddressFromHostAddress(range.Address);
|
|
||||||
if (pa != ulong.MaxValue)
|
|
||||||
{
|
|
||||||
pa += DramMemoryMap.DramBase;
|
|
||||||
if (DramMemoryMap.IsHeapPhysicalAddress(pa))
|
|
||||||
{
|
|
||||||
Context.MemoryManager.IncrementPagesReferenceCount(pa, size / PageSize);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
_cpuMemory.Map(currentVa, range.Address, size);
|
|
||||||
|
|
||||||
currentVa += size;
|
|
||||||
}
|
|
||||||
|
|
||||||
return KernelResult.Success;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// <inheritdoc/>
|
/// <inheritdoc/>
|
||||||
protected override KernelResult Unmap(ulong address, ulong pagesCount)
|
protected override KernelResult Unmap(ulong address, ulong pagesCount)
|
||||||
{
|
{
|
||||||
|
@ -172,13 +148,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
|
|
||||||
foreach (var region in regions)
|
foreach (var region in regions)
|
||||||
{
|
{
|
||||||
ulong pa = GetDramAddressFromHostAddress(region.Address);
|
ulong pa = region.Address + DramMemoryMap.DramBase;
|
||||||
if (pa == ulong.MaxValue)
|
|
||||||
{
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
pa += DramMemoryMap.DramBase;
|
|
||||||
if (DramMemoryMap.IsHeapPhysicalAddress(pa))
|
if (DramMemoryMap.IsHeapPhysicalAddress(pa))
|
||||||
{
|
{
|
||||||
pagesToClose.AddRange(pa, region.Size / PageSize);
|
pagesToClose.AddRange(pa, region.Size / PageSize);
|
||||||
|
@ -217,15 +187,5 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
{
|
{
|
||||||
_cpuMemory.Write(va, data);
|
_cpuMemory.Write(va, data);
|
||||||
}
|
}
|
||||||
|
|
||||||
private ulong GetDramAddressFromHostAddress(nuint hostAddress)
|
|
||||||
{
|
|
||||||
if (hostAddress < (nuint)(ulong)Context.Memory.Pointer || hostAddress >= (nuint)((ulong)Context.Memory.Pointer + Context.Memory.Size))
|
|
||||||
{
|
|
||||||
return ulong.MaxValue;
|
|
||||||
}
|
|
||||||
|
|
||||||
return hostAddress - (ulong)Context.Memory.Pointer;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,11 +1,9 @@
|
||||||
using Ryujinx.Common;
|
using Ryujinx.Common;
|
||||||
using Ryujinx.HLE.HOS.Kernel.Common;
|
using Ryujinx.HLE.HOS.Kernel.Common;
|
||||||
using Ryujinx.HLE.HOS.Kernel.Process;
|
using Ryujinx.HLE.HOS.Kernel.Process;
|
||||||
using Ryujinx.Memory.Range;
|
|
||||||
using System;
|
using System;
|
||||||
using System.Collections.Generic;
|
using System.Collections.Generic;
|
||||||
using System.Diagnostics;
|
using System.Diagnostics;
|
||||||
using System.Linq;
|
|
||||||
|
|
||||||
namespace Ryujinx.HLE.HOS.Kernel.Memory
|
namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
{
|
{
|
||||||
|
@ -73,8 +71,6 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
|
|
||||||
private MersenneTwister _randomNumberGenerator;
|
private MersenneTwister _randomNumberGenerator;
|
||||||
|
|
||||||
public abstract bool SupportsMemoryAliasing { get; }
|
|
||||||
|
|
||||||
private MemoryFillValue _heapFillValue;
|
private MemoryFillValue _heapFillValue;
|
||||||
private MemoryFillValue _ipcFillValue;
|
private MemoryFillValue _ipcFillValue;
|
||||||
|
|
||||||
|
@ -380,8 +376,9 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
public KernelResult UnmapPages(ulong address, ulong pagesCount, IEnumerable<HostMemoryRange> ranges, MemoryState stateExpected)
|
public KernelResult UnmapPages(ulong address, KPageList pageList, MemoryState stateExpected)
|
||||||
{
|
{
|
||||||
|
ulong pagesCount = pageList.GetPagesCount();
|
||||||
ulong size = pagesCount * PageSize;
|
ulong size = pagesCount * PageSize;
|
||||||
|
|
||||||
ulong endAddr = address + size;
|
ulong endAddr = address + size;
|
||||||
|
@ -405,9 +402,11 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
|
|
||||||
lock (_blockManager)
|
lock (_blockManager)
|
||||||
{
|
{
|
||||||
var currentRanges = GetPhysicalRegions(address, size);
|
KPageList currentPageList = new KPageList();
|
||||||
|
|
||||||
if (!currentRanges.SequenceEqual(ranges))
|
GetPhysicalRegions(address, size, currentPageList);
|
||||||
|
|
||||||
|
if (!currentPageList.IsEqual(pageList))
|
||||||
{
|
{
|
||||||
return KernelResult.InvalidMemRange;
|
return KernelResult.InvalidMemRange;
|
||||||
}
|
}
|
||||||
|
@ -1096,6 +1095,77 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
public KernelResult UnmapProcessMemory(ulong dst, ulong size, KPageTableBase srcPageTable, ulong src)
|
||||||
|
{
|
||||||
|
lock (_blockManager)
|
||||||
|
{
|
||||||
|
lock (srcPageTable._blockManager)
|
||||||
|
{
|
||||||
|
bool success = CheckRange(
|
||||||
|
dst,
|
||||||
|
size,
|
||||||
|
MemoryState.Mask,
|
||||||
|
MemoryState.ProcessMemory,
|
||||||
|
KMemoryPermission.ReadAndWrite,
|
||||||
|
KMemoryPermission.ReadAndWrite,
|
||||||
|
MemoryAttribute.Mask,
|
||||||
|
MemoryAttribute.None,
|
||||||
|
MemoryAttribute.IpcAndDeviceMapped,
|
||||||
|
out _,
|
||||||
|
out _,
|
||||||
|
out _);
|
||||||
|
|
||||||
|
success &= srcPageTable.CheckRange(
|
||||||
|
src,
|
||||||
|
size,
|
||||||
|
MemoryState.MapProcessAllowed,
|
||||||
|
MemoryState.MapProcessAllowed,
|
||||||
|
KMemoryPermission.None,
|
||||||
|
KMemoryPermission.None,
|
||||||
|
MemoryAttribute.Mask,
|
||||||
|
MemoryAttribute.None,
|
||||||
|
MemoryAttribute.IpcAndDeviceMapped,
|
||||||
|
out _,
|
||||||
|
out _,
|
||||||
|
out _);
|
||||||
|
|
||||||
|
if (!success)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemState;
|
||||||
|
}
|
||||||
|
|
||||||
|
KPageList srcPageList = new KPageList();
|
||||||
|
KPageList dstPageList = new KPageList();
|
||||||
|
|
||||||
|
srcPageTable.GetPhysicalRegions(src, size, srcPageList);
|
||||||
|
GetPhysicalRegions(dst, size, dstPageList);
|
||||||
|
|
||||||
|
if (!dstPageList.IsEqual(srcPageList))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemRange;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!_slabManager.CanAllocate(MaxBlocksNeededForInsertion))
|
||||||
|
{
|
||||||
|
return KernelResult.OutOfResource;
|
||||||
|
}
|
||||||
|
|
||||||
|
ulong pagesCount = size / PageSize;
|
||||||
|
|
||||||
|
KernelResult result = Unmap(dst, pagesCount);
|
||||||
|
|
||||||
|
if (result != KernelResult.Success)
|
||||||
|
{
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
_blockManager.InsertBlock(dst, pagesCount, MemoryState.Unmapped);
|
||||||
|
|
||||||
|
return KernelResult.Success;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
public KernelResult SetProcessMemoryPermission(ulong address, ulong size, KMemoryPermission permission)
|
public KernelResult SetProcessMemoryPermission(ulong address, ulong size, KMemoryPermission permission)
|
||||||
{
|
{
|
||||||
lock (_blockManager)
|
lock (_blockManager)
|
||||||
|
@ -1690,11 +1760,6 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
bool send,
|
bool send,
|
||||||
out ulong dst)
|
out ulong dst)
|
||||||
{
|
{
|
||||||
if (!SupportsMemoryAliasing)
|
|
||||||
{
|
|
||||||
throw new NotSupportedException("Memory aliasing not supported, can't map IPC buffers.");
|
|
||||||
}
|
|
||||||
|
|
||||||
dst = 0;
|
dst = 0;
|
||||||
|
|
||||||
if (!_slabManager.CanAllocate(MaxBlocksNeededForInsertion))
|
if (!_slabManager.CanAllocate(MaxBlocksNeededForInsertion))
|
||||||
|
@ -1828,7 +1893,10 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
{
|
{
|
||||||
ulong alignedSize = endAddrTruncated - addressRounded;
|
ulong alignedSize = endAddrTruncated - addressRounded;
|
||||||
|
|
||||||
KernelResult result = MapPages(currentVa, srcPageTable.GetPhysicalRegions(addressRounded, alignedSize), permission);
|
KPageList pageList = new KPageList();
|
||||||
|
srcPageTable.GetPhysicalRegions(addressRounded, alignedSize, pageList);
|
||||||
|
|
||||||
|
KernelResult result = MapPages(currentVa, pageList, permission);
|
||||||
|
|
||||||
if (result != KernelResult.Success)
|
if (result != KernelResult.Success)
|
||||||
{
|
{
|
||||||
|
@ -2026,6 +2094,49 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
block.RestoreIpcMappingPermission();
|
block.RestoreIpcMappingPermission();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
public KernelResult GetPagesIfStateEquals(
|
||||||
|
ulong address,
|
||||||
|
ulong size,
|
||||||
|
MemoryState stateMask,
|
||||||
|
MemoryState stateExpected,
|
||||||
|
KMemoryPermission permissionMask,
|
||||||
|
KMemoryPermission permissionExpected,
|
||||||
|
MemoryAttribute attributeMask,
|
||||||
|
MemoryAttribute attributeExpected,
|
||||||
|
KPageList pageList)
|
||||||
|
{
|
||||||
|
if (!InsideAddrSpace(address, size))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemState;
|
||||||
|
}
|
||||||
|
|
||||||
|
lock (_blockManager)
|
||||||
|
{
|
||||||
|
if (CheckRange(
|
||||||
|
address,
|
||||||
|
size,
|
||||||
|
stateMask | MemoryState.IsPoolAllocated,
|
||||||
|
stateExpected | MemoryState.IsPoolAllocated,
|
||||||
|
permissionMask,
|
||||||
|
permissionExpected,
|
||||||
|
attributeMask,
|
||||||
|
attributeExpected,
|
||||||
|
MemoryAttribute.IpcAndDeviceMapped,
|
||||||
|
out _,
|
||||||
|
out _,
|
||||||
|
out _))
|
||||||
|
{
|
||||||
|
GetPhysicalRegions(address, size, pageList);
|
||||||
|
|
||||||
|
return KernelResult.Success;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemState;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
public KernelResult BorrowIpcBuffer(ulong address, ulong size)
|
public KernelResult BorrowIpcBuffer(ulong address, ulong size)
|
||||||
{
|
{
|
||||||
return SetAttributesAndChangePermission(
|
return SetAttributesAndChangePermission(
|
||||||
|
@ -2041,7 +2152,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
MemoryAttribute.Borrowed);
|
MemoryAttribute.Borrowed);
|
||||||
}
|
}
|
||||||
|
|
||||||
public KernelResult BorrowTransferMemory(List<HostMemoryRange> ranges, ulong address, ulong size, KMemoryPermission permission)
|
public KernelResult BorrowTransferMemory(KPageList pageList, ulong address, ulong size, KMemoryPermission permission)
|
||||||
{
|
{
|
||||||
return SetAttributesAndChangePermission(
|
return SetAttributesAndChangePermission(
|
||||||
address,
|
address,
|
||||||
|
@ -2054,7 +2165,23 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
MemoryAttribute.None,
|
MemoryAttribute.None,
|
||||||
permission,
|
permission,
|
||||||
MemoryAttribute.Borrowed,
|
MemoryAttribute.Borrowed,
|
||||||
ranges);
|
pageList);
|
||||||
|
}
|
||||||
|
|
||||||
|
public KernelResult BorrowCodeMemory(KPageList pageList, ulong address, ulong size)
|
||||||
|
{
|
||||||
|
return SetAttributesAndChangePermission(
|
||||||
|
address,
|
||||||
|
size,
|
||||||
|
MemoryState.CodeMemoryAllowed,
|
||||||
|
MemoryState.CodeMemoryAllowed,
|
||||||
|
KMemoryPermission.Mask,
|
||||||
|
KMemoryPermission.ReadAndWrite,
|
||||||
|
MemoryAttribute.Mask,
|
||||||
|
MemoryAttribute.None,
|
||||||
|
KMemoryPermission.None,
|
||||||
|
MemoryAttribute.Borrowed,
|
||||||
|
pageList);
|
||||||
}
|
}
|
||||||
|
|
||||||
private KernelResult SetAttributesAndChangePermission(
|
private KernelResult SetAttributesAndChangePermission(
|
||||||
|
@ -2068,7 +2195,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
MemoryAttribute attributeExpected,
|
MemoryAttribute attributeExpected,
|
||||||
KMemoryPermission newPermission,
|
KMemoryPermission newPermission,
|
||||||
MemoryAttribute attributeSetMask,
|
MemoryAttribute attributeSetMask,
|
||||||
List<HostMemoryRange> ranges = null)
|
KPageList pageList = null)
|
||||||
{
|
{
|
||||||
if (address + size <= address || !InsideAddrSpace(address, size))
|
if (address + size <= address || !InsideAddrSpace(address, size))
|
||||||
{
|
{
|
||||||
|
@ -2093,7 +2220,10 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
{
|
{
|
||||||
ulong pagesCount = size / PageSize;
|
ulong pagesCount = size / PageSize;
|
||||||
|
|
||||||
ranges?.AddRange(GetPhysicalRegions(address, size));
|
if (pageList != null)
|
||||||
|
{
|
||||||
|
GetPhysicalRegions(address, pagesCount * PageSize, pageList);
|
||||||
|
}
|
||||||
|
|
||||||
if (!_slabManager.CanAllocate(MaxBlocksNeededForInsertion))
|
if (!_slabManager.CanAllocate(MaxBlocksNeededForInsertion))
|
||||||
{
|
{
|
||||||
|
@ -2143,7 +2273,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
MemoryAttribute.Borrowed);
|
MemoryAttribute.Borrowed);
|
||||||
}
|
}
|
||||||
|
|
||||||
public KernelResult UnborrowTransferMemory(ulong address, ulong size, List<HostMemoryRange> ranges)
|
public KernelResult UnborrowTransferMemory(ulong address, ulong size, KPageList pageList)
|
||||||
{
|
{
|
||||||
return ClearAttributesAndChangePermission(
|
return ClearAttributesAndChangePermission(
|
||||||
address,
|
address,
|
||||||
|
@ -2156,7 +2286,23 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
MemoryAttribute.Borrowed,
|
MemoryAttribute.Borrowed,
|
||||||
KMemoryPermission.ReadAndWrite,
|
KMemoryPermission.ReadAndWrite,
|
||||||
MemoryAttribute.Borrowed,
|
MemoryAttribute.Borrowed,
|
||||||
ranges);
|
pageList);
|
||||||
|
}
|
||||||
|
|
||||||
|
public KernelResult UnborrowCodeMemory(ulong address, ulong size, KPageList pageList)
|
||||||
|
{
|
||||||
|
return ClearAttributesAndChangePermission(
|
||||||
|
address,
|
||||||
|
size,
|
||||||
|
MemoryState.CodeMemoryAllowed,
|
||||||
|
MemoryState.CodeMemoryAllowed,
|
||||||
|
KMemoryPermission.None,
|
||||||
|
KMemoryPermission.None,
|
||||||
|
MemoryAttribute.Mask,
|
||||||
|
MemoryAttribute.Borrowed,
|
||||||
|
KMemoryPermission.ReadAndWrite,
|
||||||
|
MemoryAttribute.Borrowed,
|
||||||
|
pageList);
|
||||||
}
|
}
|
||||||
|
|
||||||
private KernelResult ClearAttributesAndChangePermission(
|
private KernelResult ClearAttributesAndChangePermission(
|
||||||
|
@ -2170,7 +2316,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
MemoryAttribute attributeExpected,
|
MemoryAttribute attributeExpected,
|
||||||
KMemoryPermission newPermission,
|
KMemoryPermission newPermission,
|
||||||
MemoryAttribute attributeClearMask,
|
MemoryAttribute attributeClearMask,
|
||||||
List<HostMemoryRange> ranges = null)
|
KPageList pageList = null)
|
||||||
{
|
{
|
||||||
if (address + size <= address || !InsideAddrSpace(address, size))
|
if (address + size <= address || !InsideAddrSpace(address, size))
|
||||||
{
|
{
|
||||||
|
@ -2195,11 +2341,13 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
{
|
{
|
||||||
ulong pagesCount = size / PageSize;
|
ulong pagesCount = size / PageSize;
|
||||||
|
|
||||||
if (ranges != null)
|
if (pageList != null)
|
||||||
{
|
{
|
||||||
var currentRanges = GetPhysicalRegions(address, size);
|
KPageList currentPageList = new KPageList();
|
||||||
|
|
||||||
if (!currentRanges.SequenceEqual(ranges))
|
GetPhysicalRegions(address, pagesCount * PageSize, currentPageList);
|
||||||
|
|
||||||
|
if (!currentPageList.IsEqual(pageList))
|
||||||
{
|
{
|
||||||
return KernelResult.InvalidMemRange;
|
return KernelResult.InvalidMemRange;
|
||||||
}
|
}
|
||||||
|
@ -2741,8 +2889,8 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
/// </summary>
|
/// </summary>
|
||||||
/// <param name="va">Virtual address of the range</param>
|
/// <param name="va">Virtual address of the range</param>
|
||||||
/// <param name="size">Size of the range</param>
|
/// <param name="size">Size of the range</param>
|
||||||
/// <returns>Array of physical regions</returns>
|
/// <param name="pageList">Page list where the ranges will be added</param>
|
||||||
protected abstract IEnumerable<HostMemoryRange> GetPhysicalRegions(ulong va, ulong size);
|
protected abstract void GetPhysicalRegions(ulong va, ulong size, KPageList pageList);
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Gets a read-only span of data from CPU mapped memory.
|
/// Gets a read-only span of data from CPU mapped memory.
|
||||||
|
@ -2803,16 +2951,6 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
/// <returns>Result of the mapping operation</returns>
|
/// <returns>Result of the mapping operation</returns>
|
||||||
protected abstract KernelResult MapPages(ulong address, KPageList pageList, KMemoryPermission permission, bool shouldFillPages = false, byte fillValue = 0);
|
protected abstract KernelResult MapPages(ulong address, KPageList pageList, KMemoryPermission permission, bool shouldFillPages = false, byte fillValue = 0);
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Maps a region of memory into the specified host memory ranges.
|
|
||||||
/// </summary>
|
|
||||||
/// <param name="address">Destination virtual address that should be mapped</param>
|
|
||||||
/// <param name="ranges">Ranges of host memory that should be mapped</param>
|
|
||||||
/// <param name="permission">Permission of the region to be mapped</param>
|
|
||||||
/// <returns>Result of the mapping operation</returns>
|
|
||||||
/// <exception cref="NotSupportedException">The implementation does not support memory aliasing</exception>
|
|
||||||
protected abstract KernelResult MapPages(ulong address, IEnumerable<HostMemoryRange> ranges, KMemoryPermission permission);
|
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Unmaps a region of memory that was previously mapped with one of the page mapping methods.
|
/// Unmaps a region of memory that was previously mapped with one of the page mapping methods.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
|
|
|
@ -1,139 +0,0 @@
|
||||||
using Ryujinx.HLE.HOS.Kernel.Common;
|
|
||||||
using Ryujinx.Memory;
|
|
||||||
using Ryujinx.Memory.Range;
|
|
||||||
using System;
|
|
||||||
using System.Collections.Generic;
|
|
||||||
using System.Linq;
|
|
||||||
|
|
||||||
namespace Ryujinx.HLE.HOS.Kernel.Memory
|
|
||||||
{
|
|
||||||
class KPageTableHostMapped : KPageTableBase
|
|
||||||
{
|
|
||||||
private const int CopyChunckSize = 0x100000;
|
|
||||||
|
|
||||||
private readonly IVirtualMemoryManager _cpuMemory;
|
|
||||||
|
|
||||||
public override bool SupportsMemoryAliasing => false;
|
|
||||||
|
|
||||||
public KPageTableHostMapped(KernelContext context, IVirtualMemoryManager cpuMemory) : base(context)
|
|
||||||
{
|
|
||||||
_cpuMemory = cpuMemory;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// <inheritdoc/>
|
|
||||||
protected override IEnumerable<HostMemoryRange> GetPhysicalRegions(ulong va, ulong size)
|
|
||||||
{
|
|
||||||
return _cpuMemory.GetPhysicalRegions(va, size);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// <inheritdoc/>
|
|
||||||
protected override ReadOnlySpan<byte> GetSpan(ulong va, int size)
|
|
||||||
{
|
|
||||||
return _cpuMemory.GetSpan(va, size);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// <inheritdoc/>
|
|
||||||
protected override KernelResult MapMemory(ulong src, ulong dst, ulong pagesCount, KMemoryPermission oldSrcPermission, KMemoryPermission newDstPermission)
|
|
||||||
{
|
|
||||||
ulong size = pagesCount * PageSize;
|
|
||||||
|
|
||||||
_cpuMemory.Map(dst, 0, size);
|
|
||||||
|
|
||||||
ulong currentSize = size;
|
|
||||||
while (currentSize > 0)
|
|
||||||
{
|
|
||||||
ulong copySize = Math.Min(currentSize, CopyChunckSize);
|
|
||||||
_cpuMemory.Write(dst, _cpuMemory.GetSpan(src, (int)copySize));
|
|
||||||
currentSize -= copySize;
|
|
||||||
}
|
|
||||||
|
|
||||||
return KernelResult.Success;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// <inheritdoc/>
|
|
||||||
protected override KernelResult UnmapMemory(ulong dst, ulong src, ulong pagesCount, KMemoryPermission oldDstPermission, KMemoryPermission newSrcPermission)
|
|
||||||
{
|
|
||||||
ulong size = pagesCount * PageSize;
|
|
||||||
|
|
||||||
// TODO: Validation.
|
|
||||||
|
|
||||||
ulong currentSize = size;
|
|
||||||
while (currentSize > 0)
|
|
||||||
{
|
|
||||||
ulong copySize = Math.Min(currentSize, CopyChunckSize);
|
|
||||||
_cpuMemory.Write(src, _cpuMemory.GetSpan(dst, (int)copySize));
|
|
||||||
currentSize -= copySize;
|
|
||||||
}
|
|
||||||
|
|
||||||
_cpuMemory.Unmap(dst, size);
|
|
||||||
return KernelResult.Success;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// <inheritdoc/>
|
|
||||||
protected override KernelResult MapPages(ulong dstVa, ulong pagesCount, ulong srcPa, KMemoryPermission permission, bool shouldFillPages, byte fillValue)
|
|
||||||
{
|
|
||||||
_cpuMemory.Map(dstVa, 0, pagesCount * PageSize);
|
|
||||||
|
|
||||||
if (shouldFillPages)
|
|
||||||
{
|
|
||||||
_cpuMemory.Fill(dstVa, pagesCount * PageSize, fillValue);
|
|
||||||
}
|
|
||||||
|
|
||||||
return KernelResult.Success;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// <inheritdoc/>
|
|
||||||
protected override KernelResult MapPages(ulong address, KPageList pageList, KMemoryPermission permission, bool shouldFillPages, byte fillValue)
|
|
||||||
{
|
|
||||||
ulong pagesCount = pageList.GetPagesCount();
|
|
||||||
|
|
||||||
_cpuMemory.Map(address, 0, pagesCount * PageSize);
|
|
||||||
|
|
||||||
if (shouldFillPages)
|
|
||||||
{
|
|
||||||
_cpuMemory.Fill(address, pagesCount * PageSize, fillValue);
|
|
||||||
}
|
|
||||||
|
|
||||||
return KernelResult.Success;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// <inheritdoc/>
|
|
||||||
protected override KernelResult MapPages(ulong address, IEnumerable<HostMemoryRange> ranges, KMemoryPermission permission)
|
|
||||||
{
|
|
||||||
throw new NotSupportedException();
|
|
||||||
}
|
|
||||||
|
|
||||||
/// <inheritdoc/>
|
|
||||||
protected override KernelResult Unmap(ulong address, ulong pagesCount)
|
|
||||||
{
|
|
||||||
_cpuMemory.Unmap(address, pagesCount * PageSize);
|
|
||||||
return KernelResult.Success;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// <inheritdoc/>
|
|
||||||
protected override KernelResult Reprotect(ulong address, ulong pagesCount, KMemoryPermission permission)
|
|
||||||
{
|
|
||||||
// TODO.
|
|
||||||
return KernelResult.Success;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// <inheritdoc/>
|
|
||||||
protected override KernelResult ReprotectWithAttributes(ulong address, ulong pagesCount, KMemoryPermission permission)
|
|
||||||
{
|
|
||||||
// TODO.
|
|
||||||
return KernelResult.Success;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// <inheritdoc/>
|
|
||||||
protected override void SignalMemoryTracking(ulong va, ulong size, bool write)
|
|
||||||
{
|
|
||||||
_cpuMemory.SignalMemoryTracking(va, size, write);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// <inheritdoc/>
|
|
||||||
protected override void Write(ulong va, ReadOnlySpan<byte> data)
|
|
||||||
{
|
|
||||||
_cpuMemory.Write(va, data);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -6,7 +6,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
{
|
{
|
||||||
class KSharedMemory : KAutoObject
|
class KSharedMemory : KAutoObject
|
||||||
{
|
{
|
||||||
private readonly SharedMemoryStorage _storage;
|
private readonly KPageList _pageList;
|
||||||
|
|
||||||
private readonly ulong _ownerPid;
|
private readonly ulong _ownerPid;
|
||||||
|
|
||||||
|
@ -20,7 +20,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
KMemoryPermission ownerPermission,
|
KMemoryPermission ownerPermission,
|
||||||
KMemoryPermission userPermission) : base(context)
|
KMemoryPermission userPermission) : base(context)
|
||||||
{
|
{
|
||||||
_storage = storage;
|
_pageList = storage.GetPageList();
|
||||||
_ownerPid = ownerPid;
|
_ownerPid = ownerPid;
|
||||||
_ownerPermission = ownerPermission;
|
_ownerPermission = ownerPermission;
|
||||||
_userPermission = userPermission;
|
_userPermission = userPermission;
|
||||||
|
@ -33,10 +33,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
KProcess process,
|
KProcess process,
|
||||||
KMemoryPermission permission)
|
KMemoryPermission permission)
|
||||||
{
|
{
|
||||||
ulong pagesCountRounded = BitUtils.DivRoundUp(size, KPageTableBase.PageSize);
|
if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
|
||||||
|
|
||||||
var pageList = _storage.GetPageList();
|
|
||||||
if (pageList.GetPagesCount() != pagesCountRounded)
|
|
||||||
{
|
{
|
||||||
return KernelResult.InvalidSize;
|
return KernelResult.InvalidSize;
|
||||||
}
|
}
|
||||||
|
@ -50,35 +47,17 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
return KernelResult.InvalidPermission;
|
return KernelResult.InvalidPermission;
|
||||||
}
|
}
|
||||||
|
|
||||||
KernelResult result = memoryManager.MapPages(address, pageList, MemoryState.SharedMemory, permission);
|
return memoryManager.MapPages(address, _pageList, MemoryState.SharedMemory, permission);
|
||||||
|
|
||||||
if (result == KernelResult.Success && !memoryManager.SupportsMemoryAliasing)
|
|
||||||
{
|
|
||||||
_storage.Borrow(process, address);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
return result;
|
public KernelResult UnmapFromProcess(KPageTableBase memoryManager, ulong address, ulong size, KProcess process)
|
||||||
}
|
|
||||||
|
|
||||||
public KernelResult UnmapFromProcess(
|
|
||||||
KPageTableBase memoryManager,
|
|
||||||
ulong address,
|
|
||||||
ulong size,
|
|
||||||
KProcess process)
|
|
||||||
{
|
{
|
||||||
ulong pagesCountRounded = BitUtils.DivRoundUp(size, KPageTableBase.PageSize);
|
if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
|
||||||
|
|
||||||
var pageList = _storage.GetPageList();
|
|
||||||
ulong pagesCount = pageList.GetPagesCount();
|
|
||||||
|
|
||||||
if (pagesCount != pagesCountRounded)
|
|
||||||
{
|
{
|
||||||
return KernelResult.InvalidSize;
|
return KernelResult.InvalidSize;
|
||||||
}
|
}
|
||||||
|
|
||||||
var ranges = _storage.GetRanges();
|
return memoryManager.UnmapPages(address, _pageList, MemoryState.SharedMemory);
|
||||||
|
|
||||||
return memoryManager.UnmapPages(address, pagesCount, ranges, MemoryState.SharedMemory);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
|
@ -1,9 +1,7 @@
|
||||||
using Ryujinx.Common;
|
using Ryujinx.Common;
|
||||||
using Ryujinx.HLE.HOS.Kernel.Common;
|
using Ryujinx.HLE.HOS.Kernel.Common;
|
||||||
using Ryujinx.HLE.HOS.Kernel.Process;
|
using Ryujinx.HLE.HOS.Kernel.Process;
|
||||||
using Ryujinx.Memory.Range;
|
|
||||||
using System;
|
using System;
|
||||||
using System.Collections.Generic;
|
|
||||||
|
|
||||||
namespace Ryujinx.HLE.HOS.Kernel.Memory
|
namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
{
|
{
|
||||||
|
@ -14,9 +12,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
// TODO: Remove when we no longer need to read it from the owner directly.
|
// TODO: Remove when we no longer need to read it from the owner directly.
|
||||||
public KProcess Creator => _creator;
|
public KProcess Creator => _creator;
|
||||||
|
|
||||||
private readonly List<HostMemoryRange> _ranges;
|
private readonly KPageList _pageList;
|
||||||
|
|
||||||
private readonly SharedMemoryStorage _storage;
|
|
||||||
|
|
||||||
public ulong Address { get; private set; }
|
public ulong Address { get; private set; }
|
||||||
public ulong Size { get; private set; }
|
public ulong Size { get; private set; }
|
||||||
|
@ -28,12 +24,12 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
|
|
||||||
public KTransferMemory(KernelContext context) : base(context)
|
public KTransferMemory(KernelContext context) : base(context)
|
||||||
{
|
{
|
||||||
_ranges = new List<HostMemoryRange>();
|
_pageList = new KPageList();
|
||||||
}
|
}
|
||||||
|
|
||||||
public KTransferMemory(KernelContext context, SharedMemoryStorage storage) : base(context)
|
public KTransferMemory(KernelContext context, SharedMemoryStorage storage) : base(context)
|
||||||
{
|
{
|
||||||
_storage = storage;
|
_pageList = storage.GetPageList();
|
||||||
Permission = KMemoryPermission.ReadAndWrite;
|
Permission = KMemoryPermission.ReadAndWrite;
|
||||||
|
|
||||||
_hasBeenInitialized = true;
|
_hasBeenInitialized = true;
|
||||||
|
@ -46,7 +42,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
|
|
||||||
_creator = creator;
|
_creator = creator;
|
||||||
|
|
||||||
KernelResult result = creator.MemoryManager.BorrowTransferMemory(_ranges, address, size, permission);
|
KernelResult result = creator.MemoryManager.BorrowTransferMemory(_pageList, address, size, permission);
|
||||||
|
|
||||||
if (result != KernelResult.Success)
|
if (result != KernelResult.Success)
|
||||||
{
|
{
|
||||||
|
@ -71,15 +67,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
KProcess process,
|
KProcess process,
|
||||||
KMemoryPermission permission)
|
KMemoryPermission permission)
|
||||||
{
|
{
|
||||||
if (_storage == null)
|
if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
|
||||||
{
|
|
||||||
throw new NotImplementedException();
|
|
||||||
}
|
|
||||||
|
|
||||||
ulong pagesCountRounded = BitUtils.DivRoundUp(size, KPageTableBase.PageSize);
|
|
||||||
|
|
||||||
var pageList = _storage.GetPageList();
|
|
||||||
if (pageList.GetPagesCount() != pagesCountRounded)
|
|
||||||
{
|
{
|
||||||
return KernelResult.InvalidSize;
|
return KernelResult.InvalidSize;
|
||||||
}
|
}
|
||||||
|
@ -91,16 +79,11 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
|
|
||||||
MemoryState state = Permission == KMemoryPermission.None ? MemoryState.TransferMemoryIsolated : MemoryState.TransferMemory;
|
MemoryState state = Permission == KMemoryPermission.None ? MemoryState.TransferMemoryIsolated : MemoryState.TransferMemory;
|
||||||
|
|
||||||
KernelResult result = memoryManager.MapPages(address, pageList, state, KMemoryPermission.ReadAndWrite);
|
KernelResult result = memoryManager.MapPages(address, _pageList, state, KMemoryPermission.ReadAndWrite);
|
||||||
|
|
||||||
if (result == KernelResult.Success)
|
if (result == KernelResult.Success)
|
||||||
{
|
{
|
||||||
_isMapped = true;
|
_isMapped = true;
|
||||||
|
|
||||||
if (!memoryManager.SupportsMemoryAliasing)
|
|
||||||
{
|
|
||||||
_storage.Borrow(process, address);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
return result;
|
return result;
|
||||||
|
@ -112,26 +95,14 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
ulong size,
|
ulong size,
|
||||||
KProcess process)
|
KProcess process)
|
||||||
{
|
{
|
||||||
if (_storage == null)
|
if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
|
||||||
{
|
|
||||||
throw new NotImplementedException();
|
|
||||||
}
|
|
||||||
|
|
||||||
ulong pagesCountRounded = BitUtils.DivRoundUp(size, KPageTableBase.PageSize);
|
|
||||||
|
|
||||||
var pageList = _storage.GetPageList();
|
|
||||||
ulong pagesCount = pageList.GetPagesCount();
|
|
||||||
|
|
||||||
if (pagesCount != pagesCountRounded)
|
|
||||||
{
|
{
|
||||||
return KernelResult.InvalidSize;
|
return KernelResult.InvalidSize;
|
||||||
}
|
}
|
||||||
|
|
||||||
var ranges = _storage.GetRanges();
|
|
||||||
|
|
||||||
MemoryState state = Permission == KMemoryPermission.None ? MemoryState.TransferMemoryIsolated : MemoryState.TransferMemory;
|
MemoryState state = Permission == KMemoryPermission.None ? MemoryState.TransferMemoryIsolated : MemoryState.TransferMemory;
|
||||||
|
|
||||||
KernelResult result = memoryManager.UnmapPages(address, pagesCount, ranges, state);
|
KernelResult result = memoryManager.UnmapPages(address, _pageList, state);
|
||||||
|
|
||||||
if (result == KernelResult.Success)
|
if (result == KernelResult.Success)
|
||||||
{
|
{
|
||||||
|
@ -145,7 +116,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
{
|
{
|
||||||
if (_hasBeenInitialized)
|
if (_hasBeenInitialized)
|
||||||
{
|
{
|
||||||
if (!_isMapped && _creator.MemoryManager.UnborrowTransferMemory(Address, Size, _ranges) != KernelResult.Success)
|
if (!_isMapped && _creator.MemoryManager.UnborrowTransferMemory(Address, Size, _pageList) != KernelResult.Success)
|
||||||
{
|
{
|
||||||
throw new InvalidOperationException("Unexpected failure restoring transfer memory attributes.");
|
throw new InvalidOperationException("Unexpected failure restoring transfer memory attributes.");
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,8 +1,4 @@
|
||||||
using Ryujinx.HLE.HOS.Kernel.Process;
|
using System;
|
||||||
using Ryujinx.Memory;
|
|
||||||
using Ryujinx.Memory.Range;
|
|
||||||
using System;
|
|
||||||
using System.Collections.Generic;
|
|
||||||
|
|
||||||
namespace Ryujinx.HLE.HOS.Kernel.Memory
|
namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
{
|
{
|
||||||
|
@ -12,9 +8,6 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
private readonly KPageList _pageList;
|
private readonly KPageList _pageList;
|
||||||
private readonly ulong _size;
|
private readonly ulong _size;
|
||||||
|
|
||||||
private IVirtualMemoryManager _borrowerMemory;
|
|
||||||
private ulong _borrowerVa;
|
|
||||||
|
|
||||||
public SharedMemoryStorage(KernelContext context, KPageList pageList)
|
public SharedMemoryStorage(KernelContext context, KPageList pageList)
|
||||||
{
|
{
|
||||||
_context = context;
|
_context = context;
|
||||||
|
@ -29,24 +22,6 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
public void Borrow(KProcess dstProcess, ulong va)
|
|
||||||
{
|
|
||||||
ulong currentOffset = 0;
|
|
||||||
|
|
||||||
foreach (KPageNode pageNode in _pageList)
|
|
||||||
{
|
|
||||||
ulong address = pageNode.Address - DramMemoryMap.DramBase;
|
|
||||||
ulong size = pageNode.PagesCount * KPageTableBase.PageSize;
|
|
||||||
|
|
||||||
dstProcess.CpuMemory.Write(va + currentOffset, _context.Memory.GetSpan(address + currentOffset, (int)size));
|
|
||||||
|
|
||||||
currentOffset += size;
|
|
||||||
}
|
|
||||||
|
|
||||||
_borrowerMemory = dstProcess.CpuMemory;
|
|
||||||
_borrowerVa = va;
|
|
||||||
}
|
|
||||||
|
|
||||||
public void ZeroFill()
|
public void ZeroFill()
|
||||||
{
|
{
|
||||||
for (ulong offset = 0; offset < _size; offset += sizeof(ulong))
|
for (ulong offset = 0; offset < _size; offset += sizeof(ulong))
|
||||||
|
@ -56,8 +31,6 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
}
|
}
|
||||||
|
|
||||||
public ref T GetRef<T>(ulong offset) where T : unmanaged
|
public ref T GetRef<T>(ulong offset) where T : unmanaged
|
||||||
{
|
|
||||||
if (_borrowerMemory == null)
|
|
||||||
{
|
{
|
||||||
if (_pageList.Nodes.Count == 1)
|
if (_pageList.Nodes.Count == 1)
|
||||||
{
|
{
|
||||||
|
@ -67,33 +40,6 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
|
||||||
|
|
||||||
throw new NotImplementedException("Non-contiguous shared memory is not yet supported.");
|
throw new NotImplementedException("Non-contiguous shared memory is not yet supported.");
|
||||||
}
|
}
|
||||||
else
|
|
||||||
{
|
|
||||||
return ref _borrowerMemory.GetRef<T>(_borrowerVa + offset);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
public IEnumerable<HostMemoryRange> GetRanges()
|
|
||||||
{
|
|
||||||
if (_borrowerMemory == null)
|
|
||||||
{
|
|
||||||
var ranges = new List<HostMemoryRange>();
|
|
||||||
|
|
||||||
foreach (KPageNode pageNode in _pageList)
|
|
||||||
{
|
|
||||||
ulong address = pageNode.Address - DramMemoryMap.DramBase;
|
|
||||||
ulong size = pageNode.PagesCount * KPageTableBase.PageSize;
|
|
||||||
|
|
||||||
ranges.Add(new HostMemoryRange(_context.Memory.GetPointer(address, size), size));
|
|
||||||
}
|
|
||||||
|
|
||||||
return ranges;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
return _borrowerMemory.GetPhysicalRegions(_borrowerVa, _size);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
public KPageList GetPageList()
|
public KPageList GetPageList()
|
||||||
{
|
{
|
||||||
|
|
|
@ -1076,15 +1076,8 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
|
||||||
|
|
||||||
Context = _contextFactory.Create(KernelContext, Pid, 1UL << addrSpaceBits, InvalidAccessHandler, for64Bit);
|
Context = _contextFactory.Create(KernelContext, Pid, 1UL << addrSpaceBits, InvalidAccessHandler, for64Bit);
|
||||||
|
|
||||||
if (Context.AddressSpace is MemoryManagerHostMapped)
|
|
||||||
{
|
|
||||||
MemoryManager = new KPageTableHostMapped(KernelContext, CpuMemory);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
MemoryManager = new KPageTable(KernelContext, CpuMemory);
|
MemoryManager = new KPageTable(KernelContext, CpuMemory);
|
||||||
}
|
}
|
||||||
}
|
|
||||||
|
|
||||||
private bool InvalidAccessHandler(ulong va)
|
private bool InvalidAccessHandler(ulong va)
|
||||||
{
|
{
|
||||||
|
|
|
@ -6,7 +6,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
|
||||||
{
|
{
|
||||||
public IProcessContext Create(KernelContext context, ulong pid, ulong addressSpaceSize, InvalidAccessHandler invalidAccessHandler, bool for64Bit)
|
public IProcessContext Create(KernelContext context, ulong pid, ulong addressSpaceSize, InvalidAccessHandler invalidAccessHandler, bool for64Bit)
|
||||||
{
|
{
|
||||||
return new ProcessContext(new AddressSpaceManager(addressSpaceSize));
|
return new ProcessContext(new AddressSpaceManager(context.Memory, addressSpaceSize));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
10
Ryujinx.HLE/HOS/Kernel/SupervisorCall/CodeMemoryOperation.cs
Normal file
10
Ryujinx.HLE/HOS/Kernel/SupervisorCall/CodeMemoryOperation.cs
Normal file
|
@ -0,0 +1,10 @@
|
||||||
|
namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
|
||||||
|
{
|
||||||
|
enum CodeMemoryOperation : uint
|
||||||
|
{
|
||||||
|
Map,
|
||||||
|
MapToOwner,
|
||||||
|
Unmap,
|
||||||
|
UnmapFromOwner
|
||||||
|
};
|
||||||
|
}
|
|
@ -1317,6 +1317,247 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
|
||||||
return process.MemoryManager.UnmapPhysicalMemory(address, size);
|
return process.MemoryManager.UnmapPhysicalMemory(address, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
public KernelResult CreateCodeMemory(ulong address, ulong size, out int handle)
|
||||||
|
{
|
||||||
|
handle = 0;
|
||||||
|
|
||||||
|
if (!PageAligned(address))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidAddress;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!PageAligned(size) || size == 0)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (size + address <= address)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemState;
|
||||||
|
}
|
||||||
|
|
||||||
|
KCodeMemory codeMemory = new KCodeMemory(_context);
|
||||||
|
|
||||||
|
using var _ = new OnScopeExit(codeMemory.DecrementReferenceCount);
|
||||||
|
|
||||||
|
KProcess currentProcess = KernelStatic.GetCurrentProcess();
|
||||||
|
|
||||||
|
if (!currentProcess.MemoryManager.InsideAddrSpace(address, size))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemState;
|
||||||
|
}
|
||||||
|
|
||||||
|
KernelResult result = codeMemory.Initialize(address, size);
|
||||||
|
|
||||||
|
if (result != KernelResult.Success)
|
||||||
|
{
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
return currentProcess.HandleTable.GenerateHandle(codeMemory, out handle);
|
||||||
|
}
|
||||||
|
|
||||||
|
public KernelResult ControlCodeMemory(int handle, CodeMemoryOperation op, ulong address, ulong size, KMemoryPermission permission)
|
||||||
|
{
|
||||||
|
KProcess currentProcess = KernelStatic.GetCurrentProcess();
|
||||||
|
|
||||||
|
KCodeMemory codeMemory = currentProcess.HandleTable.GetObject<KCodeMemory>(handle);
|
||||||
|
|
||||||
|
if (codeMemory == null || codeMemory.Owner == currentProcess)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidHandle;
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (op)
|
||||||
|
{
|
||||||
|
case CodeMemoryOperation.Map:
|
||||||
|
if (!currentProcess.MemoryManager.CanContain(address, size, MemoryState.CodeWritable))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemRange;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (permission != KMemoryPermission.ReadAndWrite)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidPermission;
|
||||||
|
}
|
||||||
|
|
||||||
|
return codeMemory.Map(address, size, permission);
|
||||||
|
|
||||||
|
case CodeMemoryOperation.MapToOwner:
|
||||||
|
if (!currentProcess.MemoryManager.CanContain(address, size, MemoryState.CodeReadOnly))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemRange;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (permission != KMemoryPermission.Read && permission != KMemoryPermission.ReadAndExecute)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidPermission;
|
||||||
|
}
|
||||||
|
|
||||||
|
return codeMemory.MapToOwner(address, size, permission);
|
||||||
|
|
||||||
|
case CodeMemoryOperation.Unmap:
|
||||||
|
if (!currentProcess.MemoryManager.CanContain(address, size, MemoryState.CodeWritable))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemRange;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (permission != KMemoryPermission.None)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidPermission;
|
||||||
|
}
|
||||||
|
|
||||||
|
return codeMemory.Unmap(address, size);
|
||||||
|
|
||||||
|
case CodeMemoryOperation.UnmapFromOwner:
|
||||||
|
if (!currentProcess.MemoryManager.CanContain(address, size, MemoryState.CodeReadOnly))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemRange;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (permission != KMemoryPermission.None)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidPermission;
|
||||||
|
}
|
||||||
|
|
||||||
|
return codeMemory.UnmapFromOwner(address, size);
|
||||||
|
|
||||||
|
default: return KernelResult.InvalidEnumValue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public KernelResult SetProcessMemoryPermission(int handle, ulong src, ulong size, KMemoryPermission permission)
|
||||||
|
{
|
||||||
|
if (!PageAligned(src))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidAddress;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!PageAligned(size) || size == 0)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (permission != KMemoryPermission.None &&
|
||||||
|
permission != KMemoryPermission.Read &&
|
||||||
|
permission != KMemoryPermission.ReadAndWrite &&
|
||||||
|
permission != KMemoryPermission.ReadAndExecute)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidPermission;
|
||||||
|
}
|
||||||
|
|
||||||
|
KProcess currentProcess = KernelStatic.GetCurrentProcess();
|
||||||
|
|
||||||
|
KProcess targetProcess = currentProcess.HandleTable.GetObject<KProcess>(handle);
|
||||||
|
|
||||||
|
if (targetProcess == null)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidHandle;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (targetProcess.MemoryManager.OutsideAddrSpace(src, size))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemState;
|
||||||
|
}
|
||||||
|
|
||||||
|
return targetProcess.MemoryManager.SetProcessMemoryPermission(src, size, permission);
|
||||||
|
}
|
||||||
|
|
||||||
|
public KernelResult MapProcessMemory(ulong dst, int handle, ulong src, ulong size)
|
||||||
|
{
|
||||||
|
if (!PageAligned(src) || !PageAligned(dst))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidAddress;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!PageAligned(size) || size == 0)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (dst + size <= dst || src + size <= src)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemRange;
|
||||||
|
}
|
||||||
|
|
||||||
|
KProcess dstProcess = KernelStatic.GetCurrentProcess();
|
||||||
|
KProcess srcProcess = dstProcess.HandleTable.GetObject<KProcess>(handle);
|
||||||
|
|
||||||
|
if (srcProcess == null)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidHandle;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!srcProcess.MemoryManager.InsideAddrSpace(src, size) ||
|
||||||
|
!dstProcess.MemoryManager.CanContain(dst, size, MemoryState.ProcessMemory))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemRange;
|
||||||
|
}
|
||||||
|
|
||||||
|
KPageList pageList = new KPageList();
|
||||||
|
|
||||||
|
KernelResult result = srcProcess.MemoryManager.GetPagesIfStateEquals(
|
||||||
|
src,
|
||||||
|
size,
|
||||||
|
MemoryState.MapProcessAllowed,
|
||||||
|
MemoryState.MapProcessAllowed,
|
||||||
|
KMemoryPermission.None,
|
||||||
|
KMemoryPermission.None,
|
||||||
|
MemoryAttribute.Mask,
|
||||||
|
MemoryAttribute.None,
|
||||||
|
pageList);
|
||||||
|
|
||||||
|
if (result != KernelResult.Success)
|
||||||
|
{
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
return dstProcess.MemoryManager.MapPages(dst, pageList, MemoryState.ProcessMemory, KMemoryPermission.ReadAndWrite);
|
||||||
|
}
|
||||||
|
|
||||||
|
public KernelResult UnmapProcessMemory(ulong dst, int handle, ulong src, ulong size)
|
||||||
|
{
|
||||||
|
if (!PageAligned(src) || !PageAligned(dst))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidAddress;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!PageAligned(size) || size == 0)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (dst + size <= dst || src + size <= src)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemRange;
|
||||||
|
}
|
||||||
|
|
||||||
|
KProcess dstProcess = KernelStatic.GetCurrentProcess();
|
||||||
|
KProcess srcProcess = dstProcess.HandleTable.GetObject<KProcess>(handle);
|
||||||
|
|
||||||
|
if (srcProcess == null)
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidHandle;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!srcProcess.MemoryManager.InsideAddrSpace(src, size) ||
|
||||||
|
!dstProcess.MemoryManager.CanContain(dst, size, MemoryState.ProcessMemory))
|
||||||
|
{
|
||||||
|
return KernelResult.InvalidMemRange;
|
||||||
|
}
|
||||||
|
|
||||||
|
KernelResult result = dstProcess.MemoryManager.UnmapProcessMemory(dst, size, srcProcess.MemoryManager, src);
|
||||||
|
|
||||||
|
if (result != KernelResult.Success)
|
||||||
|
{
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
srcProcess.Context.InvalidateCacheRegion(src, size);
|
||||||
|
|
||||||
|
return KernelResult.Success;
|
||||||
|
}
|
||||||
|
|
||||||
public KernelResult MapProcessCodeMemory(int handle, ulong dst, ulong src, ulong size)
|
public KernelResult MapProcessCodeMemory(int handle, ulong dst, ulong src, ulong size)
|
||||||
{
|
{
|
||||||
if (!PageAligned(dst) || !PageAligned(src))
|
if (!PageAligned(dst) || !PageAligned(src))
|
||||||
|
@ -1391,43 +1632,6 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
|
||||||
return targetProcess.MemoryManager.UnmapProcessCodeMemory(dst, src, size);
|
return targetProcess.MemoryManager.UnmapProcessCodeMemory(dst, src, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
public KernelResult SetProcessMemoryPermission(int handle, ulong src, ulong size, KMemoryPermission permission)
|
|
||||||
{
|
|
||||||
if (!PageAligned(src))
|
|
||||||
{
|
|
||||||
return KernelResult.InvalidAddress;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!PageAligned(size) || size == 0)
|
|
||||||
{
|
|
||||||
return KernelResult.InvalidSize;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (permission != KMemoryPermission.None &&
|
|
||||||
permission != KMemoryPermission.Read &&
|
|
||||||
permission != KMemoryPermission.ReadAndWrite &&
|
|
||||||
permission != KMemoryPermission.ReadAndExecute)
|
|
||||||
{
|
|
||||||
return KernelResult.InvalidPermission;
|
|
||||||
}
|
|
||||||
|
|
||||||
KProcess currentProcess = KernelStatic.GetCurrentProcess();
|
|
||||||
|
|
||||||
KProcess targetProcess = currentProcess.HandleTable.GetObject<KProcess>(handle);
|
|
||||||
|
|
||||||
if (targetProcess == null)
|
|
||||||
{
|
|
||||||
return KernelResult.InvalidHandle;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (targetProcess.MemoryManager.OutsideAddrSpace(src, size))
|
|
||||||
{
|
|
||||||
return KernelResult.InvalidMemState;
|
|
||||||
}
|
|
||||||
|
|
||||||
return targetProcess.MemoryManager.SetProcessMemoryPermission(src, size, permission);
|
|
||||||
}
|
|
||||||
|
|
||||||
private static bool PageAligned(ulong address)
|
private static bool PageAligned(ulong address)
|
||||||
{
|
{
|
||||||
return (address & (KPageTableBase.PageSize - 1)) == 0;
|
return (address & (KPageTableBase.PageSize - 1)) == 0;
|
||||||
|
|
|
@ -160,6 +160,16 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
|
||||||
return _syscall.CreateTransferMemory(out handle, address, size, permission);
|
return _syscall.CreateTransferMemory(out handle, address, size, permission);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
public KernelResult CreateCodeMemory64([R(1)] ulong address, [R(2)] ulong size, [R(1)] out int handle)
|
||||||
|
{
|
||||||
|
return _syscall.CreateCodeMemory(address, size, out handle);
|
||||||
|
}
|
||||||
|
|
||||||
|
public KernelResult ControlCodeMemory64([R(0)] int handle, [R(1)] CodeMemoryOperation op, [R(2)] ulong address, [R(3)] ulong size, [R(4)] KMemoryPermission permission)
|
||||||
|
{
|
||||||
|
return _syscall.ControlCodeMemory(handle, op, address, size, permission);
|
||||||
|
}
|
||||||
|
|
||||||
public KernelResult MapTransferMemory64([R(0)] int handle, [R(1)] ulong address, [R(2)] ulong size, [R(3)] KMemoryPermission permission)
|
public KernelResult MapTransferMemory64([R(0)] int handle, [R(1)] ulong address, [R(2)] ulong size, [R(3)] KMemoryPermission permission)
|
||||||
{
|
{
|
||||||
return _syscall.MapTransferMemory(handle, address, size, permission);
|
return _syscall.MapTransferMemory(handle, address, size, permission);
|
||||||
|
@ -180,6 +190,21 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
|
||||||
return _syscall.UnmapPhysicalMemory(address, size);
|
return _syscall.UnmapPhysicalMemory(address, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
public KernelResult SetProcessMemoryPermission64([R(0)] int handle, [R(1)] ulong src, [R(2)] ulong size, [R(3)] KMemoryPermission permission)
|
||||||
|
{
|
||||||
|
return _syscall.SetProcessMemoryPermission(handle, src, size, permission);
|
||||||
|
}
|
||||||
|
|
||||||
|
public KernelResult MapProcessMemory64([R(0)] ulong dst, [R(1)] int handle, [R(2)] ulong src, [R(3)] ulong size)
|
||||||
|
{
|
||||||
|
return _syscall.MapProcessMemory(dst, handle, src, size);
|
||||||
|
}
|
||||||
|
|
||||||
|
public KernelResult UnmapProcessMemory64([R(0)] ulong dst, [R(1)] int handle, [R(2)] ulong src, [R(3)] ulong size)
|
||||||
|
{
|
||||||
|
return _syscall.UnmapProcessMemory(dst, handle, src, size);
|
||||||
|
}
|
||||||
|
|
||||||
public KernelResult MapProcessCodeMemory64([R(0)] int handle, [R(1)] ulong dst, [R(2)] ulong src, [R(3)] ulong size)
|
public KernelResult MapProcessCodeMemory64([R(0)] int handle, [R(1)] ulong dst, [R(2)] ulong src, [R(3)] ulong size)
|
||||||
{
|
{
|
||||||
return _syscall.MapProcessCodeMemory(handle, dst, src, size);
|
return _syscall.MapProcessCodeMemory(handle, dst, src, size);
|
||||||
|
@ -190,11 +215,6 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
|
||||||
return _syscall.UnmapProcessCodeMemory(handle, dst, src, size);
|
return _syscall.UnmapProcessCodeMemory(handle, dst, src, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
public KernelResult SetProcessMemoryPermission64([R(0)] int handle, [R(1)] ulong src, [R(2)] ulong size, [R(3)] KMemoryPermission permission)
|
|
||||||
{
|
|
||||||
return _syscall.SetProcessMemoryPermission(handle, src, size, permission);
|
|
||||||
}
|
|
||||||
|
|
||||||
// System
|
// System
|
||||||
|
|
||||||
public void ExitProcess64()
|
public void ExitProcess64()
|
||||||
|
|
|
@ -78,6 +78,8 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
|
||||||
{ 0x43, nameof(Syscall64.ReplyAndReceive64) },
|
{ 0x43, nameof(Syscall64.ReplyAndReceive64) },
|
||||||
{ 0x44, nameof(Syscall64.ReplyAndReceiveWithUserBuffer64) },
|
{ 0x44, nameof(Syscall64.ReplyAndReceiveWithUserBuffer64) },
|
||||||
{ 0x45, nameof(Syscall64.CreateEvent64) },
|
{ 0x45, nameof(Syscall64.CreateEvent64) },
|
||||||
|
{ 0x4b, nameof(Syscall64.CreateCodeMemory64) },
|
||||||
|
{ 0x4c, nameof(Syscall64.ControlCodeMemory64) },
|
||||||
{ 0x51, nameof(Syscall64.MapTransferMemory64) },
|
{ 0x51, nameof(Syscall64.MapTransferMemory64) },
|
||||||
{ 0x52, nameof(Syscall64.UnmapTransferMemory64) },
|
{ 0x52, nameof(Syscall64.UnmapTransferMemory64) },
|
||||||
{ 0x65, nameof(Syscall64.GetProcessList64) },
|
{ 0x65, nameof(Syscall64.GetProcessList64) },
|
||||||
|
@ -86,6 +88,8 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
|
||||||
{ 0x71, nameof(Syscall64.ManageNamedPort64) },
|
{ 0x71, nameof(Syscall64.ManageNamedPort64) },
|
||||||
{ 0x72, nameof(Syscall64.ConnectToPort64) },
|
{ 0x72, nameof(Syscall64.ConnectToPort64) },
|
||||||
{ 0x73, nameof(Syscall64.SetProcessMemoryPermission64) },
|
{ 0x73, nameof(Syscall64.SetProcessMemoryPermission64) },
|
||||||
|
{ 0x74, nameof(Syscall64.MapProcessMemory64) },
|
||||||
|
{ 0x75, nameof(Syscall64.UnmapProcessMemory64) },
|
||||||
{ 0x77, nameof(Syscall64.MapProcessCodeMemory64) },
|
{ 0x77, nameof(Syscall64.MapProcessCodeMemory64) },
|
||||||
{ 0x78, nameof(Syscall64.UnmapProcessCodeMemory64) },
|
{ 0x78, nameof(Syscall64.UnmapProcessCodeMemory64) },
|
||||||
{ 0x7B, nameof(Syscall64.TerminateProcess64) },
|
{ 0x7B, nameof(Syscall64.TerminateProcess64) },
|
||||||
|
|
|
@ -1,8 +1,31 @@
|
||||||
namespace Ryujinx.HLE.HOS.Services.Pm
|
using Ryujinx.HLE.HOS.Ipc;
|
||||||
|
using Ryujinx.HLE.HOS.Kernel;
|
||||||
|
using Ryujinx.HLE.HOS.Kernel.Common;
|
||||||
|
using Ryujinx.HLE.HOS.Kernel.Process;
|
||||||
|
|
||||||
|
namespace Ryujinx.HLE.HOS.Services.Pm
|
||||||
{
|
{
|
||||||
[Service("pm:dmnt")]
|
[Service("pm:dmnt")]
|
||||||
class IDebugMonitorInterface : IpcService
|
class IDebugMonitorInterface : IpcService
|
||||||
{
|
{
|
||||||
public IDebugMonitorInterface(ServiceCtx context) { }
|
public IDebugMonitorInterface(ServiceCtx context) { }
|
||||||
|
|
||||||
|
[CommandHipc(65000)]
|
||||||
|
// AtmosphereGetProcessInfo(os::ProcessId process_id) -> sf::OutCopyHandle out_process_handle, sf::Out<ncm::ProgramLocation> out_loc, sf::Out<cfg::OverrideStatus> out_status
|
||||||
|
public ResultCode GetProcessInfo(ServiceCtx context)
|
||||||
|
{
|
||||||
|
long pid = context.RequestData.ReadInt64();
|
||||||
|
|
||||||
|
KProcess process = KernelStatic.GetProcessByPid(pid);
|
||||||
|
|
||||||
|
if (context.Process.HandleTable.GenerateHandle(process, out int processHandle) != KernelResult.Success)
|
||||||
|
{
|
||||||
|
throw new System.Exception("Out of handles!");
|
||||||
|
}
|
||||||
|
|
||||||
|
context.Response.HandleDesc = IpcHandleDesc.MakeCopy(processHandle);
|
||||||
|
|
||||||
|
return ResultCode.Success;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
|
@ -49,7 +49,7 @@ namespace Ryujinx.HLE
|
||||||
UiHandler = Configuration.HostUiHandler;
|
UiHandler = Configuration.HostUiHandler;
|
||||||
|
|
||||||
AudioDeviceDriver = new CompatLayerHardwareDeviceDriver(Configuration.AudioDeviceDriver);
|
AudioDeviceDriver = new CompatLayerHardwareDeviceDriver(Configuration.AudioDeviceDriver);
|
||||||
Memory = new MemoryBlock(Configuration.MemoryConfiguration.ToDramSize(), MemoryAllocationFlags.Reserve);
|
Memory = new MemoryBlock(Configuration.MemoryConfiguration.ToDramSize(), MemoryAllocationFlags.Reserve | MemoryAllocationFlags.Mirrorable);
|
||||||
Gpu = new GpuContext(Configuration.GpuRenderer);
|
Gpu = new GpuContext(Configuration.GpuRenderer);
|
||||||
System = new Horizon(this);
|
System = new Horizon(this);
|
||||||
Statistics = new PerformanceStatistics();
|
Statistics = new PerformanceStatistics();
|
||||||
|
|
|
@ -14,7 +14,7 @@ namespace Ryujinx.Memory.Tests
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
public void Map(ulong va, nuint hostAddress, ulong size)
|
public void Map(ulong va, ulong pa, ulong size)
|
||||||
{
|
{
|
||||||
throw new NotImplementedException();
|
throw new NotImplementedException();
|
||||||
}
|
}
|
||||||
|
@ -59,9 +59,9 @@ namespace Ryujinx.Memory.Tests
|
||||||
throw new NotImplementedException();
|
throw new NotImplementedException();
|
||||||
}
|
}
|
||||||
|
|
||||||
IEnumerable<HostMemoryRange> IVirtualMemoryManager.GetPhysicalRegions(ulong va, ulong size)
|
IEnumerable<MemoryRange> IVirtualMemoryManager.GetPhysicalRegions(ulong va, ulong size)
|
||||||
{
|
{
|
||||||
return NoMappings ? new HostMemoryRange[0] : new HostMemoryRange[] { new HostMemoryRange((nuint)va, size) };
|
return NoMappings ? new MemoryRange[0] : new MemoryRange[] { new MemoryRange(va, size) };
|
||||||
}
|
}
|
||||||
|
|
||||||
public bool IsMapped(ulong va)
|
public bool IsMapped(ulong va)
|
||||||
|
|
|
@ -13,9 +13,9 @@ namespace Ryujinx.Memory
|
||||||
/// </summary>
|
/// </summary>
|
||||||
public sealed class AddressSpaceManager : IVirtualMemoryManager, IWritableBlock
|
public sealed class AddressSpaceManager : IVirtualMemoryManager, IWritableBlock
|
||||||
{
|
{
|
||||||
public const int PageBits = PageTable<nuint>.PageBits;
|
public const int PageBits = PageTable<ulong>.PageBits;
|
||||||
public const int PageSize = PageTable<nuint>.PageSize;
|
public const int PageSize = PageTable<ulong>.PageSize;
|
||||||
public const int PageMask = PageTable<nuint>.PageMask;
|
public const int PageMask = PageTable<ulong>.PageMask;
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Address space width in bits.
|
/// Address space width in bits.
|
||||||
|
@ -24,14 +24,15 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
private readonly ulong _addressSpaceSize;
|
private readonly ulong _addressSpaceSize;
|
||||||
|
|
||||||
private readonly PageTable<nuint> _pageTable;
|
private readonly MemoryBlock _backingMemory;
|
||||||
|
private readonly PageTable<ulong> _pageTable;
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Creates a new instance of the memory manager.
|
/// Creates a new instance of the memory manager.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
/// <param name="backingMemory">Physical backing memory where virtual memory will be mapped to</param>
|
/// <param name="backingMemory">Physical backing memory where virtual memory will be mapped to</param>
|
||||||
/// <param name="addressSpaceSize">Size of the address space</param>
|
/// <param name="addressSpaceSize">Size of the address space</param>
|
||||||
public AddressSpaceManager(ulong addressSpaceSize)
|
public AddressSpaceManager(MemoryBlock backingMemory, ulong addressSpaceSize)
|
||||||
{
|
{
|
||||||
ulong asSize = PageSize;
|
ulong asSize = PageSize;
|
||||||
int asBits = PageBits;
|
int asBits = PageBits;
|
||||||
|
@ -44,37 +45,26 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
AddressSpaceBits = asBits;
|
AddressSpaceBits = asBits;
|
||||||
_addressSpaceSize = asSize;
|
_addressSpaceSize = asSize;
|
||||||
_pageTable = new PageTable<nuint>();
|
_backingMemory = backingMemory;
|
||||||
|
_pageTable = new PageTable<ulong>();
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <inheritdoc/>
|
||||||
/// Maps a virtual memory range into a physical memory range.
|
public void Map(ulong va, ulong pa, ulong size)
|
||||||
/// </summary>
|
|
||||||
/// <remarks>
|
|
||||||
/// Addresses and size must be page aligned.
|
|
||||||
/// </remarks>
|
|
||||||
/// <param name="va">Virtual memory address</param>
|
|
||||||
/// <param name="hostAddress">Physical memory address</param>
|
|
||||||
/// <param name="size">Size to be mapped</param>
|
|
||||||
public void Map(ulong va, nuint hostAddress, ulong size)
|
|
||||||
{
|
{
|
||||||
AssertValidAddressAndSize(va, size);
|
AssertValidAddressAndSize(va, size);
|
||||||
|
|
||||||
while (size != 0)
|
while (size != 0)
|
||||||
{
|
{
|
||||||
_pageTable.Map(va, hostAddress);
|
_pageTable.Map(va, pa);
|
||||||
|
|
||||||
va += PageSize;
|
va += PageSize;
|
||||||
hostAddress += PageSize;
|
pa += PageSize;
|
||||||
size -= PageSize;
|
size -= PageSize;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <inheritdoc/>
|
||||||
/// 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>
|
|
||||||
public void Unmap(ulong va, ulong size)
|
public void Unmap(ulong va, ulong size)
|
||||||
{
|
{
|
||||||
AssertValidAddressAndSize(va, size);
|
AssertValidAddressAndSize(va, size);
|
||||||
|
@ -88,47 +78,25 @@ namespace Ryujinx.Memory
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <inheritdoc/>
|
||||||
/// Reads data from 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>
|
|
||||||
public T Read<T>(ulong va) where T : unmanaged
|
public T Read<T>(ulong va) where T : unmanaged
|
||||||
{
|
{
|
||||||
return MemoryMarshal.Cast<byte, T>(GetSpan(va, Unsafe.SizeOf<T>()))[0];
|
return MemoryMarshal.Cast<byte, T>(GetSpan(va, Unsafe.SizeOf<T>()))[0];
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <inheritdoc/>
|
||||||
/// Reads data from 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>
|
|
||||||
public void Read(ulong va, Span<byte> data)
|
public void Read(ulong va, Span<byte> data)
|
||||||
{
|
{
|
||||||
ReadImpl(va, data);
|
ReadImpl(va, data);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <inheritdoc/>
|
||||||
/// Writes data to 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>
|
|
||||||
public void Write<T>(ulong va, T value) where T : unmanaged
|
public void Write<T>(ulong va, T value) where T : unmanaged
|
||||||
{
|
{
|
||||||
Write(va, MemoryMarshal.Cast<T, byte>(MemoryMarshal.CreateSpan(ref value, 1)));
|
Write(va, MemoryMarshal.Cast<T, byte>(MemoryMarshal.CreateSpan(ref value, 1)));
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <inheritdoc/>
|
||||||
/// Writes data to mapped memory.
|
|
||||||
/// </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>
|
|
||||||
public void Write(ulong va, ReadOnlySpan<byte> data)
|
public void Write(ulong va, ReadOnlySpan<byte> data)
|
||||||
{
|
{
|
||||||
if (data.Length == 0)
|
if (data.Length == 0)
|
||||||
|
@ -140,7 +108,7 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
if (IsContiguousAndMapped(va, data.Length))
|
if (IsContiguousAndMapped(va, data.Length))
|
||||||
{
|
{
|
||||||
data.CopyTo(GetHostSpanContiguous(va, data.Length));
|
data.CopyTo(_backingMemory.GetSpan(GetPhysicalAddressInternal(va), data.Length));
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -148,34 +116,27 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
if ((va & PageMask) != 0)
|
if ((va & PageMask) != 0)
|
||||||
{
|
{
|
||||||
|
ulong pa = GetPhysicalAddressInternal(va);
|
||||||
|
|
||||||
size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
|
size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
|
||||||
|
|
||||||
data.Slice(0, size).CopyTo(GetHostSpanContiguous(va, size));
|
data.Slice(0, size).CopyTo(_backingMemory.GetSpan(pa, size));
|
||||||
|
|
||||||
offset += size;
|
offset += size;
|
||||||
}
|
}
|
||||||
|
|
||||||
for (; offset < data.Length; offset += size)
|
for (; offset < data.Length; offset += size)
|
||||||
{
|
{
|
||||||
|
ulong pa = GetPhysicalAddressInternal(va + (ulong)offset);
|
||||||
|
|
||||||
size = Math.Min(data.Length - offset, PageSize);
|
size = Math.Min(data.Length - offset, PageSize);
|
||||||
|
|
||||||
data.Slice(offset, size).CopyTo(GetHostSpanContiguous(va + (ulong)offset, size));
|
data.Slice(offset, size).CopyTo(_backingMemory.GetSpan(pa, size));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <inheritdoc/>
|
||||||
/// Gets a read-only span of data from mapped memory.
|
|
||||||
/// </summary>
|
|
||||||
/// <remarks>
|
|
||||||
/// This may perform a allocation if the data is not contiguous in memory.
|
|
||||||
/// For this reason, the span is read-only, you can't modify the data.
|
|
||||||
/// </remarks>
|
|
||||||
/// <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>
|
|
||||||
public ReadOnlySpan<byte> GetSpan(ulong va, int size, bool tracked = false)
|
public ReadOnlySpan<byte> GetSpan(ulong va, int size, bool tracked = false)
|
||||||
{
|
{
|
||||||
if (size == 0)
|
if (size == 0)
|
||||||
|
@ -185,7 +146,7 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
if (IsContiguousAndMapped(va, size))
|
if (IsContiguousAndMapped(va, size))
|
||||||
{
|
{
|
||||||
return GetHostSpanContiguous(va, size);
|
return _backingMemory.GetSpan(GetPhysicalAddressInternal(va), size);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -197,19 +158,7 @@ namespace Ryujinx.Memory
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <inheritdoc/>
|
||||||
/// Gets a region of memory that can be written to.
|
|
||||||
/// </summary>
|
|
||||||
/// <remarks>
|
|
||||||
/// If the requested region is not contiguous in physical memory,
|
|
||||||
/// this will perform an allocation, and flush the data (writing it
|
|
||||||
/// back to the backing memory) on disposal.
|
|
||||||
/// </remarks>
|
|
||||||
/// <param name="va">Virtual address of the data</param>
|
|
||||||
/// <param name="size">Size of the data</param>
|
|
||||||
/// <param name="tracked">True if write tracking is triggered on the span</param>
|
|
||||||
/// <returns>A writable region of memory containing the data</returns>
|
|
||||||
/// <exception cref="InvalidMemoryRegionException">Throw for unhandled invalid or unmapped memory accesses</exception>
|
|
||||||
public unsafe WritableRegion GetWritableRegion(ulong va, int size, bool tracked = false)
|
public unsafe WritableRegion GetWritableRegion(ulong va, int size, bool tracked = false)
|
||||||
{
|
{
|
||||||
if (size == 0)
|
if (size == 0)
|
||||||
|
@ -219,7 +168,7 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
if (IsContiguousAndMapped(va, size))
|
if (IsContiguousAndMapped(va, size))
|
||||||
{
|
{
|
||||||
return new WritableRegion(null, va, new NativeMemoryManager<byte>((byte*)GetHostAddress(va), size).Memory);
|
return new WritableRegion(null, va, _backingMemory.GetMemory(GetPhysicalAddressInternal(va), size));
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -231,33 +180,18 @@ namespace Ryujinx.Memory
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <inheritdoc/>
|
||||||
/// Gets a reference for the given type at the specified virtual memory address.
|
public ref T GetRef<T>(ulong va) where T : unmanaged
|
||||||
/// </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>
|
|
||||||
public unsafe ref T GetRef<T>(ulong va) where T : unmanaged
|
|
||||||
{
|
{
|
||||||
if (!IsContiguous(va, Unsafe.SizeOf<T>()))
|
if (!IsContiguous(va, Unsafe.SizeOf<T>()))
|
||||||
{
|
{
|
||||||
ThrowMemoryNotContiguous();
|
ThrowMemoryNotContiguous();
|
||||||
}
|
}
|
||||||
|
|
||||||
return ref *(T*)GetHostAddress(va);
|
return ref _backingMemory.GetRef<T>(GetPhysicalAddressInternal(va));
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <inheritdoc/>
|
||||||
/// Computes the number of pages in a virtual address range.
|
|
||||||
/// </summary>
|
|
||||||
/// <param name="va">Virtual address of the range</param>
|
|
||||||
/// <param name="size">Size of the range</param>
|
|
||||||
/// <param name="startVa">The virtual address of the beginning of the first page</param>
|
|
||||||
/// <remarks>This function does not differentiate between allocated and unallocated pages.</remarks>
|
|
||||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||||
private int GetPagesCount(ulong va, uint size, out ulong startVa)
|
private int GetPagesCount(ulong va, uint size, out ulong startVa)
|
||||||
{
|
{
|
||||||
|
@ -268,7 +202,7 @@ namespace Ryujinx.Memory
|
||||||
return (int)(vaSpan / PageSize);
|
return (int)(vaSpan / PageSize);
|
||||||
}
|
}
|
||||||
|
|
||||||
private void ThrowMemoryNotContiguous() => throw new MemoryNotContiguousException();
|
private static void ThrowMemoryNotContiguous() => throw new MemoryNotContiguousException();
|
||||||
|
|
||||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||||
private bool IsContiguousAndMapped(ulong va, int size) => IsContiguous(va, size) && IsMapped(va);
|
private bool IsContiguousAndMapped(ulong va, int size) => IsContiguous(va, size) && IsMapped(va);
|
||||||
|
@ -290,7 +224,7 @@ namespace Ryujinx.Memory
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (GetHostAddress(va) + PageSize != GetHostAddress(va + PageSize))
|
if (GetPhysicalAddressInternal(va) + PageSize != GetPhysicalAddressInternal(va + PageSize))
|
||||||
{
|
{
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
@ -301,18 +235,12 @@ namespace Ryujinx.Memory
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <inheritdoc/>
|
||||||
/// Gets the physical regions that make up the given virtual address region.
|
public IEnumerable<MemoryRange> GetPhysicalRegions(ulong va, ulong size)
|
||||||
/// 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>
|
|
||||||
public IEnumerable<HostMemoryRange> GetPhysicalRegions(ulong va, ulong size)
|
|
||||||
{
|
{
|
||||||
if (size == 0)
|
if (size == 0)
|
||||||
{
|
{
|
||||||
return Enumerable.Empty<HostMemoryRange>();
|
return Enumerable.Empty<MemoryRange>();
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!ValidateAddress(va) || !ValidateAddressAndSize(va, size))
|
if (!ValidateAddress(va) || !ValidateAddressAndSize(va, size))
|
||||||
|
@ -322,9 +250,9 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
int pages = GetPagesCount(va, (uint)size, out va);
|
int pages = GetPagesCount(va, (uint)size, out va);
|
||||||
|
|
||||||
var regions = new List<HostMemoryRange>();
|
var regions = new List<MemoryRange>();
|
||||||
|
|
||||||
nuint regionStart = GetHostAddress(va);
|
ulong regionStart = GetPhysicalAddressInternal(va);
|
||||||
ulong regionSize = PageSize;
|
ulong regionSize = PageSize;
|
||||||
|
|
||||||
for (int page = 0; page < pages - 1; page++)
|
for (int page = 0; page < pages - 1; page++)
|
||||||
|
@ -334,12 +262,12 @@ namespace Ryujinx.Memory
|
||||||
return null;
|
return null;
|
||||||
}
|
}
|
||||||
|
|
||||||
nuint newHostAddress = GetHostAddress(va + PageSize);
|
ulong newPa = GetPhysicalAddressInternal(va + PageSize);
|
||||||
|
|
||||||
if (GetHostAddress(va) + PageSize != newHostAddress)
|
if (GetPhysicalAddressInternal(va) + PageSize != newPa)
|
||||||
{
|
{
|
||||||
regions.Add(new HostMemoryRange(regionStart, regionSize));
|
regions.Add(new MemoryRange(regionStart, regionSize));
|
||||||
regionStart = newHostAddress;
|
regionStart = newPa;
|
||||||
regionSize = 0;
|
regionSize = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -347,7 +275,7 @@ namespace Ryujinx.Memory
|
||||||
regionSize += PageSize;
|
regionSize += PageSize;
|
||||||
}
|
}
|
||||||
|
|
||||||
regions.Add(new HostMemoryRange(regionStart, regionSize));
|
regions.Add(new MemoryRange(regionStart, regionSize));
|
||||||
|
|
||||||
return regions;
|
return regions;
|
||||||
}
|
}
|
||||||
|
@ -365,26 +293,26 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
if ((va & PageMask) != 0)
|
if ((va & PageMask) != 0)
|
||||||
{
|
{
|
||||||
|
ulong pa = GetPhysicalAddressInternal(va);
|
||||||
|
|
||||||
size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
|
size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
|
||||||
|
|
||||||
GetHostSpanContiguous(va, size).CopyTo(data.Slice(0, size));
|
_backingMemory.GetSpan(pa, size).CopyTo(data.Slice(0, size));
|
||||||
|
|
||||||
offset += size;
|
offset += size;
|
||||||
}
|
}
|
||||||
|
|
||||||
for (; offset < data.Length; offset += size)
|
for (; offset < data.Length; offset += size)
|
||||||
{
|
{
|
||||||
|
ulong pa = GetPhysicalAddressInternal(va + (ulong)offset);
|
||||||
|
|
||||||
size = Math.Min(data.Length - offset, PageSize);
|
size = Math.Min(data.Length - offset, PageSize);
|
||||||
|
|
||||||
GetHostSpanContiguous(va + (ulong)offset, size).CopyTo(data.Slice(offset, size));
|
_backingMemory.GetSpan(pa, size).CopyTo(data.Slice(offset, size));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <inheritdoc/>
|
||||||
/// Checks if the page at a given virtual address is mapped.
|
|
||||||
/// </summary>
|
|
||||||
/// <param name="va">Virtual address to check</param>
|
|
||||||
/// <returns>True if the address is mapped, false otherwise</returns>
|
|
||||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||||
public bool IsMapped(ulong va)
|
public bool IsMapped(ulong va)
|
||||||
{
|
{
|
||||||
|
@ -396,12 +324,7 @@ namespace Ryujinx.Memory
|
||||||
return _pageTable.Read(va) != 0;
|
return _pageTable.Read(va) != 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <inheritdoc/>
|
||||||
/// 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>
|
|
||||||
public bool IsRangeMapped(ulong va, ulong size)
|
public bool IsRangeMapped(ulong va, ulong size)
|
||||||
{
|
{
|
||||||
if (size == 0UL)
|
if (size == 0UL)
|
||||||
|
@ -460,14 +383,20 @@ namespace Ryujinx.Memory
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
private unsafe Span<byte> GetHostSpanContiguous(ulong va, int size)
|
private ulong GetPhysicalAddress(ulong va)
|
||||||
{
|
{
|
||||||
return new Span<byte>((void*)GetHostAddress(va), size);
|
// We return -1L if the virtual address is invalid or unmapped.
|
||||||
|
if (!ValidateAddress(va) || !IsMapped(va))
|
||||||
|
{
|
||||||
|
return ulong.MaxValue;
|
||||||
}
|
}
|
||||||
|
|
||||||
private nuint GetHostAddress(ulong va)
|
return GetPhysicalAddressInternal(va);
|
||||||
|
}
|
||||||
|
|
||||||
|
private ulong GetPhysicalAddressInternal(ulong va)
|
||||||
{
|
{
|
||||||
return _pageTable.Read(va) + (nuint)(va & PageMask);
|
return _pageTable.Read(va) + (va & PageMask);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
|
|
@ -13,9 +13,9 @@ namespace Ryujinx.Memory
|
||||||
/// Addresses and size must be page aligned.
|
/// Addresses and size must be page aligned.
|
||||||
/// </remarks>
|
/// </remarks>
|
||||||
/// <param name="va">Virtual memory address</param>
|
/// <param name="va">Virtual memory address</param>
|
||||||
/// <param name="hostAddress">Pointer where the region should be mapped to</param>
|
/// <param name="pa">Physical memory address where the region should be mapped to</param>
|
||||||
/// <param name="size">Size to be mapped</param>
|
/// <param name="size">Size to be mapped</param>
|
||||||
void Map(ulong va, nuint hostAddress, ulong size);
|
void Map(ulong va, ulong pa, ulong size);
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Unmaps a previously mapped range of virtual memory.
|
/// Unmaps a previously mapped range of virtual memory.
|
||||||
|
@ -111,7 +111,7 @@ namespace Ryujinx.Memory
|
||||||
/// <param name="va">Virtual address of the range</param>
|
/// <param name="va">Virtual address of the range</param>
|
||||||
/// <param name="size">Size of the range</param>
|
/// <param name="size">Size of the range</param>
|
||||||
/// <returns>Array of physical regions</returns>
|
/// <returns>Array of physical regions</returns>
|
||||||
IEnumerable<HostMemoryRange> GetPhysicalRegions(ulong va, ulong size);
|
IEnumerable<MemoryRange> GetPhysicalRegions(ulong va, ulong size);
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Checks if the page at a given CPU virtual address is mapped.
|
/// Checks if the page at a given CPU virtual address is mapped.
|
||||||
|
|
|
@ -29,6 +29,12 @@ namespace Ryujinx.Memory
|
||||||
/// Enables mirroring of the memory block through aliasing of memory pages.
|
/// Enables mirroring of the memory block through aliasing of memory pages.
|
||||||
/// When enabled, this allows creating more memory blocks sharing the same backing storage.
|
/// When enabled, this allows creating more memory blocks sharing the same backing storage.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
Mirrorable = 1 << 2
|
Mirrorable = 1 << 2,
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Indicates that the memory block should support mapping views of a mirrorable memory block.
|
||||||
|
/// The block that is to have their views mapped should be created with the <see cref="Mirrorable"/> flag.
|
||||||
|
/// </summary>
|
||||||
|
ViewCompatible = 1 << 3
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -11,6 +11,7 @@ namespace Ryujinx.Memory
|
||||||
{
|
{
|
||||||
private readonly bool _usesSharedMemory;
|
private readonly bool _usesSharedMemory;
|
||||||
private readonly bool _isMirror;
|
private readonly bool _isMirror;
|
||||||
|
private readonly bool _viewCompatible;
|
||||||
private IntPtr _sharedMemory;
|
private IntPtr _sharedMemory;
|
||||||
private IntPtr _pointer;
|
private IntPtr _pointer;
|
||||||
|
|
||||||
|
@ -41,7 +42,8 @@ namespace Ryujinx.Memory
|
||||||
}
|
}
|
||||||
else if (flags.HasFlag(MemoryAllocationFlags.Reserve))
|
else if (flags.HasFlag(MemoryAllocationFlags.Reserve))
|
||||||
{
|
{
|
||||||
_pointer = MemoryManagement.Reserve(size);
|
_viewCompatible = flags.HasFlag(MemoryAllocationFlags.ViewCompatible);
|
||||||
|
_pointer = MemoryManagement.Reserve(size, _viewCompatible);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -112,6 +114,36 @@ namespace Ryujinx.Memory
|
||||||
return MemoryManagement.Decommit(GetPointerInternal(offset, size), size);
|
return MemoryManagement.Decommit(GetPointerInternal(offset, size), size);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Maps a view of memory from another memory block.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="srcBlock">Memory block from where the backing memory will be taken</param>
|
||||||
|
/// <param name="srcOffset">Offset on <paramref name="srcBlock"/> of the region that should be mapped</param>
|
||||||
|
/// <param name="dstOffset">Offset to map the view into on this block</param>
|
||||||
|
/// <param name="size">Size of the range to be mapped</param>
|
||||||
|
/// <exception cref="NotSupportedException">Throw when the source memory block does not support mirroring</exception>
|
||||||
|
/// <exception cref="ObjectDisposedException">Throw when the memory block has already been disposed</exception>
|
||||||
|
/// <exception cref="InvalidMemoryRegionException">Throw when either <paramref name="offset"/> or <paramref name="size"/> are out of range</exception>
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Unmaps a view of memory from another memory block.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="offset">Offset of the view previously mapped with <see cref="MapView"/></param>
|
||||||
|
/// <param name="size">Size of the range to be unmapped</param>
|
||||||
|
public void UnmapView(ulong offset, ulong size)
|
||||||
|
{
|
||||||
|
MemoryManagement.UnmapView(GetPointerInternal(offset, size), size);
|
||||||
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Reprotects a region of memory.
|
/// Reprotects a region of memory.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
|
@ -124,7 +156,7 @@ namespace Ryujinx.Memory
|
||||||
/// <exception cref="MemoryProtectionException">Throw when <paramref name="permission"/> is invalid</exception>
|
/// <exception cref="MemoryProtectionException">Throw when <paramref name="permission"/> is invalid</exception>
|
||||||
public void Reprotect(ulong offset, ulong size, MemoryPermission permission, bool throwOnFail = true)
|
public void Reprotect(ulong offset, ulong size, MemoryPermission permission, bool throwOnFail = true)
|
||||||
{
|
{
|
||||||
MemoryManagement.Reprotect(GetPointerInternal(offset, size), size, permission, throwOnFail);
|
MemoryManagement.Reprotect(GetPointerInternal(offset, size), size, permission, _viewCompatible, throwOnFail);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
@ -382,7 +414,27 @@ namespace Ryujinx.Memory
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
private void ThrowObjectDisposed() => throw new ObjectDisposedException(nameof(MemoryBlock));
|
/// <summary>
|
||||||
private void ThrowInvalidMemoryRegionException() => throw new InvalidMemoryRegionException();
|
/// Checks if the specified memory allocation flags are supported on the current platform.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="flags">Flags to be checked</param>
|
||||||
|
/// <returns>True if the platform supports all the flags, false otherwise</returns>
|
||||||
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static void ThrowObjectDisposed() => throw new ObjectDisposedException(nameof(MemoryBlock));
|
||||||
|
private static void ThrowInvalidMemoryRegionException() => throw new InvalidMemoryRegionException();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -12,8 +12,7 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
return MemoryManagementWindows.Allocate(sizeNint);
|
return MemoryManagementWindows.Allocate(sizeNint);
|
||||||
}
|
}
|
||||||
else if (OperatingSystem.IsLinux() ||
|
else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
|
||||||
OperatingSystem.IsMacOS())
|
|
||||||
{
|
{
|
||||||
return MemoryManagementUnix.Allocate(size);
|
return MemoryManagementUnix.Allocate(size);
|
||||||
}
|
}
|
||||||
|
@ -23,16 +22,15 @@ namespace Ryujinx.Memory
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
public static IntPtr Reserve(ulong size)
|
public static IntPtr Reserve(ulong size, bool viewCompatible)
|
||||||
{
|
{
|
||||||
if (OperatingSystem.IsWindows())
|
if (OperatingSystem.IsWindows())
|
||||||
{
|
{
|
||||||
IntPtr sizeNint = new IntPtr((long)size);
|
IntPtr sizeNint = new IntPtr((long)size);
|
||||||
|
|
||||||
return MemoryManagementWindows.Reserve(sizeNint);
|
return MemoryManagementWindows.Reserve(sizeNint, viewCompatible);
|
||||||
}
|
}
|
||||||
else if (OperatingSystem.IsLinux() ||
|
else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
|
||||||
OperatingSystem.IsMacOS())
|
|
||||||
{
|
{
|
||||||
return MemoryManagementUnix.Reserve(size);
|
return MemoryManagementUnix.Reserve(size);
|
||||||
}
|
}
|
||||||
|
@ -50,8 +48,7 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
return MemoryManagementWindows.Commit(address, sizeNint);
|
return MemoryManagementWindows.Commit(address, sizeNint);
|
||||||
}
|
}
|
||||||
else if (OperatingSystem.IsLinux() ||
|
else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
|
||||||
OperatingSystem.IsMacOS())
|
|
||||||
{
|
{
|
||||||
return MemoryManagementUnix.Commit(address, size);
|
return MemoryManagementUnix.Commit(address, size);
|
||||||
}
|
}
|
||||||
|
@ -69,8 +66,7 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
return MemoryManagementWindows.Decommit(address, sizeNint);
|
return MemoryManagementWindows.Decommit(address, sizeNint);
|
||||||
}
|
}
|
||||||
else if (OperatingSystem.IsLinux() ||
|
else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
|
||||||
OperatingSystem.IsMacOS())
|
|
||||||
{
|
{
|
||||||
return MemoryManagementUnix.Decommit(address, size);
|
return MemoryManagementUnix.Decommit(address, size);
|
||||||
}
|
}
|
||||||
|
@ -80,7 +76,43 @@ namespace Ryujinx.Memory
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
public static void Reprotect(IntPtr address, ulong size, MemoryPermission permission, bool throwOnFail)
|
public static void MapView(IntPtr sharedMemory, ulong srcOffset, IntPtr address, ulong size)
|
||||||
|
{
|
||||||
|
if (OperatingSystem.IsWindows())
|
||||||
|
{
|
||||||
|
IntPtr sizeNint = new IntPtr((long)size);
|
||||||
|
|
||||||
|
MemoryManagementWindows.MapView(sharedMemory, srcOffset, address, sizeNint);
|
||||||
|
}
|
||||||
|
else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
|
||||||
|
{
|
||||||
|
MemoryManagementUnix.Remap(address, (IntPtr)((ulong)sharedMemory + srcOffset), size);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
throw new PlatformNotSupportedException();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public static void UnmapView(IntPtr address, ulong size)
|
||||||
|
{
|
||||||
|
if (OperatingSystem.IsWindows())
|
||||||
|
{
|
||||||
|
IntPtr sizeNint = new IntPtr((long)size);
|
||||||
|
|
||||||
|
MemoryManagementWindows.UnmapView(address, sizeNint);
|
||||||
|
}
|
||||||
|
else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
|
||||||
|
{
|
||||||
|
MemoryManagementUnix.Unmap(address, size);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
throw new PlatformNotSupportedException();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public static void Reprotect(IntPtr address, ulong size, MemoryPermission permission, bool forView, bool throwOnFail)
|
||||||
{
|
{
|
||||||
bool result;
|
bool result;
|
||||||
|
|
||||||
|
@ -88,10 +120,9 @@ namespace Ryujinx.Memory
|
||||||
{
|
{
|
||||||
IntPtr sizeNint = new IntPtr((long)size);
|
IntPtr sizeNint = new IntPtr((long)size);
|
||||||
|
|
||||||
result = MemoryManagementWindows.Reprotect(address, sizeNint, permission);
|
result = MemoryManagementWindows.Reprotect(address, sizeNint, permission, forView);
|
||||||
}
|
}
|
||||||
else if (OperatingSystem.IsLinux() ||
|
else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
|
||||||
OperatingSystem.IsMacOS())
|
|
||||||
{
|
{
|
||||||
result = MemoryManagementUnix.Reprotect(address, size, permission);
|
result = MemoryManagementUnix.Reprotect(address, size, permission);
|
||||||
}
|
}
|
||||||
|
@ -112,8 +143,7 @@ namespace Ryujinx.Memory
|
||||||
{
|
{
|
||||||
return MemoryManagementWindows.Free(address);
|
return MemoryManagementWindows.Free(address);
|
||||||
}
|
}
|
||||||
else if (OperatingSystem.IsLinux() ||
|
else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
|
||||||
OperatingSystem.IsMacOS())
|
|
||||||
{
|
{
|
||||||
return MemoryManagementUnix.Free(address);
|
return MemoryManagementUnix.Free(address);
|
||||||
}
|
}
|
||||||
|
@ -131,8 +161,7 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
return MemoryManagementWindows.CreateSharedMemory(sizeNint, reserve);
|
return MemoryManagementWindows.CreateSharedMemory(sizeNint, reserve);
|
||||||
}
|
}
|
||||||
else if (OperatingSystem.IsLinux() ||
|
else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
|
||||||
OperatingSystem.IsMacOS())
|
|
||||||
{
|
{
|
||||||
return MemoryManagementUnix.CreateSharedMemory(size, reserve);
|
return MemoryManagementUnix.CreateSharedMemory(size, reserve);
|
||||||
}
|
}
|
||||||
|
@ -148,8 +177,7 @@ namespace Ryujinx.Memory
|
||||||
{
|
{
|
||||||
MemoryManagementWindows.DestroySharedMemory(handle);
|
MemoryManagementWindows.DestroySharedMemory(handle);
|
||||||
}
|
}
|
||||||
else if (OperatingSystem.IsLinux() ||
|
else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
|
||||||
OperatingSystem.IsMacOS())
|
|
||||||
{
|
{
|
||||||
MemoryManagementUnix.DestroySharedMemory(handle);
|
MemoryManagementUnix.DestroySharedMemory(handle);
|
||||||
}
|
}
|
||||||
|
@ -165,8 +193,7 @@ namespace Ryujinx.Memory
|
||||||
{
|
{
|
||||||
return MemoryManagementWindows.MapSharedMemory(handle);
|
return MemoryManagementWindows.MapSharedMemory(handle);
|
||||||
}
|
}
|
||||||
else if (OperatingSystem.IsLinux() ||
|
else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
|
||||||
OperatingSystem.IsMacOS())
|
|
||||||
{
|
{
|
||||||
return MemoryManagementUnix.MapSharedMemory(handle);
|
return MemoryManagementUnix.MapSharedMemory(handle);
|
||||||
}
|
}
|
||||||
|
@ -182,8 +209,7 @@ namespace Ryujinx.Memory
|
||||||
{
|
{
|
||||||
MemoryManagementWindows.UnmapSharedMemory(address);
|
MemoryManagementWindows.UnmapSharedMemory(address);
|
||||||
}
|
}
|
||||||
else if (OperatingSystem.IsLinux() ||
|
else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
|
||||||
OperatingSystem.IsMacOS())
|
|
||||||
{
|
{
|
||||||
MemoryManagementUnix.UnmapSharedMemory(address);
|
MemoryManagementUnix.UnmapSharedMemory(address);
|
||||||
}
|
}
|
||||||
|
@ -195,8 +221,7 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
public static IntPtr Remap(IntPtr target, IntPtr source, ulong size)
|
public static IntPtr Remap(IntPtr target, IntPtr source, ulong size)
|
||||||
{
|
{
|
||||||
if (OperatingSystem.IsLinux() ||
|
if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
|
||||||
OperatingSystem.IsMacOS())
|
|
||||||
{
|
{
|
||||||
return MemoryManagementUnix.Remap(target, source, size);
|
return MemoryManagementUnix.Remap(target, source, size);
|
||||||
}
|
}
|
||||||
|
|
|
@ -136,6 +136,11 @@ namespace Ryujinx.Memory
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
public static bool Unmap(IntPtr address, ulong size)
|
||||||
|
{
|
||||||
|
return munmap(address, size) == 0;
|
||||||
|
}
|
||||||
|
|
||||||
public static IntPtr Remap(IntPtr target, IntPtr source, ulong size)
|
public static IntPtr Remap(IntPtr target, IntPtr source, ulong size)
|
||||||
{
|
{
|
||||||
int flags = 1;
|
int flags = 1;
|
||||||
|
|
|
@ -1,6 +1,5 @@
|
||||||
using Ryujinx.Memory.WindowsShared;
|
using Ryujinx.Memory.WindowsShared;
|
||||||
using System;
|
using System;
|
||||||
using System.Collections.Generic;
|
|
||||||
using System.Runtime.InteropServices;
|
using System.Runtime.InteropServices;
|
||||||
using System.Runtime.Versioning;
|
using System.Runtime.Versioning;
|
||||||
|
|
||||||
|
@ -9,12 +8,10 @@ namespace Ryujinx.Memory
|
||||||
[SupportedOSPlatform("windows")]
|
[SupportedOSPlatform("windows")]
|
||||||
static class MemoryManagementWindows
|
static class MemoryManagementWindows
|
||||||
{
|
{
|
||||||
private static readonly IntPtr InvalidHandleValue = new IntPtr(-1);
|
private const int PageSize = 0x1000;
|
||||||
private static bool UseWin10Placeholders;
|
|
||||||
|
|
||||||
private static object _emulatedHandleLock = new object();
|
private static readonly IntPtr InvalidHandleValue = new IntPtr(-1);
|
||||||
private static EmulatedSharedMemoryWindows[] _emulatedShared = new EmulatedSharedMemoryWindows[64];
|
private static readonly IntPtr CurrentProcessHandle = new IntPtr(-1);
|
||||||
private static List<EmulatedSharedMemoryWindows> _emulatedSharedList = new List<EmulatedSharedMemoryWindows>();
|
|
||||||
|
|
||||||
[DllImport("kernel32.dll", SetLastError = true)]
|
[DllImport("kernel32.dll", SetLastError = true)]
|
||||||
private static extern IntPtr VirtualAlloc(
|
private static extern IntPtr VirtualAlloc(
|
||||||
|
@ -23,6 +20,16 @@ namespace Ryujinx.Memory
|
||||||
AllocationType flAllocationType,
|
AllocationType flAllocationType,
|
||||||
MemoryProtection flProtect);
|
MemoryProtection flProtect);
|
||||||
|
|
||||||
|
[DllImport("KernelBase.dll", SetLastError = true)]
|
||||||
|
private static extern IntPtr VirtualAlloc2(
|
||||||
|
IntPtr process,
|
||||||
|
IntPtr lpAddress,
|
||||||
|
IntPtr dwSize,
|
||||||
|
AllocationType flAllocationType,
|
||||||
|
MemoryProtection flProtect,
|
||||||
|
IntPtr extendedParameters,
|
||||||
|
ulong parameterCount);
|
||||||
|
|
||||||
[DllImport("kernel32.dll", SetLastError = true)]
|
[DllImport("kernel32.dll", SetLastError = true)]
|
||||||
private static extern bool VirtualProtect(
|
private static extern bool VirtualProtect(
|
||||||
IntPtr lpAddress,
|
IntPtr lpAddress,
|
||||||
|
@ -53,24 +60,39 @@ namespace Ryujinx.Memory
|
||||||
uint dwFileOffsetLow,
|
uint dwFileOffsetLow,
|
||||||
IntPtr dwNumberOfBytesToMap);
|
IntPtr dwNumberOfBytesToMap);
|
||||||
|
|
||||||
|
[DllImport("KernelBase.dll", SetLastError = true)]
|
||||||
|
private static extern IntPtr MapViewOfFile3(
|
||||||
|
IntPtr hFileMappingObject,
|
||||||
|
IntPtr process,
|
||||||
|
IntPtr baseAddress,
|
||||||
|
ulong offset,
|
||||||
|
IntPtr dwNumberOfBytesToMap,
|
||||||
|
ulong allocationType,
|
||||||
|
MemoryProtection dwDesiredAccess,
|
||||||
|
IntPtr extendedParameters,
|
||||||
|
ulong parameterCount);
|
||||||
|
|
||||||
[DllImport("kernel32.dll", SetLastError = true)]
|
[DllImport("kernel32.dll", SetLastError = true)]
|
||||||
private static extern bool UnmapViewOfFile(IntPtr lpBaseAddress);
|
private static extern bool UnmapViewOfFile(IntPtr lpBaseAddress);
|
||||||
|
|
||||||
[DllImport("kernel32.dll", SetLastError = true)]
|
[DllImport("KernelBase.dll", SetLastError = true)]
|
||||||
private static extern uint GetLastError();
|
private static extern bool UnmapViewOfFile2(IntPtr process, IntPtr lpBaseAddress, ulong unmapFlags);
|
||||||
|
|
||||||
static MemoryManagementWindows()
|
[DllImport("kernel32.dll")]
|
||||||
{
|
private static extern uint GetLastError();
|
||||||
UseWin10Placeholders = OperatingSystem.IsWindowsVersionAtLeast(10, 0, 17134);
|
|
||||||
}
|
|
||||||
|
|
||||||
public static IntPtr Allocate(IntPtr size)
|
public static IntPtr Allocate(IntPtr size)
|
||||||
{
|
{
|
||||||
return AllocateInternal(size, AllocationType.Reserve | AllocationType.Commit);
|
return AllocateInternal(size, AllocationType.Reserve | AllocationType.Commit);
|
||||||
}
|
}
|
||||||
|
|
||||||
public static IntPtr Reserve(IntPtr size)
|
public static IntPtr Reserve(IntPtr size, bool viewCompatible)
|
||||||
{
|
{
|
||||||
|
if (viewCompatible)
|
||||||
|
{
|
||||||
|
return AllocateInternal2(size, AllocationType.Reserve | AllocationType.ReservePlaceholder);
|
||||||
|
}
|
||||||
|
|
||||||
return AllocateInternal(size, AllocationType.Reserve);
|
return AllocateInternal(size, AllocationType.Reserve);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -86,62 +108,88 @@ namespace Ryujinx.Memory
|
||||||
return ptr;
|
return ptr;
|
||||||
}
|
}
|
||||||
|
|
||||||
public static bool Commit(IntPtr location, IntPtr size)
|
private static IntPtr AllocateInternal2(IntPtr size, AllocationType flags = 0)
|
||||||
{
|
{
|
||||||
if (UseWin10Placeholders)
|
IntPtr ptr = VirtualAlloc2(CurrentProcessHandle, IntPtr.Zero, size, flags, MemoryProtection.NoAccess, IntPtr.Zero, 0);
|
||||||
|
|
||||||
|
if (ptr == IntPtr.Zero)
|
||||||
{
|
{
|
||||||
lock (_emulatedSharedList)
|
throw new OutOfMemoryException();
|
||||||
{
|
|
||||||
foreach (var shared in _emulatedSharedList)
|
|
||||||
{
|
|
||||||
if (shared.CommitMap(location, size))
|
|
||||||
{
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
return ptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
public static bool Commit(IntPtr location, IntPtr size)
|
||||||
|
{
|
||||||
return VirtualAlloc(location, size, AllocationType.Commit, MemoryProtection.ReadWrite) != IntPtr.Zero;
|
return VirtualAlloc(location, size, AllocationType.Commit, MemoryProtection.ReadWrite) != IntPtr.Zero;
|
||||||
}
|
}
|
||||||
|
|
||||||
public static bool Decommit(IntPtr location, IntPtr size)
|
public static bool Decommit(IntPtr location, IntPtr size)
|
||||||
{
|
{
|
||||||
if (UseWin10Placeholders)
|
|
||||||
{
|
|
||||||
lock (_emulatedSharedList)
|
|
||||||
{
|
|
||||||
foreach (var shared in _emulatedSharedList)
|
|
||||||
{
|
|
||||||
if (shared.DecommitMap(location, size))
|
|
||||||
{
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return VirtualFree(location, size, AllocationType.Decommit);
|
return VirtualFree(location, size, AllocationType.Decommit);
|
||||||
}
|
}
|
||||||
|
|
||||||
public static bool Reprotect(IntPtr address, IntPtr size, MemoryPermission permission)
|
public static void MapView(IntPtr sharedMemory, ulong srcOffset, IntPtr location, IntPtr size)
|
||||||
{
|
{
|
||||||
if (UseWin10Placeholders)
|
IntPtr endLocation = (nint)location + (nint)size;
|
||||||
|
|
||||||
|
while (location != endLocation)
|
||||||
|
{
|
||||||
|
VirtualFree(location, (IntPtr)PageSize, AllocationType.Release | AllocationType.PreservePlaceholder);
|
||||||
|
|
||||||
|
var ptr = MapViewOfFile3(
|
||||||
|
sharedMemory,
|
||||||
|
CurrentProcessHandle,
|
||||||
|
location,
|
||||||
|
srcOffset,
|
||||||
|
(IntPtr)PageSize,
|
||||||
|
0x4000,
|
||||||
|
MemoryProtection.ReadWrite,
|
||||||
|
IntPtr.Zero,
|
||||||
|
0);
|
||||||
|
|
||||||
|
if (ptr == IntPtr.Zero)
|
||||||
|
{
|
||||||
|
throw new Exception($"MapViewOfFile3 failed with error code 0x{GetLastError():X}.");
|
||||||
|
}
|
||||||
|
|
||||||
|
location += PageSize;
|
||||||
|
srcOffset += PageSize;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public static void UnmapView(IntPtr location, IntPtr size)
|
||||||
|
{
|
||||||
|
IntPtr endLocation = (nint)location + (int)size;
|
||||||
|
|
||||||
|
while (location != endLocation)
|
||||||
|
{
|
||||||
|
bool result = UnmapViewOfFile2(CurrentProcessHandle, location, 2);
|
||||||
|
if (!result)
|
||||||
|
{
|
||||||
|
throw new Exception($"UnmapViewOfFile2 failed with error code 0x{GetLastError():X}.");
|
||||||
|
}
|
||||||
|
|
||||||
|
location += PageSize;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public static bool Reprotect(IntPtr address, IntPtr size, MemoryPermission permission, bool forView)
|
||||||
|
{
|
||||||
|
if (forView)
|
||||||
{
|
{
|
||||||
ulong uaddress = (ulong)address;
|
ulong uaddress = (ulong)address;
|
||||||
ulong usize = (ulong)size;
|
ulong usize = (ulong)size;
|
||||||
while (usize > 0)
|
while (usize > 0)
|
||||||
{
|
{
|
||||||
ulong nextGranular = (uaddress & ~EmulatedSharedMemoryWindows.MappingMask) + EmulatedSharedMemoryWindows.MappingGranularity;
|
if (!VirtualProtect((IntPtr)uaddress, (IntPtr)PageSize, GetProtection(permission), out _))
|
||||||
ulong mapSize = Math.Min(usize, nextGranular - uaddress);
|
|
||||||
|
|
||||||
if (!VirtualProtect((IntPtr)uaddress, (IntPtr)mapSize, GetProtection(permission), out _))
|
|
||||||
{
|
{
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
uaddress = nextGranular;
|
uaddress += PageSize;
|
||||||
usize -= mapSize;
|
usize -= PageSize;
|
||||||
}
|
}
|
||||||
|
|
||||||
return true;
|
return true;
|
||||||
|
@ -171,41 +219,7 @@ namespace Ryujinx.Memory
|
||||||
return VirtualFree(address, IntPtr.Zero, AllocationType.Release);
|
return VirtualFree(address, IntPtr.Zero, AllocationType.Release);
|
||||||
}
|
}
|
||||||
|
|
||||||
private static int GetEmulatedHandle()
|
|
||||||
{
|
|
||||||
// Assumes we have the handle lock.
|
|
||||||
|
|
||||||
for (int i = 0; i < _emulatedShared.Length; i++)
|
|
||||||
{
|
|
||||||
if (_emulatedShared[i] == null)
|
|
||||||
{
|
|
||||||
return i + 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
throw new InvalidProgramException("Too many shared memory handles were created.");
|
|
||||||
}
|
|
||||||
|
|
||||||
public static bool EmulatedHandleValid(ref int handle)
|
|
||||||
{
|
|
||||||
handle--;
|
|
||||||
return handle >= 0 && handle < _emulatedShared.Length && _emulatedShared[handle] != null;
|
|
||||||
}
|
|
||||||
|
|
||||||
public static IntPtr CreateSharedMemory(IntPtr size, bool reserve)
|
public static IntPtr CreateSharedMemory(IntPtr size, bool reserve)
|
||||||
{
|
|
||||||
if (UseWin10Placeholders && reserve)
|
|
||||||
{
|
|
||||||
lock (_emulatedHandleLock)
|
|
||||||
{
|
|
||||||
int handle = GetEmulatedHandle();
|
|
||||||
_emulatedShared[handle - 1] = new EmulatedSharedMemoryWindows((ulong)size);
|
|
||||||
_emulatedSharedList.Add(_emulatedShared[handle - 1]);
|
|
||||||
|
|
||||||
return (IntPtr)handle;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
{
|
||||||
var prot = reserve ? FileMapProtection.SectionReserve : FileMapProtection.SectionCommit;
|
var prot = reserve ? FileMapProtection.SectionReserve : FileMapProtection.SectionCommit;
|
||||||
|
|
||||||
|
@ -224,27 +238,9 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
return handle;
|
return handle;
|
||||||
}
|
}
|
||||||
}
|
|
||||||
|
|
||||||
public static void DestroySharedMemory(IntPtr handle)
|
public static void DestroySharedMemory(IntPtr handle)
|
||||||
{
|
{
|
||||||
if (UseWin10Placeholders)
|
|
||||||
{
|
|
||||||
lock (_emulatedHandleLock)
|
|
||||||
{
|
|
||||||
int iHandle = (int)(ulong)handle;
|
|
||||||
|
|
||||||
if (EmulatedHandleValid(ref iHandle))
|
|
||||||
{
|
|
||||||
_emulatedSharedList.Remove(_emulatedShared[iHandle]);
|
|
||||||
_emulatedShared[iHandle].Dispose();
|
|
||||||
_emulatedShared[iHandle] = null;
|
|
||||||
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!CloseHandle(handle))
|
if (!CloseHandle(handle))
|
||||||
{
|
{
|
||||||
throw new ArgumentException("Invalid handle.", nameof(handle));
|
throw new ArgumentException("Invalid handle.", nameof(handle));
|
||||||
|
@ -253,19 +249,6 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
public static IntPtr MapSharedMemory(IntPtr handle)
|
public static IntPtr MapSharedMemory(IntPtr handle)
|
||||||
{
|
{
|
||||||
if (UseWin10Placeholders)
|
|
||||||
{
|
|
||||||
lock (_emulatedHandleLock)
|
|
||||||
{
|
|
||||||
int iHandle = (int)(ulong)handle;
|
|
||||||
|
|
||||||
if (EmulatedHandleValid(ref iHandle))
|
|
||||||
{
|
|
||||||
return _emulatedShared[iHandle].Map();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
IntPtr ptr = MapViewOfFile(handle, 4 | 2, 0, 0, IntPtr.Zero);
|
IntPtr ptr = MapViewOfFile(handle, 4 | 2, 0, 0, IntPtr.Zero);
|
||||||
|
|
||||||
if (ptr == IntPtr.Zero)
|
if (ptr == IntPtr.Zero)
|
||||||
|
@ -278,20 +261,6 @@ namespace Ryujinx.Memory
|
||||||
|
|
||||||
public static void UnmapSharedMemory(IntPtr address)
|
public static void UnmapSharedMemory(IntPtr address)
|
||||||
{
|
{
|
||||||
if (UseWin10Placeholders)
|
|
||||||
{
|
|
||||||
lock (_emulatedHandleLock)
|
|
||||||
{
|
|
||||||
foreach (EmulatedSharedMemoryWindows shared in _emulatedSharedList)
|
|
||||||
{
|
|
||||||
if (shared.Unmap((ulong)address))
|
|
||||||
{
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!UnmapViewOfFile(address))
|
if (!UnmapViewOfFile(address))
|
||||||
{
|
{
|
||||||
throw new ArgumentException("Invalid address.", nameof(address));
|
throw new ArgumentException("Invalid address.", nameof(address));
|
||||||
|
|
|
@ -1,6 +1,6 @@
|
||||||
namespace Ryujinx.Memory
|
namespace Ryujinx.Memory
|
||||||
{
|
{
|
||||||
class PageTable<T> where T : unmanaged
|
public class PageTable<T> where T : unmanaged
|
||||||
{
|
{
|
||||||
public const int PageBits = 12;
|
public const int PageBits = 12;
|
||||||
public const int PageSize = 1 << PageBits;
|
public const int PageSize = 1 << PageBits;
|
||||||
|
|
|
@ -1,71 +0,0 @@
|
||||||
using System;
|
|
||||||
|
|
||||||
namespace Ryujinx.Memory.Range
|
|
||||||
{
|
|
||||||
/// <summary>
|
|
||||||
/// Range of memory composed of an address and size.
|
|
||||||
/// </summary>
|
|
||||||
public struct HostMemoryRange : IEquatable<HostMemoryRange>
|
|
||||||
{
|
|
||||||
/// <summary>
|
|
||||||
/// An empty memory range, with a null address and zero size.
|
|
||||||
/// </summary>
|
|
||||||
public static HostMemoryRange Empty => new HostMemoryRange(0, 0);
|
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Start address of the range.
|
|
||||||
/// </summary>
|
|
||||||
public nuint Address { get; }
|
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Size of the range in bytes.
|
|
||||||
/// </summary>
|
|
||||||
public ulong Size { get; }
|
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Address where the range ends (exclusive).
|
|
||||||
/// </summary>
|
|
||||||
public nuint EndAddress => Address + (nuint)Size;
|
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Creates a new memory range with the specified address and size.
|
|
||||||
/// </summary>
|
|
||||||
/// <param name="address">Start address</param>
|
|
||||||
/// <param name="size">Size in bytes</param>
|
|
||||||
public HostMemoryRange(nuint address, ulong size)
|
|
||||||
{
|
|
||||||
Address = address;
|
|
||||||
Size = size;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Checks if the range overlaps with another.
|
|
||||||
/// </summary>
|
|
||||||
/// <param name="other">The other range to check for overlap</param>
|
|
||||||
/// <returns>True if the ranges overlap, false otherwise</returns>
|
|
||||||
public bool OverlapsWith(HostMemoryRange other)
|
|
||||||
{
|
|
||||||
nuint thisAddress = Address;
|
|
||||||
nuint thisEndAddress = EndAddress;
|
|
||||||
nuint otherAddress = other.Address;
|
|
||||||
nuint otherEndAddress = other.EndAddress;
|
|
||||||
|
|
||||||
return thisAddress < otherEndAddress && otherAddress < thisEndAddress;
|
|
||||||
}
|
|
||||||
|
|
||||||
public override bool Equals(object obj)
|
|
||||||
{
|
|
||||||
return obj is HostMemoryRange other && Equals(other);
|
|
||||||
}
|
|
||||||
|
|
||||||
public bool Equals(HostMemoryRange other)
|
|
||||||
{
|
|
||||||
return Address == other.Address && Size == other.Size;
|
|
||||||
}
|
|
||||||
|
|
||||||
public override int GetHashCode()
|
|
||||||
{
|
|
||||||
return HashCode.Combine(Address, Size);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -54,9 +54,9 @@ namespace Ryujinx.Tests.Cpu
|
||||||
_currAddress = CodeBaseAddress;
|
_currAddress = CodeBaseAddress;
|
||||||
|
|
||||||
_ram = new MemoryBlock(Size * 2);
|
_ram = new MemoryBlock(Size * 2);
|
||||||
_memory = new MemoryManager(1ul << 16);
|
_memory = new MemoryManager(_ram, 1ul << 16);
|
||||||
_memory.IncrementReferenceCount();
|
_memory.IncrementReferenceCount();
|
||||||
_memory.Map(CodeBaseAddress, _ram.GetPointer(0, Size * 2), Size * 2);
|
_memory.Map(CodeBaseAddress, 0, Size * 2);
|
||||||
|
|
||||||
_context = CpuContext.CreateExecutionContext();
|
_context = CpuContext.CreateExecutionContext();
|
||||||
Translator.IsReadyForTranslation.Set();
|
Translator.IsReadyForTranslation.Set();
|
||||||
|
|
|
@ -49,9 +49,9 @@ namespace Ryujinx.Tests.Cpu
|
||||||
_currAddress = CodeBaseAddress;
|
_currAddress = CodeBaseAddress;
|
||||||
|
|
||||||
_ram = new MemoryBlock(Size * 2);
|
_ram = new MemoryBlock(Size * 2);
|
||||||
_memory = new MemoryManager(1ul << 16);
|
_memory = new MemoryManager(_ram, 1ul << 16);
|
||||||
_memory.IncrementReferenceCount();
|
_memory.IncrementReferenceCount();
|
||||||
_memory.Map(CodeBaseAddress, _ram.GetPointer(0, Size * 2), Size * 2);
|
_memory.Map(CodeBaseAddress, 0, Size * 2);
|
||||||
|
|
||||||
_context = CpuContext.CreateExecutionContext();
|
_context = CpuContext.CreateExecutionContext();
|
||||||
_context.IsAarch32 = true;
|
_context.IsAarch32 = true;
|
||||||
|
|
Loading…
Reference in a new issue