forked from Mirror/Ryujinx
fb1d9493a3
* Rename enum fields
* Naming conventions
* Remove unneeded ".this"
* Remove unneeded semicolons
* Remove unused Usings
* Don't use var
* Remove unneeded enum underlying types
* Explicitly label class visibility
* Remove unneeded @ prefixes
* Remove unneeded commas
* Remove unneeded if expressions
* Method doesn't use unsafe code
* Remove unneeded casts
* Initialized objects don't need an empty constructor
* Remove settings from DotSettings
* Revert "Explicitly label class visibility"
This reverts commit ad5eb5787c.
* Small changes
* Revert external enum renaming
* Changes from feedback
* Apply previous refactorings to the merged code
581 lines
No EOL
20 KiB
C#
581 lines
No EOL
20 KiB
C#
using ChocolArm64.State;
|
|
using Ryujinx.Common.Logging;
|
|
|
|
using static Ryujinx.HLE.HOS.ErrorCode;
|
|
|
|
namespace Ryujinx.HLE.HOS.Kernel
|
|
{
|
|
partial class SvcHandler
|
|
{
|
|
private void SvcSetHeapSize(CpuThreadState threadState)
|
|
{
|
|
ulong size = threadState.X1;
|
|
|
|
if ((size & 0xfffffffe001fffff) != 0)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Heap size 0x{size:x16} is not aligned!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize);
|
|
|
|
return;
|
|
}
|
|
|
|
KernelResult result = _process.MemoryManager.SetHeapSize(size, out ulong position);
|
|
|
|
threadState.X0 = (ulong)result;
|
|
|
|
if (result == KernelResult.Success)
|
|
{
|
|
threadState.X1 = position;
|
|
}
|
|
else
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{result}\".");
|
|
}
|
|
}
|
|
|
|
private void SvcSetMemoryAttribute(CpuThreadState threadState)
|
|
{
|
|
ulong position = threadState.X0;
|
|
ulong size = threadState.X1;
|
|
|
|
if (!PageAligned(position))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{position:x16} is not page aligned!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress);
|
|
|
|
return;
|
|
}
|
|
|
|
if (!PageAligned(size) || size == 0)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize);
|
|
|
|
return;
|
|
}
|
|
|
|
MemoryAttribute attributeMask = (MemoryAttribute)threadState.X2;
|
|
MemoryAttribute attributeValue = (MemoryAttribute)threadState.X3;
|
|
|
|
MemoryAttribute attributes = attributeMask | attributeValue;
|
|
|
|
if (attributes != attributeMask ||
|
|
(attributes | MemoryAttribute.Uncached) != MemoryAttribute.Uncached)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, "Invalid memory attributes!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMaskValue);
|
|
|
|
return;
|
|
}
|
|
|
|
KernelResult result = _process.MemoryManager.SetMemoryAttribute(
|
|
position,
|
|
size,
|
|
attributeMask,
|
|
attributeValue);
|
|
|
|
if (result != KernelResult.Success)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{result}\".");
|
|
}
|
|
else
|
|
{
|
|
_memory.StopObservingRegion((long)position, (long)size);
|
|
}
|
|
|
|
threadState.X0 = (ulong)result;
|
|
}
|
|
|
|
private void SvcMapMemory(CpuThreadState threadState)
|
|
{
|
|
ulong dst = threadState.X0;
|
|
ulong src = threadState.X1;
|
|
ulong size = threadState.X2;
|
|
|
|
if (!PageAligned(src | dst))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, "Addresses are not page aligned!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress);
|
|
|
|
return;
|
|
}
|
|
|
|
if (!PageAligned(size) || size == 0)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize);
|
|
|
|
return;
|
|
}
|
|
|
|
if (src + size <= src || dst + size <= dst)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, "Addresses outside of range!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
|
|
|
|
return;
|
|
}
|
|
|
|
KProcess currentProcess = _system.Scheduler.GetCurrentProcess();
|
|
|
|
if (!currentProcess.MemoryManager.InsideAddrSpace(src, size))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Src address 0x{src:x16} out of range!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
|
|
|
|
return;
|
|
}
|
|
|
|
if (currentProcess.MemoryManager.OutsideStackRegion(dst, size) ||
|
|
currentProcess.MemoryManager.InsideHeapRegion (dst, size) ||
|
|
currentProcess.MemoryManager.InsideAliasRegion (dst, size))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Dst address 0x{dst:x16} out of range!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMemRange);
|
|
|
|
return;
|
|
}
|
|
|
|
KernelResult result = _process.MemoryManager.Map(dst, src, size);
|
|
|
|
if (result != KernelResult.Success)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!");
|
|
}
|
|
|
|
threadState.X0 = (ulong)result;
|
|
}
|
|
|
|
private void SvcUnmapMemory(CpuThreadState threadState)
|
|
{
|
|
ulong dst = threadState.X0;
|
|
ulong src = threadState.X1;
|
|
ulong size = threadState.X2;
|
|
|
|
if (!PageAligned(src | dst))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, "Addresses are not page aligned!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress);
|
|
|
|
return;
|
|
}
|
|
|
|
if (!PageAligned(size) || size == 0)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize);
|
|
|
|
return;
|
|
}
|
|
|
|
if (src + size <= src || dst + size <= dst)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, "Addresses outside of range!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
|
|
|
|
return;
|
|
}
|
|
|
|
KProcess currentProcess = _system.Scheduler.GetCurrentProcess();
|
|
|
|
if (!currentProcess.MemoryManager.InsideAddrSpace(src, size))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Src address 0x{src:x16} out of range!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
|
|
|
|
return;
|
|
}
|
|
|
|
if (currentProcess.MemoryManager.OutsideStackRegion(dst, size) ||
|
|
currentProcess.MemoryManager.InsideHeapRegion (dst, size) ||
|
|
currentProcess.MemoryManager.InsideAliasRegion (dst, size))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Dst address 0x{dst:x16} out of range!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMemRange);
|
|
|
|
return;
|
|
}
|
|
|
|
KernelResult result = _process.MemoryManager.Unmap(dst, src, size);
|
|
|
|
if (result != KernelResult.Success)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!");
|
|
}
|
|
|
|
threadState.X0 = (ulong)result;
|
|
}
|
|
|
|
private void SvcQueryMemory(CpuThreadState threadState)
|
|
{
|
|
long infoPtr = (long)threadState.X0;
|
|
ulong position = threadState.X2;
|
|
|
|
KMemoryInfo blkInfo = _process.MemoryManager.QueryMemory(position);
|
|
|
|
_memory.WriteUInt64(infoPtr + 0x00, blkInfo.Address);
|
|
_memory.WriteUInt64(infoPtr + 0x08, blkInfo.Size);
|
|
_memory.WriteInt32 (infoPtr + 0x10, (int)blkInfo.State & 0xff);
|
|
_memory.WriteInt32 (infoPtr + 0x14, (int)blkInfo.Attribute);
|
|
_memory.WriteInt32 (infoPtr + 0x18, (int)blkInfo.Permission);
|
|
_memory.WriteInt32 (infoPtr + 0x1c, blkInfo.IpcRefCount);
|
|
_memory.WriteInt32 (infoPtr + 0x20, blkInfo.DeviceRefCount);
|
|
_memory.WriteInt32 (infoPtr + 0x24, 0);
|
|
|
|
threadState.X0 = 0;
|
|
threadState.X1 = 0;
|
|
}
|
|
|
|
private void SvcMapSharedMemory(CpuThreadState threadState)
|
|
{
|
|
int handle = (int)threadState.X0;
|
|
ulong address = threadState.X1;
|
|
ulong size = threadState.X2;
|
|
|
|
if (!PageAligned(address))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{address:x16} is not page aligned!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress);
|
|
|
|
return;
|
|
}
|
|
|
|
if (!PageAligned(size) || size == 0)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize);
|
|
|
|
return;
|
|
}
|
|
|
|
if (address + size <= address)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{address:x16} / size 0x{size:x16}!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
|
|
|
|
return;
|
|
}
|
|
|
|
MemoryPermission permission = (MemoryPermission)threadState.X3;
|
|
|
|
if ((permission | MemoryPermission.Write) != MemoryPermission.ReadAndWrite)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Invalid permission {permission}!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidPermission);
|
|
|
|
return;
|
|
}
|
|
|
|
KProcess currentProcess = _system.Scheduler.GetCurrentProcess();
|
|
|
|
KSharedMemory sharedMemory = currentProcess.HandleTable.GetObject<KSharedMemory>(handle);
|
|
|
|
if (sharedMemory == null)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Invalid shared memory handle 0x{handle:x8}!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
|
|
|
|
return;
|
|
}
|
|
|
|
if (currentProcess.MemoryManager.IsInvalidRegion (address, size) ||
|
|
currentProcess.MemoryManager.InsideHeapRegion (address, size) ||
|
|
currentProcess.MemoryManager.InsideAliasRegion(address, size))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{address:x16} out of range!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
|
|
|
|
return;
|
|
}
|
|
|
|
KernelResult result = sharedMemory.MapIntoProcess(
|
|
currentProcess.MemoryManager,
|
|
address,
|
|
size,
|
|
currentProcess,
|
|
permission);
|
|
|
|
if (result != KernelResult.Success)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{result}\".");
|
|
}
|
|
|
|
threadState.X0 = (ulong)result;
|
|
}
|
|
|
|
private void SvcUnmapSharedMemory(CpuThreadState threadState)
|
|
{
|
|
int handle = (int)threadState.X0;
|
|
ulong address = threadState.X1;
|
|
ulong size = threadState.X2;
|
|
|
|
if (!PageAligned(address))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{address:x16} is not page aligned!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress);
|
|
|
|
return;
|
|
}
|
|
|
|
if (!PageAligned(size) || size == 0)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize);
|
|
|
|
return;
|
|
}
|
|
|
|
if (address + size <= address)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{address:x16} / size 0x{size:x16}!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
|
|
|
|
return;
|
|
}
|
|
|
|
KProcess currentProcess = _system.Scheduler.GetCurrentProcess();
|
|
|
|
KSharedMemory sharedMemory = currentProcess.HandleTable.GetObject<KSharedMemory>(handle);
|
|
|
|
if (sharedMemory == null)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Invalid shared memory handle 0x{handle:x8}!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
|
|
|
|
return;
|
|
}
|
|
|
|
if (currentProcess.MemoryManager.IsInvalidRegion (address, size) ||
|
|
currentProcess.MemoryManager.InsideHeapRegion (address, size) ||
|
|
currentProcess.MemoryManager.InsideAliasRegion(address, size))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{address:x16} out of range!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
|
|
|
|
return;
|
|
}
|
|
|
|
KernelResult result = sharedMemory.UnmapFromProcess(
|
|
currentProcess.MemoryManager,
|
|
address,
|
|
size,
|
|
currentProcess);
|
|
|
|
if (result != KernelResult.Success)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{result}\".");
|
|
}
|
|
|
|
threadState.X0 = (ulong)result;
|
|
}
|
|
|
|
private void SvcCreateTransferMemory(CpuThreadState threadState)
|
|
{
|
|
ulong address = threadState.X1;
|
|
ulong size = threadState.X2;
|
|
|
|
if (!PageAligned(address))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{address:x16} is not page aligned!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress);
|
|
|
|
return;
|
|
}
|
|
|
|
if (!PageAligned(size) || size == 0)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress);
|
|
|
|
return;
|
|
}
|
|
|
|
if (address + size <= address)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{address:x16} / size 0x{size:x16}!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
|
|
|
|
return;
|
|
}
|
|
|
|
MemoryPermission permission = (MemoryPermission)threadState.X3;
|
|
|
|
if (permission > MemoryPermission.ReadAndWrite || permission == MemoryPermission.Write)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Invalid permission {permission}!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidPermission);
|
|
|
|
return;
|
|
}
|
|
|
|
_process.MemoryManager.ReserveTransferMemory(address, size, permission);
|
|
|
|
KTransferMemory transferMemory = new KTransferMemory(address, size);
|
|
|
|
KernelResult result = _process.HandleTable.GenerateHandle(transferMemory, out int handle);
|
|
|
|
threadState.X0 = (uint)result;
|
|
threadState.X1 = (ulong)handle;
|
|
}
|
|
|
|
private void SvcMapPhysicalMemory(CpuThreadState threadState)
|
|
{
|
|
ulong address = threadState.X0;
|
|
ulong size = threadState.X1;
|
|
|
|
if (!PageAligned(address))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{address:x16} is not page aligned!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress);
|
|
|
|
return;
|
|
}
|
|
|
|
if (!PageAligned(size) || size == 0)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize);
|
|
|
|
return;
|
|
}
|
|
|
|
if (address + size <= address)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{address:x16} / size 0x{size:x16}!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
|
|
|
|
return;
|
|
}
|
|
|
|
KProcess currentProcess = _system.Scheduler.GetCurrentProcess();
|
|
|
|
if ((currentProcess.PersonalMmHeapPagesCount & 0xfffffffffffff) == 0)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"System resource size is zero.");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidState);
|
|
|
|
return;
|
|
}
|
|
|
|
if (!currentProcess.MemoryManager.InsideAddrSpace (address, size) ||
|
|
currentProcess.MemoryManager.OutsideAliasRegion(address, size))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address {address:x16}.");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
|
|
|
|
return;
|
|
}
|
|
|
|
KernelResult result = _process.MemoryManager.MapPhysicalMemory(address, size);
|
|
|
|
if (result != KernelResult.Success)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!");
|
|
}
|
|
|
|
threadState.X0 = (ulong)result;
|
|
}
|
|
|
|
private void SvcUnmapPhysicalMemory(CpuThreadState threadState)
|
|
{
|
|
ulong address = threadState.X0;
|
|
ulong size = threadState.X1;
|
|
|
|
if (!PageAligned(address))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{address:x16} is not page aligned!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress);
|
|
|
|
return;
|
|
}
|
|
|
|
if (!PageAligned(size) || size == 0)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize);
|
|
|
|
return;
|
|
}
|
|
|
|
if (address + size <= address)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{address:x16} / size 0x{size:x16}!");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
|
|
|
|
return;
|
|
}
|
|
|
|
KProcess currentProcess = _system.Scheduler.GetCurrentProcess();
|
|
|
|
if ((currentProcess.PersonalMmHeapPagesCount & 0xfffffffffffff) == 0)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"System resource size is zero.");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidState);
|
|
|
|
return;
|
|
}
|
|
|
|
if (!currentProcess.MemoryManager.InsideAddrSpace (address, size) ||
|
|
currentProcess.MemoryManager.OutsideAliasRegion(address, size))
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address {address:x16}.");
|
|
|
|
threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
|
|
|
|
return;
|
|
}
|
|
|
|
KernelResult result = _process.MemoryManager.UnmapPhysicalMemory(address, size);
|
|
|
|
if (result != KernelResult.Success)
|
|
{
|
|
Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!");
|
|
}
|
|
|
|
threadState.X0 = (ulong)result;
|
|
}
|
|
|
|
private static bool PageAligned(ulong position)
|
|
{
|
|
return (position & (KMemoryManager.PageSize - 1)) == 0;
|
|
}
|
|
}
|
|
} |