RyuKen/Ryujinx.HLE/HOS/Kernel/Memory/KCodeMemory.cs
gdkchan 1cbca5eecb
Implement code memory syscalls (#2958)
* Implement code memory syscalls

* Remove owner process validation

* Add 32-bit code memory syscalls

* Remove unused field
2022-05-03 13:16:31 +02:00

168 lines
No EOL
4.9 KiB
C#

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 _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;
_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();
}
}
}