0
0
Fork 0
This repository has been archived on 2024-10-12. You can view files and clone it, but cannot push or open issues or pull requests.
ryujinx-final/Ryujinx.Core/OsHle/Kernel/SvcSystem.cs

370 lines
11 KiB
C#
Raw Normal View History

2018-02-04 23:08:20 +00:00
using ChocolArm64.Memory;
using ChocolArm64.State;
2018-04-24 18:57:39 +00:00
using Ryujinx.Core.Logging;
using Ryujinx.Core.OsHle.Exceptions;
using Ryujinx.Core.OsHle.Handles;
using Ryujinx.Core.OsHle.Ipc;
2018-03-20 20:00:00 +00:00
using Ryujinx.Core.OsHle.Services;
2018-02-04 23:08:20 +00:00
using System;
2018-02-19 19:37:13 +00:00
using System.Threading;
2018-02-04 23:08:20 +00:00
using static Ryujinx.Core.OsHle.ErrorCode;
namespace Ryujinx.Core.OsHle.Kernel
2018-02-04 23:08:20 +00:00
{
partial class SvcHandler
{
private const int AllowedCpuIdBitmask = 0b1111;
private const bool EnableProcessDebugging = false;
private const bool IsVirtualMemoryEnabled = true; //This is always true(?)
private void SvcExitProcess(AThreadState ThreadState)
{
Ns.Os.ExitProcess(ThreadState.ProcessId);
}
private void SvcClearEvent(AThreadState ThreadState)
{
int Handle = (int)ThreadState.X0;
//TODO: Implement events.
ThreadState.X0 = 0;
}
2018-02-18 19:28:07 +00:00
private void SvcCloseHandle(AThreadState ThreadState)
2018-02-04 23:08:20 +00:00
{
2018-02-18 19:28:07 +00:00
int Handle = (int)ThreadState.X0;
2018-02-04 23:08:20 +00:00
object Obj = Process.HandleTable.CloseHandle(Handle);
if (Obj == null)
{
Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid handle 0x{Handle:x8}!");
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
return;
}
if (Obj is KSession Session)
{
Session.Dispose();
}
else if (Obj is HTransferMem TMem)
{
TMem.Memory.Manager.Reprotect(
TMem.Position,
TMem.Size,
TMem.Perm);
}
2018-02-04 23:08:20 +00:00
ThreadState.X0 = 0;
2018-02-04 23:08:20 +00:00
}
2018-02-18 19:28:07 +00:00
private void SvcResetSignal(AThreadState ThreadState)
2018-02-04 23:08:20 +00:00
{
2018-02-18 19:28:07 +00:00
int Handle = (int)ThreadState.X0;
2018-02-04 23:08:20 +00:00
KEvent Event = Process.HandleTable.GetData<KEvent>(Handle);
2018-02-04 23:08:20 +00:00
if (Event != null)
{
Event.WaitEvent.Reset();
ThreadState.X0 = 0;
}
else
{
2018-04-24 18:57:39 +00:00
Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid event handle 0x{Handle:x8}!");
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
}
2018-02-04 23:08:20 +00:00
}
2018-02-18 19:28:07 +00:00
private void SvcWaitSynchronization(AThreadState ThreadState)
2018-02-04 23:08:20 +00:00
{
long HandlesPtr = (long)ThreadState.X1;
int HandlesCount = (int)ThreadState.X2;
ulong Timeout = ThreadState.X3;
2018-02-04 23:08:20 +00:00
Ns.Log.PrintDebug(LogClass.KernelSvc,
"HandlesPtr = " + HandlesPtr .ToString("x16") + ", " +
"HandlesCount = " + HandlesCount.ToString("x8") + ", " +
"Timeout = " + Timeout .ToString("x16"));
if ((uint)HandlesCount > 0x40)
{
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.CountOutOfRange);
return;
}
KThread CurrThread = Process.GetThread(ThreadState.Tpidr);
2018-02-04 23:08:20 +00:00
WaitHandle[] Handles = new WaitHandle[HandlesCount + 1];
for (int Index = 0; Index < HandlesCount; Index++)
{
int Handle = Memory.ReadInt32(HandlesPtr + Index * 4);
KSynchronizationObject SyncObj = Process.HandleTable.GetData<KSynchronizationObject>(Handle);
if (SyncObj == null)
{
2018-04-24 18:57:39 +00:00
Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid handle 0x{Handle:x8}!");
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
return;
}
Handles[Index] = SyncObj.WaitEvent;
}
using (AutoResetEvent WaitEvent = new AutoResetEvent(false))
{
if (!SyncWaits.TryAdd(CurrThread, WaitEvent))
{
throw new InvalidOperationException();
}
Handles[HandlesCount] = WaitEvent;
Process.Scheduler.Suspend(CurrThread);
int HandleIndex;
ulong Result = 0;
if (Timeout != ulong.MaxValue)
{
HandleIndex = WaitHandle.WaitAny(Handles, NsTimeConverter.GetTimeMs(Timeout));
}
else
{
HandleIndex = WaitHandle.WaitAny(Handles);
}
if (HandleIndex == WaitHandle.WaitTimeout)
{
Result = MakeError(ErrorModule.Kernel, KernelErr.Timeout);
}
else if (HandleIndex == HandlesCount)
{
Result = MakeError(ErrorModule.Kernel, KernelErr.Canceled);
}
SyncWaits.TryRemove(CurrThread, out _);
Process.Scheduler.Resume(CurrThread);
ThreadState.X0 = Result;
if (Result == 0)
{
ThreadState.X1 = (ulong)HandleIndex;
}
}
}
private void SvcCancelSynchronization(AThreadState ThreadState)
{
int ThreadHandle = (int)ThreadState.X0;
KThread Thread = GetThread(ThreadState.Tpidr, ThreadHandle);
if (Thread == null)
{
Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{ThreadHandle:x8}!");
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
return;
}
if (SyncWaits.TryRemove(Thread, out AutoResetEvent WaitEvent))
{
WaitEvent.Set();
}
ThreadState.X0 = 0;
2018-02-04 23:08:20 +00:00
}
2018-02-18 19:28:07 +00:00
private void SvcGetSystemTick(AThreadState ThreadState)
2018-02-04 23:08:20 +00:00
{
2018-03-10 23:51:55 +00:00
ThreadState.X0 = ThreadState.CntpctEl0;
2018-02-04 23:08:20 +00:00
}
2018-02-18 19:28:07 +00:00
private void SvcConnectToNamedPort(AThreadState ThreadState)
2018-02-04 23:08:20 +00:00
{
2018-02-18 19:28:07 +00:00
long StackPtr = (long)ThreadState.X0;
long NamePtr = (long)ThreadState.X1;
2018-02-04 23:08:20 +00:00
string Name = AMemoryHelper.ReadAsciiString(Memory, NamePtr, 8);
//TODO: Validate that app has perms to access the service, and that the service
//actually exists, return error codes otherwise.
KSession Session = new KSession(ServiceFactory.MakeService(Name), Name);
2018-02-04 23:08:20 +00:00
ulong Handle = (ulong)Process.HandleTable.OpenHandle(Session);
ThreadState.X0 = 0;
ThreadState.X1 = Handle;
2018-02-04 23:08:20 +00:00
}
2018-02-18 19:28:07 +00:00
private void SvcSendSyncRequest(AThreadState ThreadState)
2018-02-04 23:08:20 +00:00
{
SendSyncRequest(ThreadState, ThreadState.Tpidr, 0x100, (int)ThreadState.X0);
2018-02-04 23:08:20 +00:00
}
2018-02-18 19:28:07 +00:00
private void SvcSendSyncRequestWithUserBuffer(AThreadState ThreadState)
2018-02-04 23:08:20 +00:00
{
SendSyncRequest(
ThreadState,
(long)ThreadState.X0,
(long)ThreadState.X1,
(int)ThreadState.X2);
2018-02-04 23:08:20 +00:00
}
private void SendSyncRequest(AThreadState ThreadState, long CmdPtr, long Size, int Handle)
2018-02-04 23:08:20 +00:00
{
KThread CurrThread = Process.GetThread(ThreadState.Tpidr);
2018-02-04 23:08:20 +00:00
byte[] CmdData = AMemoryHelper.ReadBytes(Memory, CmdPtr, Size);
2018-02-04 23:08:20 +00:00
KSession Session = Process.HandleTable.GetData<KSession>(Handle);
2018-02-19 19:37:13 +00:00
if (Session != null)
{
Process.Scheduler.Suspend(CurrThread);
2018-02-19 19:37:13 +00:00
IpcMessage Cmd = new IpcMessage(CmdData, CmdPtr);
2018-02-04 23:08:20 +00:00
long Result = IpcHandler.IpcCall(Ns, Process, Memory, Session, Cmd, CmdPtr);
2018-02-04 23:08:20 +00:00
Thread.Yield();
2018-02-04 23:08:20 +00:00
Process.Scheduler.Resume(CurrThread);
2018-02-04 23:08:20 +00:00
ThreadState.X0 = (ulong)Result;
2018-02-04 23:08:20 +00:00
}
else
{
2018-04-24 18:57:39 +00:00
Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid session handle 0x{Handle:x8}!");
2018-02-19 19:37:13 +00:00
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
}
2018-02-04 23:08:20 +00:00
}
2018-02-18 19:28:07 +00:00
private void SvcBreak(AThreadState ThreadState)
2018-02-04 23:08:20 +00:00
{
2018-02-18 19:28:07 +00:00
long Reason = (long)ThreadState.X0;
long Unknown = (long)ThreadState.X1;
long Info = (long)ThreadState.X2;
2018-02-04 23:08:20 +00:00
Process.PrintStackTrace(ThreadState);
throw new GuestBrokeExecutionException();
2018-02-04 23:08:20 +00:00
}
2018-02-18 19:28:07 +00:00
private void SvcOutputDebugString(AThreadState ThreadState)
2018-02-04 23:08:20 +00:00
{
2018-02-18 19:28:07 +00:00
long Position = (long)ThreadState.X0;
long Size = (long)ThreadState.X1;
2018-02-04 23:08:20 +00:00
string Str = AMemoryHelper.ReadAsciiString(Memory, Position, Size);
2018-02-04 23:08:20 +00:00
2018-04-24 18:57:39 +00:00
Ns.Log.PrintWarning(LogClass.KernelSvc, Str);
2018-02-04 23:08:20 +00:00
ThreadState.X0 = 0;
2018-02-04 23:08:20 +00:00
}
2018-02-18 19:28:07 +00:00
private void SvcGetInfo(AThreadState ThreadState)
2018-02-04 23:08:20 +00:00
{
2018-02-18 19:28:07 +00:00
long StackPtr = (long)ThreadState.X0;
int InfoType = (int)ThreadState.X1;
long Handle = (long)ThreadState.X2;
int InfoId = (int)ThreadState.X3;
2018-02-04 23:08:20 +00:00
//Fail for info not available on older Kernel versions.
if (InfoType == 18 ||
InfoType == 19 ||
InfoType == 20)
{
ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidInfo);
return;
}
2018-02-04 23:08:20 +00:00
switch (InfoType)
{
case 0:
ThreadState.X1 = AllowedCpuIdBitmask;
break;
case 2:
ThreadState.X1 = MemoryRegions.MapRegionAddress;
break;
case 3:
ThreadState.X1 = MemoryRegions.MapRegionSize;
break;
case 4:
ThreadState.X1 = MemoryRegions.HeapRegionAddress;
break;
case 5:
ThreadState.X1 = MemoryRegions.HeapRegionSize;
break;
case 6:
ThreadState.X1 = MemoryRegions.TotalMemoryAvailable;
break;
case 7:
ThreadState.X1 = MemoryRegions.TotalMemoryUsed + CurrentHeapSize;
break;
case 8:
ThreadState.X1 = EnableProcessDebugging ? 1 : 0;
break;
case 11:
ThreadState.X1 = (ulong)Rng.Next() + ((ulong)Rng.Next() << 32);
break;
case 12:
ThreadState.X1 = MemoryRegions.AddrSpaceStart;
break;
case 13:
ThreadState.X1 = MemoryRegions.AddrSpaceSize;
break;
case 14:
ThreadState.X1 = MemoryRegions.MapRegionAddress;
break;
case 15:
ThreadState.X1 = MemoryRegions.MapRegionSize;
break;
case 16:
ThreadState.X1 = IsVirtualMemoryEnabled ? 1 : 0;
break;
2018-02-04 23:08:20 +00:00
default:
Process.PrintStackTrace(ThreadState);
throw new NotImplementedException($"SvcGetInfo: {InfoType} {Handle:x8} {InfoId}");
2018-02-04 23:08:20 +00:00
}
ThreadState.X0 = 0;
2018-02-04 23:08:20 +00:00
}
}
}