Ryujinx/Ryujinx.Core/OsHle/Svc/SvcMemory.cs

264 lines
8.3 KiB
C#
Raw Normal View History

2018-02-05 00:08:20 +01:00
using ChocolArm64.Memory;
using ChocolArm64.State;
using Ryujinx.Core.OsHle.Handles;
2018-02-05 00:08:20 +01:00
using static Ryujinx.Core.OsHle.ErrorCode;
namespace Ryujinx.Core.OsHle.Svc
2018-02-05 00:08:20 +01:00
{
partial class SvcHandler
{
2018-02-18 20:28:07 +01:00
private void SvcSetHeapSize(AThreadState ThreadState)
2018-02-05 00:08:20 +01:00
{
2018-02-18 20:28:07 +01:00
uint Size = (uint)ThreadState.X1;
2018-02-05 00:08:20 +01:00
long Position = MemoryRegions.HeapRegionAddress;
if (Size > CurrentHeapSize)
{
Memory.Manager.Map(Position, Size, (int)MemoryType.Heap, AMemoryPerm.RW);
}
else
{
Memory.Manager.Unmap(Position + Size, (long)CurrentHeapSize - Size);
}
CurrentHeapSize = Size;
2018-02-05 00:08:20 +01:00
ThreadState.X0 = 0;
ThreadState.X1 = (ulong)Position;
2018-02-05 00:08:20 +01:00
}
2018-02-18 20:28:07 +01:00
private void SvcSetMemoryAttribute(AThreadState ThreadState)
2018-02-05 00:08:20 +01:00
{
2018-02-18 20:28:07 +01:00
long Position = (long)ThreadState.X0;
long Size = (long)ThreadState.X1;
int State0 = (int)ThreadState.X2;
int State1 = (int)ThreadState.X3;
2018-02-05 00:08:20 +01:00
2018-02-26 02:53:01 +01:00
if ((State0 == 0 && State1 == 0) ||
(State0 == 8 && State1 == 0))
{
Memory.Manager.ClearAttrBit(Position, Size, 3);
}
else if (State0 == 8 && State1 == 8)
{
Memory.Manager.SetAttrBit(Position, Size, 3);
}
2018-02-05 00:08:20 +01:00
ThreadState.X0 = 0;
2018-02-05 00:08:20 +01:00
}
2018-02-18 20:28:07 +01:00
private void SvcMapMemory(AThreadState ThreadState)
2018-02-05 00:08:20 +01:00
{
2018-02-18 20:28:07 +01:00
long Dst = (long)ThreadState.X0;
long Src = (long)ThreadState.X1;
long Size = (long)ThreadState.X2;
2018-02-05 00:08:20 +01:00
if (!IsValidPosition(Src))
{
Logging.Warn(LogClass.KernelSvc, $"Tried to map Memory at invalid src address {Src:x16}!");
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMemRange);
return;
}
if (!IsValidMapPosition(Dst))
{
Logging.Warn(LogClass.KernelSvc, $"Tried to map Memory at invalid dst address {Dst:x16}!");
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMemRange);
return;
}
AMemoryMapInfo SrcInfo = Memory.Manager.GetMapInfo(Src);
Memory.Manager.Map(Dst, Size, (int)MemoryType.MappedMemory, SrcInfo.Perm);
Memory.Manager.Reprotect(Src, Size, AMemoryPerm.None);
Memory.Manager.SetAttrBit(Src, Size, 0);
ThreadState.X0 = 0;
}
private void SvcUnmapMemory(AThreadState ThreadState)
{
long Dst = (long)ThreadState.X0;
long Src = (long)ThreadState.X1;
long Size = (long)ThreadState.X2;
if (!IsValidPosition(Src))
{
Logging.Warn(LogClass.KernelSvc, $"Tried to unmap Memory at invalid src address {Src:x16}!");
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMemRange);
return;
}
if (!IsValidMapPosition(Dst))
{
Logging.Warn(LogClass.KernelSvc, $"Tried to unmap Memory at invalid dst address {Dst:x16}!");
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMemRange);
return;
}
AMemoryMapInfo DstInfo = Memory.Manager.GetMapInfo(Dst);
Memory.Manager.Unmap(Dst, Size, (int)MemoryType.MappedMemory);
Memory.Manager.Reprotect(Src, Size, DstInfo.Perm);
Memory.Manager.ClearAttrBit(Src, Size, 0);
2018-02-05 00:08:20 +01:00
ThreadState.X0 = 0;
2018-02-05 00:08:20 +01:00
}
2018-02-18 20:28:07 +01:00
private void SvcQueryMemory(AThreadState ThreadState)
2018-02-05 00:08:20 +01:00
{
2018-02-18 20:28:07 +01:00
long InfoPtr = (long)ThreadState.X0;
long Position = (long)ThreadState.X2;
2018-02-05 00:08:20 +01:00
AMemoryMapInfo MapInfo = Memory.Manager.GetMapInfo(Position);
if (MapInfo == null)
{
long AddrSpaceEnd = MemoryRegions.AddrSpaceStart + MemoryRegions.AddrSpaceSize;
2018-02-05 00:08:20 +01:00
long ReservedSize = (long)(ulong.MaxValue - (ulong)AddrSpaceEnd) + 1;
MapInfo = new AMemoryMapInfo(AddrSpaceEnd, ReservedSize, (int)MemoryType.Reserved, 0, AMemoryPerm.None);
}
2018-02-05 00:08:20 +01:00
Memory.WriteInt64(InfoPtr + 0x00, MapInfo.Position);
Memory.WriteInt64(InfoPtr + 0x08, MapInfo.Size);
Memory.WriteInt32(InfoPtr + 0x10, MapInfo.Type);
Memory.WriteInt32(InfoPtr + 0x14, MapInfo.Attr);
Memory.WriteInt32(InfoPtr + 0x18, (int)MapInfo.Perm);
Memory.WriteInt32(InfoPtr + 0x1c, 0);
Memory.WriteInt32(InfoPtr + 0x20, 0);
Memory.WriteInt32(InfoPtr + 0x24, 0);
2018-02-05 00:08:20 +01:00
//TODO: X1.
ThreadState.X0 = 0;
2018-02-18 20:28:07 +01:00
ThreadState.X1 = 0;
2018-02-05 00:08:20 +01:00
}
2018-02-18 20:28:07 +01:00
private void SvcMapSharedMemory(AThreadState ThreadState)
2018-02-05 00:08:20 +01:00
{
2018-02-18 20:28:07 +01:00
int Handle = (int)ThreadState.X0;
long Src = (long)ThreadState.X1;
long Size = (long)ThreadState.X2;
int Perm = (int)ThreadState.X3;
2018-02-05 00:08:20 +01:00
if (!IsValidPosition(Src))
{
Logging.Warn(LogClass.KernelSvc, $"Tried to map SharedMemory at invalid address {Src:x16}!");
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMemRange);
return;
}
HSharedMem SharedMem = Process.HandleTable.GetData<HSharedMem>(Handle);
2018-02-05 00:08:20 +01:00
if (SharedMem != null)
2018-02-05 00:08:20 +01:00
{
Memory.Manager.Map(Src, Size, (int)MemoryType.SharedMemory, AMemoryPerm.Write);
AMemoryHelper.FillWithZeros(Memory, Src, (int)Size);
Memory.Manager.Reprotect(Src, Size, (AMemoryPerm)Perm);
2018-02-05 00:08:20 +01:00
lock (MappedSharedMems)
{
MappedSharedMems.Add((SharedMem, Src));
}
SharedMem.AddVirtualPosition(Memory, Src);
2018-02-10 01:13:18 +01:00
ThreadState.X0 = 0;
2018-02-05 00:08:20 +01:00
}
//TODO: Error codes.
}
2018-02-18 20:28:07 +01:00
private void SvcUnmapSharedMemory(AThreadState ThreadState)
2018-02-05 00:08:20 +01:00
{
int Handle = (int)ThreadState.X0;
long Src = (long)ThreadState.X1;
long Size = (long)ThreadState.X2;
if (!IsValidPosition(Src))
{
Logging.Warn(LogClass.KernelSvc, $"Tried to unmap SharedMemory at invalid address {Src:x16}!");
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMemRange);
return;
}
2018-02-05 00:08:20 +01:00
HSharedMem SharedMem = Process.HandleTable.GetData<HSharedMem>(Handle);
2018-02-05 00:08:20 +01:00
if (SharedMem != null)
2018-02-05 00:08:20 +01:00
{
Memory.Manager.Unmap(Src, Size, (int)MemoryType.SharedMemory);
SharedMem.RemoveVirtualPosition(Memory, Src);
lock (MappedSharedMems)
{
MappedSharedMems.Remove((SharedMem, Src));
}
ThreadState.X0 = 0;
2018-02-05 00:08:20 +01:00
}
//TODO: Error codes.
}
2018-02-18 20:28:07 +01:00
private void SvcCreateTransferMemory(AThreadState ThreadState)
2018-02-05 00:08:20 +01:00
{
long Src = (long)ThreadState.X1;
long Size = (long)ThreadState.X2;
int Perm = (int)ThreadState.X3;
2018-02-05 00:08:20 +01:00
if (!IsValidPosition(Src))
{
Logging.Warn(LogClass.KernelSvc, $"Tried to create TransferMemory at invalid address {Src:x16}!");
2018-02-05 00:08:20 +01:00
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMemRange);
return;
}
2018-02-05 00:08:20 +01:00
AMemoryMapInfo MapInfo = Memory.Manager.GetMapInfo(Src);
Memory.Manager.Reprotect(Src, Size, (AMemoryPerm)Perm);
HTransferMem TMem = new HTransferMem(Memory, MapInfo.Perm, Src, Size);
2018-02-05 00:08:20 +01:00
ulong Handle = (ulong)Process.HandleTable.OpenHandle(TMem);
ThreadState.X0 = 0;
ThreadState.X1 = Handle;
2018-02-05 00:08:20 +01:00
}
private static bool IsValidPosition(long Position)
{
return Position >= MemoryRegions.AddrSpaceStart &&
Position < MemoryRegions.AddrSpaceStart + MemoryRegions.AddrSpaceSize;
}
private static bool IsValidMapPosition(long Position)
{
return Position >= MemoryRegions.MapRegionAddress &&
Position < MemoryRegions.MapRegionAddress + MemoryRegions.MapRegionSize;
}
2018-02-05 00:08:20 +01:00
}
}