1 files changed, 385 insertions, 0 deletions
diff --git a/Ryujinx.HLE/HOS/Kernel/SvcThread.cs b/Ryujinx.HLE/HOS/Kernel/SvcThread.cs
new file mode 100644
index 00000000..69e75ec0
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Kernel/SvcThread.cs
@@ -0,0 +1,385 @@
+using ChocolArm64.State;
+using Ryujinx.HLE.Logging;
+using System.Threading;
+
+using static Ryujinx.HLE.HOS.ErrorCode;
+
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    partial class SvcHandler
+    {
+        private void SvcCreateThread(AThreadState ThreadState)
+        {
+            long EntryPoint  = (long)ThreadState.X1;
+            long ArgsPtr     = (long)ThreadState.X2;
+            long StackTop    = (long)ThreadState.X3;
+            int  Priority    =  (int)ThreadState.X4;
+            int  ProcessorId =  (int)ThreadState.X5;
+
+            if ((uint)Priority > 0x3f)
+            {
+                Device.Log.PrintWarning(LogClass.KernelSvc, $"Invalid priority 0x{Priority:x8}!");
+
+                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidPriority);
+
+                return;
+            }
+
+            if (ProcessorId == -2)
+            {
+                //TODO: Get this value from the NPDM file.
+                ProcessorId = 0;
+            }
+            else if ((uint)ProcessorId > 3)
+            {
+                Device.Log.PrintWarning(LogClass.KernelSvc, $"Invalid core id 0x{ProcessorId:x8}!");
+
+                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidCoreId);
+
+                return;
+            }
+
+            int Handle = Process.MakeThread(
+                EntryPoint,
+                StackTop,
+                ArgsPtr,
+                Priority,
+                ProcessorId);
+
+            ThreadState.X0 = 0;
+            ThreadState.X1 = (ulong)Handle;
+        }
+
+        private void SvcStartThread(AThreadState ThreadState)
+        {
+            int Handle = (int)ThreadState.X0;
+
+            KThread NewThread = Process.HandleTable.GetData<KThread>(Handle);
+
+            if (NewThread != null)
+            {
+                Process.Scheduler.StartThread(NewThread);
+                Process.Scheduler.SetReschedule(NewThread.ProcessorId);
+
+                ThreadState.X0 = 0;
+            }
+            else
+            {
+                Device.Log.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!");
+
+                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
+            }
+        }
+
+        private void SvcExitThread(AThreadState ThreadState)
+        {
+            KThread CurrThread = Process.GetThread(ThreadState.Tpidr);
+
+            CurrThread.Thread.StopExecution();
+        }
+
+        private void SvcSleepThread(AThreadState ThreadState)
+        {
+            ulong TimeoutNs = ThreadState.X0;
+
+            Device.Log.PrintDebug(LogClass.KernelSvc, "Timeout = 0x" + TimeoutNs.ToString("x16"));
+
+            KThread CurrThread = Process.GetThread(ThreadState.Tpidr);
+
+            if (TimeoutNs == 0 || TimeoutNs == ulong.MaxValue)
+            {
+                Process.Scheduler.Yield(CurrThread);
+            }
+            else
+            {
+                Process.Scheduler.Suspend(CurrThread);
+
+                Thread.Sleep(NsTimeConverter.GetTimeMs(TimeoutNs));
+
+                Process.Scheduler.Resume(CurrThread);
+            }
+        }
+
+        private void SvcGetThreadPriority(AThreadState ThreadState)
+        {
+            int Handle = (int)ThreadState.X1;
+
+            KThread Thread = GetThread(ThreadState.Tpidr, Handle);
+
+            if (Thread != null)
+            {
+                ThreadState.X0 = 0;
+                ThreadState.X1 = (ulong)Thread.ActualPriority;
+            }
+            else
+            {
+                Device.Log.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!");
+
+                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
+            }
+        }
+
+        private void SvcSetThreadPriority(AThreadState ThreadState)
+        {
+            int Handle   = (int)ThreadState.X0;
+            int Priority = (int)ThreadState.X1;
+
+            Device.Log.PrintDebug(LogClass.KernelSvc,
+                "Handle = 0x"   + Handle  .ToString("x8") + ", " +
+                "Priority = 0x" + Priority.ToString("x8"));
+
+            KThread Thread = GetThread(ThreadState.Tpidr, Handle);
+
+            if (Thread != null)
+            {
+                Thread.SetPriority(Priority);
+
+                ThreadState.X0 = 0;
+            }
+            else
+            {
+                Device.Log.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!");
+
+                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
+            }
+        }
+
+        private void SvcGetThreadCoreMask(AThreadState ThreadState)
+        {
+            int Handle = (int)ThreadState.X2;
+
+            Device.Log.PrintDebug(LogClass.KernelSvc, "Handle = 0x" + Handle.ToString("x8"));
+
+            KThread Thread = GetThread(ThreadState.Tpidr, Handle);
+
+            if (Thread != null)
+            {
+                ThreadState.X0 = 0;
+                ThreadState.X1 = (ulong)Thread.IdealCore;
+                ThreadState.X2 = (ulong)Thread.CoreMask;
+            }
+            else
+            {
+                Device.Log.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!");
+
+                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
+            }
+        }
+
+        private void SvcSetThreadCoreMask(AThreadState ThreadState)
+        {
+            int  Handle    =  (int)ThreadState.X0;
+            int  IdealCore =  (int)ThreadState.X1;
+            long CoreMask  = (long)ThreadState.X2;
+
+            Device.Log.PrintDebug(LogClass.KernelSvc,
+                "Handle = 0x"    + Handle   .ToString("x8") + ", " +
+                "IdealCore = 0x" + IdealCore.ToString("x8") + ", " +
+                "CoreMask = 0x"  + CoreMask .ToString("x16"));
+
+            KThread Thread = GetThread(ThreadState.Tpidr, Handle);
+
+            if (IdealCore == -2)
+            {
+                //TODO: Get this value from the NPDM file.
+                IdealCore = 0;
+
+                CoreMask = 1 << IdealCore;
+            }
+            else
+            {
+                if ((uint)IdealCore > 3)
+                {
+                    if ((IdealCore | 2) != -1)
+                    {
+                        Device.Log.PrintWarning(LogClass.KernelSvc, $"Invalid core id 0x{IdealCore:x8}!");
+
+                        ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidCoreId);
+
+                        return;
+                    }
+                }
+                else if ((CoreMask & (1 << IdealCore)) == 0)
+                {
+                    Device.Log.PrintWarning(LogClass.KernelSvc, $"Invalid core mask 0x{CoreMask:x8}!");
+
+                    ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMaskValue);
+
+                    return;
+                }
+            }
+
+            if (Thread == null)
+            {
+                Device.Log.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!");
+
+                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
+
+                return;
+            }
+
+            //-1 is used as "don't care", so the IdealCore value is ignored.
+            //-2 is used as "use NPDM default core id" (handled above).
+            //-3 is used as "don't update", the old IdealCore value is kept.
+            if (IdealCore == -3 && (CoreMask & (1 << Thread.IdealCore)) == 0)
+            {
+                Device.Log.PrintWarning(LogClass.KernelSvc, $"Invalid core mask 0x{CoreMask:x8}!");
+
+                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMaskValue);
+
+                return;
+            }
+
+            Process.Scheduler.ChangeCore(Thread, IdealCore, (int)CoreMask);
+
+            ThreadState.X0 = 0;
+        }
+
+        private void SvcGetCurrentProcessorNumber(AThreadState ThreadState)
+        {
+            ThreadState.X0 = (ulong)Process.GetThread(ThreadState.Tpidr).ActualCore;
+        }
+
+        private void SvcGetThreadId(AThreadState ThreadState)
+        {
+            int Handle = (int)ThreadState.X1;
+
+            KThread Thread = GetThread(ThreadState.Tpidr, Handle);
+
+            if (Thread != null)
+            {
+                ThreadState.X0 = 0;
+                ThreadState.X1 = (ulong)Thread.ThreadId;
+            }
+            else
+            {
+                Device.Log.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!");
+
+                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
+            }
+        }
+
+        private void SvcSetThreadActivity(AThreadState ThreadState)
+        {
+            int  Handle = (int)ThreadState.X0;
+            bool Active = (int)ThreadState.X1 == 0;
+
+            KThread Thread = Process.HandleTable.GetData<KThread>(Handle);
+
+            if (Thread != null)
+            {
+                Process.Scheduler.SetThreadActivity(Thread, Active);
+
+                ThreadState.X0 = 0;
+            }
+            else
+            {
+                Device.Log.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!");
+
+                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
+            }
+        }
+
+        private void SvcGetThreadContext3(AThreadState ThreadState)
+        {
+            long Position = (long)ThreadState.X0;
+            int  Handle   =  (int)ThreadState.X1;
+
+            KThread Thread = Process.HandleTable.GetData<KThread>(Handle);
+
+            if (Thread == null)
+            {
+                Device.Log.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!");
+
+                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
+
+                return;
+            }
+
+            if (Process.GetThread(ThreadState.Tpidr) == Thread)
+            {
+                Device.Log.PrintWarning(LogClass.KernelSvc, $"Thread handle 0x{Handle:x8} is current thread!");
+
+                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidThread);
+
+                return;
+            }
+
+            Memory.WriteUInt64(Position + 0x0,  ThreadState.X0);
+            Memory.WriteUInt64(Position + 0x8,  ThreadState.X1);
+            Memory.WriteUInt64(Position + 0x10, ThreadState.X2);
+            Memory.WriteUInt64(Position + 0x18, ThreadState.X3);
+            Memory.WriteUInt64(Position + 0x20, ThreadState.X4);
+            Memory.WriteUInt64(Position + 0x28, ThreadState.X5);
+            Memory.WriteUInt64(Position + 0x30, ThreadState.X6);
+            Memory.WriteUInt64(Position + 0x38, ThreadState.X7);
+            Memory.WriteUInt64(Position + 0x40, ThreadState.X8);
+            Memory.WriteUInt64(Position + 0x48, ThreadState.X9);
+            Memory.WriteUInt64(Position + 0x50, ThreadState.X10);
+            Memory.WriteUInt64(Position + 0x58, ThreadState.X11);
+            Memory.WriteUInt64(Position + 0x60, ThreadState.X12);
+            Memory.WriteUInt64(Position + 0x68, ThreadState.X13);
+            Memory.WriteUInt64(Position + 0x70, ThreadState.X14);
+            Memory.WriteUInt64(Position + 0x78, ThreadState.X15);
+            Memory.WriteUInt64(Position + 0x80, ThreadState.X16);
+            Memory.WriteUInt64(Position + 0x88, ThreadState.X17);
+            Memory.WriteUInt64(Position + 0x90, ThreadState.X18);
+            Memory.WriteUInt64(Position + 0x98, ThreadState.X19);
+            Memory.WriteUInt64(Position + 0xa0, ThreadState.X20);
+            Memory.WriteUInt64(Position + 0xa8, ThreadState.X21);
+            Memory.WriteUInt64(Position + 0xb0, ThreadState.X22);
+            Memory.WriteUInt64(Position + 0xb8, ThreadState.X23);
+            Memory.WriteUInt64(Position + 0xc0, ThreadState.X24);
+            Memory.WriteUInt64(Position + 0xc8, ThreadState.X25);
+            Memory.WriteUInt64(Position + 0xd0, ThreadState.X26);
+            Memory.WriteUInt64(Position + 0xd8, ThreadState.X27);
+            Memory.WriteUInt64(Position + 0xe0, ThreadState.X28);
+            Memory.WriteUInt64(Position + 0xe8, ThreadState.X29);
+            Memory.WriteUInt64(Position + 0xf0, ThreadState.X30);
+            Memory.WriteUInt64(Position + 0xf8, ThreadState.X31);
+
+            Memory.WriteInt64(Position + 0x100, Thread.LastPc);
+
+            Memory.WriteUInt64(Position + 0x108, (ulong)ThreadState.Psr);
+
+            Memory.WriteVector128(Position + 0x110, ThreadState.V0);
+            Memory.WriteVector128(Position + 0x120, ThreadState.V1);
+            Memory.WriteVector128(Position + 0x130, ThreadState.V2);
+            Memory.WriteVector128(Position + 0x140, ThreadState.V3);
+            Memory.WriteVector128(Position + 0x150, ThreadState.V4);
+            Memory.WriteVector128(Position + 0x160, ThreadState.V5);
+            Memory.WriteVector128(Position + 0x170, ThreadState.V6);
+            Memory.WriteVector128(Position + 0x180, ThreadState.V7);
+            Memory.WriteVector128(Position + 0x190, ThreadState.V8);
+            Memory.WriteVector128(Position + 0x1a0, ThreadState.V9);
+            Memory.WriteVector128(Position + 0x1b0, ThreadState.V10);
+            Memory.WriteVector128(Position + 0x1c0, ThreadState.V11);
+            Memory.WriteVector128(Position + 0x1d0, ThreadState.V12);
+            Memory.WriteVector128(Position + 0x1e0, ThreadState.V13);
+            Memory.WriteVector128(Position + 0x1f0, ThreadState.V14);
+            Memory.WriteVector128(Position + 0x200, ThreadState.V15);
+            Memory.WriteVector128(Position + 0x210, ThreadState.V16);
+            Memory.WriteVector128(Position + 0x220, ThreadState.V17);
+            Memory.WriteVector128(Position + 0x230, ThreadState.V18);
+            Memory.WriteVector128(Position + 0x240, ThreadState.V19);
+            Memory.WriteVector128(Position + 0x250, ThreadState.V20);
+            Memory.WriteVector128(Position + 0x260, ThreadState.V21);
+            Memory.WriteVector128(Position + 0x270, ThreadState.V22);
+            Memory.WriteVector128(Position + 0x280, ThreadState.V23);
+            Memory.WriteVector128(Position + 0x290, ThreadState.V24);
+            Memory.WriteVector128(Position + 0x2a0, ThreadState.V25);
+            Memory.WriteVector128(Position + 0x2b0, ThreadState.V26);
+            Memory.WriteVector128(Position + 0x2c0, ThreadState.V27);
+            Memory.WriteVector128(Position + 0x2d0, ThreadState.V28);
+            Memory.WriteVector128(Position + 0x2e0, ThreadState.V29);
+            Memory.WriteVector128(Position + 0x2f0, ThreadState.V30);
+            Memory.WriteVector128(Position + 0x300, ThreadState.V31);
+
+            Memory.WriteInt32(Position + 0x310, ThreadState.Fpcr);
+            Memory.WriteInt32(Position + 0x314, ThreadState.Fpsr);
+            Memory.WriteInt64(Position + 0x318, ThreadState.Tpidr);
+
+            ThreadState.X0 = 0;
+        }
+    }
+}
+\ No newline at end of file