Better process implementation (#491)

* Initial implementation of KProcess

* Some improvements to the memory manager, implement back guest stack trace printing

* Better GetInfo implementation, improve checking in some places with information from process capabilities

* Allow the cpu to read/write from the correct memory locations for accesses crossing a page boundary

* Change long -> ulong for address/size on memory related methods to avoid unnecessary casts

* Attempt at implementing ldr:ro with new KProcess

* Allow BSS with size 0 on ldr:ro

* Add checking for memory block slab heap usage, return errors if full, exit gracefully

* Use KMemoryBlockSize const from KMemoryManager

* Allow all methods to read from non-contiguous locations

* Fix for TransactParcelAuto

* Address PR feedback, additionally fix some small issues related to the KIP loader and implement SVCs GetProcessId, GetProcessList, GetSystemInfo, CreatePort and ManageNamedPort

* Fix wrong check for source pages count from page list on MapPhysicalMemory

* Fix some issues with UnloadNro on ldr:ro

ChocolArm64/CpuThread.cs

@@ -18,7 +18,7 @@ namespace ChocolArm64
 
         private int _isExecuting;
 
-        public CpuThread(Translator translator, MemoryManager memory, long entryPoint)
+        public CpuThread(Translator translator, MemoryManager memory, long entrypoint)
         {
             _translator = translator;
             Memory      = memory;
@@ -31,7 +31,7 @@ namespace ChocolArm64
 
             Work = new Thread(delegate()
             {
-                translator.ExecuteSubroutine(this, entryPoint);
+                translator.ExecuteSubroutine(this, entrypoint);
 
                 memory.RemoveMonitor(ThreadState.Core);
 

ChocolArm64/Exceptions/VmmOutOfMemoryException.cs

@@ -1,13 +0,0 @@
-using System;
-
-namespace ChocolArm64.Exceptions
-{
-    public class VmmAccessException : Exception
-    {
-        private const string ExMsg = "Memory region at 0x{0} with size 0x{1} is not contiguous!";
-
-        public VmmAccessException() { }
-
-        public VmmAccessException(long position, long size) : base(string.Format(ExMsg, position, size)) { }
-    }
-}

ChocolArm64/Memory/MemoryHelper.cs

@@ -26,22 +26,26 @@ namespace ChocolArm64.Memory
         {
             long size = Marshal.SizeOf<T>();
 
-            memory.EnsureRangeIsValid(position, size);
+            byte[] data = memory.ReadBytes(position, size);
 
-            IntPtr ptr = (IntPtr)memory.Translate(position);
-
-            return Marshal.PtrToStructure<T>(ptr);
+            fixed (byte* ptr = data)
+            {
+                return Marshal.PtrToStructure<T>((IntPtr)ptr);
+            }
         }
 
         public unsafe static void Write<T>(MemoryManager memory, long position, T value) where T : struct
         {
             long size = Marshal.SizeOf<T>();
 
-            memory.EnsureRangeIsValid(position, size);
+            byte[] data = new byte[size];
 
-            IntPtr ptr = (IntPtr)memory.TranslateWrite(position);
+            fixed (byte* ptr = data)
+            {
+                Marshal.StructureToPtr<T>(value, (IntPtr)ptr, false);
+            }
 
-            Marshal.StructureToPtr<T>(value, ptr, false);
+            memory.WriteBytes(position, data);
         }
 
         public static string ReadAsciiString(MemoryManager memory, long position, long maxSize = -1)

ChocolArm64/Memory/MemoryManager.cs

@@ -1,5 +1,6 @@
 using ChocolArm64.Events;
 using ChocolArm64.Exceptions;
+using ChocolArm64.Instructions;
 using ChocolArm64.State;
 using System;
 using System.Collections.Concurrent;
@@ -197,17 +198,41 @@ namespace ChocolArm64.Memory
 
         public ushort ReadUInt16(long position)
         {
-            return *((ushort*)Translate(position));
+            if ((position & 1) == 0)
+            {
+                return *((ushort*)Translate(position));
+            }
+            else
+            {
+                return (ushort)(ReadByte(position + 0) << 0 |
+                                ReadByte(position + 1) << 8);
+            }
         }
 
         public uint ReadUInt32(long position)
         {
-            return *((uint*)Translate(position));
+            if ((position & 3) == 0)
+            {
+                return *((uint*)Translate(position));
+            }
+            else
+            {
+                return (uint)(ReadUInt16(position + 0) << 0 |
+                              ReadUInt16(position + 2) << 16);
+            }
         }
 
         public ulong ReadUInt64(long position)
         {
-            return *((ulong*)Translate(position));
+            if ((position & 7) == 0)
+            {
+                return *((ulong*)Translate(position));
+            }
+            else
+            {
+                return (ulong)ReadUInt32(position + 0) << 0 |
+                       (ulong)ReadUInt32(position + 4) << 32;
+            }
         }
 
         public Vector128<float> ReadVector8(long position)
@@ -218,74 +243,117 @@ namespace ChocolArm64.Memory
             }
             else
             {
-                throw new PlatformNotSupportedException();
+                Vector128<float> value = VectorHelper.VectorSingleZero();
+
+                value = VectorHelper.VectorInsertInt(ReadByte(position), value, 0, 0);
+
+                return value;
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Vector128<float> ReadVector16(long position)
         {
-            if (Sse2.IsSupported)
+            if (Sse2.IsSupported && (position & 1) == 0)
             {
                 return Sse.StaticCast<ushort, float>(Sse2.Insert(Sse2.SetZeroVector128<ushort>(), ReadUInt16(position), 0));
             }
             else
             {
-                throw new PlatformNotSupportedException();
+                Vector128<float> value = VectorHelper.VectorSingleZero();
+
+                value = VectorHelper.VectorInsertInt(ReadUInt16(position), value, 0, 1);
+
+                return value;
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Vector128<float> ReadVector32(long position)
         {
-            if (Sse.IsSupported)
+            if (Sse.IsSupported && (position & 3) == 0)
             {
                 return Sse.LoadScalarVector128((float*)Translate(position));
             }
             else
             {
-                throw new PlatformNotSupportedException();
+                Vector128<float> value = VectorHelper.VectorSingleZero();
+
+                value = VectorHelper.VectorInsertInt(ReadUInt32(position), value, 0, 2);
+
+                return value;
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Vector128<float> ReadVector64(long position)
         {
-            if (Sse2.IsSupported)
+            if (Sse2.IsSupported && (position & 7) == 0)
             {
                 return Sse.StaticCast<double, float>(Sse2.LoadScalarVector128((double*)Translate(position)));
             }
             else
             {
-                throw new PlatformNotSupportedException();
+                Vector128<float> value = VectorHelper.VectorSingleZero();
+
+                value = VectorHelper.VectorInsertInt(ReadUInt64(position), value, 0, 3);
+
+                return value;
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Vector128<float> ReadVector128(long position)
         {
-            if (Sse.IsSupported)
+            if (Sse.IsSupported && (position & 15) == 0)
             {
                 return Sse.LoadVector128((float*)Translate(position));
             }
             else
             {
-                throw new PlatformNotSupportedException();
+                Vector128<float> value = VectorHelper.VectorSingleZero();
+
+                value = VectorHelper.VectorInsertInt(ReadUInt64(position + 0), value, 0, 3);
+                value = VectorHelper.VectorInsertInt(ReadUInt64(position + 8), value, 1, 3);
+
+                return value;
             }
         }
 
         public byte[] ReadBytes(long position, long size)
         {
-            if ((uint)size > int.MaxValue)
+            long endAddr = position + size;
+
+            if ((ulong)size > int.MaxValue)
             {
                 throw new ArgumentOutOfRangeException(nameof(size));
             }
 
-            EnsureRangeIsValid(position, size);
+            if ((ulong)endAddr < (ulong)position)
+            {
+                throw new ArgumentOutOfRangeException(nameof(position));
+            }
 
             byte[] data = new byte[size];
 
-            Marshal.Copy((IntPtr)Translate(position), data, 0, (int)size);
+            int offset = 0;
+
+            while ((ulong)position < (ulong)endAddr)
+            {
+                long pageLimit = (position + PageSize) & ~(long)PageMask;
+
+                if ((ulong)pageLimit > (ulong)endAddr)
+                {
+                    pageLimit = endAddr;
+                }
+
+                int copySize = (int)(pageLimit - position);
+
+                Marshal.Copy((IntPtr)Translate(position), data, offset, copySize);
+
+                position += copySize;
+                offset   += copySize;
+            }
 
             return data;
         }
@@ -293,9 +361,36 @@ namespace ChocolArm64.Memory
         public void ReadBytes(long position, byte[] data, int startIndex, int size)
         {
             //Note: This will be moved later.
-            EnsureRangeIsValid(position, (uint)size);
+            long endAddr = position + size;
 
-            Marshal.Copy((IntPtr)Translate(position), data, startIndex, size);
+            if ((ulong)size > int.MaxValue)
+            {
+                throw new ArgumentOutOfRangeException(nameof(size));
+            }
+
+            if ((ulong)endAddr < (ulong)position)
+            {
+                throw new ArgumentOutOfRangeException(nameof(position));
+            }
+
+            int offset = startIndex;
+
+            while ((ulong)position < (ulong)endAddr)
+            {
+                long pageLimit = (position + PageSize) & ~(long)PageMask;
+
+                if ((ulong)pageLimit > (ulong)endAddr)
+                {
+                    pageLimit = endAddr;
+                }
+
+                int copySize = (int)(pageLimit - position);
+
+                Marshal.Copy((IntPtr)Translate(position), data, offset, copySize);
+
+                position += copySize;
+                offset   += copySize;
+            }
         }
 
         public void WriteSByte(long position, sbyte value)
@@ -325,17 +420,41 @@ namespace ChocolArm64.Memory
 
         public void WriteUInt16(long position, ushort value)
         {
-            *((ushort*)TranslateWrite(position)) = value;
+            if ((position & 1) == 0)
+            {
+                *((ushort*)TranslateWrite(position)) = value;
+            }
+            else
+            {
+                WriteByte(position + 0, (byte)(value >> 0));
+                WriteByte(position + 1, (byte)(value >> 8));
+            }
         }
 
         public void WriteUInt32(long position, uint value)
         {
-            *((uint*)TranslateWrite(position)) = value;
+            if ((position & 3) == 0)
+            {
+                *((uint*)TranslateWrite(position)) = value;
+            }
+            else
+            {
+                WriteUInt16(position + 0, (ushort)(value >> 0));
+                WriteUInt16(position + 2, (ushort)(value >> 16));
+            }
         }
 
         public void WriteUInt64(long position, ulong value)
         {
-            *((ulong*)TranslateWrite(position)) = value;
+            if ((position & 7) == 0)
+            {
+                *((ulong*)TranslateWrite(position)) = value;
+            }
+            else
+            {
+                WriteUInt32(position + 0, (uint)(value >> 0));
+                WriteUInt32(position + 4, (uint)(value >> 32));
+            }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -351,7 +470,7 @@ namespace ChocolArm64.Memory
             }
             else
             {
-                throw new PlatformNotSupportedException();
+                WriteByte(position, (byte)VectorHelper.VectorExtractIntZx(value, 0, 0));
             }
         }
 
@@ -364,46 +483,47 @@ namespace ChocolArm64.Memory
             }
             else
             {
-                throw new PlatformNotSupportedException();
+                WriteUInt16(position, (ushort)VectorHelper.VectorExtractIntZx(value, 0, 1));
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteVector32(long position, Vector128<float> value)
         {
-            if (Sse.IsSupported)
+            if (Sse.IsSupported && (position & 3) == 0)
             {
                 Sse.StoreScalar((float*)TranslateWrite(position), value);
             }
             else
             {
-                throw new PlatformNotSupportedException();
+                WriteUInt32(position, (uint)VectorHelper.VectorExtractIntZx(value, 0, 2));
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteVector64(long position, Vector128<float> value)
         {
-            if (Sse2.IsSupported)
+            if (Sse2.IsSupported && (position & 7) == 0)
             {
                 Sse2.StoreScalar((double*)TranslateWrite(position), Sse.StaticCast<float, double>(value));
             }
             else
             {
-                throw new PlatformNotSupportedException();
+                WriteUInt64(position, VectorHelper.VectorExtractIntZx(value, 0, 3));
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteVector128(long position, Vector128<float> value)
         {
-            if (Sse.IsSupported)
+            if (Sse.IsSupported && (position & 15) == 0)
             {
                 Sse.Store((float*)TranslateWrite(position), value);
             }
             else
             {
-                throw new PlatformNotSupportedException();
+                WriteUInt64(position + 0, VectorHelper.VectorExtractIntZx(value, 0, 3));
+                WriteUInt64(position + 8, VectorHelper.VectorExtractIntZx(value, 1, 3));
             }
         }
 
@@ -439,22 +559,48 @@ namespace ChocolArm64.Memory
         public void WriteBytes(long position, byte[] data, int startIndex, int size)
         {
             //Note: This will be moved later.
-            //Using Translate instead of TranslateWrite is on purpose.
-            EnsureRangeIsValid(position, (uint)size);
+            long endAddr = position + size;
 
-            Marshal.Copy(data, startIndex, (IntPtr)Translate(position), size);
+            if ((ulong)endAddr < (ulong)position)
+            {
+                throw new ArgumentOutOfRangeException(nameof(position));
+            }
+
+            int offset = startIndex;
+
+            while ((ulong)position < (ulong)endAddr)
+            {
+                long pageLimit = (position + PageSize) & ~(long)PageMask;
+
+                if ((ulong)pageLimit > (ulong)endAddr)
+                {
+                    pageLimit = endAddr;
+                }
+
+                int copySize = (int)(pageLimit - position);
+
+                Marshal.Copy(data, offset, (IntPtr)TranslateWrite(position), copySize);
+
+                position += copySize;
+                offset   += copySize;
+            }
         }
 
         public void CopyBytes(long src, long dst, long size)
         {
             //Note: This will be moved later.
-            EnsureRangeIsValid(src, size);
-            EnsureRangeIsValid(dst, size);
+            if (IsContiguous(src, size) &&
+                IsContiguous(dst, size))
+            {
+                byte* srcPtr = Translate(src);
+                byte* dstPtr = TranslateWrite(dst);
 
-            byte* srcPtr = Translate(src);
-            byte* dstPtr = TranslateWrite(dst);
-
-            Buffer.MemoryCopy(srcPtr, dstPtr, size, size);
+                Buffer.MemoryCopy(srcPtr, dstPtr, size, size);
+            }
+            else
+            {
+                WriteBytes(dst, ReadBytes(src, size));
+            }
         }
 
         public void Map(long va, long pa, long size)
@@ -703,14 +849,21 @@ Unmapped:
             }
         }
 
-        public IntPtr GetHostAddress(long position, long size)
+        public bool TryGetHostAddress(long position, long size, out IntPtr ptr)
         {
-            EnsureRangeIsValid(position, size);
+            if (IsContiguous(position, size))
+            {
+                ptr = (IntPtr)Translate(position);
 
-            return (IntPtr)Translate(position);
+                return true;
+            }
+
+            ptr = IntPtr.Zero;
+
+            return false;
         }
 
-        internal void EnsureRangeIsValid(long position, long size)
+        private bool IsContiguous(long position, long size)
         {
             long endPos = position + size;
 
@@ -724,12 +877,14 @@ Unmapped:
 
                 if (pa != expectedPa)
                 {
-                    throw new VmmAccessException(position, size);
+                    return false;
                 }
 
                 position   += PageSize;
                 expectedPa += PageSize;
             }
+
+            return true;
         }
 
         public bool IsValidPosition(long position)

Ryujinx.Common/BitUtils.cs

@@ -0,0 +1,104 @@
+namespace Ryujinx.Common
+{
+    public static class BitUtils
+    {
+        public static int AlignUp(int Value, int Size)
+        {
+            return (Value + (Size - 1)) & -Size;
+        }
+
+        public static ulong AlignUp(ulong Value, int Size)
+        {
+            return (ulong)AlignUp((long)Value, Size);
+        }
+
+        public static long AlignUp(long Value, int Size)
+        {
+            return (Value + (Size - 1)) & -(long)Size;
+        }
+
+        public static int AlignDown(int Value, int Size)
+        {
+            return Value & -Size;
+        }
+
+        public static ulong AlignDown(ulong Value, int Size)
+        {
+            return (ulong)AlignDown((long)Value, Size);
+        }
+
+        public static long AlignDown(long Value, int Size)
+        {
+            return Value & -(long)Size;
+        }
+
+        public static ulong DivRoundUp(ulong Value, uint Dividend)
+        {
+            return (Value + Dividend - 1) / Dividend;
+        }
+
+        public static long DivRoundUp(long Value, int Dividend)
+        {
+            return (Value + Dividend - 1) / Dividend;
+        }
+
+        public static bool IsPowerOfTwo32(int Value)
+        {
+            return Value != 0 && (Value & (Value - 1)) == 0;
+        }
+
+        public static bool IsPowerOfTwo64(long Value)
+        {
+            return Value != 0 && (Value & (Value - 1)) == 0;
+        }
+
+        public static int CountLeadingZeros32(int Value)
+        {
+            return (int)CountLeadingZeros((ulong)Value, 32);
+        }
+
+        public static int CountLeadingZeros64(long Value)
+        {
+            return (int)CountLeadingZeros((ulong)Value, 64);
+        }
+
+        private static readonly byte[] ClzNibbleTbl = { 4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+        private static ulong CountLeadingZeros(ulong Value, int Size) // Size is 8, 16, 32 or 64 (SIMD&FP or Base Inst.).
+        {
+            if (Value == 0ul)
+            {
+                return (ulong)Size;
+            }
+
+            int NibbleIdx = Size;
+            int PreCount, Count = 0;
+
+            do
+            {
+                NibbleIdx -= 4;
+                PreCount = ClzNibbleTbl[(Value >> NibbleIdx) & 0b1111];
+                Count += PreCount;
+            }
+            while (PreCount == 4);
+
+            return (ulong)Count;
+        }
+
+        public static long ReverseBits64(long Value)
+        {
+            return (long)ReverseBits64((ulong)Value);
+        }
+
+        private static ulong ReverseBits64(ulong Value)
+        {
+            Value = ((Value & 0xaaaaaaaaaaaaaaaa) >> 1 ) | ((Value & 0x5555555555555555) << 1 );
+            Value = ((Value & 0xcccccccccccccccc) >> 2 ) | ((Value & 0x3333333333333333) << 2 );
+            Value = ((Value & 0xf0f0f0f0f0f0f0f0) >> 4 ) | ((Value & 0x0f0f0f0f0f0f0f0f) << 4 );
+            Value = ((Value & 0xff00ff00ff00ff00) >> 8 ) | ((Value & 0x00ff00ff00ff00ff) << 8 );
+            Value = ((Value & 0xffff0000ffff0000) >> 16) | ((Value & 0x0000ffff0000ffff) << 16);
+
+            return (Value >> 32) | (Value << 32);
+        }
+    }
+}

Ryujinx.Graphics/Gal/GalVertexAttrib.cs

@@ -1,5 +1,3 @@
-using System;
-
 namespace Ryujinx.Graphics.Gal
 {
     public struct GalVertexAttrib
@@ -7,7 +5,7 @@ namespace Ryujinx.Graphics.Gal
         public int    Index   { get; private set; }
         public bool   IsConst { get; private set; }
         public int    Offset  { get; private set; }
-        public IntPtr Pointer { get; private set; }
+        public byte[] Data    { get; private set; }
 
         public GalVertexAttribSize Size { get; private set; }
         public GalVertexAttribType Type { get; private set; }
@@ -18,14 +16,14 @@ namespace Ryujinx.Graphics.Gal
             int                 Index,
             bool                IsConst,
             int                 Offset,
-            IntPtr              Pointer,
+            byte[]              Data,
             GalVertexAttribSize Size,
             GalVertexAttribType Type,
             bool                IsBgra)
         {
             this.Index   = Index;
             this.IsConst = IsConst;
-            this.Pointer = Pointer;
+            this.Data    = Data;
             this.Offset  = Offset;
             this.Size    = Size;
             this.Type    = Type;

Ryujinx.Graphics/Gal/IGalConstBuffer.cs

@@ -12,5 +12,6 @@ namespace Ryujinx.Graphics.Gal
         bool IsCached(long Key, long Size);
 
         void SetData(long Key, long Size, IntPtr HostAddress);
+        void SetData(long Key, byte[] Data);
     }
 }

Ryujinx.Graphics/Gal/IGalRasterizer.cs

@@ -22,6 +22,7 @@ namespace Ryujinx.Graphics.Gal
         bool IsIboCached(long Key, long DataSize);
 
         void CreateVbo(long Key, int DataSize, IntPtr HostAddress);
+        void CreateVbo(long Key, byte[] Data);
 
         void CreateIbo(long Key, int DataSize, IntPtr HostAddress);
         void CreateIbo(long Key, int DataSize, byte[] Buffer);

Ryujinx.Graphics/Gal/OpenGL/OGLConstBuffer.cs

@@ -44,6 +44,14 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             }
         }
 
+        public void SetData(long Key, byte[] Data)
+        {
+            if (Cache.TryGetValue(Key, out OGLStreamBuffer Buffer))
+            {
+                Buffer.SetData(Data);
+            }
+        }
+
         public bool TryGetUbo(long Key, out int UboHandle)
         {
             if (Cache.TryGetValue(Key, out OGLStreamBuffer Buffer))

Ryujinx.Graphics/Gal/OpenGL/OGLPipeline.cs

@@ -600,122 +600,125 @@ namespace Ryujinx.Graphics.Gal.OpenGL
                 ThrowUnsupportedAttrib(Attrib);
             }
 
-            if (Attrib.Type == GalVertexAttribType.Unorm)
+            fixed (byte* Ptr = Attrib.Data)
             {
-                switch (Attrib.Size)
+                if (Attrib.Type == GalVertexAttribType.Unorm)
                 {
-                    case GalVertexAttribSize._8:
-                    case GalVertexAttribSize._8_8:
-                    case GalVertexAttribSize._8_8_8:
-                    case GalVertexAttribSize._8_8_8_8:
-                        GL.VertexAttrib4N((uint)Attrib.Index, (byte*)Attrib.Pointer);
-                        break;
+                    switch (Attrib.Size)
+                    {
+                        case GalVertexAttribSize._8:
+                        case GalVertexAttribSize._8_8:
+                        case GalVertexAttribSize._8_8_8:
+                        case GalVertexAttribSize._8_8_8_8:
+                            GL.VertexAttrib4N((uint)Attrib.Index, Ptr);
+                            break;
 
-                    case GalVertexAttribSize._16:
-                    case GalVertexAttribSize._16_16:
-                    case GalVertexAttribSize._16_16_16:
-                    case GalVertexAttribSize._16_16_16_16:
-                        GL.VertexAttrib4N((uint)Attrib.Index, (ushort*)Attrib.Pointer);
-                        break;
+                        case GalVertexAttribSize._16:
+                        case GalVertexAttribSize._16_16:
+                        case GalVertexAttribSize._16_16_16:
+                        case GalVertexAttribSize._16_16_16_16:
+                            GL.VertexAttrib4N((uint)Attrib.Index, (ushort*)Ptr);
+                            break;
 
-                    case GalVertexAttribSize._32:
-                    case GalVertexAttribSize._32_32:
-                    case GalVertexAttribSize._32_32_32:
-                    case GalVertexAttribSize._32_32_32_32:
-                        GL.VertexAttrib4N((uint)Attrib.Index, (uint*)Attrib.Pointer);
-                        break;
+                        case GalVertexAttribSize._32:
+                        case GalVertexAttribSize._32_32:
+                        case GalVertexAttribSize._32_32_32:
+                        case GalVertexAttribSize._32_32_32_32:
+                            GL.VertexAttrib4N((uint)Attrib.Index, (uint*)Ptr);
+                            break;
+                    }
                 }
-            }
-            else if (Attrib.Type == GalVertexAttribType.Snorm)
-            {
-                switch (Attrib.Size)
+                else if (Attrib.Type == GalVertexAttribType.Snorm)
                 {
-                    case GalVertexAttribSize._8:
-                    case GalVertexAttribSize._8_8:
-                    case GalVertexAttribSize._8_8_8:
-                    case GalVertexAttribSize._8_8_8_8:
-                        GL.VertexAttrib4N((uint)Attrib.Index, (sbyte*)Attrib.Pointer);
-                        break;
+                    switch (Attrib.Size)
+                    {
+                        case GalVertexAttribSize._8:
+                        case GalVertexAttribSize._8_8:
+                        case GalVertexAttribSize._8_8_8:
+                        case GalVertexAttribSize._8_8_8_8:
+                            GL.VertexAttrib4N((uint)Attrib.Index, (sbyte*)Ptr);
+                            break;
 
-                    case GalVertexAttribSize._16:
-                    case GalVertexAttribSize._16_16:
-                    case GalVertexAttribSize._16_16_16:
-                    case GalVertexAttribSize._16_16_16_16:
-                        GL.VertexAttrib4N((uint)Attrib.Index, (short*)Attrib.Pointer);
-                        break;
+                        case GalVertexAttribSize._16:
+                        case GalVertexAttribSize._16_16:
+                        case GalVertexAttribSize._16_16_16:
+                        case GalVertexAttribSize._16_16_16_16:
+                            GL.VertexAttrib4N((uint)Attrib.Index, (short*)Ptr);
+                            break;
 
-                    case GalVertexAttribSize._32:
-                    case GalVertexAttribSize._32_32:
-                    case GalVertexAttribSize._32_32_32:
-                    case GalVertexAttribSize._32_32_32_32:
-                        GL.VertexAttrib4N((uint)Attrib.Index, (int*)Attrib.Pointer);
-                        break;
+                        case GalVertexAttribSize._32:
+                        case GalVertexAttribSize._32_32:
+                        case GalVertexAttribSize._32_32_32:
+                        case GalVertexAttribSize._32_32_32_32:
+                            GL.VertexAttrib4N((uint)Attrib.Index, (int*)Ptr);
+                            break;
+                    }
                 }
-            }
-            else if (Attrib.Type == GalVertexAttribType.Uint)
-            {
-                switch (Attrib.Size)
+                else if (Attrib.Type == GalVertexAttribType.Uint)
                 {
-                    case GalVertexAttribSize._8:
-                    case GalVertexAttribSize._8_8:
-                    case GalVertexAttribSize._8_8_8:
-                    case GalVertexAttribSize._8_8_8_8:
-                        GL.VertexAttribI4((uint)Attrib.Index, (byte*)Attrib.Pointer);
-                        break;
+                    switch (Attrib.Size)
+                    {
+                        case GalVertexAttribSize._8:
+                        case GalVertexAttribSize._8_8:
+                        case GalVertexAttribSize._8_8_8:
+                        case GalVertexAttribSize._8_8_8_8:
+                            GL.VertexAttribI4((uint)Attrib.Index, Ptr);
+                            break;
 
-                    case GalVertexAttribSize._16:
-                    case GalVertexAttribSize._16_16:
-                    case GalVertexAttribSize._16_16_16:
-                    case GalVertexAttribSize._16_16_16_16:
-                        GL.VertexAttribI4((uint)Attrib.Index, (ushort*)Attrib.Pointer);
-                        break;
+                        case GalVertexAttribSize._16:
+                        case GalVertexAttribSize._16_16:
+                        case GalVertexAttribSize._16_16_16:
+                        case GalVertexAttribSize._16_16_16_16:
+                            GL.VertexAttribI4((uint)Attrib.Index, (ushort*)Ptr);
+                            break;
 
-                    case GalVertexAttribSize._32:
-                    case GalVertexAttribSize._32_32:
-                    case GalVertexAttribSize._32_32_32:
-                    case GalVertexAttribSize._32_32_32_32:
-                        GL.VertexAttribI4((uint)Attrib.Index, (uint*)Attrib.Pointer);
-                        break;
+                        case GalVertexAttribSize._32:
+                        case GalVertexAttribSize._32_32:
+                        case GalVertexAttribSize._32_32_32:
+                        case GalVertexAttribSize._32_32_32_32:
+                            GL.VertexAttribI4((uint)Attrib.Index, (uint*)Ptr);
+                            break;
+                    }
                 }
-            }
-            else if (Attrib.Type == GalVertexAttribType.Sint)
-            {
-                switch (Attrib.Size)
+                else if (Attrib.Type == GalVertexAttribType.Sint)
                 {
-                    case GalVertexAttribSize._8:
-                    case GalVertexAttribSize._8_8:
-                    case GalVertexAttribSize._8_8_8:
-                    case GalVertexAttribSize._8_8_8_8:
-                        GL.VertexAttribI4((uint)Attrib.Index, (sbyte*)Attrib.Pointer);
-                        break;
+                    switch (Attrib.Size)
+                    {
+                        case GalVertexAttribSize._8:
+                        case GalVertexAttribSize._8_8:
+                        case GalVertexAttribSize._8_8_8:
+                        case GalVertexAttribSize._8_8_8_8:
+                            GL.VertexAttribI4((uint)Attrib.Index, (sbyte*)Ptr);
+                            break;
 
-                    case GalVertexAttribSize._16:
-                    case GalVertexAttribSize._16_16:
-                    case GalVertexAttribSize._16_16_16:
-                    case GalVertexAttribSize._16_16_16_16:
-                        GL.VertexAttribI4((uint)Attrib.Index, (short*)Attrib.Pointer);
-                        break;
+                        case GalVertexAttribSize._16:
+                        case GalVertexAttribSize._16_16:
+                        case GalVertexAttribSize._16_16_16:
+                        case GalVertexAttribSize._16_16_16_16:
+                            GL.VertexAttribI4((uint)Attrib.Index, (short*)Ptr);
+                            break;
 
-                    case GalVertexAttribSize._32:
-                    case GalVertexAttribSize._32_32:
-                    case GalVertexAttribSize._32_32_32:
-                    case GalVertexAttribSize._32_32_32_32:
-                        GL.VertexAttribI4((uint)Attrib.Index, (int*)Attrib.Pointer);
-                        break;
+                        case GalVertexAttribSize._32:
+                        case GalVertexAttribSize._32_32:
+                        case GalVertexAttribSize._32_32_32:
+                        case GalVertexAttribSize._32_32_32_32:
+                            GL.VertexAttribI4((uint)Attrib.Index, (int*)Ptr);
+                            break;
+                    }
                 }
-            }
-            else if (Attrib.Type == GalVertexAttribType.Float)
-            {
-                switch (Attrib.Size)
+                else if (Attrib.Type == GalVertexAttribType.Float)
                 {
-                    case GalVertexAttribSize._32:
-                    case GalVertexAttribSize._32_32:
-                    case GalVertexAttribSize._32_32_32:
-                    case GalVertexAttribSize._32_32_32_32:
-                        GL.VertexAttrib4(Attrib.Index, (float*)Attrib.Pointer);
-                        break;
+                    switch (Attrib.Size)
+                    {
+                        case GalVertexAttribSize._32:
+                        case GalVertexAttribSize._32_32:
+                        case GalVertexAttribSize._32_32_32:
+                        case GalVertexAttribSize._32_32_32_32:
+                            GL.VertexAttrib4(Attrib.Index, (float*)Ptr);
+                            break;
 
-                    default: ThrowUnsupportedAttrib(Attrib); break;
+                        default: ThrowUnsupportedAttrib(Attrib); break;
+                    }
                 }
             }
         }

Ryujinx.Graphics/Gal/OpenGL/OGLRasterizer.cs

@@ -92,7 +92,7 @@ namespace Ryujinx.Graphics.Gal.OpenGL
         {
             int Handle = GL.GenBuffer();
 
-            VboCache.AddOrUpdate(Key, Handle, (uint)DataSize);
+            VboCache.AddOrUpdate(Key, Handle, DataSize);
 
             IntPtr Length = new IntPtr(DataSize);
 
@@ -100,6 +100,18 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             GL.BufferData(BufferTarget.ArrayBuffer, Length, HostAddress, BufferUsageHint.StreamDraw);
         }
 
+        public void CreateVbo(long Key, byte[] Data)
+        {
+            int Handle = GL.GenBuffer();
+
+            VboCache.AddOrUpdate(Key, Handle, Data.Length);
+
+            IntPtr Length = new IntPtr(Data.Length);
+
+            GL.BindBuffer(BufferTarget.ArrayBuffer, Handle);
+            GL.BufferData(BufferTarget.ArrayBuffer, Length, Data, BufferUsageHint.StreamDraw);
+        }
+
         public void CreateIbo(long Key, int DataSize, IntPtr HostAddress)
         {
             int Handle = GL.GenBuffer();
@@ -116,7 +128,7 @@ namespace Ryujinx.Graphics.Gal.OpenGL
         {
             int Handle = GL.GenBuffer();
 
-            IboCache.AddOrUpdate(Key, Handle, (uint)DataSize);
+            IboCache.AddOrUpdate(Key, Handle, DataSize);
 
             IntPtr Length = new IntPtr(Buffer.Length);
 

Ryujinx.Graphics/Gal/OpenGL/OGLStreamBuffer.cs

@@ -30,6 +30,13 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             GL.BufferSubData(Target, IntPtr.Zero, (IntPtr)Size, HostAddress);
         }
 
+        public void SetData(byte[] Data)
+        {
+            GL.BindBuffer(Target, Handle);
+
+            GL.BufferSubData(Target, IntPtr.Zero, (IntPtr)Data.Length, Data);
+        }
+
         public void Dispose()
         {
             Dispose(true);

Ryujinx.Graphics/Memory/NvGpuVmm.cs

@@ -243,9 +243,9 @@ namespace Ryujinx.Graphics.Memory
             return Cache.IsRegionModified(Memory, BufferType, PA, Size);
         }
 
-        public IntPtr GetHostAddress(long Position, long Size)
+        public bool TryGetHostAddress(long Position, long Size, out IntPtr Ptr)
         {
-            return Memory.GetHostAddress(GetPhysicalAddress(Position), Size);
+            return Memory.TryGetHostAddress(GetPhysicalAddress(Position), Size, out Ptr);
         }
 
         public byte ReadByte(long Position)

Ryujinx.Graphics/NvGpuEngine3d.cs

@@ -615,9 +615,14 @@ namespace Ryujinx.Graphics
 
                     if (Gpu.ResourceManager.MemoryRegionModified(Vmm, Key, Cb.Size, NvGpuBufferType.ConstBuffer))
                     {
-                        IntPtr Source = Vmm.GetHostAddress(Cb.Position, Cb.Size);
-
-                        Gpu.Renderer.Buffer.SetData(Key, Cb.Size, Source);
+                        if (Vmm.TryGetHostAddress(Cb.Position, Cb.Size, out IntPtr CbPtr))
+                        {
+                            Gpu.Renderer.Buffer.SetData(Key, Cb.Size, CbPtr);
+                        }
+                        else
+                        {
+                            Gpu.Renderer.Buffer.SetData(Key, Vmm.ReadBytes(Cb.Position, Cb.Size));
+                        }
                     }
 
                     State.ConstBufferKeys[Stage][DeclInfo.Cbuf] = Key;
@@ -660,9 +665,14 @@ namespace Ryujinx.Graphics
                 {
                     if (!UsesLegacyQuads)
                     {
-                        IntPtr DataAddress = Vmm.GetHostAddress(IbPosition, IbSize);
-
-                        Gpu.Renderer.Rasterizer.CreateIbo(IboKey, IbSize, DataAddress);
+                        if (Vmm.TryGetHostAddress(IbPosition, IbSize, out IntPtr IbPtr))
+                        {
+                            Gpu.Renderer.Rasterizer.CreateIbo(IboKey, IbSize, IbPtr);
+                        }
+                        else
+                        {
+                            Gpu.Renderer.Rasterizer.CreateIbo(IboKey, IbSize, Vmm.ReadBytes(IbPosition, IbSize));
+                        }
                     }
                     else
                     {
@@ -711,22 +721,22 @@ namespace Ryujinx.Graphics
                     Attribs[ArrayIndex] = new List<GalVertexAttrib>();
                 }
 
-                long VertexPosition = MakeInt64From2xInt32(NvGpuEngine3dReg.VertexArrayNAddress + ArrayIndex * 4);
+                long VbPosition = MakeInt64From2xInt32(NvGpuEngine3dReg.VertexArrayNAddress + ArrayIndex * 4);
+
+                bool IsConst = ((Packed >> 6) & 1) != 0;
 
                 int Offset = (Packed >> 7) & 0x3fff;
 
+                GalVertexAttribSize Size = (GalVertexAttribSize)((Packed >> 21) & 0x3f);
+                GalVertexAttribType Type = (GalVertexAttribType)((Packed >> 27) & 0x7);
+
+                bool IsRgba = ((Packed >> 31) & 1) != 0;
+
                 //Note: 16 is the maximum size of an attribute,
                 //having a component size of 32-bits with 4 elements (a vec4).
-                IntPtr Pointer = Vmm.GetHostAddress(VertexPosition + Offset, 16);
+                byte[] Data = Vmm.ReadBytes(VbPosition + Offset, 16);
 
-                Attribs[ArrayIndex].Add(new GalVertexAttrib(
-                                           Attr,
-                                         ((Packed >>  6) & 0x1) != 0,
-                                           Offset,
-                                           Pointer,
-                    (GalVertexAttribSize)((Packed >> 21) & 0x3f),
-                    (GalVertexAttribType)((Packed >> 27) & 0x7),
-                                         ((Packed >> 31) & 0x1) != 0));
+                Attribs[ArrayIndex].Add(new GalVertexAttrib(Attr, IsConst, Offset, Data, Size, Type, IsRgba));
             }
 
             State.VertexBindings = new GalVertexBinding[32];
@@ -747,8 +757,8 @@ namespace Ryujinx.Graphics
                     continue;
                 }
 
-                long VertexPosition = MakeInt64From2xInt32(NvGpuEngine3dReg.VertexArrayNAddress + Index * 4);
-                long VertexEndPos   = MakeInt64From2xInt32(NvGpuEngine3dReg.VertexArrayNEndAddr + Index * 2);
+                long VbPosition = MakeInt64From2xInt32(NvGpuEngine3dReg.VertexArrayNAddress + Index * 4);
+                long VbEndPos   = MakeInt64From2xInt32(NvGpuEngine3dReg.VertexArrayNEndAddr + Index * 2);
 
                 int VertexDivisor = ReadRegister(NvGpuEngine3dReg.VertexArrayNDivisor + Index * 4);
 
@@ -758,26 +768,31 @@ namespace Ryujinx.Graphics
 
                 if (Instanced && VertexDivisor != 0)
                 {
-                    VertexPosition += Stride * (CurrentInstance / VertexDivisor);
+                    VbPosition += Stride * (CurrentInstance / VertexDivisor);
                 }
 
-                if (VertexPosition > VertexEndPos)
+                if (VbPosition > VbEndPos)
                 {
                     //Instance is invalid, ignore the draw call
                     continue;
                 }
 
-                long VboKey = Vmm.GetPhysicalAddress(VertexPosition);
+                long VboKey = Vmm.GetPhysicalAddress(VbPosition);
 
-                long VbSize = (VertexEndPos - VertexPosition) + 1;
+                long VbSize = (VbEndPos - VbPosition) + 1;
 
                 bool VboCached = Gpu.Renderer.Rasterizer.IsVboCached(VboKey, VbSize);
 
                 if (!VboCached || Gpu.ResourceManager.MemoryRegionModified(Vmm, VboKey, VbSize, NvGpuBufferType.Vertex))
                 {
-                    IntPtr DataAddress = Vmm.GetHostAddress(VertexPosition, VbSize);
-
-                    Gpu.Renderer.Rasterizer.CreateVbo(VboKey, (int)VbSize, DataAddress);
+                    if (Vmm.TryGetHostAddress(VbPosition, VbSize, out IntPtr VbPtr))
+                    {
+                        Gpu.Renderer.Rasterizer.CreateVbo(VboKey, (int)VbSize, VbPtr);
+                    }
+                    else
+                    {
+                        Gpu.Renderer.Rasterizer.CreateVbo(VboKey, Vmm.ReadBytes(VbPosition, VbSize));
+                    }
                 }
 
                 State.VertexBindings[Index].Enabled   = true;

Ryujinx.HLE/DeviceMemory.cs

@@ -1,22 +1,18 @@
 using System;
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.Memory
+namespace Ryujinx.HLE
 {
     class DeviceMemory : IDisposable
     {
         public const long RamSize = 4L * 1024 * 1024 * 1024;
 
-        public ArenaAllocator Allocator { get; private set; }
-
         public IntPtr RamPointer { get; private set; }
 
         private unsafe byte* RamPtr;
 
         public unsafe DeviceMemory()
         {
-            Allocator = new ArenaAllocator(RamSize);
-
             RamPointer = Marshal.AllocHGlobal(new IntPtr(RamSize));
 
             RamPtr = (byte*)RamPointer;

Ryujinx.HLE/FileSystem/SaveHelper.cs

@@ -29,10 +29,7 @@ namespace Ryujinx.HLE.FileSystem
 
             if (SaveMetaData.TitleId == 0 && SaveMetaData.SaveDataType == SaveDataType.SaveData)
             {
-                if (Context.Process.MetaData != null)
-                {
-                    CurrentTitleId = Context.Process.MetaData.ACI0.TitleId;
-                }
+                CurrentTitleId = Context.Process.TitleId;
             }
 
             string SaveAccount = SaveMetaData.UserId.IsZero() ? "savecommon" : SaveMetaData.UserId.ToString();

Ryujinx.HLE/HOS/Font/SharedFontManager.cs

@@ -1,4 +1,4 @@
-using LibHac;
+using LibHac;
 using Ryujinx.HLE.FileSystem;
 using Ryujinx.HLE.FileSystem.Content;
 using Ryujinx.HLE.Resource;

Ryujinx.HLE/HOS/GlobalStateTable.cs

@@ -1,3 +1,4 @@
+using Ryujinx.HLE.HOS.Kernel;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 
@@ -5,28 +6,28 @@ namespace Ryujinx.HLE.HOS
 {
     class GlobalStateTable
     {
-        private ConcurrentDictionary<Process, IdDictionary> DictByProcess;
+        private ConcurrentDictionary<KProcess, IdDictionary> DictByProcess;
 
         public GlobalStateTable()
         {
-            DictByProcess = new ConcurrentDictionary<Process, IdDictionary>();
+            DictByProcess = new ConcurrentDictionary<KProcess, IdDictionary>();
         }
 
-        public bool Add(Process Process, int Id, object Data)
+        public bool Add(KProcess Process, int Id, object Data)
         {
             IdDictionary Dict = DictByProcess.GetOrAdd(Process, (Key) => new IdDictionary());
 
             return Dict.Add(Id, Data);
         }
 
-        public int Add(Process Process, object Data)
+        public int Add(KProcess Process, object Data)
         {
             IdDictionary Dict = DictByProcess.GetOrAdd(Process, (Key) => new IdDictionary());
 
             return Dict.Add(Data);
         }
 
-        public object GetData(Process Process, int Id)
+        public object GetData(KProcess Process, int Id)
         {
             if (DictByProcess.TryGetValue(Process, out IdDictionary Dict))
             {
@@ -36,7 +37,7 @@ namespace Ryujinx.HLE.HOS
             return null;
         }
 
-        public T GetData<T>(Process Process, int Id)
+        public T GetData<T>(KProcess Process, int Id)
         {
             if (DictByProcess.TryGetValue(Process, out IdDictionary Dict))
             {
@@ -46,7 +47,7 @@ namespace Ryujinx.HLE.HOS
             return default(T);
         }
 
-        public object Delete(Process Process, int Id)
+        public object Delete(KProcess Process, int Id)
         {
             if (DictByProcess.TryGetValue(Process, out IdDictionary Dict))
             {
@@ -56,7 +57,7 @@ namespace Ryujinx.HLE.HOS
             return null;
         }
 
-        public ICollection<object> DeleteProcess(Process Process)
+        public ICollection<object> DeleteProcess(KProcess Process)
         {
             if (DictByProcess.TryRemove(Process, out IdDictionary Dict))
             {

Ryujinx.HLE/HOS/Horizon.cs

@@ -11,32 +11,68 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using Nso = Ryujinx.HLE.Loaders.Executables.Nso;
+using System.Reflection;
+using System.Threading;
+
+using NxStaticObject = Ryujinx.HLE.Loaders.Executables.NxStaticObject;
 
 namespace Ryujinx.HLE.HOS
 {
     public class Horizon : IDisposable
     {
+        internal const int InitialKipId     = 1;
+        internal const int InitialProcessId = 0x51;
+
         internal const int HidSize  = 0x40000;
         internal const int FontSize = 0x1100000;
 
-        private Switch Device;
+        private const int MemoryBlockAllocatorSize = 0x2710;
 
-        private ConcurrentDictionary<int, Process> Processes;
+        private const ulong UserSlabHeapBase     = DramMemoryMap.SlabHeapBase;
+        private const ulong UserSlabHeapItemSize = KMemoryManager.PageSize;
+        private const ulong UserSlabHeapSize     = 0x3de000;
+
+        internal long PrivilegedProcessLowestId  { get; set; } = 1;
+        internal long PrivilegedProcessHighestId { get; set; } = 8;
+
+        internal Switch Device { get; private set; }
 
         public SystemStateMgr State { get; private set; }
 
-        internal KRecursiveLock CriticalSectionLock { get; private set; }
+        internal bool KernelInitialized { get; private set; }
+
+        internal KResourceLimit ResourceLimit { get; private set; }
+
+        internal KMemoryRegionManager[] MemoryRegions { get; private set; }
+
+        internal KMemoryBlockAllocator LargeMemoryBlockAllocator { get; private set; }
+        internal KMemoryBlockAllocator SmallMemoryBlockAllocator { get; private set; }
+
+        internal KSlabHeap UserSlabHeapPages { get; private set; }
+
+        internal KCriticalSection CriticalSection { get; private set; }
 
         internal KScheduler Scheduler { get; private set; }
 
         internal KTimeManager TimeManager { get; private set; }
 
-        internal KAddressArbiter AddressArbiter { get; private set; }
-
         internal KSynchronization Synchronization { get; private set; }
 
-        internal LinkedList<KThread> Withholders { get; private set; }
+        internal KContextIdManager ContextIdManager { get; private set; }
+
+        private long KipId;
+        private long ProcessId;
+        private long ThreadUid;
+
+        internal CountdownEvent ThreadCounter;
+
+        internal SortedDictionary<long, KProcess> Processes;
+
+        internal ConcurrentDictionary<string, KAutoObject> AutoObjectNames;
+
+        internal bool EnableVersionChecks { get; private set; }
+
+        internal AppletStateMgr AppletState { get; private set; }
 
         internal KSharedMemory HidSharedMem  { get; private set; }
         internal KSharedMemory FontSharedMem { get; private set; }
@@ -57,38 +93,74 @@ namespace Ryujinx.HLE.HOS
 
         public IntegrityCheckLevel FsIntegrityCheckLevel { get; set; }
 
+        internal long HidBaseAddress { get; private set; }
+
         public Horizon(Switch Device)
         {
             this.Device = Device;
 
-            Processes = new ConcurrentDictionary<int, Process>();
-
             State = new SystemStateMgr();
 
-            CriticalSectionLock = new KRecursiveLock(this);
+            ResourceLimit = new KResourceLimit(this);
+
+            KernelInit.InitializeResourceLimit(ResourceLimit);
+
+            MemoryRegions = KernelInit.GetMemoryRegions();
+
+            LargeMemoryBlockAllocator = new KMemoryBlockAllocator(MemoryBlockAllocatorSize * 2);
+            SmallMemoryBlockAllocator = new KMemoryBlockAllocator(MemoryBlockAllocatorSize);
+
+            UserSlabHeapPages = new KSlabHeap(
+                UserSlabHeapBase,
+                UserSlabHeapItemSize,
+                UserSlabHeapSize);
+
+            CriticalSection = new KCriticalSection(this);
 
             Scheduler = new KScheduler(this);
 
             TimeManager = new KTimeManager();
 
-            AddressArbiter = new KAddressArbiter(this);
-
             Synchronization = new KSynchronization(this);
 
-            Withholders = new LinkedList<KThread>();
+            ContextIdManager = new KContextIdManager();
+
+            KipId     = InitialKipId;
+            ProcessId = InitialProcessId;
 
             Scheduler.StartAutoPreemptionThread();
 
-            if (!Device.Memory.Allocator.TryAllocate(HidSize,  out long HidPA) ||
-                !Device.Memory.Allocator.TryAllocate(FontSize, out long FontPA))
-            {
-                throw new InvalidOperationException();
-            }
+            KernelInitialized = true;
 
-            HidSharedMem  = new KSharedMemory(HidPA, HidSize);
-            FontSharedMem = new KSharedMemory(FontPA, FontSize);
+            ThreadCounter = new CountdownEvent(1);
 
-            Font = new SharedFontManager(Device, FontSharedMem.PA);
+            Processes = new SortedDictionary<long, KProcess>();
+
+            AutoObjectNames = new ConcurrentDictionary<string, KAutoObject>();
+
+            //Note: This is not really correct, but with HLE of services, the only memory
+            //region used that is used is Application, so we can use the other ones for anything.
+            KMemoryRegionManager Region = MemoryRegions[(int)MemoryRegion.NvServices];
+
+            ulong HidPa  = Region.Address;
+            ulong FontPa = Region.Address + HidSize;
+
+            HidBaseAddress = (long)(HidPa - DramMemoryMap.DramBase);
+
+            KPageList HidPageList  = new KPageList();
+            KPageList FontPageList = new KPageList();
+
+            HidPageList .AddRange(HidPa,  HidSize  / KMemoryManager.PageSize);
+            FontPageList.AddRange(FontPa, FontSize / KMemoryManager.PageSize);
+
+            HidSharedMem  = new KSharedMemory(HidPageList,  0, 0, MemoryPermission.Read);
+            FontSharedMem = new KSharedMemory(FontPageList, 0, 0, MemoryPermission.Read);
+
+            AppletState = new AppletStateMgr(this);
+
+            AppletState.SetFocus(true);
+
+            Font = new SharedFontManager(Device, (long)(FontPa - DramMemoryMap.DramBase));
 
             VsyncEvent = new KEvent(this);
 
@@ -120,13 +192,15 @@ namespace Ryujinx.HLE.HOS
             else
             {
                 Logger.PrintWarning(LogClass.Loader, $"NPDM file not found, using default values!");
+
+                MetaData = GetDefaultNpdm();
             }
 
-            Process MainProcess = MakeProcess(MetaData);
+            List<IExecutable> StaticObjects = new List<IExecutable>();
 
-            void LoadNso(string FileName)
+            void LoadNso(string SearchPattern)
             {
-                foreach (string File in Directory.GetFiles(ExeFsDir, FileName))
+                foreach (string File in Directory.GetFiles(ExeFsDir, SearchPattern))
                 {
                     if (Path.GetExtension(File) != string.Empty)
                     {
@@ -137,33 +211,28 @@ namespace Ryujinx.HLE.HOS
 
                     using (FileStream Input = new FileStream(File, FileMode.Open))
                     {
-                        string Name = Path.GetFileNameWithoutExtension(File);
+                        NxStaticObject StaticObject = new NxStaticObject(Input);
 
-                        Nso Program = new Nso(Input, Name);
-
-                        MainProcess.LoadProgram(Program);
+                        StaticObjects.Add(StaticObject);
                     }
                 }
             }
 
-            if (!(MainProcess.MetaData?.Is64Bits ?? true))
+            if (!MetaData.Is64Bits)
             {
                 throw new NotImplementedException("32-bit titles are unsupported!");
             }
 
-            CurrentTitle = MainProcess.MetaData.ACI0.TitleId.ToString("x16");
+            CurrentTitle = MetaData.ACI0.TitleId.ToString("x16");
 
             LoadNso("rtld");
-
-            MainProcess.SetEmptyArgs();
-
             LoadNso("main");
             LoadNso("subsdk*");
             LoadNso("sdk");
 
             ContentManager.LoadEntries();
 
-            MainProcess.Run();
+            ProgramLoader.LoadStaticObjects(this, MetaData, StaticObjects.ToArray());
         }
 
         public void LoadXci(string XciFile)
@@ -356,9 +425,11 @@ namespace Ryujinx.HLE.HOS
             else
             {
                 Logger.PrintWarning(LogClass.Loader, $"NPDM file not found, using default values!");
+
+                MetaData = GetDefaultNpdm();
             }
 
-            Process MainProcess = MakeProcess(MetaData);
+            List<IExecutable> StaticObjects = new List<IExecutable>();
 
             void LoadNso(string Filename)
             {
@@ -371,11 +442,9 @@ namespace Ryujinx.HLE.HOS
 
                     Logger.PrintInfo(LogClass.Loader, $"Loading {Filename}...");
 
-                    string Name = Path.GetFileNameWithoutExtension(File.Name);
+                    NxStaticObject StaticObject = new NxStaticObject(Exefs.OpenFile(File));
 
-                    Nso Program = new Nso(Exefs.OpenFile(File), Name);
-
-                    MainProcess.LoadProgram(Program);
+                    StaticObjects.Add(StaticObject);
                 }
             }
 
@@ -401,69 +470,52 @@ namespace Ryujinx.HLE.HOS
 
             if (ControlNca != null)
             {
-                MainProcess.ControlData = ReadControlData();
+                ReadControlData();
             }
             else
             {
-                CurrentTitle = MainProcess.MetaData.ACI0.TitleId.ToString("x16");
+                CurrentTitle = MetaData.ACI0.TitleId.ToString("x16");
             }
 
-            if (!MainProcess.MetaData.Is64Bits)
+            if (!MetaData.Is64Bits)
             {
-                throw new NotImplementedException("32-bit titles are unsupported!");
+                throw new NotImplementedException("32-bit titles are not supported!");
             }
 
             LoadNso("rtld");
-
-            MainProcess.SetEmptyArgs();
-
             LoadNso("main");
             LoadNso("subsdk");
             LoadNso("sdk");
 
             ContentManager.LoadEntries();
 
-            MainProcess.Run();
+            ProgramLoader.LoadStaticObjects(this, MetaData, StaticObjects.ToArray());
         }
 
         public void LoadProgram(string FilePath)
         {
+            Npdm MetaData = GetDefaultNpdm();
+
             bool IsNro = Path.GetExtension(FilePath).ToLower() == ".nro";
 
-            string Name           = Path.GetFileNameWithoutExtension(FilePath);
-            string SwitchFilePath = Device.FileSystem.SystemPathToSwitchPath(FilePath);
-
-            if (IsNro && (SwitchFilePath == null || !SwitchFilePath.StartsWith("sdmc:/")))
-            {
-                string SwitchPath = $"sdmc:/switch/{Name}{Homebrew.TemporaryNroSuffix}";
-                string TempPath   = Device.FileSystem.SwitchPathToSystemPath(SwitchPath);
-
-                string SwitchDir = Path.GetDirectoryName(TempPath);
-
-                if (!Directory.Exists(SwitchDir))
-                {
-                    Directory.CreateDirectory(SwitchDir);
-                }
-
-                File.Copy(FilePath, TempPath, true);
-
-                FilePath = TempPath;
-            }
-
-            Process MainProcess = MakeProcess();
-
             using (FileStream Input = new FileStream(FilePath, FileMode.Open))
             {
-                MainProcess.LoadProgram(IsNro
-                    ? (IExecutable)new Nro(Input, FilePath)
-                    : (IExecutable)new Nso(Input, FilePath));
+                IExecutable StaticObject = IsNro
+                    ? (IExecutable)new NxRelocatableObject(Input)
+                    : (IExecutable)new NxStaticObject(Input);
+
+                ProgramLoader.LoadStaticObjects(this, MetaData, new IExecutable[] { StaticObject });
             }
+        }
 
-            MainProcess.SetEmptyArgs();
+        private Npdm GetDefaultNpdm()
+        {
+            Assembly Asm = Assembly.GetCallingAssembly();
 
-            ContentManager.LoadEntries();
-
-            MainProcess.Run(IsNro);
+            using (Stream NpdmStream = Asm.GetManifestResourceStream("Ryujinx.HLE.Homebrew.npdm"))
+            {
+                return new Npdm(NpdmStream);
+            }
         }
 
         public void LoadKeySet()
@@ -507,51 +559,19 @@ namespace Ryujinx.HLE.HOS
             VsyncEvent.ReadableEvent.Signal();
         }
 
-        private Process MakeProcess(Npdm MetaData = null)
+        internal long GetThreadUid()
         {
-            HasStarted = true;
-
-            Process Process;
-
-            lock (Processes)
-            {
-                int ProcessId = 0;
-
-                while (Processes.ContainsKey(ProcessId))
-                {
-                    ProcessId++;
-                }
-
-                Process = new Process(Device, ProcessId, MetaData);
-
-                Processes.TryAdd(ProcessId, Process);
-            }
-
-            InitializeProcess(Process);
-
-            return Process;
+            return Interlocked.Increment(ref ThreadUid) - 1;
         }
 
-        private void InitializeProcess(Process Process)
+        internal long GetKipId()
         {
-            Process.AppletState.SetFocus(true);
+            return Interlocked.Increment(ref KipId) - 1;
         }
 
-        internal void ExitProcess(int ProcessId)
+        internal long GetProcessId()
         {
-            if (Processes.TryRemove(ProcessId, out Process Process))
-            {
-                Process.Dispose();
-
-                if (Processes.Count == 0)
-                {
-                    Scheduler.Dispose();
-
-                    TimeManager.Dispose();
-
-                    Device.Unload();
-                }
-            }
+            return Interlocked.Increment(ref ProcessId) - 1;
         }
 
         public void EnableMultiCoreScheduling()
@@ -579,10 +599,25 @@ namespace Ryujinx.HLE.HOS
         {
             if (Disposing)
             {
-                foreach (Process Process in Processes.Values)
+                //Force all threads to exit.
+                lock (Processes)
                 {
-                    Process.Dispose();
+                    foreach (KProcess Process in Processes.Values)
+                    {
+                        Process.StopAllThreads();
+                    }
                 }
+
+                //It's only safe to release resources once all threads
+                //have exited.
+                ThreadCounter.Signal();
+                ThreadCounter.Wait();
+
+                Scheduler.Dispose();
+
+                TimeManager.Dispose();
+
+                Device.Unload();
             }
         }
     }

Ryujinx.HLE/HOS/Ipc/IpcHandler.cs

@@ -8,8 +8,8 @@ namespace Ryujinx.HLE.HOS.Ipc
     static class IpcHandler
     {
         public static long IpcCall(
-            Switch        Ns,
-            Process       Process,
+            Switch        Device,
+            KProcess      Process,
             MemoryManager Memory,
             KSession      Session,
             IpcMessage    Request,
@@ -31,7 +31,7 @@ namespace Ryujinx.HLE.HOS.Ipc
                         BinaryWriter ResWriter = new BinaryWriter(ResMS);
 
                         ServiceCtx Context = new ServiceCtx(
-                            Ns,
+                            Device,
                             Process,
                             Memory,
                             Session,

Ryujinx.HLE/HOS/Kernel/AddressSpaceType.cs

@@ -4,7 +4,7 @@ namespace Ryujinx.HLE.HOS.Kernel
     {
         Addr32Bits      = 0,
         Addr36Bits      = 1,
-        Addr36BitsNoMap = 2,
+        Addr32BitsNoMap = 2,
         Addr39Bits      = 3
     }
 }

Ryujinx.HLE/HOS/Kernel/DramMemoryMap.cs

@@ -0,0 +1,15 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    static class DramMemoryMap
+    {
+        public const ulong DramBase = 0x80000000;
+        public const ulong DramSize = 0x100000000;
+        public const ulong DramEnd  = DramBase + DramSize;
+
+        public const ulong KernelReserveBase = DramBase + 0x60000;
+
+        public const ulong SlabHeapBase = KernelReserveBase + 0x85000;
+        public const ulong SlapHeapSize = 0xa21000;
+        public const ulong SlabHeapEnd  = SlabHeapBase + SlapHeapSize;
+    }
+}

Ryujinx.HLE/HOS/Kernel/HleCoreManager.cs

@@ -5,24 +5,61 @@ namespace Ryujinx.HLE.HOS.Kernel
 {
     class HleCoreManager
     {
-        private ConcurrentDictionary<Thread, ManualResetEvent> Threads;
+        private class PausableThread
+        {
+            public ManualResetEvent Event { get; private set; }
+
+            public bool IsExiting { get; set; }
+
+            public PausableThread()
+            {
+                Event = new ManualResetEvent(false);
+            }
+        }
+
+        private ConcurrentDictionary<Thread, PausableThread> Threads;
 
         public HleCoreManager()
         {
-            Threads = new ConcurrentDictionary<Thread, ManualResetEvent>();
+            Threads = new ConcurrentDictionary<Thread, PausableThread>();
         }
 
-        public ManualResetEvent GetThread(Thread Thread)
+        public void Set(Thread Thread)
         {
-            return Threads.GetOrAdd(Thread, (Key) => new ManualResetEvent(false));
+            GetThread(Thread).Event.Set();
+        }
+
+        public void Reset(Thread Thread)
+        {
+            GetThread(Thread).Event.Reset();
+        }
+
+        public void Wait(Thread Thread)
+        {
+            PausableThread PausableThread = GetThread(Thread);
+
+            if (!PausableThread.IsExiting)
+            {
+                PausableThread.Event.WaitOne();
+            }
+        }
+
+        public void Exit(Thread Thread)
+        {
+            GetThread(Thread).IsExiting = true;
+        }
+
+        private PausableThread GetThread(Thread Thread)
+        {
+            return Threads.GetOrAdd(Thread, (Key) => new PausableThread());
         }
 
         public void RemoveThread(Thread Thread)
         {
-            if (Threads.TryRemove(Thread, out ManualResetEvent Event))
+            if (Threads.TryRemove(Thread, out PausableThread PausableThread))
             {
-                Event.Set();
-                Event.Dispose();
+                PausableThread.Event.Set();
+                PausableThread.Event.Dispose();
             }
         }
     }

Ryujinx.HLE/HOS/Kernel/HleProcessDebugger.cs

@@ -0,0 +1,310 @@
+using ChocolArm64.Memory;
+using ChocolArm64.State;
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Diagnostics.Demangler;
+using Ryujinx.HLE.Loaders.Elf;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class HleProcessDebugger
+    {
+        private const int Mod0 = 'M' << 0 | 'O' << 8 | 'D' << 16 | '0' << 24;
+
+        private KProcess Owner;
+
+        private class Image
+        {
+            public long BaseAddress { get; private set; }
+
+            public ElfSymbol[] Symbols { get; private set; }
+
+            public Image(long BaseAddress, ElfSymbol[] Symbols)
+            {
+                this.BaseAddress = BaseAddress;
+                this.Symbols     = Symbols;
+            }
+        }
+
+        private List<Image> Images;
+
+        private int Loaded;
+
+        public HleProcessDebugger(KProcess Owner)
+        {
+            this.Owner = Owner;
+
+            Images = new List<Image>();
+        }
+
+        public void PrintGuestStackTrace(CpuThreadState ThreadState)
+        {
+            EnsureLoaded();
+
+            StringBuilder Trace = new StringBuilder();
+
+            Trace.AppendLine("Guest stack trace:");
+
+            void AppendTrace(long Address)
+            {
+                Image Image = GetImage(Address, out int ImageIndex);
+
+                if (Image == null || !TryGetSubName(Image, Address, out string SubName))
+                {
+                    SubName = $"Sub{Address:x16}";
+                }
+                else if (SubName.StartsWith("_Z"))
+                {
+                    SubName = Demangler.Parse(SubName);
+                }
+
+                if (Image != null)
+                {
+                    long Offset = Address - Image.BaseAddress;
+
+                    string ImageName = GetGuessedNsoNameFromIndex(ImageIndex);
+
+                    string ImageNameAndOffset = $"[{Owner.Name}] {ImageName}:0x{Offset:x8}";
+
+                    Trace.AppendLine($" {ImageNameAndOffset} {SubName}");
+                }
+                else
+                {
+                    Trace.AppendLine($" [{Owner.Name}] ??? {SubName}");
+                }
+            }
+
+            long FramePointer = (long)ThreadState.X29;
+
+            while (FramePointer != 0)
+            {
+                if ((FramePointer & 7) != 0                 ||
+                    !Owner.CpuMemory.IsMapped(FramePointer) ||
+                    !Owner.CpuMemory.IsMapped(FramePointer + 8))
+                {
+                    break;
+                }
+
+                //Note: This is the return address, we need to subtract one instruction
+                //worth of bytes to get the branch instruction address.
+                AppendTrace(Owner.CpuMemory.ReadInt64(FramePointer + 8) - 4);
+
+                FramePointer = Owner.CpuMemory.ReadInt64(FramePointer);
+            }
+
+            Logger.PrintInfo(LogClass.Cpu, Trace.ToString());
+        }
+
+        private bool TryGetSubName(Image Image, long Address, out string Name)
+        {
+            Address -= Image.BaseAddress;
+
+            int Left  = 0;
+            int Right = Image.Symbols.Length - 1;
+
+            while (Left <= Right)
+            {
+                int Size = Right - Left;
+
+                int Middle = Left + (Size >> 1);
+
+                ElfSymbol Symbol = Image.Symbols[Middle];
+
+                long EndAddr = Symbol.Value + Symbol.Size;
+
+                if ((ulong)Address >= (ulong)Symbol.Value && (ulong)Address < (ulong)EndAddr)
+                {
+                    Name = Symbol.Name;
+
+                    return true;
+                }
+
+                if ((ulong)Address < (ulong)Symbol.Value)
+                {
+                    Right = Middle - 1;
+                }
+                else
+                {
+                    Left = Middle + 1;
+                }
+            }
+
+            Name = null;
+
+            return false;
+        }
+
+        private Image GetImage(long Address, out int Index)
+        {
+            lock (Images)
+            {
+                for (Index = Images.Count - 1; Index >= 0; Index--)
+                {
+                    if ((ulong)Address >= (ulong)Images[Index].BaseAddress)
+                    {
+                        return Images[Index];
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        private string GetGuessedNsoNameFromIndex(int Index)
+        {
+            if ((uint)Index > 11)
+            {
+                return "???";
+            }
+
+            if (Index == 0)
+            {
+                return "rtld";
+            }
+            else if (Index == 1)
+            {
+                return "main";
+            }
+            else if (Index == GetImagesCount() - 1)
+            {
+                return "sdk";
+            }
+            else
+            {
+                return "subsdk" + (Index - 2);
+            }
+        }
+
+        private int GetImagesCount()
+        {
+            lock (Images)
+            {
+                return Images.Count;
+            }
+        }
+
+        private void EnsureLoaded()
+        {
+            if (Interlocked.CompareExchange(ref Loaded, 1, 0) == 0)
+            {
+                ScanMemoryForTextSegments();
+            }
+        }
+
+        private void ScanMemoryForTextSegments()
+        {
+            ulong OldAddress = 0;
+            ulong Address    = 0;
+
+            while (Address >= OldAddress)
+            {
+                KMemoryInfo Info = Owner.MemoryManager.QueryMemory(Address);
+
+                if (Info.State == MemoryState.Reserved)
+                {
+                    break;
+                }
+
+                if (Info.State == MemoryState.CodeStatic && Info.Permission == MemoryPermission.ReadAndExecute)
+                {
+                    LoadMod0Symbols(Owner.CpuMemory, (long)Info.Address);
+                }
+
+                OldAddress = Address;
+
+                Address = Info.Address + Info.Size;
+            }
+        }
+
+        private void LoadMod0Symbols(MemoryManager Memory, long TextOffset)
+        {
+            long Mod0Offset = TextOffset + Memory.ReadUInt32(TextOffset + 4);
+
+            if (Mod0Offset < TextOffset || !Memory.IsMapped(Mod0Offset) || (Mod0Offset & 3) != 0)
+            {
+                return;
+            }
+
+            Dictionary<ElfDynamicTag, long> Dynamic = new Dictionary<ElfDynamicTag, long>();
+
+            int Mod0Magic = Memory.ReadInt32(Mod0Offset + 0x0);
+
+            if (Mod0Magic != Mod0)
+            {
+                return;
+            }
+
+            long DynamicOffset    = Memory.ReadInt32(Mod0Offset + 0x4)  + Mod0Offset;
+            long BssStartOffset   = Memory.ReadInt32(Mod0Offset + 0x8)  + Mod0Offset;
+            long BssEndOffset     = Memory.ReadInt32(Mod0Offset + 0xc)  + Mod0Offset;
+            long EhHdrStartOffset = Memory.ReadInt32(Mod0Offset + 0x10) + Mod0Offset;
+            long EhHdrEndOffset   = Memory.ReadInt32(Mod0Offset + 0x14) + Mod0Offset;
+            long ModObjOffset     = Memory.ReadInt32(Mod0Offset + 0x18) + Mod0Offset;
+
+            while (true)
+            {
+                long TagVal = Memory.ReadInt64(DynamicOffset + 0);
+                long Value  = Memory.ReadInt64(DynamicOffset + 8);
+
+                DynamicOffset += 0x10;
+
+                ElfDynamicTag Tag = (ElfDynamicTag)TagVal;
+
+                if (Tag == ElfDynamicTag.DT_NULL)
+                {
+                    break;
+                }
+
+                Dynamic[Tag] = Value;
+            }
+
+            if (!Dynamic.TryGetValue(ElfDynamicTag.DT_STRTAB, out long StrTab) ||
+                !Dynamic.TryGetValue(ElfDynamicTag.DT_SYMTAB, out long SymTab) ||
+                !Dynamic.TryGetValue(ElfDynamicTag.DT_SYMENT, out long SymEntSize))
+            {
+                return;
+            }
+
+            long StrTblAddr = TextOffset + StrTab;
+            long SymTblAddr = TextOffset + SymTab;
+
+            List<ElfSymbol> Symbols = new List<ElfSymbol>();
+
+            while ((ulong)SymTblAddr < (ulong)StrTblAddr)
+            {
+                ElfSymbol Sym = GetSymbol(Memory, SymTblAddr, StrTblAddr);
+
+                Symbols.Add(Sym);
+
+                SymTblAddr += SymEntSize;
+            }
+
+            lock (Images)
+            {
+                Images.Add(new Image(TextOffset, Symbols.OrderBy(x => x.Value).ToArray()));
+            }
+        }
+
+        private ElfSymbol GetSymbol(MemoryManager Memory, long Address, long StrTblAddr)
+        {
+            int  NameIndex = Memory.ReadInt32(Address + 0);
+            int  Info      = Memory.ReadByte (Address + 4);
+            int  Other     = Memory.ReadByte (Address + 5);
+            int  SHIdx     = Memory.ReadInt16(Address + 6);
+            long Value     = Memory.ReadInt64(Address + 8);
+            long Size      = Memory.ReadInt64(Address + 16);
+
+            string Name = string.Empty;
+
+            for (int Chr; (Chr = Memory.ReadByte(StrTblAddr + NameIndex++)) != 0;)
+            {
+                Name += (char)Chr;
+            }
+
+            return new ElfSymbol(Name, Info, Other, SHIdx, Value, Size);
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/HleScheduler.cs

@@ -11,7 +11,7 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         public bool MultiCoreScheduling { get; set; }
 
-        private HleCoreManager CoreManager;
+        public HleCoreManager CoreManager { get; private set; }
 
         private bool KeepPreempting;
 
@@ -49,11 +49,11 @@ namespace Ryujinx.HLE.HOS.Kernel
 
                     if (SelectedCount == 0)
                     {
-                        CoreManager.GetThread(Thread.CurrentThread).Reset();
+                        CoreManager.Reset(Thread.CurrentThread);
                     }
                     else if (SelectedCount == 1)
                     {
-                        CoreManager.GetThread(Thread.CurrentThread).Set();
+                        CoreManager.Set(Thread.CurrentThread);
                     }
                     else
                     {
@@ -77,7 +77,7 @@ namespace Ryujinx.HLE.HOS.Kernel
                             return;
                         }
 
-                        CoreManager.GetThread(CurrentThread.Context.Work).Reset();
+                        CoreManager.Reset(CurrentThread.Context.Work);
                     }
 
                     //Advance current core and try picking a thread,
@@ -94,7 +94,7 @@ namespace Ryujinx.HLE.HOS.Kernel
                         {
                             CoreContext.CurrentThread.ClearExclusive();
 
-                            CoreManager.GetThread(CoreContext.CurrentThread.Context.Work).Set();
+                            CoreManager.Set(CoreContext.CurrentThread.Context.Work);
 
                             CoreContext.CurrentThread.Context.Execute();
 
@@ -111,7 +111,7 @@ namespace Ryujinx.HLE.HOS.Kernel
                 }
             }
 
-            CoreManager.GetThread(Thread.CurrentThread).WaitOne();
+            CoreManager.Wait(Thread.CurrentThread);
         }
 
         private void PreemptCurrentThread()
@@ -134,11 +134,11 @@ namespace Ryujinx.HLE.HOS.Kernel
             }
         }
 
-        public void StopThread(KThread Thread)
+        public void ExitThread(KThread Thread)
         {
             Thread.Context.StopExecution();
 
-            CoreManager.GetThread(Thread.Context.Work).Set();
+            CoreManager.Exit(Thread.Context.Work);
         }
 
         public void RemoveThread(KThread Thread)

Ryujinx.HLE/HOS/Kernel/KAddressArbiter.cs

@@ -1,4 +1,3 @@
-using ChocolArm64.Memory;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -23,39 +22,36 @@ namespace Ryujinx.HLE.HOS.Kernel
             ArbiterThreads = new List<KThread>();
         }
 
-        public long ArbitrateLock(
-            Process       Process,
-            MemoryManager Memory,
-            int           OwnerHandle,
-            long          MutexAddress,
-            int           RequesterHandle)
+        public long ArbitrateLock(int OwnerHandle, long MutexAddress, int RequesterHandle)
         {
-            System.CriticalSectionLock.Lock();
-
             KThread CurrentThread = System.Scheduler.GetCurrentThread();
 
+            System.CriticalSection.Enter();
+
             CurrentThread.SignaledObj   = null;
             CurrentThread.ObjSyncResult = 0;
 
-            if (!UserToKernelInt32(Memory, MutexAddress, out int MutexValue))
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            if (!KernelTransfer.UserToKernelInt32(System, MutexAddress, out int MutexValue))
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);;
             }
 
             if (MutexValue != (OwnerHandle | HasListenersMask))
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return 0;
             }
 
-            KThread MutexOwner = Process.HandleTable.GetObject<KThread>(OwnerHandle);
+            KThread MutexOwner = CurrentProcess.HandleTable.GetObject<KThread>(OwnerHandle);
 
             if (MutexOwner == null)
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
             }
@@ -67,26 +63,26 @@ namespace Ryujinx.HLE.HOS.Kernel
 
             CurrentThread.Reschedule(ThreadSchedState.Paused);
 
-            System.CriticalSectionLock.Unlock();
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Leave();
+            System.CriticalSection.Enter();
 
             if (CurrentThread.MutexOwner != null)
             {
                 CurrentThread.MutexOwner.RemoveMutexWaiter(CurrentThread);
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             return (uint)CurrentThread.ObjSyncResult;
         }
 
-        public long ArbitrateUnlock(MemoryManager Memory, long MutexAddress)
+        public long ArbitrateUnlock(long MutexAddress)
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             KThread CurrentThread = System.Scheduler.GetCurrentThread();
 
-            (long Result, KThread NewOwnerThread) = MutexUnlock(Memory, CurrentThread, MutexAddress);
+            (long Result, KThread NewOwnerThread) = MutexUnlock(CurrentThread, MutexAddress);
 
             if (Result != 0 && NewOwnerThread != null)
             {
@@ -94,19 +90,18 @@ namespace Ryujinx.HLE.HOS.Kernel
                 NewOwnerThread.ObjSyncResult = (int)Result;
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             return Result;
         }
 
         public long WaitProcessWideKeyAtomic(
-            MemoryManager Memory,
-            long          MutexAddress,
-            long          CondVarAddress,
-            int           ThreadHandle,
-            long          Timeout)
+            long MutexAddress,
+            long CondVarAddress,
+            int  ThreadHandle,
+            long Timeout)
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             KThread CurrentThread = System.Scheduler.GetCurrentThread();
 
@@ -116,16 +111,16 @@ namespace Ryujinx.HLE.HOS.Kernel
             if (CurrentThread.ShallBeTerminated ||
                 CurrentThread.SchedFlags == ThreadSchedState.TerminationPending)
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return MakeError(ErrorModule.Kernel, KernelErr.ThreadTerminating);
             }
 
-            (long Result, _) = MutexUnlock(Memory, CurrentThread, MutexAddress);
+            (long Result, _) = MutexUnlock(CurrentThread, MutexAddress);
 
             if (Result != 0)
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return Result;
             }
@@ -146,14 +141,14 @@ namespace Ryujinx.HLE.HOS.Kernel
                 }
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             if (Timeout > 0)
             {
                 System.TimeManager.UnscheduleFutureInvocation(CurrentThread);
             }
 
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             if (CurrentThread.MutexOwner != null)
             {
@@ -162,12 +157,12 @@ namespace Ryujinx.HLE.HOS.Kernel
 
             CondVarThreads.Remove(CurrentThread);
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             return (uint)CurrentThread.ObjSyncResult;
         }
 
-        private (long, KThread) MutexUnlock(MemoryManager Memory, KThread CurrentThread, long MutexAddress)
+        private (long, KThread) MutexUnlock(KThread CurrentThread, long MutexAddress)
         {
             KThread NewOwnerThread = CurrentThread.RelinquishMutex(MutexAddress, out int Count);
 
@@ -190,7 +185,7 @@ namespace Ryujinx.HLE.HOS.Kernel
 
             long Result = 0;
 
-            if (!KernelToUserInt32(Memory, MutexAddress, MutexValue))
+            if (!KernelTransfer.KernelToUserInt32(System, MutexAddress, MutexValue))
             {
                 Result = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
             }
@@ -198,17 +193,17 @@ namespace Ryujinx.HLE.HOS.Kernel
             return (Result, NewOwnerThread);
         }
 
-        public void SignalProcessWideKey(Process Process, MemoryManager Memory, long Address, int Count)
+        public void SignalProcessWideKey(long Address, int Count)
         {
             Queue<KThread> SignaledThreads = new Queue<KThread>();
 
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             IOrderedEnumerable<KThread> SortedThreads = CondVarThreads.OrderBy(x => x.DynamicPriority);
 
             foreach (KThread Thread in SortedThreads.Where(x => x.CondVarAddress == Address))
             {
-                TryAcquireMutex(Process, Memory, Thread);
+                TryAcquireMutex(Thread);
 
                 SignaledThreads.Enqueue(Thread);
 
@@ -224,19 +219,21 @@ namespace Ryujinx.HLE.HOS.Kernel
                 CondVarThreads.Remove(Thread);
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
         }
 
-        private KThread TryAcquireMutex(Process Process, MemoryManager Memory, KThread Requester)
+        private KThread TryAcquireMutex(KThread Requester)
         {
             long Address = Requester.MutexAddress;
 
-            Memory.SetExclusive(0, Address);
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
 
-            if (!UserToKernelInt32(Memory, Address, out int MutexValue))
+            CurrentProcess.CpuMemory.SetExclusive(0, Address);
+
+            if (!KernelTransfer.UserToKernelInt32(System, Address, out int MutexValue))
             {
                 //Invalid address.
-                Memory.ClearExclusive(0);
+                CurrentProcess.CpuMemory.ClearExclusive(0);
 
                 Requester.SignaledObj   = null;
                 Requester.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
@@ -246,27 +243,27 @@ namespace Ryujinx.HLE.HOS.Kernel
 
             while (true)
             {
-                if (Memory.TestExclusive(0, Address))
+                if (CurrentProcess.CpuMemory.TestExclusive(0, Address))
                 {
                     if (MutexValue != 0)
                     {
                         //Update value to indicate there is a mutex waiter now.
-                        Memory.WriteInt32(Address, MutexValue | HasListenersMask);
+                        CurrentProcess.CpuMemory.WriteInt32(Address, MutexValue | HasListenersMask);
                     }
                     else
                     {
                         //No thread owning the mutex, assign to requesting thread.
-                        Memory.WriteInt32(Address, Requester.ThreadHandleForUserMutex);
+                        CurrentProcess.CpuMemory.WriteInt32(Address, Requester.ThreadHandleForUserMutex);
                     }
 
-                    Memory.ClearExclusiveForStore(0);
+                    CurrentProcess.CpuMemory.ClearExclusiveForStore(0);
 
                     break;
                 }
 
-                Memory.SetExclusive(0, Address);
+                CurrentProcess.CpuMemory.SetExclusive(0, Address);
 
-                MutexValue = Memory.ReadInt32(Address);
+                MutexValue = CurrentProcess.CpuMemory.ReadInt32(Address);
             }
 
             if (MutexValue == 0)
@@ -282,7 +279,7 @@ namespace Ryujinx.HLE.HOS.Kernel
 
             MutexValue &= ~HasListenersMask;
 
-            KThread MutexOwner = Process.HandleTable.GetObject<KThread>(MutexValue);
+            KThread MutexOwner = CurrentProcess.HandleTable.GetObject<KThread>(MutexValue);
 
             if (MutexOwner != null)
             {
@@ -301,16 +298,16 @@ namespace Ryujinx.HLE.HOS.Kernel
             return MutexOwner;
         }
 
-        public long WaitForAddressIfEqual(MemoryManager Memory, long Address, int Value, long Timeout)
+        public long WaitForAddressIfEqual(long Address, int Value, long Timeout)
         {
             KThread CurrentThread = System.Scheduler.GetCurrentThread();
 
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             if (CurrentThread.ShallBeTerminated ||
                 CurrentThread.SchedFlags == ThreadSchedState.TerminationPending)
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return MakeError(ErrorModule.Kernel, KernelErr.ThreadTerminating);
             }
@@ -318,9 +315,9 @@ namespace Ryujinx.HLE.HOS.Kernel
             CurrentThread.SignaledObj   = null;
             CurrentThread.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.Timeout);
 
-            if (!UserToKernelInt32(Memory, Address, out int CurrentValue))
+            if (!KernelTransfer.UserToKernelInt32(System, Address, out int CurrentValue))
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
             }
@@ -329,7 +326,7 @@ namespace Ryujinx.HLE.HOS.Kernel
             {
                 if (Timeout == 0)
                 {
-                    System.CriticalSectionLock.Unlock();
+                    System.CriticalSection.Leave();
 
                     return MakeError(ErrorModule.Kernel, KernelErr.Timeout);
                 }
@@ -346,14 +343,14 @@ namespace Ryujinx.HLE.HOS.Kernel
                     System.TimeManager.ScheduleFutureInvocation(CurrentThread, Timeout);
                 }
 
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 if (Timeout > 0)
                 {
                     System.TimeManager.UnscheduleFutureInvocation(CurrentThread);
                 }
 
-                System.CriticalSectionLock.Lock();
+                System.CriticalSection.Enter();
 
                 if (CurrentThread.WaitingInArbitration)
                 {
@@ -362,31 +359,26 @@ namespace Ryujinx.HLE.HOS.Kernel
                     CurrentThread.WaitingInArbitration = false;
                 }
 
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return CurrentThread.ObjSyncResult;
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             return MakeError(ErrorModule.Kernel, KernelErr.InvalidState);
         }
 
-        public long WaitForAddressIfLessThan(
-            MemoryManager Memory,
-            long          Address,
-            int           Value,
-            bool          ShouldDecrement,
-            long          Timeout)
+        public long WaitForAddressIfLessThan(long Address, int Value, bool ShouldDecrement, long Timeout)
         {
             KThread CurrentThread = System.Scheduler.GetCurrentThread();
 
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             if (CurrentThread.ShallBeTerminated ||
                 CurrentThread.SchedFlags == ThreadSchedState.TerminationPending)
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return MakeError(ErrorModule.Kernel, KernelErr.ThreadTerminating);
             }
@@ -394,12 +386,14 @@ namespace Ryujinx.HLE.HOS.Kernel
             CurrentThread.SignaledObj   = null;
             CurrentThread.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.Timeout);
 
-            //If ShouldDecrement is true, do atomic decrement of the value at Address.
-            Memory.SetExclusive(0, Address);
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
 
-            if (!UserToKernelInt32(Memory, Address, out int CurrentValue))
+            //If ShouldDecrement is true, do atomic decrement of the value at Address.
+            CurrentProcess.CpuMemory.SetExclusive(0, Address);
+
+            if (!KernelTransfer.UserToKernelInt32(System, Address, out int CurrentValue))
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
             }
@@ -408,28 +402,28 @@ namespace Ryujinx.HLE.HOS.Kernel
             {
                 while (CurrentValue < Value)
                 {
-                    if (Memory.TestExclusive(0, Address))
+                    if (CurrentProcess.CpuMemory.TestExclusive(0, Address))
                     {
-                        Memory.WriteInt32(Address, CurrentValue - 1);
+                        CurrentProcess.CpuMemory.WriteInt32(Address, CurrentValue - 1);
 
-                        Memory.ClearExclusiveForStore(0);
+                        CurrentProcess.CpuMemory.ClearExclusiveForStore(0);
 
                         break;
                     }
 
-                    Memory.SetExclusive(0, Address);
+                    CurrentProcess.CpuMemory.SetExclusive(0, Address);
 
-                    CurrentValue = Memory.ReadInt32(Address);
+                    CurrentValue = CurrentProcess.CpuMemory.ReadInt32(Address);
                 }
             }
 
-            Memory.ClearExclusive(0);
+            CurrentProcess.CpuMemory.ClearExclusive(0);
 
             if (CurrentValue < Value)
             {
                 if (Timeout == 0)
                 {
-                    System.CriticalSectionLock.Unlock();
+                    System.CriticalSection.Leave();
 
                     return MakeError(ErrorModule.Kernel, KernelErr.Timeout);
                 }
@@ -446,14 +440,14 @@ namespace Ryujinx.HLE.HOS.Kernel
                     System.TimeManager.ScheduleFutureInvocation(CurrentThread, Timeout);
                 }
 
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 if (Timeout > 0)
                 {
                     System.TimeManager.UnscheduleFutureInvocation(CurrentThread);
                 }
 
-                System.CriticalSectionLock.Lock();
+                System.CriticalSection.Enter();
 
                 if (CurrentThread.WaitingInArbitration)
                 {
@@ -462,12 +456,12 @@ namespace Ryujinx.HLE.HOS.Kernel
                     CurrentThread.WaitingInArbitration = false;
                 }
 
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return CurrentThread.ObjSyncResult;
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             return MakeError(ErrorModule.Kernel, KernelErr.InvalidState);
         }
@@ -498,63 +492,65 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         public long Signal(long Address, int Count)
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             WakeArbiterThreads(Address, Count);
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             return 0;
         }
 
-        public long SignalAndIncrementIfEqual(MemoryManager Memory, long Address, int Value, int Count)
+        public long SignalAndIncrementIfEqual(long Address, int Value, int Count)
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
-            Memory.SetExclusive(0, Address);
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
 
-            if (!UserToKernelInt32(Memory, Address, out int CurrentValue))
+            CurrentProcess.CpuMemory.SetExclusive(0, Address);
+
+            if (!KernelTransfer.UserToKernelInt32(System, Address, out int CurrentValue))
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
             }
 
             while (CurrentValue == Value)
             {
-                if (Memory.TestExclusive(0, Address))
+                if (CurrentProcess.CpuMemory.TestExclusive(0, Address))
                 {
-                    Memory.WriteInt32(Address, CurrentValue + 1);
+                    CurrentProcess.CpuMemory.WriteInt32(Address, CurrentValue + 1);
 
-                    Memory.ClearExclusiveForStore(0);
+                    CurrentProcess.CpuMemory.ClearExclusiveForStore(0);
 
                     break;
                 }
 
-                Memory.SetExclusive(0, Address);
+                CurrentProcess.CpuMemory.SetExclusive(0, Address);
 
-                CurrentValue = Memory.ReadInt32(Address);
+                CurrentValue = CurrentProcess.CpuMemory.ReadInt32(Address);
             }
 
-            Memory.ClearExclusive(0);
+            CurrentProcess.CpuMemory.ClearExclusive(0);
 
             if (CurrentValue != Value)
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return MakeError(ErrorModule.Kernel, KernelErr.InvalidState);
             }
 
             WakeArbiterThreads(Address, Count);
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             return 0;
         }
 
-        public long SignalAndModifyIfEqual(MemoryManager Memory, long Address, int Value, int Count)
+        public long SignalAndModifyIfEqual(long Address, int Value, int Count)
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             int Offset;
 
@@ -580,43 +576,45 @@ namespace Ryujinx.HLE.HOS.Kernel
                 Offset = 1;
             }
 
-            Memory.SetExclusive(0, Address);
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
 
-            if (!UserToKernelInt32(Memory, Address, out int CurrentValue))
+            CurrentProcess.CpuMemory.SetExclusive(0, Address);
+
+            if (!KernelTransfer.UserToKernelInt32(System, Address, out int CurrentValue))
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
             }
 
             while (CurrentValue == Value)
             {
-                if (Memory.TestExclusive(0, Address))
+                if (CurrentProcess.CpuMemory.TestExclusive(0, Address))
                 {
-                    Memory.WriteInt32(Address, CurrentValue + Offset);
+                    CurrentProcess.CpuMemory.WriteInt32(Address, CurrentValue + Offset);
 
-                    Memory.ClearExclusiveForStore(0);
+                    CurrentProcess.CpuMemory.ClearExclusiveForStore(0);
 
                     break;
                 }
 
-                Memory.SetExclusive(0, Address);
+                CurrentProcess.CpuMemory.SetExclusive(0, Address);
 
-                CurrentValue = Memory.ReadInt32(Address);
+                CurrentValue = CurrentProcess.CpuMemory.ReadInt32(Address);
             }
 
-            Memory.ClearExclusive(0);
+            CurrentProcess.CpuMemory.ClearExclusive(0);
 
             if (CurrentValue != Value)
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return MakeError(ErrorModule.Kernel, KernelErr.InvalidState);
             }
 
             WakeArbiterThreads(Address, Count);
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             return 0;
         }
@@ -648,31 +646,5 @@ namespace Ryujinx.HLE.HOS.Kernel
                 ArbiterThreads.Remove(Thread);
             }
         }
-
-        private bool UserToKernelInt32(MemoryManager Memory, long Address, out int Value)
-        {
-            if (Memory.IsMapped(Address))
-            {
-                Value = Memory.ReadInt32(Address);
-
-                return true;
-            }
-
-            Value = 0;
-
-            return false;
-        }
-
-        private bool KernelToUserInt32(MemoryManager Memory, long Address, int Value)
-        {
-            if (Memory.IsMapped(Address))
-            {
-                Memory.WriteInt32ToSharedAddr(Address, Value);
-
-                return true;
-            }
-
-            return false;
-        }
     }
 }

Ryujinx.HLE/HOS/Kernel/KAutoObject.cs

@@ -0,0 +1,42 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class KAutoObject
+    {
+        protected Horizon System;
+
+        public KAutoObject(Horizon System)
+        {
+            this.System = System;
+        }
+
+        public virtual KernelResult SetName(string Name)
+        {
+            if (!System.AutoObjectNames.TryAdd(Name, this))
+            {
+                return KernelResult.InvalidState;
+            }
+
+            return KernelResult.Success;
+        }
+
+        public static KernelResult RemoveName(Horizon System, string Name)
+        {
+            if (!System.AutoObjectNames.TryRemove(Name, out _))
+            {
+                return KernelResult.NotFound;
+            }
+
+            return KernelResult.Success;
+        }
+
+        public static KAutoObject FindNamedObject(Horizon System, string Name)
+        {
+            if (System.AutoObjectNames.TryGetValue(Name, out KAutoObject Obj))
+            {
+                return Obj;
+            }
+
+            return null;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KClientPort.cs

@@ -0,0 +1,31 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class KClientPort : KSynchronizationObject
+    {
+        private int SessionsCount;
+        private int CurrentCapacity;
+        private int MaxSessions;
+
+        private KPort Parent;
+
+        public KClientPort(Horizon System) : base(System) { }
+
+        public void Initialize(KPort Parent, int MaxSessions)
+        {
+            this.MaxSessions = MaxSessions;
+            this.Parent      = Parent;
+        }
+
+        public new static KernelResult RemoveName(Horizon System, string Name)
+        {
+            KAutoObject FoundObj = KAutoObject.FindNamedObject(System, Name);
+
+            if (!(FoundObj is KClientPort))
+            {
+                return KernelResult.NotFound;
+            }
+
+            return KAutoObject.RemoveName(System, Name);
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KConditionVariable.cs

@@ -0,0 +1,71 @@
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    static class KConditionVariable
+    {
+        public static void Wait(Horizon System, LinkedList<KThread> ThreadList, object Mutex, long Timeout)
+        {
+            KThread CurrentThread = System.Scheduler.GetCurrentThread();
+
+            System.CriticalSection.Enter();
+
+            Monitor.Exit(Mutex);
+
+            CurrentThread.Withholder = ThreadList;
+
+            CurrentThread.Reschedule(ThreadSchedState.Paused);
+
+            CurrentThread.WithholderNode = ThreadList.AddLast(CurrentThread);
+
+            if (CurrentThread.ShallBeTerminated ||
+                CurrentThread.SchedFlags == ThreadSchedState.TerminationPending)
+            {
+                ThreadList.Remove(CurrentThread.WithholderNode);
+
+                CurrentThread.Reschedule(ThreadSchedState.Running);
+
+                CurrentThread.Withholder = null;
+
+                System.CriticalSection.Leave();
+            }
+            else
+            {
+                if (Timeout > 0)
+                {
+                    System.TimeManager.ScheduleFutureInvocation(CurrentThread, Timeout);
+                }
+
+                System.CriticalSection.Leave();
+
+                if (Timeout > 0)
+                {
+                    System.TimeManager.UnscheduleFutureInvocation(CurrentThread);
+                }
+            }
+
+            Monitor.Enter(Mutex);
+        }
+
+        public static void NotifyAll(Horizon System, LinkedList<KThread> ThreadList)
+        {
+            System.CriticalSection.Enter();
+
+            LinkedListNode<KThread> Node = ThreadList.First;
+
+            for (; Node != null; Node = ThreadList.First)
+            {
+                KThread Thread = Node.Value;
+
+                ThreadList.Remove(Thread.WithholderNode);
+
+                Thread.Withholder = null;
+
+                Thread.Reschedule(ThreadSchedState.Running);
+            }
+
+            System.CriticalSection.Leave();
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KContextIdManager.cs

@@ -0,0 +1,83 @@
+using Ryujinx.Common;
+using System;
+
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class KContextIdManager
+    {
+        private const int IdMasksCount = 8;
+
+        private int[] IdMasks;
+
+        private int NextFreeBitHint;
+
+        public KContextIdManager()
+        {
+            IdMasks = new int[IdMasksCount];
+        }
+
+        public int GetId()
+        {
+            lock (IdMasks)
+            {
+                int Id = 0;
+
+                if (!TestBit(NextFreeBitHint))
+                {
+                    Id = NextFreeBitHint;
+                }
+                else
+                {
+                    for (int Index = 0; Index < IdMasksCount; Index++)
+                    {
+                        int Mask = IdMasks[Index];
+
+                        int FirstFreeBit = BitUtils.CountLeadingZeros32((Mask + 1) & ~Mask);
+
+                        if (FirstFreeBit < 32)
+                        {
+                            int BaseBit = Index * 32 + 31;
+
+                            Id = BaseBit - FirstFreeBit;
+
+                            break;
+                        }
+                        else if (Index == IdMasksCount - 1)
+                        {
+                            throw new InvalidOperationException("Maximum number of Ids reached!");
+                        }
+                    }
+                }
+
+                NextFreeBitHint = Id + 1;
+
+                SetBit(Id);
+
+                return Id;
+            }
+        }
+
+        public void PutId(int Id)
+        {
+            lock (IdMasks)
+            {
+                ClearBit(Id);
+            }
+        }
+
+        private bool TestBit(int Bit)
+        {
+            return (IdMasks[NextFreeBitHint / 32] & (1 << (NextFreeBitHint & 31))) != 0;
+        }
+
+        private void SetBit(int Bit)
+        {
+            IdMasks[NextFreeBitHint / 32] |= (1 << (NextFreeBitHint & 31));
+        }
+
+        private void ClearBit(int Bit)
+        {
+            IdMasks[NextFreeBitHint / 32] &= ~(1 << (NextFreeBitHint & 31));
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KCoreContext.cs

@@ -1,5 +1,4 @@
 using Ryujinx.Common;
-using System;
 
 namespace Ryujinx.HLE.HOS.Kernel
 {
@@ -11,6 +10,10 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         public bool ContextSwitchNeeded { get; private set; }
 
+        public long LastContextSwitchTime { get; private set; }
+
+        public long TotalIdleTimeTicks { get; private set; } //TODO
+
         public KThread CurrentThread  { get; private set; }
         public KThread SelectedThread { get; private set; }
 
@@ -24,11 +27,6 @@ namespace Ryujinx.HLE.HOS.Kernel
         {
             SelectedThread = Thread;
 
-            if (Thread != null)
-            {
-                Thread.LastScheduledTicks = PerformanceCounter.ElapsedMilliseconds;
-            }
-
             if (SelectedThread != CurrentThread)
             {
                 ContextSwitchNeeded = true;
@@ -39,25 +37,42 @@ namespace Ryujinx.HLE.HOS.Kernel
         {
             ContextSwitchNeeded = false;
 
+            LastContextSwitchTime = PerformanceCounter.ElapsedMilliseconds;
+
             CurrentThread = SelectedThread;
+
+            if (CurrentThread != null)
+            {
+                long CurrentTime = PerformanceCounter.ElapsedMilliseconds;
+
+                CurrentThread.TotalTimeRunning += CurrentTime - CurrentThread.LastScheduledTime;
+                CurrentThread.LastScheduledTime = CurrentTime;
+            }
         }
 
         public void ContextSwitch()
         {
             ContextSwitchNeeded = false;
 
+            LastContextSwitchTime = PerformanceCounter.ElapsedMilliseconds;
+
             if (CurrentThread != null)
             {
-                CoreManager.GetThread(CurrentThread.Context.Work).Reset();
+                CoreManager.Reset(CurrentThread.Context.Work);
             }
 
             CurrentThread = SelectedThread;
 
             if (CurrentThread != null)
             {
+                long CurrentTime = PerformanceCounter.ElapsedMilliseconds;
+
+                CurrentThread.TotalTimeRunning += CurrentTime - CurrentThread.LastScheduledTime;
+                CurrentThread.LastScheduledTime = CurrentTime;
+
                 CurrentThread.ClearExclusive();
 
-                CoreManager.GetThread(CurrentThread.Context.Work).Set();
+                CoreManager.Set(CurrentThread.Context.Work);
 
                 CurrentThread.Context.Execute();
             }

Ryujinx.HLE/HOS/Kernel/KCriticalSection.cs

@@ -3,7 +3,7 @@ using System.Threading;
 
 namespace Ryujinx.HLE.HOS.Kernel
 {
-    class KRecursiveLock
+    class KCriticalSection
     {
         private Horizon System;
 
@@ -11,21 +11,21 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private int RecursionCount;
 
-        public KRecursiveLock(Horizon System)
+        public KCriticalSection(Horizon System)
         {
             this.System = System;
 
             LockObj = new object();
         }
 
-        public void Lock()
+        public void Enter()
         {
             Monitor.Enter(LockObj);
 
             RecursionCount++;
         }
 
-        public void Unlock()
+        public void Leave()
         {
             if (RecursionCount == 0)
             {

Ryujinx.HLE/HOS/Kernel/KHandleTable.cs

@@ -2,7 +2,7 @@ using System;
 
 namespace Ryujinx.HLE.HOS.Kernel
 {
-    class KProcessHandleTable
+    class KHandleTable
     {
         private const int SelfThreadHandle  = (0x1ffff << 15) | 0;
         private const int SelfProcessHandle = (0x1ffff << 15) | 1;
@@ -20,12 +20,24 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private ushort IdCounter;
 
-        private object LockObj;
-
-        public KProcessHandleTable(Horizon System, int Size = 1024)
+        public KHandleTable(Horizon System)
         {
             this.System = System;
-            this.Size   = Size;
+        }
+
+        public KernelResult Initialize(int Size)
+        {
+            if ((uint)Size > 1024)
+            {
+                return KernelResult.OutOfMemory;
+            }
+
+            if (Size < 1)
+            {
+                Size = 1024;
+            }
+
+            this.Size = Size;
 
             IdCounter = 1;
 
@@ -48,14 +60,14 @@ namespace Ryujinx.HLE.HOS.Kernel
 
             NextFreeEntry = TableHead;
 
-            LockObj = new object();
+            return KernelResult.Success;
         }
 
         public KernelResult GenerateHandle(object Obj, out int Handle)
         {
             Handle = 0;
 
-            lock (LockObj)
+            lock (Table)
             {
                 if (ActiveSlotsCount >= Size)
                 {
@@ -95,12 +107,12 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return false;
             }
 
-            int Index    = (Handle >>  0) & 0x7fff;
+            int Index    = (Handle >> 0) & 0x7fff;
             int HandleId = (Handle >> 15);
 
             bool Result = false;
 
-            lock (LockObj)
+            lock (Table)
             {
                 if (HandleId != 0 && Index < Size)
                 {
@@ -125,10 +137,10 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         public T GetObject<T>(int Handle)
         {
-            int Index    = (Handle >>  0) & 0x7fff;
+            int Index    = (Handle >> 0) & 0x7fff;
             int HandleId = (Handle >> 15);
 
-            lock (LockObj)
+            lock (Table)
             {
                 if ((Handle >> 30) == 0 && HandleId != 0)
                 {
@@ -156,9 +168,21 @@ namespace Ryujinx.HLE.HOS.Kernel
             }
         }
 
+        public KProcess GetKProcess(int Handle)
+        {
+            if (Handle == SelfProcessHandle)
+            {
+                return System.Scheduler.GetCurrentProcess();
+            }
+            else
+            {
+                return GetObject<KProcess>(Handle);
+            }
+        }
+
         public void Destroy()
         {
-            lock (LockObj)
+            lock (Table)
             {
                 for (int Index = 0; Index < Size; Index++)
                 {

Ryujinx.HLE/HOS/Kernel/KMemoryArrange.cs

@@ -0,0 +1,22 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class KMemoryArrange
+    {
+        public KMemoryArrangeRegion Service     { get; private set; }
+        public KMemoryArrangeRegion NvServices  { get; private set; }
+        public KMemoryArrangeRegion Applet      { get; private set; }
+        public KMemoryArrangeRegion Application { get; private set; }
+
+        public KMemoryArrange(
+            KMemoryArrangeRegion Service,
+            KMemoryArrangeRegion NvServices,
+            KMemoryArrangeRegion Applet,
+            KMemoryArrangeRegion Application)
+        {
+            this.Service     = Service;
+            this.NvServices  = NvServices;
+            this.Applet      = Applet;
+            this.Application = Application;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KMemoryArrangeRegion.cs

@@ -0,0 +1,16 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    struct KMemoryArrangeRegion
+    {
+        public ulong Address { get; private set; }
+        public ulong Size    { get; private set; }
+
+        public ulong EndAddr => Address + Size;
+
+        public KMemoryArrangeRegion(ulong Address, ulong Size)
+        {
+            this.Address = Address;
+            this.Size    = Size;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KMemoryBlock.cs

@@ -2,8 +2,8 @@ namespace Ryujinx.HLE.HOS.Kernel
 {
     class KMemoryBlock
     {
-        public long BasePosition { get; set; }
-        public long PagesCount   { get; set; }
+        public ulong BaseAddress { get; set; }
+        public ulong PagesCount  { get; set; }
 
         public MemoryState      State      { get; set; }
         public MemoryPermission Permission { get; set; }
@@ -13,25 +13,25 @@ namespace Ryujinx.HLE.HOS.Kernel
         public int DeviceRefCount { get; set; }
 
         public KMemoryBlock(
-            long             BasePosition,
-            long             PagesCount,
+            ulong            BaseAddress,
+            ulong            PagesCount,
             MemoryState      State,
             MemoryPermission Permission,
             MemoryAttribute  Attribute)
         {
-            this.BasePosition = BasePosition;
-            this.PagesCount   = PagesCount;
-            this.State        = State;
-            this.Attribute    = Attribute;
-            this.Permission   = Permission;
+            this.BaseAddress = BaseAddress;
+            this.PagesCount  = PagesCount;
+            this.State       = State;
+            this.Attribute   = Attribute;
+            this.Permission  = Permission;
         }
 
         public KMemoryInfo GetInfo()
         {
-            long Size = PagesCount * KMemoryManager.PageSize;
+            ulong Size = PagesCount * KMemoryManager.PageSize;
 
             return new KMemoryInfo(
-                BasePosition,
+                BaseAddress,
                 Size,
                 State,
                 Permission,

Ryujinx.HLE/HOS/Kernel/KMemoryBlockAllocator.cs

@@ -0,0 +1,19 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class KMemoryBlockAllocator
+    {
+        private ulong CapacityElements;
+
+        public int Count { get; set; }
+
+        public KMemoryBlockAllocator(ulong CapacityElements)
+        {
+            this.CapacityElements = CapacityElements;
+        }
+
+        public bool CanAllocate(int Count)
+        {
+            return (ulong)(this.Count + Count) <= CapacityElements;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KMemoryInfo.cs

@@ -2,8 +2,8 @@ namespace Ryujinx.HLE.HOS.Kernel
 {
     class KMemoryInfo
     {
-        public long Position { get; private set; }
-        public long Size     { get; private set; }
+        public ulong Address { get; private set; }
+        public ulong Size    { get; private set; }
 
         public MemoryState      State      { get; private set; }
         public MemoryPermission Permission { get; private set; }
@@ -13,15 +13,15 @@ namespace Ryujinx.HLE.HOS.Kernel
         public int DeviceRefCount { get; private set; }
 
         public KMemoryInfo(
-            long             Position,
-            long             Size,
+            ulong            Address,
+            ulong            Size,
             MemoryState      State,
             MemoryPermission Permission,
             MemoryAttribute  Attribute,
             int              IpcRefCount,
             int              DeviceRefCount)
         {
-            this.Position       = Position;
+            this.Address        = Address;
             this.Size           = Size;
             this.State          = State;
             this.Attribute      = Attribute;

Ryujinx.HLE/HOS/Kernel/KMemoryRegionBlock.cs

@@ -0,0 +1,43 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class KMemoryRegionBlock
+    {
+        public long[][] Masks;
+
+        public ulong FreeCount;
+        public int   MaxLevel;
+        public ulong StartAligned;
+        public ulong SizeInBlocksTruncated;
+        public ulong SizeInBlocksRounded;
+        public int   Order;
+        public int   NextOrder;
+
+        public bool TryCoalesce(int Index, int Size)
+        {
+            long Mask = ((1L << Size) - 1) << (Index & 63);
+
+            Index /= 64;
+
+            if ((Mask & ~Masks[MaxLevel - 1][Index]) != 0)
+            {
+                return false;
+            }
+
+            Masks[MaxLevel - 1][Index] &= ~Mask;
+
+            for (int Level = MaxLevel - 2; Level >= 0; Level--, Index /= 64)
+            {
+                Masks[Level][Index / 64] &= ~(1L << (Index & 63));
+
+                if (Masks[Level][Index / 64] != 0)
+                {
+                    break;
+                }
+            }
+
+            FreeCount -= (ulong)Size;
+
+            return true;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KMemoryRegionManager.cs

@@ -0,0 +1,428 @@
+using Ryujinx.Common;
+
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class KMemoryRegionManager
+    {
+        private static readonly int[] BlockOrders = new int[] { 12, 16, 21, 22, 25, 29, 30 };
+
+        public ulong Address { get; private set; }
+        public ulong EndAddr { get; private set; }
+        public ulong Size    { get; private set; }
+
+        private int BlockOrdersCount;
+
+        private KMemoryRegionBlock[] Blocks;
+
+        public KMemoryRegionManager(ulong Address, ulong Size, ulong EndAddr)
+        {
+            Blocks = new KMemoryRegionBlock[BlockOrders.Length];
+
+            this.Address = Address;
+            this.Size    = Size;
+            this.EndAddr = EndAddr;
+
+            BlockOrdersCount = BlockOrders.Length;
+
+            for (int BlockIndex = 0; BlockIndex < BlockOrdersCount; BlockIndex++)
+            {
+                Blocks[BlockIndex] = new KMemoryRegionBlock();
+
+                Blocks[BlockIndex].Order = BlockOrders[BlockIndex];
+
+                int NextOrder = BlockIndex == BlockOrdersCount - 1 ? 0 : BlockOrders[BlockIndex + 1];
+
+                Blocks[BlockIndex].NextOrder = NextOrder;
+
+                int CurrBlockSize = 1 << BlockOrders[BlockIndex];
+                int NextBlockSize = CurrBlockSize;
+
+                if (NextOrder != 0)
+                {
+                    NextBlockSize = 1 << NextOrder;
+                }
+
+                ulong StartAligned   = BitUtils.AlignDown(Address, NextBlockSize);
+                ulong EndAddrAligned = BitUtils.AlignDown(EndAddr, CurrBlockSize);
+
+                ulong SizeInBlocksTruncated = (EndAddrAligned - StartAligned) >> BlockOrders[BlockIndex];
+
+                ulong EndAddrRounded = BitUtils.AlignUp(Address + Size, NextBlockSize);
+
+                ulong SizeInBlocksRounded = (EndAddrRounded - StartAligned) >> BlockOrders[BlockIndex];
+
+                Blocks[BlockIndex].StartAligned          = StartAligned;
+                Blocks[BlockIndex].SizeInBlocksTruncated = SizeInBlocksTruncated;
+                Blocks[BlockIndex].SizeInBlocksRounded   = SizeInBlocksRounded;
+
+                ulong CurrSizeInBlocks = SizeInBlocksRounded;
+
+                int MaxLevel = 0;
+
+                do
+                {
+                    MaxLevel++;
+                }
+                while ((CurrSizeInBlocks /= 64) != 0);
+
+                Blocks[BlockIndex].MaxLevel = MaxLevel;
+
+                Blocks[BlockIndex].Masks = new long[MaxLevel][];
+
+                CurrSizeInBlocks = SizeInBlocksRounded;
+
+                for (int Level = MaxLevel - 1; Level >= 0; Level--)
+                {
+                    CurrSizeInBlocks = (CurrSizeInBlocks + 63) / 64;
+
+                    Blocks[BlockIndex].Masks[Level] = new long[CurrSizeInBlocks];
+                }
+            }
+
+            if (Size != 0)
+            {
+                FreePages(Address, Size / KMemoryManager.PageSize);
+            }
+        }
+
+        public KernelResult AllocatePages(ulong PagesCount, bool Backwards, out KPageList PageList)
+        {
+            lock (Blocks)
+            {
+                return AllocatePagesImpl(PagesCount, Backwards, out PageList);
+            }
+        }
+
+        private KernelResult AllocatePagesImpl(ulong PagesCount, bool Backwards, out KPageList PageList)
+        {
+            PageList = new KPageList();
+
+            if (BlockOrdersCount > 0)
+            {
+                if (GetFreePagesImpl() < PagesCount)
+                {
+                    return KernelResult.OutOfMemory;
+                }
+            }
+            else if (PagesCount != 0)
+            {
+                return KernelResult.OutOfMemory;
+            }
+
+            for (int BlockIndex = BlockOrdersCount - 1; BlockIndex >= 0; BlockIndex--)
+            {
+                KMemoryRegionBlock Block = Blocks[BlockIndex];
+
+                ulong BestFitBlockSize = 1UL << Block.Order;
+
+                ulong BlockPagesCount = BestFitBlockSize / KMemoryManager.PageSize;
+
+                //Check if this is the best fit for this page size.
+                //If so, try allocating as much requested pages as possible.
+                while (BlockPagesCount <= PagesCount)
+                {
+                    ulong Address = 0;
+
+                    for (int CurrBlockIndex = BlockIndex;
+                             CurrBlockIndex < BlockOrdersCount && Address == 0;
+                             CurrBlockIndex++)
+                    {
+                        Block = Blocks[CurrBlockIndex];
+
+                        int Index = 0;
+
+                        bool ZeroMask = false;
+
+                        for (int Level = 0; Level < Block.MaxLevel; Level++)
+                        {
+                            long Mask = Block.Masks[Level][Index];
+
+                            if (Mask == 0)
+                            {
+                                ZeroMask = true;
+
+                                break;
+                            }
+
+                            if (Backwards)
+                            {
+                                Index = (Index * 64 + 63) - BitUtils.CountLeadingZeros64(Mask);
+                            }
+                            else
+                            {
+                                Index = Index * 64 + BitUtils.CountLeadingZeros64(BitUtils.ReverseBits64(Mask));
+                            }
+                        }
+
+                        if (Block.SizeInBlocksTruncated <= (ulong)Index || ZeroMask)
+                        {
+                            continue;
+                        }
+
+                        Block.FreeCount--;
+
+                        int TempIdx = Index;
+
+                        for (int Level = Block.MaxLevel - 1; Level >= 0; Level--, TempIdx /= 64)
+                        {
+                            Block.Masks[Level][TempIdx / 64] &= ~(1L << (TempIdx & 63));
+
+                            if (Block.Masks[Level][TempIdx / 64] != 0)
+                            {
+                                break;
+                            }
+                        }
+
+                        Address = Block.StartAligned + ((ulong)Index << Block.Order);
+                    }
+
+                    for (int CurrBlockIndex = BlockIndex;
+                             CurrBlockIndex < BlockOrdersCount && Address == 0;
+                             CurrBlockIndex++)
+                    {
+                        Block = Blocks[CurrBlockIndex];
+
+                        int Index = 0;
+
+                        bool ZeroMask = false;
+
+                        for (int Level = 0; Level < Block.MaxLevel; Level++)
+                        {
+                            long Mask = Block.Masks[Level][Index];
+
+                            if (Mask == 0)
+                            {
+                                ZeroMask = true;
+
+                                break;
+                            }
+
+                            if (Backwards)
+                            {
+                                Index = Index * 64 + BitUtils.CountLeadingZeros64(BitUtils.ReverseBits64(Mask));
+                            }
+                            else
+                            {
+                                Index = (Index * 64 + 63) - BitUtils.CountLeadingZeros64(Mask);
+                            }
+                        }
+
+                        if (Block.SizeInBlocksTruncated <= (ulong)Index || ZeroMask)
+                        {
+                            continue;
+                        }
+
+                        Block.FreeCount--;
+
+                        int TempIdx = Index;
+
+                        for (int Level = Block.MaxLevel - 1; Level >= 0; Level--, TempIdx /= 64)
+                        {
+                            Block.Masks[Level][TempIdx / 64] &= ~(1L << (TempIdx & 63));
+
+                            if (Block.Masks[Level][TempIdx / 64] != 0)
+                            {
+                                break;
+                            }
+                        }
+
+                        Address = Block.StartAligned + ((ulong)Index << Block.Order);
+                    }
+
+                    //The address being zero means that no free space was found on that order,
+                    //just give up and try with the next one.
+                    if (Address == 0)
+                    {
+                        break;
+                    }
+
+                    //If we are using a larger order than best fit, then we should
+                    //split it into smaller blocks.
+                    ulong FirstFreeBlockSize = 1UL << Block.Order;
+
+                    if (FirstFreeBlockSize > BestFitBlockSize)
+                    {
+                        FreePages(Address + BestFitBlockSize, (FirstFreeBlockSize - BestFitBlockSize) / KMemoryManager.PageSize);
+                    }
+
+                    //Add new allocated page(s) to the pages list.
+                    //If an error occurs, then free all allocated pages and fail.
+                    KernelResult Result = PageList.AddRange(Address, BlockPagesCount);
+
+                    if (Result != KernelResult.Success)
+                    {
+                        FreePages(Address, BlockPagesCount);
+
+                        foreach (KPageNode PageNode in PageList)
+                        {
+                            FreePages(PageNode.Address, PageNode.PagesCount);
+                        }
+
+                        return Result;
+                    }
+
+                    PagesCount -= BlockPagesCount;
+                }
+            }
+
+            //Success case, all requested pages were allocated successfully.
+            if (PagesCount == 0)
+            {
+                return KernelResult.Success;
+            }
+
+            //Error case, free allocated pages and return out of memory.
+            foreach (KPageNode PageNode in PageList)
+            {
+                FreePages(PageNode.Address, PageNode.PagesCount);
+            }
+
+            PageList = null;
+
+            return KernelResult.OutOfMemory;
+        }
+
+        public void FreePages(KPageList PageList)
+        {
+            lock (Blocks)
+            {
+                foreach (KPageNode PageNode in PageList)
+                {
+                    FreePages(PageNode.Address, PageNode.PagesCount);
+                }
+            }
+        }
+
+        private void FreePages(ulong Address, ulong PagesCount)
+        {
+            ulong EndAddr = Address + PagesCount * KMemoryManager.PageSize;
+
+            int BlockIndex = BlockOrdersCount - 1;
+
+            ulong AddressRounded   = 0;
+            ulong EndAddrTruncated = 0;
+
+            for (; BlockIndex >= 0; BlockIndex--)
+            {
+                KMemoryRegionBlock AllocInfo = Blocks[BlockIndex];
+
+                int BlockSize = 1 << AllocInfo.Order;
+
+                AddressRounded   = BitUtils.AlignUp  (Address, BlockSize);
+                EndAddrTruncated = BitUtils.AlignDown(EndAddr, BlockSize);
+
+                if (AddressRounded < EndAddrTruncated)
+                {
+                    break;
+                }
+            }
+
+            void FreeRegion(ulong CurrAddress)
+            {
+                for (int CurrBlockIndex = BlockIndex;
+                         CurrBlockIndex < BlockOrdersCount && CurrAddress != 0;
+                         CurrBlockIndex++)
+                {
+                    KMemoryRegionBlock Block = Blocks[CurrBlockIndex];
+
+                    Block.FreeCount++;
+
+                    ulong FreedBlocks = (CurrAddress - Block.StartAligned) >> Block.Order;
+
+                    int Index = (int)FreedBlocks;
+
+                    for (int Level = Block.MaxLevel - 1; Level >= 0; Level--, Index /= 64)
+                    {
+                        long Mask = Block.Masks[Level][Index / 64];
+
+                        Block.Masks[Level][Index / 64] = Mask | (1L << (Index & 63));
+
+                        if (Mask != 0)
+                        {
+                            break;
+                        }
+                    }
+
+                    int BlockSizeDelta = 1 << (Block.NextOrder - Block.Order);
+
+                    int FreedBlocksTruncated = BitUtils.AlignDown((int)FreedBlocks, BlockSizeDelta);
+
+                    if (!Block.TryCoalesce(FreedBlocksTruncated, BlockSizeDelta))
+                    {
+                        break;
+                    }
+
+                    CurrAddress = Block.StartAligned + ((ulong)FreedBlocksTruncated << Block.Order);
+                }
+            }
+
+            //Free inside aligned region.
+            ulong BaseAddress = AddressRounded;
+
+            while (BaseAddress < EndAddrTruncated)
+            {
+                ulong BlockSize = 1UL << Blocks[BlockIndex].Order;
+
+                FreeRegion(BaseAddress);
+
+                BaseAddress += BlockSize;
+            }
+
+            int NextBlockIndex = BlockIndex - 1;
+
+            //Free region between Address and aligned region start.
+            BaseAddress = AddressRounded;
+
+            for (BlockIndex = NextBlockIndex; BlockIndex >= 0; BlockIndex--)
+            {
+                ulong BlockSize = 1UL << Blocks[BlockIndex].Order;
+
+                while (BaseAddress - BlockSize >= Address)
+                {
+                    BaseAddress -= BlockSize;
+
+                    FreeRegion(BaseAddress);
+                }
+            }
+
+            //Free region between aligned region end and End Address.
+            BaseAddress = EndAddrTruncated;
+
+            for (BlockIndex = NextBlockIndex; BlockIndex >= 0; BlockIndex--)
+            {
+                ulong BlockSize = 1UL << Blocks[BlockIndex].Order;
+
+                while (BaseAddress + BlockSize <= EndAddr)
+                {
+                    FreeRegion(BaseAddress);
+
+                    BaseAddress += BlockSize;
+                }
+            }
+        }
+
+        public ulong GetFreePages()
+        {
+            lock (Blocks)
+            {
+                return GetFreePagesImpl();
+            }
+        }
+
+        private ulong GetFreePagesImpl()
+        {
+            ulong AvailablePages = 0;
+
+            for (int BlockIndex = 0; BlockIndex < BlockOrdersCount; BlockIndex++)
+            {
+                KMemoryRegionBlock Block = Blocks[BlockIndex];
+
+                ulong BlockPagesCount = (1UL << Block.Order) / KMemoryManager.PageSize;
+
+                AvailablePages += BlockPagesCount * Block.FreeCount;
+            }
+
+            return AvailablePages;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KPageList.cs

@@ -0,0 +1,80 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class KPageList : IEnumerable<KPageNode>
+    {
+        public LinkedList<KPageNode> Nodes { get; private set; }
+
+        public KPageList()
+        {
+            Nodes = new LinkedList<KPageNode>();
+        }
+
+        public KernelResult AddRange(ulong Address, ulong PagesCount)
+        {
+            if (PagesCount != 0)
+            {
+                if (Nodes.Last != null)
+                {
+                    KPageNode LastNode = Nodes.Last.Value;
+
+                    if (LastNode.Address + LastNode.PagesCount * KMemoryManager.PageSize == Address)
+                    {
+                        Address     = LastNode.Address;
+                        PagesCount += LastNode.PagesCount;
+
+                        Nodes.RemoveLast();
+                    }
+                }
+
+                Nodes.AddLast(new KPageNode(Address, PagesCount));
+            }
+
+            return KernelResult.Success;
+        }
+
+        public ulong GetPagesCount()
+        {
+            ulong Sum = 0;
+
+            foreach (KPageNode Node in Nodes)
+            {
+                Sum += Node.PagesCount;
+            }
+
+            return Sum;
+        }
+
+        public bool IsEqual(KPageList Other)
+        {
+            LinkedListNode<KPageNode> ThisNode  = Nodes.First;
+            LinkedListNode<KPageNode> OtherNode = Other.Nodes.First;
+
+            while (ThisNode != null && OtherNode != null)
+            {
+                if (ThisNode.Value.Address    != OtherNode.Value.Address ||
+                    ThisNode.Value.PagesCount != OtherNode.Value.PagesCount)
+                {
+                    return false;
+                }
+
+                ThisNode  = ThisNode.Next;
+                OtherNode = OtherNode.Next;
+            }
+
+            return ThisNode == null && OtherNode == null;
+        }
+
+        public IEnumerator<KPageNode> GetEnumerator()
+        {
+            return Nodes.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KPageNode.cs

@@ -0,0 +1,14 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    struct KPageNode
+    {
+        public ulong Address;
+        public ulong PagesCount;
+
+        public KPageNode(ulong Address, ulong PagesCount)
+        {
+            this.Address    = Address;
+            this.PagesCount = PagesCount;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KPort.cs

@@ -0,0 +1,26 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class KPort : KAutoObject
+    {
+        public KServerPort ServerPort { get; private set; }
+        public KClientPort ClientPort { get; private set; }
+
+        private long NameAddress;
+        private bool IsLight;
+
+        public KPort(Horizon System) : base(System)
+        {
+            ServerPort = new KServerPort(System);
+            ClientPort = new KClientPort(System);
+        }
+
+        public void Initialize(int MaxSessions, bool IsLight, long NameAddress)
+        {
+            ServerPort.Initialize(this);
+            ClientPort.Initialize(this, MaxSessions);
+
+            this.IsLight     = IsLight;
+            this.NameAddress = NameAddress;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KProcessCapabilities.cs

@@ -0,0 +1,311 @@
+using Ryujinx.Common;
+
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class KProcessCapabilities
+    {
+        public byte[] SvcAccessMask { get; private set; }
+        public byte[] IrqAccessMask { get; private set; }
+
+        public long AllowedCpuCoresMask    { get; private set; }
+        public long AllowedThreadPriosMask { get; private set; }
+
+        public int DebuggingFlags       { get; private set; }
+        public int HandleTableSize      { get; private set; }
+        public int KernelReleaseVersion { get; private set; }
+        public int ApplicationType      { get; private set; }
+
+        public KProcessCapabilities()
+        {
+            SvcAccessMask = new byte[0x10];
+            IrqAccessMask = new byte[0x80];
+        }
+
+        public KernelResult InitializeForKernel(int[] Caps, KMemoryManager MemoryManager)
+        {
+            AllowedCpuCoresMask    = 0xf;
+            AllowedThreadPriosMask = -1;
+            DebuggingFlags        &= ~3;
+            KernelReleaseVersion   = KProcess.KernelVersionPacked;
+
+            return Parse(Caps, MemoryManager);
+        }
+
+        public KernelResult InitializeForUser(int[] Caps, KMemoryManager MemoryManager)
+        {
+            return Parse(Caps, MemoryManager);
+        }
+
+        private KernelResult Parse(int[] Caps, KMemoryManager MemoryManager)
+        {
+            int Mask0 = 0;
+            int Mask1 = 0;
+
+            for (int Index = 0; Index < Caps.Length; Index++)
+            {
+                int Cap = Caps[Index];
+
+                if (((Cap + 1) & ~Cap) != 0x40)
+                {
+                    KernelResult Result = ParseCapability(Cap, ref Mask0, ref Mask1, MemoryManager);
+
+                    if (Result != KernelResult.Success)
+                    {
+                        return Result;
+                    }
+                }
+                else
+                {
+                    if ((uint)Index + 1 >= Caps.Length)
+                    {
+                        return KernelResult.InvalidCombination;
+                    }
+
+                    int PrevCap = Cap;
+
+                    Cap = Caps[++Index];
+
+                    if (((Cap + 1) & ~Cap) != 0x40)
+                    {
+                        return KernelResult.InvalidCombination;
+                    }
+
+                    if ((Cap & 0x78000000) != 0)
+                    {
+                        return KernelResult.MaximumExceeded;
+                    }
+
+                    if ((Cap & 0x7ffff80) == 0)
+                    {
+                        return KernelResult.InvalidSize;
+                    }
+
+                    long Address = ((long)(uint)PrevCap << 5) & 0xffffff000;
+                    long Size    = ((long)(uint)Cap     << 5) & 0xfffff000;
+
+                    if (((ulong)(Address + Size - 1) >> 36) != 0)
+                    {
+                        return KernelResult.InvalidAddress;
+                    }
+
+                    MemoryPermission Perm = (PrevCap >> 31) != 0
+                        ? MemoryPermission.Read
+                        : MemoryPermission.ReadAndWrite;
+
+                    KernelResult Result;
+
+                    if ((Cap >> 31) != 0)
+                    {
+                        Result = MemoryManager.MapNormalMemory(Address, Size, Perm);
+                    }
+                    else
+                    {
+                        Result = MemoryManager.MapIoMemory(Address, Size, Perm);
+                    }
+
+                    if (Result != KernelResult.Success)
+                    {
+                        return Result;
+                    }
+                }
+            }
+
+            return KernelResult.Success;
+        }
+
+        private KernelResult ParseCapability(int Cap, ref int Mask0, ref int Mask1, KMemoryManager MemoryManager)
+        {
+            int Code = (Cap + 1) & ~Cap;
+
+            if (Code == 1)
+            {
+                return KernelResult.InvalidCapability;
+            }
+            else if (Code == 0)
+            {
+                return KernelResult.Success;
+            }
+
+            int CodeMask = 1 << (32 - BitUtils.CountLeadingZeros32(Code + 1));
+
+            //Check if the property was already set.
+            if (((Mask0 & CodeMask) & 0x1e008) != 0)
+            {
+                return KernelResult.InvalidCombination;
+            }
+
+            Mask0 |= CodeMask;
+
+            switch (Code)
+            {
+                case 8:
+                {
+                    if (AllowedCpuCoresMask != 0 || AllowedThreadPriosMask != 0)
+                    {
+                        return KernelResult.InvalidCapability;
+                    }
+
+                    int LowestCpuCore  = (Cap >> 16) & 0xff;
+                    int HighestCpuCore = (Cap >> 24) & 0xff;
+
+                    if (LowestCpuCore > HighestCpuCore)
+                    {
+                        return KernelResult.InvalidCombination;
+                    }
+
+                    int HighestThreadPrio = (Cap >>  4) & 0x3f;
+                    int LowestThreadPrio  = (Cap >> 10) & 0x3f;
+
+                    if (LowestThreadPrio > HighestThreadPrio)
+                    {
+                        return KernelResult.InvalidCombination;
+                    }
+
+                    if (HighestCpuCore >= KScheduler.CpuCoresCount)
+                    {
+                        return KernelResult.InvalidCpuCore;
+                    }
+
+                    AllowedCpuCoresMask    = GetMaskFromMinMax(LowestCpuCore,    HighestCpuCore);
+                    AllowedThreadPriosMask = GetMaskFromMinMax(LowestThreadPrio, HighestThreadPrio);
+
+                    break;
+                }
+
+                case 0x10:
+                {
+                    int Slot = (Cap >> 29) & 7;
+
+                    int SvcSlotMask = 1 << Slot;
+
+                    if ((Mask1 & SvcSlotMask) != 0)
+                    {
+                        return KernelResult.InvalidCombination;
+                    }
+
+                    Mask1 |= SvcSlotMask;
+
+                    int SvcMask = (Cap >> 5) & 0xffffff;
+
+                    int BaseSvc = Slot * 24;
+
+                    for (int Index = 0; Index < 24; Index++)
+                    {
+                        if (((SvcMask >> Index) & 1) == 0)
+                        {
+                            continue;
+                        }
+
+                        int SvcId = BaseSvc + Index;
+
+                        if (SvcId > 0x7f)
+                        {
+                            return KernelResult.MaximumExceeded;
+                        }
+
+                        SvcAccessMask[SvcId / 8] |= (byte)(1 << (SvcId & 7));
+                    }
+
+                    break;
+                }
+
+                case 0x80:
+                {
+                    long Address = ((long)(uint)Cap << 4) & 0xffffff000;
+
+                    MemoryManager.MapIoMemory(Address, KMemoryManager.PageSize, MemoryPermission.ReadAndWrite);
+
+                    break;
+                }
+
+                case 0x800:
+                {
+                    //TODO: GIC distributor check.
+                    int Irq0 = (Cap >> 12) & 0x3ff;
+                    int Irq1 = (Cap >> 22) & 0x3ff;
+
+                    if (Irq0 != 0x3ff)
+                    {
+                        IrqAccessMask[Irq0 / 8] |= (byte)(1 << (Irq0 & 7));
+                    }
+
+                    if (Irq1 != 0x3ff)
+                    {
+                        IrqAccessMask[Irq1 / 8] |= (byte)(1 << (Irq1 & 7));
+                    }
+
+                    break;
+                }
+
+                case 0x2000:
+                {
+                    int ApplicationType = Cap >> 14;
+
+                    if ((uint)ApplicationType > 7)
+                    {
+                        return KernelResult.ReservedValue;
+                    }
+
+                    this.ApplicationType = ApplicationType;
+
+                    break;
+                }
+
+                case 0x4000:
+                {
+                    //Note: This check is bugged on kernel too, we are just replicating the bug here.
+                    if ((KernelReleaseVersion >> 17) != 0 || Cap < 0x80000)
+                    {
+                        return KernelResult.ReservedValue;
+                    }
+
+                    KernelReleaseVersion = Cap;
+
+                    break;
+                }
+
+                case 0x8000:
+                {
+                    int HandleTableSize = Cap >> 26;
+
+                    if ((uint)HandleTableSize > 0x3ff)
+                    {
+                        return KernelResult.ReservedValue;
+                    }
+
+                    this.HandleTableSize = HandleTableSize;
+
+                    break;
+                }
+
+                case 0x10000:
+                {
+                    int DebuggingFlags = Cap >> 19;
+
+                    if ((uint)DebuggingFlags > 3)
+                    {
+                        return KernelResult.ReservedValue;
+                    }
+
+                    this.DebuggingFlags &= ~3;
+                    this.DebuggingFlags |= DebuggingFlags;
+
+                    break;
+                }
+
+                default: return KernelResult.InvalidCapability;
+            }
+
+            return KernelResult.Success;
+        }
+
+        private static long GetMaskFromMinMax(int Min, int Max)
+        {
+            int Range = Max - Min + 1;
+
+            long Mask = (1L << Range) - 1;
+
+            return Mask << Min;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KReadableEvent.cs

@@ -13,7 +13,7 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         public override void Signal()
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             if (!Signaled)
             {
@@ -22,7 +22,7 @@ namespace Ryujinx.HLE.HOS.Kernel
                 base.Signal();
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
         }
 
         public KernelResult Clear()
@@ -36,7 +36,7 @@ namespace Ryujinx.HLE.HOS.Kernel
         {
             KernelResult Result;
 
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             if (Signaled)
             {
@@ -49,7 +49,7 @@ namespace Ryujinx.HLE.HOS.Kernel
                 Result = KernelResult.InvalidState;
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             return Result;
         }

Ryujinx.HLE/HOS/Kernel/KResourceLimit.cs

@@ -0,0 +1,146 @@
+using Ryujinx.Common;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class KResourceLimit
+    {
+        private const int Time10SecondsMs = 10000;
+
+        private long[] Current;
+        private long[] Limit;
+        private long[] Available;
+
+        private object LockObj;
+
+        private LinkedList<KThread> WaitingThreads;
+
+        private int WaitingThreadsCount;
+
+        private Horizon System;
+
+        public KResourceLimit(Horizon System)
+        {
+            Current   = new long[(int)LimitableResource.Count];
+            Limit     = new long[(int)LimitableResource.Count];
+            Available = new long[(int)LimitableResource.Count];
+
+            LockObj = new object();
+
+            WaitingThreads = new LinkedList<KThread>();
+
+            this.System = System;
+        }
+
+        public bool Reserve(LimitableResource Resource, ulong Amount)
+        {
+            return Reserve(Resource, (long)Amount);
+        }
+
+        public bool Reserve(LimitableResource Resource, long Amount)
+        {
+            return Reserve(Resource, Amount, KTimeManager.ConvertMillisecondsToNanoseconds(Time10SecondsMs));
+        }
+
+        public bool Reserve(LimitableResource Resource, long Amount, long Timeout)
+        {
+            long EndTimePoint = KTimeManager.ConvertNanosecondsToMilliseconds(Timeout);
+
+            EndTimePoint += PerformanceCounter.ElapsedMilliseconds;
+
+            bool Success = false;
+
+            int Index = GetIndex(Resource);
+
+            lock (LockObj)
+            {
+                long NewCurrent = Current[Index] + Amount;
+
+                while (NewCurrent > Limit[Index] && Available[Index] + Amount <= Limit[Index])
+                {
+                    WaitingThreadsCount++;
+
+                    KConditionVariable.Wait(System, WaitingThreads, LockObj, Timeout);
+
+                    WaitingThreadsCount--;
+
+                    NewCurrent = Current[Index] + Amount;
+
+                    if (Timeout >= 0 && PerformanceCounter.ElapsedMilliseconds > EndTimePoint)
+                    {
+                        break;
+                    }
+                }
+
+                if (NewCurrent <= Limit[Index])
+                {
+                    Current[Index] = NewCurrent;
+
+                    Success = true;
+                }
+            }
+
+            return Success;
+        }
+
+        public void Release(LimitableResource Resource, ulong Amount)
+        {
+            Release(Resource, (long)Amount);
+        }
+
+        public void Release(LimitableResource Resource, long Amount)
+        {
+            Release(Resource, Amount, Amount);
+        }
+
+        private void Release(LimitableResource Resource, long UsedAmount, long AvailableAmount)
+        {
+            int Index = GetIndex(Resource);
+
+            lock (LockObj)
+            {
+                Current  [Index] -= UsedAmount;
+                Available[Index] -= AvailableAmount;
+
+                if (WaitingThreadsCount > 0)
+                {
+                    KConditionVariable.NotifyAll(System, WaitingThreads);
+                }
+            }
+        }
+
+        public long GetRemainingValue(LimitableResource Resource)
+        {
+            int Index = GetIndex(Resource);
+
+            lock (LockObj)
+            {
+                return Limit[Index] - Current[Index];
+            }
+        }
+
+        public KernelResult SetLimitValue(LimitableResource Resource, long Limit)
+        {
+            int Index = GetIndex(Resource);
+
+            lock (LockObj)
+            {
+                if (Current[Index] <= Limit)
+                {
+                    this.Limit[Index] = Limit;
+
+                    return KernelResult.Success;
+                }
+                else
+                {
+                    return KernelResult.InvalidState;
+                }
+            }
+        }
+
+        private static int GetIndex(LimitableResource Resource)
+        {
+            return (int)Resource;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KScheduler.cs

@@ -38,14 +38,14 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private void PreemptThreads()
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             PreemptThread(PreemptionPriorityCores012, 0);
             PreemptThread(PreemptionPriorityCores012, 1);
             PreemptThread(PreemptionPriorityCores012, 2);
             PreemptThread(PreemptionPriorityCore3,    3);
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
         }
 
         private void PreemptThread(int Prio, int Core)
@@ -82,7 +82,7 @@ namespace Ryujinx.HLE.HOS.Kernel
                     }
 
                     //If the candidate was scheduled after the current thread, then it's not worth it.
-                    if (SelectedThread == null || SelectedThread.LastScheduledTicks >= Thread.LastScheduledTicks)
+                    if (SelectedThread == null || SelectedThread.LastScheduledTime >= Thread.LastScheduledTime)
                     {
                         yield return Thread;
                     }
@@ -212,6 +212,11 @@ namespace Ryujinx.HLE.HOS.Kernel
             throw new InvalidOperationException("Current thread is not scheduled!");
         }
 
+        public KProcess GetCurrentProcess()
+        {
+            return GetCurrentThread().Owner;
+        }
+
         public void Dispose()
         {
             Dispose(true);

Ryujinx.HLE/HOS/Kernel/KServerPort.cs

@@ -0,0 +1,14 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class KServerPort : KSynchronizationObject
+    {
+        private KPort Parent;
+
+        public KServerPort(Horizon System) : base(System) { }
+
+        public void Initialize(KPort Parent)
+        {
+            this.Parent = Parent;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KSharedMemory.cs

@@ -1,14 +1,68 @@
+using Ryujinx.Common;
+
 namespace Ryujinx.HLE.HOS.Kernel
 {
     class KSharedMemory
     {
-        public long PA   { get; private set; }
-        public long Size { get; private set; }
+        private KPageList PageList;
 
-        public KSharedMemory(long PA, long Size)
+        private long OwnerPid;
+
+        private MemoryPermission OwnerPermission;
+        private MemoryPermission UserPermission;
+
+        public KSharedMemory(
+            KPageList        PageList,
+            long             OwnerPid,
+            MemoryPermission OwnerPermission,
+            MemoryPermission UserPermission)
         {
-            this.PA   = PA;
-            this.Size = Size;
+            this.PageList        = PageList;
+            this.OwnerPid        = OwnerPid;
+            this.OwnerPermission = OwnerPermission;
+            this.UserPermission  = UserPermission;
+        }
+
+        public KernelResult MapIntoProcess(
+            KMemoryManager   MemoryManager,
+            ulong            Address,
+            ulong            Size,
+            KProcess         Process,
+            MemoryPermission Permission)
+        {
+            ulong PagesCountRounded = BitUtils.DivRoundUp(Size, KMemoryManager.PageSize);
+
+            if (PageList.GetPagesCount() != PagesCountRounded)
+            {
+                return KernelResult.InvalidSize;
+            }
+
+            MemoryPermission ExpectedPermission = Process.Pid == OwnerPid
+                ? OwnerPermission
+                : UserPermission;
+
+            if (Permission != ExpectedPermission)
+            {
+                return KernelResult.InvalidPermission;
+            }
+
+            return MemoryManager.MapPages(Address, PageList, MemoryState.SharedMemory, Permission);
+        }
+
+        public KernelResult UnmapFromProcess(
+            KMemoryManager   MemoryManager,
+            ulong            Address,
+            ulong            Size,
+            KProcess         Process)
+        {
+            ulong PagesCountRounded = BitUtils.DivRoundUp(Size, KMemoryManager.PageSize);
+
+            if (PageList.GetPagesCount() != PagesCountRounded)
+            {
+                return KernelResult.InvalidSize;
+            }
+
+            return MemoryManager.UnmapPages(Address, PageList, MemoryState.SharedMemory);
         }
     }
 }

Ryujinx.HLE/HOS/Kernel/KSlabHeap.cs

@@ -0,0 +1,50 @@
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class KSlabHeap
+    {
+        private LinkedList<ulong> Items;
+
+        public KSlabHeap(ulong Pa, ulong ItemSize, ulong Size)
+        {
+            Items = new LinkedList<ulong>();
+
+            int ItemsCount = (int)(Size / ItemSize);
+
+            for (int Index = 0; Index < ItemsCount; Index++)
+            {
+                Items.AddLast(Pa);
+
+                Pa += ItemSize;
+            }
+        }
+
+        public bool TryGetItem(out ulong Pa)
+        {
+            lock (Items)
+            {
+                if (Items.First != null)
+                {
+                    Pa = Items.First.Value;
+
+                    Items.RemoveFirst();
+
+                    return true;
+                }
+            }
+
+            Pa = 0;
+
+            return false;
+        }
+
+        public void Free(ulong Pa)
+        {
+            lock (Items)
+            {
+                Items.AddFirst(Pa);
+            }
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KSynchronization.cs

@@ -17,7 +17,7 @@ namespace Ryujinx.HLE.HOS.Kernel
         {
             long Result = MakeError(ErrorModule.Kernel, KernelErr.Timeout);
 
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             //Check if objects are already signaled before waiting.
             for (int Index = 0; Index < SyncObjs.Length; Index++)
@@ -29,14 +29,14 @@ namespace Ryujinx.HLE.HOS.Kernel
 
                 HndIndex = Index;
 
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return 0;
             }
 
             if (Timeout == 0)
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return Result;
             }
@@ -74,7 +74,7 @@ namespace Ryujinx.HLE.HOS.Kernel
                     System.TimeManager.ScheduleFutureInvocation(CurrentThread, Timeout);
                 }
 
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 CurrentThread.WaitingSync = false;
 
@@ -83,7 +83,7 @@ namespace Ryujinx.HLE.HOS.Kernel
                     System.TimeManager.UnscheduleFutureInvocation(CurrentThread);
                 }
 
-                System.CriticalSectionLock.Lock();
+                System.CriticalSection.Enter();
 
                 Result = (uint)CurrentThread.ObjSyncResult;
 
@@ -100,14 +100,14 @@ namespace Ryujinx.HLE.HOS.Kernel
                 }
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             return Result;
         }
 
         public void SignalObject(KSynchronizationObject SyncObj)
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             if (SyncObj.IsSignaled())
             {
@@ -117,7 +117,7 @@ namespace Ryujinx.HLE.HOS.Kernel
                 {
                     KThread Thread = Node.Value;
 
-                    if ((Thread.SchedFlags & ThreadSchedState.LowNibbleMask) == ThreadSchedState.Paused)
+                    if ((Thread.SchedFlags & ThreadSchedState.LowMask) == ThreadSchedState.Paused)
                     {
                         Thread.SignaledObj   = SyncObj;
                         Thread.ObjSyncResult = 0;
@@ -129,7 +129,7 @@ namespace Ryujinx.HLE.HOS.Kernel
                 }
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
         }
     }
 }

Ryujinx.HLE/HOS/Kernel/KSynchronizationObject.cs

@@ -2,16 +2,12 @@ using System.Collections.Generic;
 
 namespace Ryujinx.HLE.HOS.Kernel
 {
-    class KSynchronizationObject
+    class KSynchronizationObject : KAutoObject
     {
         public LinkedList<KThread> WaitingThreads;
 
-        protected Horizon System;
-
-        public KSynchronizationObject(Horizon System)
+        public KSynchronizationObject(Horizon System) : base(System)
         {
-            this.System = System;
-
             WaitingThreads = new LinkedList<KThread>();
         }
 

Ryujinx.HLE/HOS/Kernel/KThread.cs

@@ -1,4 +1,5 @@
 using ChocolArm64;
+using ChocolArm64.Memory;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -13,20 +14,30 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         public long AffinityMask { get; set; }
 
-        public int ThreadId { get; private set; }
+        public long ThreadUid { get; private set; }
 
-        public KSynchronizationObject SignaledObj;
+        public long TotalTimeRunning { get; set; }
+
+        public KSynchronizationObject SignaledObj { get; set; }
 
         public long CondVarAddress { get; set; }
-        public long MutexAddress   { get; set; }
 
-        public Process Owner { get; private set; }
+        private ulong Entrypoint;
 
-        public long LastScheduledTicks { get; set; }
+        public long MutexAddress { get; set; }
+
+        public KProcess Owner { get; private set; }
+
+        private ulong TlsAddress;
+
+        public long LastScheduledTime { get; set; }
 
         public LinkedListNode<KThread>[] SiblingsPerCore { get; private set; }
 
-        private LinkedListNode<KThread> WithholderNode;
+        public LinkedList<KThread>     Withholder     { get; set; }
+        public LinkedListNode<KThread> WithholderNode { get; set; }
+
+        public LinkedListNode<KThread> ProcessListNode { get; set; }
 
         private LinkedList<KThread>     MutexWaiters;
         private LinkedListNode<KThread> MutexWaiterNode;
@@ -65,38 +76,131 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         public long LastPc { get; set; }
 
-        public KThread(
-            CpuThread Thread,
-            Process   Process,
-            Horizon   System,
-            int       ProcessorId,
-            int       Priority,
-            int       ThreadId) : base(System)
+        public KThread(Horizon System) : base(System)
         {
-            this.ThreadId = ThreadId;
-
-            Context        = Thread;
-            Owner          = Process;
-            PreferredCore  = ProcessorId;
             Scheduler      = System.Scheduler;
             SchedulingData = System.Scheduler.SchedulingData;
 
             SiblingsPerCore = new LinkedListNode<KThread>[KScheduler.CpuCoresCount];
 
             MutexWaiters = new LinkedList<KThread>();
-
-            AffinityMask = 1 << ProcessorId;
-
-            DynamicPriority = BasePriority = Priority;
-
-            CurrentCore = PreferredCore;
         }
 
-        public long Start()
+        public KernelResult Initialize(
+            ulong      Entrypoint,
+            ulong      ArgsPtr,
+            ulong      StackTop,
+            int        Priority,
+            int        DefaultCpuCore,
+            KProcess   Owner,
+            ThreadType Type = ThreadType.User)
         {
-            long Result = MakeError(ErrorModule.Kernel, KernelErr.ThreadTerminating);
+            if ((uint)Type > 3)
+            {
+                throw new ArgumentException($"Invalid thread type \"{Type}\".");
+            }
 
-            System.CriticalSectionLock.Lock();
+            PreferredCore = DefaultCpuCore;
+
+            AffinityMask |= 1L << DefaultCpuCore;
+
+            SchedFlags = Type == ThreadType.Dummy
+                ? ThreadSchedState.Running
+                : ThreadSchedState.None;
+
+            CurrentCore = PreferredCore;
+
+            DynamicPriority = Priority;
+            BasePriority    = Priority;
+
+            ObjSyncResult = 0x7201;
+
+            this.Entrypoint = Entrypoint;
+
+            if (Type == ThreadType.User)
+            {
+                if (Owner.AllocateThreadLocalStorage(out TlsAddress) != KernelResult.Success)
+                {
+                    return KernelResult.OutOfMemory;
+                }
+
+                MemoryHelper.FillWithZeros(Owner.CpuMemory, (long)TlsAddress, KTlsPageInfo.TlsEntrySize);
+            }
+
+            bool Is64Bits;
+
+            if (Owner != null)
+            {
+                this.Owner = Owner;
+
+                Owner.IncrementThreadCount();
+
+                Is64Bits = (Owner.MmuFlags & 1) != 0;
+            }
+            else
+            {
+                Is64Bits = true;
+            }
+
+            Context = new CpuThread(Owner.Translator, Owner.CpuMemory, (long)Entrypoint);
+
+            Context.ThreadState.X0  = ArgsPtr;
+            Context.ThreadState.X31 = StackTop;
+
+            Context.ThreadState.CntfrqEl0 = 19200000;
+            Context.ThreadState.Tpidr     = (long)TlsAddress;
+
+            Owner.SubscribeThreadEventHandlers(Context);
+
+            Context.WorkFinished += ThreadFinishedHandler;
+
+            ThreadUid = System.GetThreadUid();
+
+            if (Owner != null)
+            {
+                Owner.AddThread(this);
+
+                if (Owner.IsPaused)
+                {
+                    System.CriticalSection.Enter();
+
+                    if (ShallBeTerminated || SchedFlags == ThreadSchedState.TerminationPending)
+                    {
+                        System.CriticalSection.Leave();
+
+                        return KernelResult.Success;
+                    }
+
+                    ForcePauseFlags |= ThreadSchedState.ProcessPauseFlag;
+
+                    CombineForcePauseFlags();
+
+                    System.CriticalSection.Leave();
+                }
+            }
+
+            return KernelResult.Success;
+        }
+
+        public KernelResult Start()
+        {
+            if (!System.KernelInitialized)
+            {
+                System.CriticalSection.Enter();
+
+                if (!ShallBeTerminated && SchedFlags != ThreadSchedState.TerminationPending)
+                {
+                    ForcePauseFlags |= ThreadSchedState.KernelInitPauseFlag;
+
+                    CombineForcePauseFlags();
+                }
+
+                System.CriticalSection.Leave();
+            }
+
+            KernelResult Result = KernelResult.ThreadTerminating;
+
+            System.CriticalSection.Enter();
 
             if (!ShallBeTerminated)
             {
@@ -106,9 +210,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                        CurrentThread.SchedFlags != ThreadSchedState.TerminationPending &&
                        !CurrentThread.ShallBeTerminated)
                 {
-                    if ((SchedFlags & ThreadSchedState.LowNibbleMask) != ThreadSchedState.None)
+                    if ((SchedFlags & ThreadSchedState.LowMask) != ThreadSchedState.None)
                     {
-                        Result = MakeError(ErrorModule.Kernel, KernelErr.InvalidState);
+                        Result = KernelResult.InvalidState;
 
                         break;
                     }
@@ -122,7 +226,7 @@ namespace Ryujinx.HLE.HOS.Kernel
 
                         SetNewSchedFlags(ThreadSchedState.Running);
 
-                        Result = 0;
+                        Result = KernelResult.Success;
 
                         break;
                     }
@@ -130,8 +234,8 @@ namespace Ryujinx.HLE.HOS.Kernel
                     {
                         CurrentThread.CombineForcePauseFlags();
 
-                        System.CriticalSectionLock.Unlock();
-                        System.CriticalSectionLock.Lock();
+                        System.CriticalSection.Leave();
+                        System.CriticalSection.Enter();
 
                         if (CurrentThread.ShallBeTerminated)
                         {
@@ -141,25 +245,25 @@ namespace Ryujinx.HLE.HOS.Kernel
                 }
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             return Result;
         }
 
         public void Exit()
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
-            ForcePauseFlags &= ~ThreadSchedState.ExceptionalMask;
+            ForcePauseFlags &= ~ThreadSchedState.ForcePauseMask;
 
             ExitImpl();
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
         }
 
         private void ExitImpl()
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             SetNewSchedFlags(ThreadSchedState.TerminationPending);
 
@@ -167,16 +271,16 @@ namespace Ryujinx.HLE.HOS.Kernel
 
             Signal();
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
         }
 
         public long Sleep(long Timeout)
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             if (ShallBeTerminated || SchedFlags == ThreadSchedState.TerminationPending)
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return MakeError(ErrorModule.Kernel, KernelErr.ThreadTerminating);
             }
@@ -188,7 +292,7 @@ namespace Ryujinx.HLE.HOS.Kernel
                 System.TimeManager.ScheduleFutureInvocation(this, Timeout);
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             if (Timeout > 0)
             {
@@ -200,11 +304,11 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         public void Yield()
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             if (SchedFlags != ThreadSchedState.Running)
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 System.Scheduler.ContextSwitch();
 
@@ -219,27 +323,27 @@ namespace Ryujinx.HLE.HOS.Kernel
 
             Scheduler.ThreadReselectionRequested = true;
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             System.Scheduler.ContextSwitch();
         }
 
         public void YieldWithLoadBalancing()
         {
-            System.CriticalSectionLock.Lock();
-
-            int Prio = DynamicPriority;
-            int Core = CurrentCore;
+            System.CriticalSection.Enter();
 
             if (SchedFlags != ThreadSchedState.Running)
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 System.Scheduler.ContextSwitch();
 
                 return;
             }
 
+            int Prio = DynamicPriority;
+            int Core = CurrentCore;
+
             KThread NextThreadOnCurrentQueue = null;
 
             if (DynamicPriority < KScheduler.PrioritiesCount)
@@ -270,7 +374,7 @@ namespace Ryujinx.HLE.HOS.Kernel
 
                     //If the candidate was scheduled after the current thread, then it's not worth it,
                     //unless the priority is higher than the current one.
-                    if (NextThreadOnCurrentQueue.LastScheduledTicks >= Thread.LastScheduledTicks ||
+                    if (NextThreadOnCurrentQueue.LastScheduledTime >= Thread.LastScheduledTime ||
                         NextThreadOnCurrentQueue.DynamicPriority    <  Thread.DynamicPriority)
                     {
                         yield return Thread;
@@ -292,18 +396,18 @@ namespace Ryujinx.HLE.HOS.Kernel
                 Scheduler.ThreadReselectionRequested = true;
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             System.Scheduler.ContextSwitch();
         }
 
         public void YieldAndWaitForLoadBalancing()
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             if (SchedFlags != ThreadSchedState.Running)
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 System.Scheduler.ContextSwitch();
 
@@ -348,47 +452,47 @@ namespace Ryujinx.HLE.HOS.Kernel
                 Scheduler.ThreadReselectionRequested = true;
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
             System.Scheduler.ContextSwitch();
         }
 
         public void SetPriority(int Priority)
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             BasePriority = Priority;
 
             UpdatePriorityInheritance();
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
         }
 
         public long SetActivity(bool Pause)
         {
             long Result = 0;
 
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
-            ThreadSchedState LowNibble = SchedFlags & ThreadSchedState.LowNibbleMask;
+            ThreadSchedState LowNibble = SchedFlags & ThreadSchedState.LowMask;
 
             if (LowNibble != ThreadSchedState.Paused && LowNibble != ThreadSchedState.Running)
             {
-                System.CriticalSectionLock.Unlock();
+                System.CriticalSection.Leave();
 
                 return MakeError(ErrorModule.Kernel, KernelErr.InvalidState);
             }
 
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             if (!ShallBeTerminated && SchedFlags != ThreadSchedState.TerminationPending)
             {
                 if (Pause)
                 {
                     //Pause, the force pause flag should be clear (thread is NOT paused).
-                    if ((ForcePauseFlags & ThreadSchedState.ForcePauseFlag) == 0)
+                    if ((ForcePauseFlags & ThreadSchedState.ThreadPauseFlag) == 0)
                     {
-                        ForcePauseFlags |= ThreadSchedState.ForcePauseFlag;
+                        ForcePauseFlags |= ThreadSchedState.ThreadPauseFlag;
 
                         CombineForcePauseFlags();
                     }
@@ -400,17 +504,17 @@ namespace Ryujinx.HLE.HOS.Kernel
                 else
                 {
                     //Unpause, the force pause flag should be set (thread is paused).
-                    if ((ForcePauseFlags & ThreadSchedState.ForcePauseFlag) != 0)
+                    if ((ForcePauseFlags & ThreadSchedState.ThreadPauseFlag) != 0)
                     {
                         ThreadSchedState OldForcePauseFlags = ForcePauseFlags;
 
-                        ForcePauseFlags &= ~ThreadSchedState.ForcePauseFlag;
+                        ForcePauseFlags &= ~ThreadSchedState.ThreadPauseFlag;
 
-                        if ((OldForcePauseFlags & ~ThreadSchedState.ForcePauseFlag) == ThreadSchedState.None)
+                        if ((OldForcePauseFlags & ~ThreadSchedState.ThreadPauseFlag) == ThreadSchedState.None)
                         {
                             ThreadSchedState OldSchedFlags = SchedFlags;
 
-                            SchedFlags &= ThreadSchedState.LowNibbleMask;
+                            SchedFlags &= ThreadSchedState.LowMask;
 
                             AdjustScheduling(OldSchedFlags);
                         }
@@ -422,27 +526,27 @@ namespace Ryujinx.HLE.HOS.Kernel
                 }
             }
 
-            System.CriticalSectionLock.Unlock();
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
+            System.CriticalSection.Leave();
 
             return Result;
         }
 
         public void CancelSynchronization()
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
-            if ((SchedFlags & ThreadSchedState.LowNibbleMask) != ThreadSchedState.Paused || !WaitingSync)
+            if ((SchedFlags & ThreadSchedState.LowMask) != ThreadSchedState.Paused || !WaitingSync)
             {
                 SyncCancelled = true;
             }
-            else if (WithholderNode != null)
+            else if (Withholder != null)
             {
-                System.Withholders.Remove(WithholderNode);
+                Withholder.Remove(WithholderNode);
 
                 SetNewSchedFlags(ThreadSchedState.Running);
 
-                WithholderNode = null;
+                Withholder = null;
 
                 SyncCancelled = true;
             }
@@ -456,12 +560,12 @@ namespace Ryujinx.HLE.HOS.Kernel
                 SyncCancelled = false;
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
         }
 
-        public long SetCoreAndAffinityMask(int NewCore, long NewAffinityMask)
+        public KernelResult SetCoreAndAffinityMask(int NewCore, long NewAffinityMask)
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             bool UseOverride = AffinityOverrideCount != 0;
 
@@ -472,9 +576,9 @@ namespace Ryujinx.HLE.HOS.Kernel
 
                 if ((NewAffinityMask & (1 << NewCore)) == 0)
                 {
-                    System.CriticalSectionLock.Unlock();
+                    System.CriticalSection.Leave();
 
-                    return MakeError(ErrorModule.Kernel, KernelErr.InvalidMaskValue);
+                    return KernelResult.InvalidCombination;
                 }
             }
 
@@ -510,9 +614,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 }
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
 
-            return 0;
+            return KernelResult.Success;
         }
 
         private static int HighestSetCore(long Mask)
@@ -531,7 +635,7 @@ namespace Ryujinx.HLE.HOS.Kernel
         private void CombineForcePauseFlags()
         {
             ThreadSchedState OldFlags  = SchedFlags;
-            ThreadSchedState LowNibble = SchedFlags & ThreadSchedState.LowNibbleMask;
+            ThreadSchedState LowNibble = SchedFlags & ThreadSchedState.LowMask;
 
             SchedFlags = LowNibble | ForcePauseFlags;
 
@@ -540,33 +644,33 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private void SetNewSchedFlags(ThreadSchedState NewFlags)
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             ThreadSchedState OldFlags = SchedFlags;
 
-            SchedFlags = (OldFlags & ThreadSchedState.HighNibbleMask) | NewFlags;
+            SchedFlags = (OldFlags & ThreadSchedState.HighMask) | NewFlags;
 
-            if ((OldFlags & ThreadSchedState.LowNibbleMask) != NewFlags)
+            if ((OldFlags & ThreadSchedState.LowMask) != NewFlags)
             {
                 AdjustScheduling(OldFlags);
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
         }
 
         public void ReleaseAndResume()
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
-            if ((SchedFlags & ThreadSchedState.LowNibbleMask) == ThreadSchedState.Paused)
+            if ((SchedFlags & ThreadSchedState.LowMask) == ThreadSchedState.Paused)
             {
-                if (WithholderNode != null)
+                if (Withholder != null)
                 {
-                    System.Withholders.Remove(WithholderNode);
+                    Withholder.Remove(WithholderNode);
 
                     SetNewSchedFlags(ThreadSchedState.Running);
 
-                    WithholderNode = null;
+                    Withholder = null;
                 }
                 else
                 {
@@ -574,21 +678,21 @@ namespace Ryujinx.HLE.HOS.Kernel
                 }
             }
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
         }
 
         public void Reschedule(ThreadSchedState NewFlags)
         {
-            System.CriticalSectionLock.Lock();
+            System.CriticalSection.Enter();
 
             ThreadSchedState OldFlags = SchedFlags;
 
-            SchedFlags = (OldFlags & ThreadSchedState.HighNibbleMask) |
-                         (NewFlags & ThreadSchedState.LowNibbleMask);
+            SchedFlags = (OldFlags & ThreadSchedState.HighMask) |
+                         (NewFlags & ThreadSchedState.LowMask);
 
             AdjustScheduling(OldFlags);
 
-            System.CriticalSectionLock.Unlock();
+            System.CriticalSection.Leave();
         }
 
         public void AddMutexWaiter(KThread Requester)
@@ -866,18 +970,61 @@ namespace Ryujinx.HLE.HOS.Kernel
             return HasExited;
         }
 
+        public void SetEntryArguments(long ArgsPtr, int ThreadHandle)
+        {
+            Context.ThreadState.X0 = (ulong)ArgsPtr;
+            Context.ThreadState.X1 = (ulong)ThreadHandle;
+        }
+
         public void ClearExclusive()
         {
-            Owner.Memory.ClearExclusive(CurrentCore);
+            Owner.CpuMemory.ClearExclusive(CurrentCore);
         }
 
         public void TimeUp()
         {
-            System.CriticalSectionLock.Lock();
+            ReleaseAndResume();
+        }
 
-            SetNewSchedFlags(ThreadSchedState.Running);
+        public void PrintGuestStackTrace()
+        {
+            Owner.Debugger.PrintGuestStackTrace(Context.ThreadState);
+        }
 
-            System.CriticalSectionLock.Unlock();
+        private void ThreadFinishedHandler(object sender, EventArgs e)
+        {
+            System.Scheduler.ExitThread(this);
+
+            Terminate();
+
+            System.Scheduler.RemoveThread(this);
+        }
+
+        public void Terminate()
+        {
+            Owner?.RemoveThread(this);
+
+            if (TlsAddress != 0 && Owner.FreeThreadLocalStorage(TlsAddress) != KernelResult.Success)
+            {
+                throw new InvalidOperationException("Unexpected failure freeing thread local storage.");
+            }
+
+            System.CriticalSection.Enter();
+
+            //Wake up all threads that may be waiting for a mutex being held
+            //by this thread.
+            foreach (KThread Thread in MutexWaiters)
+            {
+                Thread.MutexOwner            = null;
+                Thread.PreferredCoreOverride = 0;
+                Thread.ObjSyncResult         = 0xfa01;
+
+                Thread.ReleaseAndResume();
+            }
+
+            System.CriticalSection.Leave();
+
+            Owner?.DecrementThreadCountAndTerminateIfZero();
         }
     }
 }

Ryujinx.HLE/HOS/Kernel/KTimeManager.cs

@@ -1,6 +1,6 @@
+using Ryujinx.Common;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 
@@ -25,18 +25,12 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private AutoResetEvent WaitEvent;
 
-        private Stopwatch Counter;
-
         private bool KeepRunning;
 
         public KTimeManager()
         {
             WaitingObjects = new List<WaitingObject>();
 
-            Counter = new Stopwatch();
-
-            Counter.Start();
-
             KeepRunning = true;
 
             Thread Work = new Thread(WaitAndCheckScheduledObjects);
@@ -46,26 +40,36 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         public void ScheduleFutureInvocation(IKFutureSchedulerObject Object, long Timeout)
         {
+            long TimePoint = PerformanceCounter.ElapsedMilliseconds + ConvertNanosecondsToMilliseconds(Timeout);
+
             lock (WaitingObjects)
             {
-                long TimePoint = Counter.ElapsedMilliseconds + ConvertNanosecondsToMilliseconds(Timeout);
-
                 WaitingObjects.Add(new WaitingObject(Object, TimePoint));
             }
 
             WaitEvent.Set();
         }
 
-        private long ConvertNanosecondsToMilliseconds(long Timeout)
+        public static long ConvertNanosecondsToMilliseconds(long Time)
         {
-            Timeout /= 1000000;
+            Time /= 1000000;
 
-            if ((ulong)Timeout > int.MaxValue)
+            if ((ulong)Time > int.MaxValue)
             {
                 return int.MaxValue;
             }
 
-            return Timeout;
+            return Time;
+        }
+
+        public static long ConvertMillisecondsToNanoseconds(long Time)
+        {
+            return Time * 1000000;
+        }
+
+        public static long ConvertMillisecondsToTicks(long Time)
+        {
+            return Time * 19200;
         }
 
         public void UnscheduleFutureInvocation(IKFutureSchedulerObject Object)
@@ -82,26 +86,31 @@ namespace Ryujinx.HLE.HOS.Kernel
             {
                 while (KeepRunning)
                 {
-                    Monitor.Enter(WaitingObjects);
+                    WaitingObject Next;
 
-                    WaitingObject Next = WaitingObjects.OrderBy(x => x.TimePoint).FirstOrDefault();
-
-                    Monitor.Exit(WaitingObjects);
+                    lock (WaitingObjects)
+                    {
+                        Next = WaitingObjects.OrderBy(x => x.TimePoint).FirstOrDefault();
+                    }
 
                     if (Next != null)
                     {
-                        long TimePoint = Counter.ElapsedMilliseconds;
+                        long TimePoint = PerformanceCounter.ElapsedMilliseconds;
 
                         if (Next.TimePoint > TimePoint)
                         {
                             WaitEvent.WaitOne((int)(Next.TimePoint - TimePoint));
                         }
 
-                        Monitor.Enter(WaitingObjects);
+                        bool TimeUp = PerformanceCounter.ElapsedMilliseconds >= Next.TimePoint;
 
-                        bool TimeUp = Counter.ElapsedMilliseconds >= Next.TimePoint && WaitingObjects.Remove(Next);
-
-                        Monitor.Exit(WaitingObjects);
+                        if (TimeUp)
+                        {
+                            lock (WaitingObjects)
+                            {
+                                TimeUp = WaitingObjects.Remove(Next);
+                            }
+                        }
 
                         if (TimeUp)
                         {

Ryujinx.HLE/HOS/Kernel/KTlsPageInfo.cs

@@ -0,0 +1,73 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class KTlsPageInfo
+    {
+        public const int TlsEntrySize = 0x200;
+
+        public ulong PageAddr { get; private set; }
+
+        private bool[] IsSlotFree;
+
+        public KTlsPageInfo(ulong PageAddress)
+        {
+            this.PageAddr = PageAddress;
+
+            IsSlotFree = new bool[KMemoryManager.PageSize / TlsEntrySize];
+
+            for (int Index = 0; Index < IsSlotFree.Length; Index++)
+            {
+                IsSlotFree[Index] = true;
+            }
+        }
+
+        public bool TryGetFreePage(out ulong Address)
+        {
+            Address = PageAddr;
+
+            for (int Index = 0; Index < IsSlotFree.Length; Index++)
+            {
+                if (IsSlotFree[Index])
+                {
+                    IsSlotFree[Index] = false;
+
+                    return true;
+                }
+
+                Address += TlsEntrySize;
+            }
+
+            Address = 0;
+
+            return false;
+        }
+
+        public bool IsFull()
+        {
+            bool HasFree = false;
+
+            for (int Index = 0; Index < IsSlotFree.Length; Index++)
+            {
+                HasFree |= IsSlotFree[Index];
+            }
+
+            return !HasFree;
+        }
+
+        public bool IsEmpty()
+        {
+            bool AllFree = true;
+
+            for (int Index = 0; Index < IsSlotFree.Length; Index++)
+            {
+                AllFree &= IsSlotFree[Index];
+            }
+
+            return AllFree;
+        }
+
+        public void FreeTlsSlot(ulong Address)
+        {
+            IsSlotFree[(Address - PageAddr) / TlsEntrySize] = true;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KTransferMemory.cs

@@ -2,13 +2,13 @@ namespace Ryujinx.HLE.HOS.Kernel
 {
     class KTransferMemory
     {
-        public long Position { get; private set; }
-        public long Size     { get; private set; }
+        public ulong Address { get; private set; }
+        public ulong Size     { get; private set; }
 
-        public KTransferMemory(long Position, long Size)
+        public KTransferMemory(ulong Address, ulong Size)
         {
-            this.Position = Position;
-            this.Size     = Size;
+            this.Address = Address;
+            this.Size    = Size;
         }
     }
 }

Ryujinx.HLE/HOS/Kernel/KernelInit.cs

@@ -0,0 +1,136 @@
+using System;
+
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    static class KernelInit
+    {
+        public static void InitializeResourceLimit(KResourceLimit ResourceLimit)
+        {
+            void EnsureSuccess(KernelResult Result)
+            {
+                if (Result != KernelResult.Success)
+                {
+                    throw new InvalidOperationException($"Unexpected result \"{Result}\".");
+                }
+            }
+
+            int KernelMemoryCfg = 0;
+
+            long RamSize = GetRamSize(KernelMemoryCfg);
+
+            EnsureSuccess(ResourceLimit.SetLimitValue(LimitableResource.Memory,         RamSize));
+            EnsureSuccess(ResourceLimit.SetLimitValue(LimitableResource.Thread,         800));
+            EnsureSuccess(ResourceLimit.SetLimitValue(LimitableResource.Event,          700));
+            EnsureSuccess(ResourceLimit.SetLimitValue(LimitableResource.TransferMemory, 200));
+            EnsureSuccess(ResourceLimit.SetLimitValue(LimitableResource.Session,        900));
+
+            if (!ResourceLimit.Reserve(LimitableResource.Memory, 0) ||
+                !ResourceLimit.Reserve(LimitableResource.Memory, 0x60000))
+            {
+                throw new InvalidOperationException("Unexpected failure reserving memory on resource limit.");
+            }
+        }
+
+        public static KMemoryRegionManager[] GetMemoryRegions()
+        {
+            KMemoryArrange Arrange = GetMemoryArrange();
+
+            return new KMemoryRegionManager[]
+            {
+                GetMemoryRegion(Arrange.Application),
+                GetMemoryRegion(Arrange.Applet),
+                GetMemoryRegion(Arrange.Service),
+                GetMemoryRegion(Arrange.NvServices)
+            };
+        }
+
+        private static KMemoryRegionManager GetMemoryRegion(KMemoryArrangeRegion Region)
+        {
+            return new KMemoryRegionManager(Region.Address, Region.Size, Region.EndAddr);
+        }
+
+        private static KMemoryArrange GetMemoryArrange()
+        {
+            int McEmemCfg = 0x1000;
+
+            ulong EmemApertureSize = (ulong)(McEmemCfg & 0x3fff) << 20;
+
+            int KernelMemoryCfg = 0;
+
+            ulong RamSize = (ulong)GetRamSize(KernelMemoryCfg);
+
+            ulong RamPart0;
+            ulong RamPart1;
+
+            if (RamSize * 2 > EmemApertureSize)
+            {
+                RamPart0 = EmemApertureSize / 2;
+                RamPart1 = EmemApertureSize / 2;
+            }
+            else
+            {
+                RamPart0 = EmemApertureSize;
+                RamPart1 = 0;
+            }
+
+            int MemoryArrange = 1;
+
+            ulong ApplicationRgSize;
+
+            switch (MemoryArrange)
+            {
+                case 2:    ApplicationRgSize = 0x80000000;  break;
+                case 0x11:
+                case 0x21: ApplicationRgSize = 0x133400000; break;
+                default:   ApplicationRgSize = 0xcd500000;  break;
+            }
+
+            ulong AppletRgSize;
+
+            switch (MemoryArrange)
+            {
+                case 2:    AppletRgSize = 0x61200000; break;
+                case 3:    AppletRgSize = 0x1c000000; break;
+                case 0x11: AppletRgSize = 0x23200000; break;
+                case 0x12:
+                case 0x21: AppletRgSize = 0x89100000; break;
+                default:   AppletRgSize = 0x1fb00000; break;
+            }
+
+            KMemoryArrangeRegion ServiceRg;
+            KMemoryArrangeRegion NvServicesRg;
+            KMemoryArrangeRegion AppletRg;
+            KMemoryArrangeRegion ApplicationRg;
+
+            const ulong NvServicesRgSize = 0x29ba000;
+
+            ulong ApplicationRgEnd = DramMemoryMap.DramEnd; //- RamPart0;
+
+            ApplicationRg = new KMemoryArrangeRegion(ApplicationRgEnd - ApplicationRgSize, ApplicationRgSize);
+
+            ulong NvServicesRgEnd = ApplicationRg.Address - AppletRgSize;
+
+            NvServicesRg = new KMemoryArrangeRegion(NvServicesRgEnd - NvServicesRgSize, NvServicesRgSize);
+            AppletRg     = new KMemoryArrangeRegion(NvServicesRgEnd, AppletRgSize);
+
+            //Note: There is an extra region used by the kernel, however
+            //since we are doing HLE we are not going to use that memory, so give all
+            //the remaining memory space to services.
+            ulong ServiceRgSize = NvServicesRg.Address - DramMemoryMap.SlabHeapEnd;
+
+            ServiceRg = new KMemoryArrangeRegion(DramMemoryMap.SlabHeapEnd, ServiceRgSize);
+
+            return new KMemoryArrange(ServiceRg, NvServicesRg, AppletRg, ApplicationRg);
+        }
+
+        private static long GetRamSize(int KernelMemoryCfg)
+        {
+            switch ((KernelMemoryCfg >> 16) & 3)
+            {
+                case 1:  return 0x180000000;
+                case 2:  return 0x200000000;
+                default: return 0x100000000;
+            }
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/KernelResult.cs

@@ -2,9 +2,30 @@ namespace Ryujinx.HLE.HOS.Kernel
 {
     enum KernelResult
     {
-        Success         = 0,
-        HandleTableFull = 0xd201,
-        InvalidHandle   = 0xe401,
-        InvalidState    = 0xfa01
+        Success            = 0,
+        InvalidCapability  = 0x1c01,
+        ThreadTerminating  = 0x7601,
+        InvalidSize        = 0xca01,
+        InvalidAddress     = 0xcc01,
+        OutOfResource      = 0xce01,
+        OutOfMemory        = 0xd001,
+        HandleTableFull    = 0xd201,
+        InvalidMemState    = 0xd401,
+        InvalidPermission  = 0xd801,
+        InvalidMemRange    = 0xdc01,
+        InvalidPriority    = 0xe001,
+        InvalidCpuCore     = 0xe201,
+        InvalidHandle      = 0xe401,
+        UserCopyFailed     = 0xe601,
+        InvalidCombination = 0xe801,
+        TimedOut           = 0xea01,
+        Cancelled          = 0xec01,
+        MaximumExceeded    = 0xee01,
+        InvalidEnumValue   = 0xf001,
+        NotFound           = 0xf201,
+        InvalidThread      = 0xf401,
+        InvalidState       = 0xfa01,
+        ReservedValue      = 0xfc01,
+        ResLimitExceeded   = 0x10801
     }
 }

Ryujinx.HLE/HOS/Kernel/KernelTransfer.cs

@@ -0,0 +1,71 @@
+using ChocolArm64.Memory;
+
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    static class KernelTransfer
+    {
+        public static bool UserToKernelInt32(Horizon System, long Address, out int Value)
+        {
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            if (CurrentProcess.CpuMemory.IsMapped(Address) &&
+                CurrentProcess.CpuMemory.IsMapped(Address + 3))
+            {
+                Value = CurrentProcess.CpuMemory.ReadInt32(Address);
+
+                return true;
+            }
+
+            Value = 0;
+
+            return false;
+        }
+
+        public static bool UserToKernelString(Horizon System, long Address, int Size, out string Value)
+        {
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            if (CurrentProcess.CpuMemory.IsMapped(Address) &&
+                CurrentProcess.CpuMemory.IsMapped(Address + Size - 1))
+            {
+                Value = MemoryHelper.ReadAsciiString(CurrentProcess.CpuMemory, Address, Size);
+
+                return true;
+            }
+
+            Value = null;
+
+            return false;
+        }
+
+        public static bool KernelToUserInt32(Horizon System, long Address, int Value)
+        {
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            if (CurrentProcess.CpuMemory.IsMapped(Address) &&
+                CurrentProcess.CpuMemory.IsMapped(Address + 3))
+            {
+                CurrentProcess.CpuMemory.WriteInt32ToSharedAddr(Address, Value);
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public static bool KernelToUserInt64(Horizon System, long Address, long Value)
+        {
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            if (CurrentProcess.CpuMemory.IsMapped(Address) &&
+                CurrentProcess.CpuMemory.IsMapped(Address + 7))
+            {
+                CurrentProcess.CpuMemory.WriteInt64(Address, Value);
+
+                return true;
+            }
+
+            return false;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/LimitableResource.cs

@@ -0,0 +1,13 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    enum LimitableResource : byte
+    {
+        Memory         = 0,
+        Thread         = 1,
+        Event          = 2,
+        TransferMemory = 3,
+        Session        = 4,
+
+        Count = 5
+    }
+}

Ryujinx.HLE/HOS/Kernel/MemoryOperation.cs

@@ -0,0 +1,12 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    enum MemoryOperation
+    {
+        MapPa,
+        MapVa,
+        Allocate,
+        Unmap,
+        ChangePermRw,
+        ChangePermsAndAttributes
+    }
+}

Ryujinx.HLE/HOS/Kernel/MemoryRegion.cs

@@ -0,0 +1,10 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    enum MemoryRegion
+    {
+        Application = 0,
+        Applet      = 1,
+        Service     = 2,
+        NvServices  = 3
+    }
+}

Ryujinx.HLE/HOS/Kernel/MemoryState.cs

@@ -15,7 +15,7 @@ namespace Ryujinx.HLE.HOS.Kernel
         ModCodeStatic          = 0x00DD7E08,
         ModCodeMutable         = 0x03FFBD09,
         IpcBuffer0             = 0x005C3C0A,
-        MappedMemory           = 0x005C3C0B,
+        Stack                  = 0x005C3C0B,
         ThreadLocal            = 0x0040200C,
         TransferMemoryIsolated = 0x015C3C0D,
         TransferMemory         = 0x005C380E,

Ryujinx.HLE/HOS/Kernel/MersenneTwister.cs

@@ -0,0 +1,128 @@
+using Ryujinx.Common;
+
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    class MersenneTwister
+    {
+        private int Index;
+        private uint[] Mt;
+
+        public MersenneTwister(uint Seed)
+        {
+            Mt = new uint[624];
+
+            Mt[0] = Seed;
+
+            for (int MtIdx = 1; MtIdx < Mt.Length; MtIdx++)
+            {
+                uint Prev = Mt[MtIdx - 1];
+
+                Mt[MtIdx] = (uint)(0x6c078965 * (Prev ^ (Prev >> 30)) + MtIdx);
+            }
+
+            Index = Mt.Length;
+        }
+
+        public long GenRandomNumber(long Min, long Max)
+        {
+            long Range = Max - Min;
+
+            if (Min == Max)
+            {
+                return Min;
+            }
+
+            if (Range == -1)
+            {
+                //Increment would cause a overflow, special case.
+                return GenRandomNumber(2, 2, 32, 0xffffffffu, 0xffffffffu);
+            }
+
+            Range++;
+
+            //This is log2(Range) plus one.
+            int NextRangeLog2 = 64 - BitUtils.CountLeadingZeros64(Range);
+
+            //If Range is already power of 2, subtract one to use log2(Range) directly.
+            int RangeLog2 = NextRangeLog2 - (BitUtils.IsPowerOfTwo64(Range) ? 1 : 0);
+
+            int Parts       = RangeLog2 > 32 ? 2 : 1;
+            int BitsPerPart = RangeLog2 / Parts;
+
+            int FullParts = Parts - (RangeLog2 - Parts * BitsPerPart);
+
+            uint Mask      = 0xffffffffu >> (32 - BitsPerPart);
+            uint MaskPlus1 = 0xffffffffu >> (31 - BitsPerPart);
+
+            long RandomNumber;
+
+            do
+            {
+                RandomNumber = GenRandomNumber(Parts, FullParts, BitsPerPart, Mask, MaskPlus1);
+            }
+            while ((ulong)RandomNumber >= (ulong)Range);
+
+            return Min + RandomNumber;
+        }
+
+        private long GenRandomNumber(
+            int  Parts,
+            int  FullParts,
+            int  BitsPerPart,
+            uint Mask,
+            uint MaskPlus1)
+        {
+            long RandomNumber = 0;
+
+            int Part = 0;
+
+            for (; Part < FullParts; Part++)
+            {
+                RandomNumber <<= BitsPerPart;
+                RandomNumber  |= GenRandomNumber() & Mask;
+            }
+
+            for (; Part < Parts; Part++)
+            {
+                RandomNumber <<= BitsPerPart + 1;
+                RandomNumber  |= GenRandomNumber() & MaskPlus1;
+            }
+
+            return RandomNumber;
+        }
+
+        private uint GenRandomNumber()
+        {
+            if (Index >= Mt.Length)
+            {
+                Twist();
+            }
+
+            uint Value = Mt[Index++];
+
+            Value ^= Value >> 11;
+            Value ^= (Value << 7) & 0x9d2c5680;
+            Value ^= (Value << 15) & 0xefc60000;
+            Value ^= Value >> 18;
+
+            return Value;
+        }
+
+        private void Twist()
+        {
+            for (int MtIdx = 0; MtIdx < Mt.Length; MtIdx++)
+            {
+                uint Value = (Mt[MtIdx] & 0x80000000) + (Mt[(MtIdx + 1) % Mt.Length] & 0x7fffffff);
+
+                Mt[MtIdx] = Mt[(MtIdx + 397) % Mt.Length] ^ (Value >> 1);
+
+                if ((Value & 1) != 0)
+                {
+                    Mt[MtIdx] ^= 0x9908b0df;
+                }
+            }
+
+            Index = 0;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/ProcessCreationInfo.cs

@@ -0,0 +1,37 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    struct ProcessCreationInfo
+    {
+        public string Name { get; private set; }
+
+        public int  Category { get; private set; }
+        public long TitleId  { get; private set; }
+
+        public ulong CodeAddress    { get; private set; }
+        public int   CodePagesCount { get; private set; }
+
+        public int MmuFlags                 { get; private set; }
+        public int ResourceLimitHandle      { get; private set; }
+        public int PersonalMmHeapPagesCount { get; private set; }
+
+        public ProcessCreationInfo(
+            string Name,
+            int    Category,
+            long   TitleId,
+            ulong  CodeAddress,
+            int    CodePagesCount,
+            int    MmuFlags,
+            int    ResourceLimitHandle,
+            int    PersonalMmHeapPagesCount)
+        {
+            this.Name                     = Name;
+            this.Category                 = Category;
+            this.TitleId                  = TitleId;
+            this.CodeAddress              = CodeAddress;
+            this.CodePagesCount           = CodePagesCount;
+            this.MmuFlags                 = MmuFlags;
+            this.ResourceLimitHandle      = ResourceLimitHandle;
+            this.PersonalMmHeapPagesCount = PersonalMmHeapPagesCount;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/ProcessState.cs

@@ -0,0 +1,14 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    enum ProcessState : byte
+    {
+        Created         = 0,
+        CreatedAttached = 1,
+        Started         = 2,
+        Crashed         = 3,
+        Attached        = 4,
+        Exiting         = 5,
+        Exited          = 6,
+        DebugSuspended  = 7
+    }
+}

Ryujinx.HLE/HOS/Kernel/SvcHandler.cs

@@ -1,8 +1,8 @@
 using ChocolArm64.Events;
 using ChocolArm64.Memory;
 using ChocolArm64.State;
-using Ryujinx.Common.Logging;
 using Ryujinx.HLE.HOS.Ipc;
+using Ryujinx.Common.Logging;
 using System;
 using System.Collections.Generic;
 
@@ -15,7 +15,7 @@ namespace Ryujinx.HLE.HOS.Kernel
         private Dictionary<int, SvcFunc> SvcFuncs;
 
         private Switch        Device;
-        private Process       Process;
+        private KProcess      Process;
         private Horizon       System;
         private MemoryManager Memory;
 
@@ -39,9 +39,7 @@ namespace Ryujinx.HLE.HOS.Kernel
             }
         }
 
-        private static Random Rng;
-
-        public SvcHandler(Switch Device, Process Process)
+        public SvcHandler(Switch Device, KProcess Process)
         {
             SvcFuncs = new Dictionary<int, SvcFunc>()
             {
@@ -51,14 +49,14 @@ namespace Ryujinx.HLE.HOS.Kernel
                 { 0x05, SvcUnmapMemory                   },
                 { 0x06, SvcQueryMemory                   },
                 { 0x07, SvcExitProcess                   },
-                { 0x08, SvcCreateThread                  },
+                { 0x08, CreateThread64                   },
                 { 0x09, SvcStartThread                   },
                 { 0x0a, SvcExitThread                    },
                 { 0x0b, SvcSleepThread                   },
                 { 0x0c, SvcGetThreadPriority             },
                 { 0x0d, SvcSetThreadPriority             },
                 { 0x0e, SvcGetThreadCoreMask             },
-                { 0x0f, SvcSetThreadCoreMask             },
+                { 0x0f, SetThreadCoreMask64              },
                 { 0x10, SvcGetCurrentProcessorNumber     },
                 { 0x11, SignalEvent64                    },
                 { 0x12, ClearEvent64                     },
@@ -77,36 +75,34 @@ namespace Ryujinx.HLE.HOS.Kernel
                 { 0x1f, SvcConnectToNamedPort            },
                 { 0x21, SvcSendSyncRequest               },
                 { 0x22, SvcSendSyncRequestWithUserBuffer },
+                { 0x24, GetProcessId64                   },
                 { 0x25, SvcGetThreadId                   },
                 { 0x26, SvcBreak                         },
                 { 0x27, SvcOutputDebugString             },
-                { 0x29, SvcGetInfo                       },
+                { 0x29, GetInfo64                        },
                 { 0x2c, SvcMapPhysicalMemory             },
                 { 0x2d, SvcUnmapPhysicalMemory           },
                 { 0x32, SvcSetThreadActivity             },
                 { 0x33, SvcGetThreadContext3             },
                 { 0x34, SvcWaitForAddress                },
                 { 0x35, SvcSignalToAddress               },
-                { 0x45, CreateEvent64                    }
+                { 0x45, CreateEvent64                    },
+                { 0x65, GetProcessList64                 },
+                { 0x6f, GetSystemInfo64                  },
+                { 0x70, CreatePort64                     },
+                { 0x71, ManageNamedPort64                }
             };
 
             this.Device  = Device;
             this.Process = Process;
-            this.System  = Process.Device.System;
-            this.Memory  = Process.Memory;
-        }
-
-        static SvcHandler()
-        {
-            Rng = new Random();
+            this.System  = Device.System;
+            this.Memory  = Process.CpuMemory;
         }
 
         public void SvcCall(object sender, InstExceptionEventArgs e)
         {
             CpuThreadState ThreadState = (CpuThreadState)sender;
 
-            Process.GetThread(ThreadState.Tpidr).LastPc = e.Position;
-
             if (SvcFuncs.TryGetValue(e.Id, out SvcFunc Func))
             {
                 Logger.PrintDebug(LogClass.KernelSvc, $"{Func.Method.Name} called.");
@@ -117,7 +113,7 @@ namespace Ryujinx.HLE.HOS.Kernel
             }
             else
             {
-                Process.PrintStackTrace(ThreadState);
+                //Process.PrintStackTrace(ThreadState);
 
                 throw new NotImplementedException($"0x{e.Id:x4}");
             }

Ryujinx.HLE/HOS/Kernel/SvcMemory.cs

@@ -11,7 +11,7 @@ namespace Ryujinx.HLE.HOS.Kernel
         {
             ulong Size = ThreadState.X1;
 
-            if ((Size & 0xFFFFFFFE001FFFFF) != 0)
+            if ((Size & 0xfffffffe001fffff) != 0)
             {
                 Logger.PrintWarning(LogClass.KernelSvc, $"Heap size 0x{Size:x16} is not aligned!");
 
@@ -20,24 +20,24 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            long Result = Process.MemoryManager.TrySetHeapSize((long)Size, out long Position);
+            KernelResult Result = Process.MemoryManager.SetHeapSize(Size, out ulong Position);
 
             ThreadState.X0 = (ulong)Result;
 
-            if (Result == 0)
+            if (Result == KernelResult.Success)
             {
-                ThreadState.X1 = (ulong)Position;
+                ThreadState.X1 = Position;
             }
             else
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{Result}\".");
             }
         }
 
         private void SvcSetMemoryAttribute(CpuThreadState ThreadState)
         {
-            long Position = (long)ThreadState.X0;
-            long Size     = (long)ThreadState.X1;
+            ulong Position = ThreadState.X0;
+            ulong Size     = ThreadState.X1;
 
             if (!PageAligned(Position))
             {
@@ -72,19 +72,19 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            long Result = Process.MemoryManager.SetMemoryAttribute(
+            KernelResult Result = Process.MemoryManager.SetMemoryAttribute(
                 Position,
                 Size,
                 AttributeMask,
                 AttributeValue);
 
-            if (Result != 0)
+            if (Result != KernelResult.Success)
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{Result}\".");
             }
             else
             {
-                Memory.StopObservingRegion(Position, Size);
+                Memory.StopObservingRegion((long)Position, (long)Size);
             }
 
             ThreadState.X0 = (ulong)Result;
@@ -92,9 +92,9 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private void SvcMapMemory(CpuThreadState ThreadState)
         {
-            long Dst  = (long)ThreadState.X0;
-            long Src  = (long)ThreadState.X1;
-            long Size = (long)ThreadState.X2;
+            ulong Dst  = ThreadState.X0;
+            ulong Src  = ThreadState.X1;
+            ulong Size = ThreadState.X2;
 
             if (!PageAligned(Src | Dst))
             {
@@ -114,7 +114,7 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if ((ulong)(Src + Size) <= (ulong)Src || (ulong)(Dst + Size) <= (ulong)Dst)
+            if (Src + Size <= Src || Dst + Size <= Dst)
             {
                 Logger.PrintWarning(LogClass.KernelSvc, "Addresses outside of range!");
 
@@ -123,7 +123,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if (!InsideAddrSpace(Src, Size))
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            if (!CurrentProcess.MemoryManager.InsideAddrSpace(Src, Size))
             {
                 Logger.PrintWarning(LogClass.KernelSvc, $"Src address 0x{Src:x16} out of range!");
 
@@ -132,7 +134,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if (!InsideNewMapRegion(Dst, Size))
+            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!");
 
@@ -141,9 +145,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            long Result = Process.MemoryManager.Map(Src, Dst, Size);
+            KernelResult Result = Process.MemoryManager.Map(Dst, Src, Size);
 
-            if (Result != 0)
+            if (Result != KernelResult.Success)
             {
                 Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!");
             }
@@ -153,9 +157,9 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private void SvcUnmapMemory(CpuThreadState ThreadState)
         {
-            long Dst  = (long)ThreadState.X0;
-            long Src  = (long)ThreadState.X1;
-            long Size = (long)ThreadState.X2;
+            ulong Dst  = ThreadState.X0;
+            ulong Src  = ThreadState.X1;
+            ulong Size = ThreadState.X2;
 
             if (!PageAligned(Src | Dst))
             {
@@ -175,7 +179,7 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if ((ulong)(Src + Size) <= (ulong)Src || (ulong)(Dst + Size) <= (ulong)Dst)
+            if (Src + Size <= Src || Dst + Size <= Dst)
             {
                 Logger.PrintWarning(LogClass.KernelSvc, "Addresses outside of range!");
 
@@ -184,7 +188,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if (!InsideAddrSpace(Src, Size))
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            if (!CurrentProcess.MemoryManager.InsideAddrSpace(Src, Size))
             {
                 Logger.PrintWarning(LogClass.KernelSvc, $"Src address 0x{Src:x16} out of range!");
 
@@ -193,7 +199,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if (!InsideNewMapRegion(Dst, Size))
+            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!");
 
@@ -202,9 +210,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            long Result = Process.MemoryManager.Unmap(Src, Dst, Size);
+            KernelResult Result = Process.MemoryManager.Unmap(Dst, Src, Size);
 
-            if (Result != 0)
+            if (Result != KernelResult.Success)
             {
                 Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!");
             }
@@ -214,19 +222,19 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private void SvcQueryMemory(CpuThreadState ThreadState)
         {
-            long InfoPtr  = (long)ThreadState.X0;
-            long Position = (long)ThreadState.X2;
+            long  InfoPtr  = (long)ThreadState.X0;
+            ulong Position =       ThreadState.X2;
 
             KMemoryInfo BlkInfo = Process.MemoryManager.QueryMemory(Position);
 
-            Memory.WriteInt64(InfoPtr + 0x00, BlkInfo.Position);
-            Memory.WriteInt64(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);
+            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;
@@ -234,13 +242,13 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private void SvcMapSharedMemory(CpuThreadState ThreadState)
         {
-            int  Handle   =  (int)ThreadState.X0;
-            long Position = (long)ThreadState.X1;
-            long Size     = (long)ThreadState.X2;
+            int   Handle  =  (int)ThreadState.X0;
+            ulong Address =       ThreadState.X1;
+            ulong Size    =       ThreadState.X2;
 
-            if (!PageAligned(Position))
+            if (!PageAligned(Address))
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Position:x16} is not page aligned!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} is not page aligned!");
 
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress);
 
@@ -256,9 +264,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if ((ulong)(Position + Size) <= (ulong)Position)
+            if (Address + Size <= Address)
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Position:x16} / size 0x{Size:x16}!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Address:x16} / size 0x{Size:x16}!");
 
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
 
@@ -276,7 +284,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            KSharedMemory SharedMemory = Process.HandleTable.GetObject<KSharedMemory>(Handle);
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            KSharedMemory SharedMemory = CurrentProcess.HandleTable.GetObject<KSharedMemory>(Handle);
 
             if (SharedMemory == null)
             {
@@ -287,29 +297,27 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if (!InsideAddrSpace(Position, Size) || InsideMapRegion(Position, Size) || InsideHeapRegion(Position, Size))
+            if (CurrentProcess.MemoryManager.IsInvalidRegion  (Address, Size) ||
+                CurrentProcess.MemoryManager.InsideHeapRegion (Address, Size) ||
+                CurrentProcess.MemoryManager.InsideAliasRegion(Address, Size))
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Position:x16} out of range!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} out of range!");
 
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
 
                 return;
             }
 
-            if (SharedMemory.Size != Size)
+            KernelResult Result = SharedMemory.MapIntoProcess(
+                CurrentProcess.MemoryManager,
+                Address,
+                Size,
+                CurrentProcess,
+                Permission);
+
+            if (Result != KernelResult.Success)
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{Size:x16} does not match shared memory size 0x{SharedMemory.Size:16}!");
-
-                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize);
-
-                return;
-            }
-
-            long Result = Process.MemoryManager.MapSharedMemory(SharedMemory, Permission, Position);
-
-            if (Result != 0)
-            {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{Result}\".");
             }
 
             ThreadState.X0 = (ulong)Result;
@@ -317,13 +325,13 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private void SvcUnmapSharedMemory(CpuThreadState ThreadState)
         {
-            int  Handle   =  (int)ThreadState.X0;
-            long Position = (long)ThreadState.X1;
-            long Size     = (long)ThreadState.X2;
+            int   Handle  =  (int)ThreadState.X0;
+            ulong Address =       ThreadState.X1;
+            ulong Size    =       ThreadState.X2;
 
-            if (!PageAligned(Position))
+            if (!PageAligned(Address))
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Position:x16} is not page aligned!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} is not page aligned!");
 
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress);
 
@@ -339,16 +347,18 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if ((ulong)(Position + Size) <= (ulong)Position)
+            if (Address + Size <= Address)
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Position:x16} / size 0x{Size:x16}!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Address:x16} / size 0x{Size:x16}!");
 
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
 
                 return;
             }
 
-            KSharedMemory SharedMemory = Process.HandleTable.GetObject<KSharedMemory>(Handle);
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            KSharedMemory SharedMemory = CurrentProcess.HandleTable.GetObject<KSharedMemory>(Handle);
 
             if (SharedMemory == null)
             {
@@ -359,20 +369,26 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if (!InsideAddrSpace(Position, Size) || InsideMapRegion(Position, Size) || InsideHeapRegion(Position, Size))
+            if (CurrentProcess.MemoryManager.IsInvalidRegion  (Address, Size) ||
+                CurrentProcess.MemoryManager.InsideHeapRegion (Address, Size) ||
+                CurrentProcess.MemoryManager.InsideAliasRegion(Address, Size))
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Position:x16} out of range!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} out of range!");
 
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
 
                 return;
             }
 
-            long Result = Process.MemoryManager.UnmapSharedMemory(Position, Size);
+            KernelResult Result = SharedMemory.UnmapFromProcess(
+                CurrentProcess.MemoryManager,
+                Address,
+                Size,
+                CurrentProcess);
 
-            if (Result != 0)
+            if (Result != KernelResult.Success)
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{Result}\".");
             }
 
             ThreadState.X0 = (ulong)Result;
@@ -380,12 +396,12 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private void SvcCreateTransferMemory(CpuThreadState ThreadState)
         {
-            long Position = (long)ThreadState.X1;
-            long Size     = (long)ThreadState.X2;
+            ulong Address = ThreadState.X1;
+            ulong Size    = ThreadState.X2;
 
-            if (!PageAligned(Position))
+            if (!PageAligned(Address))
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Position:x16} is not page aligned!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} is not page aligned!");
 
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress);
 
@@ -401,9 +417,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if ((ulong)(Position + Size) <= (ulong)Position)
+            if (Address + Size <= Address)
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Position:x16} / size 0x{Size:x16}!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Address:x16} / size 0x{Size:x16}!");
 
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
 
@@ -421,9 +437,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            Process.MemoryManager.ReserveTransferMemory(Position, Size, Permission);
+            Process.MemoryManager.ReserveTransferMemory(Address, Size, Permission);
 
-            KTransferMemory TransferMemory = new KTransferMemory(Position, Size);
+            KTransferMemory TransferMemory = new KTransferMemory(Address, Size);
 
             KernelResult Result = Process.HandleTable.GenerateHandle(TransferMemory, out int Handle);
 
@@ -433,12 +449,12 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private void SvcMapPhysicalMemory(CpuThreadState ThreadState)
         {
-            long Position = (long)ThreadState.X0;
-            long Size     = (long)ThreadState.X1;
+            ulong Address = ThreadState.X0;
+            ulong Size    = ThreadState.X1;
 
-            if (!PageAligned(Position))
+            if (!PageAligned(Address))
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Position:x16} is not page aligned!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} is not page aligned!");
 
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress);
 
@@ -454,27 +470,39 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if ((ulong)(Position + Size) <= (ulong)Position)
+            if (Address + Size <= Address)
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Position:x16} / size 0x{Size:x16}!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Address:x16} / size 0x{Size:x16}!");
 
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
 
                 return;
             }
 
-            if (!InsideAddrSpace(Position, Size))
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            if ((CurrentProcess.PersonalMmHeapPagesCount & 0xfffffffffffff) == 0)
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address {Position:x16}!");
+                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;
             }
 
-            long Result = Process.MemoryManager.MapPhysicalMemory(Position, Size);
+            KernelResult Result = Process.MemoryManager.MapPhysicalMemory(Address, Size);
 
-            if (Result != 0)
+            if (Result != KernelResult.Success)
             {
                 Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!");
             }
@@ -484,12 +512,12 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private void SvcUnmapPhysicalMemory(CpuThreadState ThreadState)
         {
-            long Position = (long)ThreadState.X0;
-            long Size     = (long)ThreadState.X1;
+            ulong Address = ThreadState.X0;
+            ulong Size    = ThreadState.X1;
 
-            if (!PageAligned(Position))
+            if (!PageAligned(Address))
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Position:x16} is not page aligned!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} is not page aligned!");
 
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress);
 
@@ -505,27 +533,39 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if ((ulong)(Position + Size) <= (ulong)Position)
+            if (Address + Size <= Address)
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Position:x16} / size 0x{Size:x16}!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Address:x16} / size 0x{Size:x16}!");
 
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);
 
                 return;
             }
 
-            if (!InsideAddrSpace(Position, Size))
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            if ((CurrentProcess.PersonalMmHeapPagesCount & 0xfffffffffffff) == 0)
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address {Position:x16}!");
+                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;
             }
 
-            long Result = Process.MemoryManager.UnmapPhysicalMemory(Position, Size);
+            KernelResult Result = Process.MemoryManager.UnmapPhysicalMemory(Address, Size);
 
-            if (Result != 0)
+            if (Result != KernelResult.Success)
             {
                 Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!");
             }
@@ -533,45 +573,9 @@ namespace Ryujinx.HLE.HOS.Kernel
             ThreadState.X0 = (ulong)Result;
         }
 
-        private static bool PageAligned(long Position)
+        private static bool PageAligned(ulong Position)
         {
             return (Position & (KMemoryManager.PageSize - 1)) == 0;
         }
-
-        private bool InsideAddrSpace(long Position, long Size)
-        {
-            ulong Start = (ulong)Position;
-            ulong End   = (ulong)Size + Start;
-
-            return Start >= (ulong)Process.MemoryManager.AddrSpaceStart &&
-                   End   <  (ulong)Process.MemoryManager.AddrSpaceEnd;
-        }
-
-        private bool InsideMapRegion(long Position, long Size)
-        {
-            ulong Start = (ulong)Position;
-            ulong End   = (ulong)Size + Start;
-
-            return Start >= (ulong)Process.MemoryManager.MapRegionStart &&
-                   End   <  (ulong)Process.MemoryManager.MapRegionEnd;
-        }
-
-        private bool InsideHeapRegion(long Position, long Size)
-        {
-            ulong Start = (ulong)Position;
-            ulong End   = (ulong)Size + Start;
-
-            return Start >= (ulong)Process.MemoryManager.HeapRegionStart &&
-                   End   <  (ulong)Process.MemoryManager.HeapRegionEnd;
-        }
-
-        private bool InsideNewMapRegion(long Position, long Size)
-        {
-            ulong Start = (ulong)Position;
-            ulong End   = (ulong)Size + Start;
-
-            return Start >= (ulong)Process.MemoryManager.NewMapRegionStart &&
-                   End   <  (ulong)Process.MemoryManager.NewMapRegionEnd;
-        }
     }
 }

Ryujinx.HLE/HOS/Kernel/SvcSystem.cs

@@ -1,5 +1,6 @@
 using ChocolArm64.Memory;
 using ChocolArm64.State;
+using Ryujinx.Common;
 using Ryujinx.Common.Logging;
 using Ryujinx.HLE.Exceptions;
 using Ryujinx.HLE.HOS.Ipc;
@@ -13,13 +14,9 @@ namespace Ryujinx.HLE.HOS.Kernel
 {
     partial class SvcHandler
     {
-        private const int AllowedCpuIdBitmask = 0b1111;
-
-        private const bool EnableProcessDebugging = false;
-
         private void SvcExitProcess(CpuThreadState ThreadState)
         {
-            Device.System.ExitProcess(Process.ProcessId);
+            System.Scheduler.GetCurrentProcess().Terminate();
         }
 
         private void SignalEvent64(CpuThreadState ThreadState)
@@ -106,7 +103,7 @@ namespace Ryujinx.HLE.HOS.Kernel
             else if (Obj is KTransferMemory TransferMemory)
             {
                 Process.MemoryManager.ResetTransferMemory(
-                    TransferMemory.Position,
+                    TransferMemory.Address,
                     TransferMemory.Size);
             }
 
@@ -120,18 +117,28 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private KernelResult ResetSignal(int Handle)
         {
-            KReadableEvent ReadableEvent = Process.HandleTable.GetObject<KReadableEvent>(Handle);
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            KReadableEvent ReadableEvent = CurrentProcess.HandleTable.GetObject<KReadableEvent>(Handle);
 
             KernelResult Result;
 
-            //TODO: KProcess support.
             if (ReadableEvent != null)
             {
                 Result = ReadableEvent.ClearIfSignaled();
             }
             else
             {
-                Result = KernelResult.InvalidHandle;
+                KProcess Process = CurrentProcess.HandleTable.GetKProcess(Handle);
+
+                if (Process != null)
+                {
+                    Result = Process.ClearIfNotExited();
+                }
+                else
+                {
+                    Result = KernelResult.InvalidHandle;
+                }
             }
 
             if (Result == KernelResult.InvalidState)
@@ -187,17 +194,13 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         private void SendSyncRequest(CpuThreadState ThreadState, long MessagePtr, long Size, int Handle)
         {
-            KThread CurrThread = Process.GetThread(ThreadState.Tpidr);
-
             byte[] MessageData = Memory.ReadBytes(MessagePtr, Size);
 
             KSession Session = Process.HandleTable.GetObject<KSession>(Handle);
 
             if (Session != null)
             {
-                //Process.Scheduler.Suspend(CurrThread);
-
-                System.CriticalSectionLock.Lock();
+                System.CriticalSection.Enter();
 
                 KThread CurrentThread = System.Scheduler.GetCurrentThread();
 
@@ -214,7 +217,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                     Message,
                     MessagePtr));
 
-                System.CriticalSectionLock.Unlock();
+                System.ThreadCounter.AddCount();
+
+                System.CriticalSection.Leave();
 
                 ThreadState.X0 = (ulong)CurrentThread.ObjSyncResult;
             }
@@ -238,25 +243,65 @@ namespace Ryujinx.HLE.HOS.Kernel
                 IpcMessage.Message,
                 IpcMessage.MessagePtr);
 
+            System.ThreadCounter.Signal();
+
             IpcMessage.Thread.Reschedule(ThreadSchedState.Running);
         }
 
+        private void GetProcessId64(CpuThreadState ThreadState)
+        {
+            int Handle = (int)ThreadState.X1;
+
+            KernelResult Result = GetProcessId(Handle, out long Pid);
+
+            ThreadState.X0 = (ulong)Result;
+            ThreadState.X1 = (ulong)Pid;
+        }
+
+        private KernelResult GetProcessId(int Handle, out long Pid)
+        {
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            KProcess Process = CurrentProcess.HandleTable.GetKProcess(Handle);
+
+            if (Process == null)
+            {
+                KThread Thread = CurrentProcess.HandleTable.GetKThread(Handle);
+
+                if (Thread != null)
+                {
+                    Process = Thread.Owner;
+                }
+
+                //TODO: KDebugEvent.
+            }
+
+            Pid = Process?.Pid ?? 0;
+
+            return Process != null
+                ? KernelResult.Success
+                : KernelResult.InvalidHandle;
+        }
+
         private void SvcBreak(CpuThreadState ThreadState)
         {
             long Reason  = (long)ThreadState.X0;
             long Unknown = (long)ThreadState.X1;
             long Info    = (long)ThreadState.X2;
 
+            KThread CurrentThread = System.Scheduler.GetCurrentThread();
+
             if ((Reason & (1 << 31)) == 0)
             {
-                Process.PrintStackTrace(ThreadState);
+                CurrentThread.PrintGuestStackTrace();
 
                 throw new GuestBrokeExecutionException();
             }
             else
             {
-                Logger.PrintInfo(LogClass.KernelSvc, "Debugger triggered");
-                Process.PrintStackTrace(ThreadState);
+                Logger.PrintInfo(LogClass.KernelSvc, "Debugger triggered.");
+
+                CurrentThread.PrintGuestStackTrace();
             }
         }
 
@@ -272,98 +317,243 @@ namespace Ryujinx.HLE.HOS.Kernel
             ThreadState.X0 = 0;
         }
 
-        private void SvcGetInfo(CpuThreadState ThreadState)
+        private void GetInfo64(CpuThreadState ThreadState)
         {
             long StackPtr = (long)ThreadState.X0;
-            int  InfoType =  (int)ThreadState.X1;
-            long Handle   = (long)ThreadState.X2;
-            int  InfoId   =  (int)ThreadState.X3;
+            uint Id       = (uint)ThreadState.X1;
+            int  Handle   =  (int)ThreadState.X2;
+            long SubId    = (long)ThreadState.X3;
 
-            //Fail for info not available on older Kernel versions.
-            if (InfoType == 18 ||
-                InfoType == 19 ||
-                InfoType == 20 ||
-                InfoType == 21 ||
-                InfoType == 22)
-            {
-                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidEnumValue);
+            KernelResult Result = GetInfo(Id, Handle, SubId, out long Value);
 
-                return;
-            }
+            ThreadState.X0 = (ulong)Result;
+            ThreadState.X1 = (ulong)Value;
+        }
 
-            switch (InfoType)
+        private KernelResult GetInfo(uint Id, int Handle, long SubId, out long Value)
+        {
+            Value = 0;
+
+            switch (Id)
             {
                 case 0:
-                    ThreadState.X1 = AllowedCpuIdBitmask;
-                    break;
-
+                case 1:
                 case 2:
-                    ThreadState.X1 = (ulong)Process.MemoryManager.MapRegionStart;
-                    break;
-
                 case 3:
-                    ThreadState.X1 = (ulong)Process.MemoryManager.MapRegionEnd -
-                                     (ulong)Process.MemoryManager.MapRegionStart;
-                    break;
-
                 case 4:
-                    ThreadState.X1 = (ulong)Process.MemoryManager.HeapRegionStart;
-                    break;
-
                 case 5:
-                    ThreadState.X1 = (ulong)Process.MemoryManager.HeapRegionEnd -
-                                     (ulong)Process.MemoryManager.HeapRegionStart;
-                    break;
-
                 case 6:
-                    ThreadState.X1 = (ulong)Process.Device.Memory.Allocator.TotalAvailableSize;
-                    break;
-
                 case 7:
-                    ThreadState.X1 = (ulong)Process.Device.Memory.Allocator.TotalUsedSize;
+                case 12:
+                case 13:
+                case 14:
+                case 15:
+                case 16:
+                case 17:
+                case 18:
+                case 20:
+                case 21:
+                case 22:
+                {
+                    if (SubId != 0)
+                    {
+                        return KernelResult.InvalidCombination;
+                    }
+
+                    KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+                    KProcess Process = CurrentProcess.HandleTable.GetKProcess(Handle);
+
+                    if (Process == null)
+                    {
+                        return KernelResult.InvalidHandle;
+                    }
+
+                    switch (Id)
+                    {
+                        case 0: Value = Process.Capabilities.AllowedCpuCoresMask;    break;
+                        case 1: Value = Process.Capabilities.AllowedThreadPriosMask; break;
+
+                        case 2: Value = (long)Process.MemoryManager.AliasRegionStart; break;
+                        case 3: Value = (long)(Process.MemoryManager.AliasRegionEnd -
+                                               Process.MemoryManager.AliasRegionStart); break;
+
+                        case 4: Value = (long)Process.MemoryManager.HeapRegionStart; break;
+                        case 5: Value = (long)(Process.MemoryManager.HeapRegionEnd -
+                                               Process.MemoryManager.HeapRegionStart); break;
+
+                        case 6: Value = (long)Process.GetMemoryCapacity(); break;
+
+                        case 7: Value = (long)Process.GetMemoryUsage(); break;
+
+                        case 12: Value = (long)Process.MemoryManager.GetAddrSpaceBaseAddr(); break;
+
+                        case 13: Value = (long)Process.MemoryManager.GetAddrSpaceSize(); break;
+
+                        case 14: Value = (long)Process.MemoryManager.StackRegionStart; break;
+                        case 15: Value = (long)(Process.MemoryManager.StackRegionEnd -
+                                                Process.MemoryManager.StackRegionStart); break;
+
+                        case 16: Value = (long)Process.PersonalMmHeapPagesCount * KMemoryManager.PageSize; break;
+
+                        case 17:
+                            if (Process.PersonalMmHeapPagesCount != 0)
+                            {
+                                Value = Process.MemoryManager.GetMmUsedPages() * KMemoryManager.PageSize;
+                            }
+
+                            break;
+
+                        case 18: Value = Process.TitleId; break;
+
+                        case 20: Value = (long)Process.UserExceptionContextAddress; break;
+
+                        case 21: Value = (long)Process.GetMemoryCapacityWithoutPersonalMmHeap(); break;
+
+                        case 22: Value = (long)Process.GetMemoryUsageWithoutPersonalMmHeap(); break;
+                    }
+
                     break;
+                }
 
                 case 8:
-                    ThreadState.X1 = EnableProcessDebugging ? 1 : 0;
+                {
+                    if (Handle != 0)
+                    {
+                        return KernelResult.InvalidHandle;
+                    }
+
+                    if (SubId != 0)
+                    {
+                        return KernelResult.InvalidCombination;
+                    }
+
+                    Value = System.Scheduler.GetCurrentProcess().Debug ? 1 : 0;
+
                     break;
+                }
+
+                case 9:
+                {
+                    if (Handle != 0)
+                    {
+                        return KernelResult.InvalidHandle;
+                    }
+
+                    if (SubId != 0)
+                    {
+                        return KernelResult.InvalidCombination;
+                    }
+
+                    KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+                    if (CurrentProcess.ResourceLimit != null)
+                    {
+                        KHandleTable   HandleTable   = CurrentProcess.HandleTable;
+                        KResourceLimit ResourceLimit = CurrentProcess.ResourceLimit;
+
+                        KernelResult Result = HandleTable.GenerateHandle(ResourceLimit, out int ResLimHandle);
+
+                        if (Result != KernelResult.Success)
+                        {
+                            return Result;
+                        }
+
+                        Value = (uint)ResLimHandle;
+                    }
+
+                    break;
+                }
+
+                case 10:
+                {
+                    if (Handle != 0)
+                    {
+                        return KernelResult.InvalidHandle;
+                    }
+
+                    int CurrentCore = System.Scheduler.GetCurrentThread().CurrentCore;
+
+                    if (SubId != -1 && SubId != CurrentCore)
+                    {
+                        return KernelResult.InvalidCombination;
+                    }
+
+                    Value = System.Scheduler.CoreContexts[CurrentCore].TotalIdleTimeTicks;
+
+                    break;
+                }
 
                 case 11:
-                    ThreadState.X1 = (ulong)Rng.Next() + ((ulong)Rng.Next() << 32);
+                {
+                    if (Handle != 0)
+                    {
+                        return KernelResult.InvalidHandle;
+                    }
+
+                    if ((ulong)SubId > 3)
+                    {
+                        return KernelResult.InvalidCombination;
+                    }
+
+                    KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+
+                    Value = CurrentProcess.RandomEntropy[SubId];
+
                     break;
+                }
+
+                case 0xf0000002u:
+                {
+                    if (SubId < -1 || SubId > 3)
+                    {
+                        return KernelResult.InvalidCombination;
+                    }
+
+                    KThread Thread = System.Scheduler.GetCurrentProcess().HandleTable.GetKThread(Handle);
+
+                    if (Thread == null)
+                    {
+                        return KernelResult.InvalidHandle;
+                    }
+
+                    KThread CurrentThread = System.Scheduler.GetCurrentThread();
+
+                    int CurrentCore = CurrentThread.CurrentCore;
+
+                    if (SubId != -1 && SubId != CurrentCore)
+                    {
+                        return KernelResult.Success;
+                    }
+
+                    KCoreContext CoreContext = System.Scheduler.CoreContexts[CurrentCore];
+
+                    long TimeDelta = PerformanceCounter.ElapsedMilliseconds - CoreContext.LastContextSwitchTime;
+
+                    if (SubId != -1)
+                    {
+                        Value = KTimeManager.ConvertMillisecondsToTicks(TimeDelta);
+                    }
+                    else
+                    {
+                        long TotalTimeRunning = Thread.TotalTimeRunning;
+
+                        if (Thread == CurrentThread)
+                        {
+                            TotalTimeRunning += TimeDelta;
+                        }
+
+                        Value = KTimeManager.ConvertMillisecondsToTicks(TotalTimeRunning);
+                    }
 
-                case 12:
-                    ThreadState.X1 = (ulong)Process.MemoryManager.AddrSpaceStart;
                     break;
+                }
 
-                case 13:
-                    ThreadState.X1 = (ulong)Process.MemoryManager.AddrSpaceEnd -
-                                     (ulong)Process.MemoryManager.AddrSpaceStart;
-                    break;
-
-                case 14:
-                    ThreadState.X1 = (ulong)Process.MemoryManager.NewMapRegionStart;
-                    break;
-
-                case 15:
-                    ThreadState.X1 = (ulong)Process.MemoryManager.NewMapRegionEnd -
-                                     (ulong)Process.MemoryManager.NewMapRegionStart;
-                    break;
-
-                case 16:
-                    ThreadState.X1 = (ulong)(Process.MetaData?.SystemResourceSize ?? 0);
-                    break;
-
-                case 17:
-                    ThreadState.X1 = (ulong)Process.MemoryManager.PersonalMmHeapUsage;
-                    break;
-
-                default:
-                    Process.PrintStackTrace(ThreadState);
-
-                    throw new NotImplementedException($"SvcGetInfo: {InfoType} 0x{Handle:x8} {InfoId}");
+                default: return KernelResult.InvalidEnumValue;
             }
 
-            ThreadState.X0 = 0;
+            return KernelResult.Success;
         }
 
         private void CreateEvent64(CpuThreadState State)
@@ -397,5 +587,241 @@ namespace Ryujinx.HLE.HOS.Kernel
 
             return Result;
         }
+
+        private void GetProcessList64(CpuThreadState State)
+        {
+            ulong Address =      State.X1;
+            int   MaxOut  = (int)State.X2;
+
+            KernelResult Result = GetProcessList(Address, MaxOut, out int Count);
+
+            State.X0 = (ulong)Result;
+            State.X1 = (ulong)Count;
+        }
+
+        private KernelResult GetProcessList(ulong Address, int MaxCount, out int Count)
+        {
+            Count = 0;
+
+            if ((MaxCount >> 28) != 0)
+            {
+                return KernelResult.MaximumExceeded;
+            }
+
+            if (MaxCount != 0)
+            {
+                KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+                ulong CopySize = (ulong)MaxCount * 8;
+
+                if (Address + CopySize <= Address)
+                {
+                    return KernelResult.InvalidMemState;
+                }
+
+                if (CurrentProcess.MemoryManager.OutsideAddrSpace(Address, CopySize))
+                {
+                    return KernelResult.InvalidMemState;
+                }
+            }
+
+            int CopyCount = 0;
+
+            lock (System.Processes)
+            {
+                foreach (KProcess Process in System.Processes.Values)
+                {
+                    if (CopyCount < MaxCount)
+                    {
+                        if (!KernelTransfer.KernelToUserInt64(System, (long)Address + CopyCount * 8, Process.Pid))
+                        {
+                            return KernelResult.UserCopyFailed;
+                        }
+                    }
+
+                    CopyCount++;
+                }
+            }
+
+            Count = CopyCount;
+
+            return KernelResult.Success;
+        }
+
+        private void GetSystemInfo64(CpuThreadState State)
+        {
+            uint Id     = (uint)State.X1;
+            int  Handle =  (int)State.X2;
+            long SubId  = (long)State.X3;
+
+            KernelResult Result = GetSystemInfo(Id, Handle, SubId, out long Value);
+
+            State.X0 = (ulong)Result;
+            State.X1 = (ulong)Value;
+        }
+
+        private KernelResult GetSystemInfo(uint Id, int Handle, long SubId, out long Value)
+        {
+            Value = 0;
+
+            if (Id > 2)
+            {
+                return KernelResult.InvalidEnumValue;
+            }
+
+            if (Handle != 0)
+            {
+                return KernelResult.InvalidHandle;
+            }
+
+            if (Id < 2)
+            {
+                if ((ulong)SubId > 3)
+                {
+                    return KernelResult.InvalidCombination;
+                }
+
+                KMemoryRegionManager Region = System.MemoryRegions[SubId];
+
+                switch (Id)
+                {
+                    //Memory region capacity.
+                    case 0: Value = (long)Region.Size; break;
+
+                    //Memory region free space.
+                    case 1:
+                    {
+                        ulong FreePagesCount = Region.GetFreePages();
+
+                        Value = (long)(FreePagesCount * KMemoryManager.PageSize);
+
+                        break;
+                    }
+                }
+            }
+            else /* if (Id == 2) */
+            {
+                if ((ulong)SubId > 1)
+                {
+                    return KernelResult.InvalidCombination;
+                }
+
+                switch (SubId)
+                {
+                    case 0: Value = System.PrivilegedProcessLowestId;  break;
+                    case 1: Value = System.PrivilegedProcessHighestId; break;
+                }
+            }
+
+            return KernelResult.Success;
+        }
+
+        private void CreatePort64(CpuThreadState State)
+        {
+            int  MaxSessions =  (int)State.X2;
+            bool IsLight     =      (State.X3 & 1) != 0;
+            long NameAddress = (long)State.X4;
+
+            KernelResult Result = CreatePort(
+                MaxSessions,
+                IsLight,
+                NameAddress,
+                out int ServerPortHandle,
+                out int ClientPortHandle);
+
+            State.X0 = (ulong)Result;
+            State.X1 = (ulong)ServerPortHandle;
+            State.X2 = (ulong)ClientPortHandle;
+        }
+
+        private KernelResult CreatePort(
+            int     MaxSessions,
+            bool    IsLight,
+            long    NameAddress,
+            out int ServerPortHandle,
+            out int ClientPortHandle)
+        {
+            ServerPortHandle = ClientPortHandle = 0;
+
+            if (MaxSessions < 1)
+            {
+                return KernelResult.MaximumExceeded;
+            }
+
+            KPort Port = new KPort(System);
+
+            Port.Initialize(MaxSessions, IsLight, NameAddress);
+
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            KernelResult Result = CurrentProcess.HandleTable.GenerateHandle(Port.ClientPort, out ClientPortHandle);
+
+            if (Result != KernelResult.Success)
+            {
+                return Result;
+            }
+
+            Result = CurrentProcess.HandleTable.GenerateHandle(Port.ServerPort, out ServerPortHandle);
+
+            if (Result != KernelResult.Success)
+            {
+                CurrentProcess.HandleTable.CloseHandle(ClientPortHandle);
+            }
+
+            return Result;
+        }
+
+        private void ManageNamedPort64(CpuThreadState State)
+        {
+            long NameAddress = (long)State.X1;
+            int  MaxSessions =  (int)State.X2;
+
+            KernelResult Result = ManageNamedPort(NameAddress, MaxSessions, out int Handle);
+
+            State.X0 = (ulong)Result;
+            State.X1 = (ulong)Handle;
+        }
+
+        private KernelResult ManageNamedPort(long NameAddress, int MaxSessions, out int Handle)
+        {
+            Handle = 0;
+
+            if (!KernelTransfer.UserToKernelString(System, NameAddress, 12, out string Name))
+            {
+                return KernelResult.UserCopyFailed;
+            }
+
+            if (MaxSessions < 0 || Name.Length > 11)
+            {
+                return KernelResult.MaximumExceeded;
+            }
+
+            if (MaxSessions == 0)
+            {
+                return KClientPort.RemoveName(System, Name);
+            }
+
+            KPort Port = new KPort(System);
+
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            KernelResult Result = CurrentProcess.HandleTable.GenerateHandle(Port.ServerPort, out Handle);
+
+            if (Result != KernelResult.Success)
+            {
+                return Result;
+            }
+
+            Port.Initialize(MaxSessions, false, 0);
+
+            Result = Port.SetName(Name);
+
+            if (Result != KernelResult.Success)
+            {
+                CurrentProcess.HandleTable.CloseHandle(Handle);
+            }
+
+            return Result;
+        }
     }
 }

Ryujinx.HLE/HOS/Kernel/SvcThread.cs

@@ -7,48 +7,84 @@ namespace Ryujinx.HLE.HOS.Kernel
 {
     partial class SvcHandler
     {
-        private void SvcCreateThread(CpuThreadState ThreadState)
+        private void CreateThread64(CpuThreadState 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;
+            ulong Entrypoint =      ThreadState.X1;
+            ulong ArgsPtr    =      ThreadState.X2;
+            ulong StackTop   =      ThreadState.X3;
+            int   Priority   = (int)ThreadState.X4;
+            int   CpuCore    = (int)ThreadState.X5;
 
-            if ((uint)Priority > 0x3f)
-            {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid priority 0x{Priority:x8}!");
+            KernelResult Result = CreateThread(Entrypoint, ArgsPtr, StackTop, Priority, CpuCore, out int Handle);
 
-                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)
-            {
-                Logger.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.X0 = (ulong)Result;
             ThreadState.X1 = (ulong)Handle;
         }
 
+        private KernelResult CreateThread(
+            ulong   Entrypoint,
+            ulong   ArgsPtr,
+            ulong   StackTop,
+            int     Priority,
+            int     CpuCore,
+            out int Handle)
+        {
+            Handle = 0;
+
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            if (CpuCore == -2)
+            {
+                CpuCore = CurrentProcess.DefaultCpuCore;
+            }
+
+            if ((uint)CpuCore >= KScheduler.CpuCoresCount || !CurrentProcess.IsCpuCoreAllowed(CpuCore))
+            {
+                return KernelResult.InvalidCpuCore;
+            }
+
+            if ((uint)Priority >= KScheduler.PrioritiesCount || !CurrentProcess.IsPriorityAllowed(Priority))
+            {
+                return KernelResult.InvalidPriority;
+            }
+
+            long Timeout = KTimeManager.ConvertMillisecondsToNanoseconds(100);
+
+            if (CurrentProcess.ResourceLimit != null &&
+               !CurrentProcess.ResourceLimit.Reserve(LimitableResource.Thread, 1, Timeout))
+            {
+                return KernelResult.ResLimitExceeded;
+            }
+
+            KThread Thread = new KThread(System);
+
+            KernelResult Result = CurrentProcess.InitializeThread(
+                Thread,
+                Entrypoint,
+                ArgsPtr,
+                StackTop,
+                Priority,
+                CpuCore);
+
+            if (Result != KernelResult.Success)
+            {
+                CurrentProcess.ResourceLimit?.Release(LimitableResource.Thread, 1);
+
+                return Result;
+            }
+
+            Result = Process.HandleTable.GenerateHandle(Thread, out Handle);
+
+            if (Result != KernelResult.Success)
+            {
+                Thread.Terminate();
+
+                CurrentProcess.ResourceLimit?.Release(LimitableResource.Thread, 1);
+            }
+
+            return Result;
+        }
+
         private void SvcStartThread(CpuThreadState ThreadState)
         {
             int Handle = (int)ThreadState.X0;
@@ -57,11 +93,11 @@ namespace Ryujinx.HLE.HOS.Kernel
 
             if (Thread != null)
             {
-                long Result = Thread.Start();
+                KernelResult Result = Thread.Start();
 
-                if (Result != 0)
+                if (Result != KernelResult.Success)
                 {
-                    Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!");
+                    Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{Result}\".");
                 }
 
                 ThreadState.X0 = (ulong)Result;
@@ -78,9 +114,9 @@ namespace Ryujinx.HLE.HOS.Kernel
         {
             KThread CurrentThread = System.Scheduler.GetCurrentThread();
 
-            CurrentThread.Exit();
+            System.Scheduler.ExitThread(CurrentThread);
 
-            System.Scheduler.StopThread(CurrentThread);
+            CurrentThread.Exit();
         }
 
         private void SvcSleepThread(CpuThreadState ThreadState)
@@ -176,46 +212,60 @@ namespace Ryujinx.HLE.HOS.Kernel
             }
         }
 
-        private void SvcSetThreadCoreMask(CpuThreadState ThreadState)
+        private void SetThreadCoreMask64(CpuThreadState ThreadState)
         {
             int  Handle        =  (int)ThreadState.X0;
-            int  PrefferedCore =  (int)ThreadState.X1;
+            int  PreferredCore =  (int)ThreadState.X1;
             long AffinityMask  = (long)ThreadState.X2;
 
             Logger.PrintDebug(LogClass.KernelSvc,
                 "Handle = 0x"        + Handle       .ToString("x8") + ", " +
-                "PrefferedCore = 0x" + PrefferedCore.ToString("x8") + ", " +
+                "PreferredCore = 0x" + PreferredCore.ToString("x8") + ", " +
                 "AffinityMask = 0x"  + AffinityMask .ToString("x16"));
 
-            if (PrefferedCore == -2)
-            {
-                //TODO: Get this value from the NPDM file.
-                PrefferedCore = 0;
+            KernelResult Result = SetThreadCoreMask(Handle, PreferredCore, AffinityMask);
 
-                AffinityMask = 1 << PrefferedCore;
+            if (Result != KernelResult.Success)
+            {
+                Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{Result}\".");
+            }
+
+            ThreadState.X0 = (ulong)Result;
+        }
+
+        private KernelResult SetThreadCoreMask(int Handle, int PreferredCore, long AffinityMask)
+        {
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            if (PreferredCore == -2)
+            {
+                PreferredCore = CurrentProcess.DefaultCpuCore;
+
+                AffinityMask = 1 << PreferredCore;
             }
             else
             {
-                //TODO: Check allowed cores from NPDM file.
-
-                if ((uint)PrefferedCore > 3)
+                if ((CurrentProcess.Capabilities.AllowedCpuCoresMask | AffinityMask) !=
+                     CurrentProcess.Capabilities.AllowedCpuCoresMask)
                 {
-                    if ((PrefferedCore | 2) != -1)
+                    return KernelResult.InvalidCpuCore;
+                }
+
+                if (AffinityMask == 0)
+                {
+                    return KernelResult.InvalidCombination;
+                }
+
+                if ((uint)PreferredCore > 3)
+                {
+                    if ((PreferredCore | 2) != -1)
                     {
-                        Logger.PrintWarning(LogClass.KernelSvc, $"Invalid core id 0x{PrefferedCore:x8}!");
-
-                        ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidCoreId);
-
-                        return;
+                        return KernelResult.InvalidCpuCore;
                     }
                 }
-                else if ((AffinityMask & (1 << PrefferedCore)) == 0)
+                else if ((AffinityMask & (1 << PreferredCore)) == 0)
                 {
-                    Logger.PrintWarning(LogClass.KernelSvc, $"Invalid core mask 0x{AffinityMask:x8}!");
-
-                    ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMaskValue);
-
-                    return;
+                    return KernelResult.InvalidCombination;
                 }
             }
 
@@ -223,26 +273,15 @@ namespace Ryujinx.HLE.HOS.Kernel
 
             if (Thread == null)
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!");
-
-                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
-
-                return;
+                return KernelResult.InvalidHandle;
             }
 
-            long Result = Thread.SetCoreAndAffinityMask(PrefferedCore, AffinityMask);
-
-            if (Result != 0)
-            {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!");
-            }
-
-            ThreadState.X0 = (ulong)Result;
+            return Thread.SetCoreAndAffinityMask(PreferredCore, AffinityMask);
         }
 
         private void SvcGetCurrentProcessorNumber(CpuThreadState ThreadState)
         {
-            ThreadState.X0 = (ulong)Process.GetThread(ThreadState.Tpidr).CurrentCore;
+            ThreadState.X0 = (ulong)System.Scheduler.GetCurrentThread().CurrentCore;
         }
 
         private void SvcGetThreadId(CpuThreadState ThreadState)
@@ -254,7 +293,7 @@ namespace Ryujinx.HLE.HOS.Kernel
             if (Thread != null)
             {
                 ThreadState.X0 = 0;
-                ThreadState.X1 = (ulong)Thread.ThreadId;
+                ThreadState.X1 = (ulong)Thread.ThreadUid;
             }
             else
             {
@@ -280,15 +319,24 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if (Thread.Owner != Process)
+            if (Thread.Owner != System.Scheduler.GetCurrentProcess())
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread owner process!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread, it belongs to another process.");
 
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
 
                 return;
             }
 
+            if (Thread == System.Scheduler.GetCurrentThread())
+            {
+                Logger.PrintWarning(LogClass.KernelSvc, "Invalid thread, current thread is not accepted.");
+
+                ThreadState.X0 = (ulong)KernelResult.InvalidThread;
+
+                return;
+            }
+
             long Result = Thread.SetActivity(Pause);
 
             if (Result != 0)
@@ -304,6 +352,9 @@ namespace Ryujinx.HLE.HOS.Kernel
             long Position = (long)ThreadState.X0;
             int  Handle   =  (int)ThreadState.X1;
 
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+            KThread  CurrentThread  = System.Scheduler.GetCurrentThread();
+
             KThread Thread = Process.HandleTable.GetObject<KThread>(Handle);
 
             if (Thread == null)
@@ -315,9 +366,18 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            if (Process.GetThread(ThreadState.Tpidr) == Thread)
+            if (Thread.Owner != CurrentProcess)
             {
-                Logger.PrintWarning(LogClass.KernelSvc, $"Thread handle 0x{Handle:x8} is current thread!");
+                Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread, it belongs to another process.");
+
+                ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle);
+
+                return;
+            }
+
+            if (CurrentThread == Thread)
+            {
+                Logger.PrintWarning(LogClass.KernelSvc, "Invalid thread, current thread is not accepted.");
 
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidThread);
 

Ryujinx.HLE/HOS/Kernel/SvcThreadSync.cs

@@ -32,6 +32,8 @@ namespace Ryujinx.HLE.HOS.Kernel
             {
                 int Handle = Memory.ReadInt32(HandlesPtr + Index * 4);
 
+                Logger.PrintDebug(LogClass.KernelSvc, $"Sync handle 0x{Handle:x8}");
+
                 KSynchronizationObject SyncObj = Process.HandleTable.GetObject<KSynchronizationObject>(Handle);
 
                 if (SyncObj == null)
@@ -116,12 +118,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            long Result = System.AddressArbiter.ArbitrateLock(
-                Process,
-                Memory,
-                OwnerHandle,
-                MutexAddress,
-                RequesterHandle);
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            long Result = CurrentProcess.AddressArbiter.ArbitrateLock(OwnerHandle, MutexAddress, RequesterHandle);
 
             if (Result != 0)
             {
@@ -155,7 +154,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            long Result = System.AddressArbiter.ArbitrateUnlock(Memory, MutexAddress);
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            long Result = CurrentProcess.AddressArbiter.ArbitrateUnlock(MutexAddress);
 
             if (Result != 0)
             {
@@ -196,8 +197,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
-            long Result = System.AddressArbiter.WaitProcessWideKeyAtomic(
-                Memory,
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            long Result = CurrentProcess.AddressArbiter.WaitProcessWideKeyAtomic(
                 MutexAddress,
                 CondVarAddress,
                 ThreadHandle,
@@ -227,7 +229,9 @@ namespace Ryujinx.HLE.HOS.Kernel
                 "Address = 0x" + Address.ToString("x16") + ", " +
                 "Count = 0x"   + Count  .ToString("x8"));
 
-            System.AddressArbiter.SignalProcessWideKey(Process, Memory, Address, Count);
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
+            CurrentProcess.AddressArbiter.SignalProcessWideKey(Address, Count);
 
             ThreadState.X0 = 0;
         }
@@ -263,20 +267,22 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
             long Result;
 
             switch (Type)
             {
                 case ArbitrationType.WaitIfLessThan:
-                    Result = System.AddressArbiter.WaitForAddressIfLessThan(Memory, Address, Value, false, Timeout);
+                    Result = CurrentProcess.AddressArbiter.WaitForAddressIfLessThan(Address, Value, false, Timeout);
                     break;
 
                 case ArbitrationType.DecrementAndWaitIfLessThan:
-                    Result = System.AddressArbiter.WaitForAddressIfLessThan(Memory, Address, Value, true, Timeout);
+                    Result = CurrentProcess.AddressArbiter.WaitForAddressIfLessThan(Address, Value, true, Timeout);
                     break;
 
                 case ArbitrationType.WaitIfEqual:
-                    Result = System.AddressArbiter.WaitForAddressIfEqual(Memory, Address, Value, Timeout);
+                    Result = CurrentProcess.AddressArbiter.WaitForAddressIfEqual(Address, Value, Timeout);
                     break;
 
                 default:
@@ -323,20 +329,22 @@ namespace Ryujinx.HLE.HOS.Kernel
                 return;
             }
 
+            KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
+
             long Result;
 
             switch (Type)
             {
                 case SignalType.Signal:
-                    Result = System.AddressArbiter.Signal(Address, Count);
+                    Result = CurrentProcess.AddressArbiter.Signal(Address, Count);
                     break;
 
                 case SignalType.SignalAndIncrementIfEqual:
-                    Result = System.AddressArbiter.SignalAndIncrementIfEqual(Memory, Address, Value, Count);
+                    Result = CurrentProcess.AddressArbiter.SignalAndIncrementIfEqual(Address, Value, Count);
                     break;
 
                 case SignalType.SignalAndModifyIfEqual:
-                    Result = System.AddressArbiter.SignalAndModifyIfEqual(Memory, Address, Value, Count);
+                    Result = CurrentProcess.AddressArbiter.SignalAndModifyIfEqual(Address, Value, Count);
                     break;
 
                 default:

Ryujinx.HLE/HOS/Kernel/ThreadSchedState.cs

@@ -1,11 +1,15 @@
 namespace Ryujinx.HLE.HOS.Kernel
 {
-    enum ThreadSchedState : byte
+    enum ThreadSchedState : ushort
     {
-        LowNibbleMask   = 0xf,
-        HighNibbleMask  = 0xf0,
-        ExceptionalMask = 0x70,
-        ForcePauseFlag  = 0x20,
+        LowMask        = 0xf,
+        HighMask       = 0xfff0,
+        ForcePauseMask = 0x70,
+
+        ProcessPauseFlag      = 1 << 4,
+        ThreadPauseFlag       = 1 << 5,
+        ProcessDebugPauseFlag = 1 << 6,
+        KernelInitPauseFlag   = 1 << 8,
 
         None               = 0,
         Paused             = 1,

Ryujinx.HLE/HOS/Kernel/ThreadType.cs

@@ -0,0 +1,10 @@
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    enum ThreadType
+    {
+        Dummy,
+        Kernel,
+        Kernel2,
+        User
+    }
+}

Ryujinx.HLE/HOS/Process.cs

@@ -1,528 +0,0 @@
-using ChocolArm64;
-using ChocolArm64.Events;
-using ChocolArm64.Memory;
-using ChocolArm64.State;
-using LibHac;
-using Ryujinx.Common.Logging;
-using Ryujinx.HLE.Exceptions;
-using Ryujinx.HLE.HOS.Diagnostics.Demangler;
-using Ryujinx.HLE.HOS.Kernel;
-using Ryujinx.HLE.HOS.Services.Nv;
-using Ryujinx.HLE.HOS.SystemState;
-using Ryujinx.HLE.Loaders;
-using Ryujinx.HLE.Loaders.Executables;
-using Ryujinx.HLE.Loaders.Npdm;
-using Ryujinx.HLE.Utilities;
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
-
-namespace Ryujinx.HLE.HOS
-{
-    class Process : IDisposable
-    {
-        private const int TickFreq = 19_200_000;
-
-        public Switch Device { get; private set; }
-
-        public bool NeedsHbAbi { get; private set; }
-
-        public long HbAbiDataPosition { get; private set; }
-
-        public int ProcessId { get; private set; }
-
-        private Translator Translator;
-
-        public MemoryManager Memory { get; private set; }
-
-        public KMemoryManager MemoryManager { get; private set; }
-
-        private List<KTlsPageManager> TlsPages;
-
-        public Npdm MetaData { get; private set; }
-
-        public Nacp ControlData { get; set; }
-
-        public KProcessHandleTable HandleTable { get; private set; }
-
-        public AppletStateMgr AppletState { get; private set; }
-
-        private SvcHandler SvcHandler;
-
-        private ConcurrentDictionary<long, KThread> Threads;
-
-        private List<Executable> Executables;
-
-        private long ImageBase;
-
-        private bool Disposed;
-
-        public Process(Switch Device, int ProcessId, Npdm MetaData)
-        {
-            this.Device    = Device;
-            this.MetaData  = MetaData;
-            this.ProcessId = ProcessId;
-
-            Memory = new MemoryManager(Device.Memory.RamPointer);
-
-            Memory.InvalidAccess += CpuInvalidAccessHandler;
-
-            MemoryManager = new KMemoryManager(this);
-
-            TlsPages = new List<KTlsPageManager>();
-
-            int HandleTableSize = 1024;
-
-            if (MetaData != null)
-            {
-                foreach (KernelAccessControlItem Item in MetaData.ACI0.KernelAccessControl.Items)
-                {
-                    if (Item.HasHandleTableSize)
-                    {
-                        HandleTableSize = Item.HandleTableSize;
-
-                        break;
-                    }
-                }
-            }
-
-            HandleTable = new KProcessHandleTable(Device.System, HandleTableSize);
-
-            AppletState = new AppletStateMgr(Device.System);
-
-            SvcHandler = new SvcHandler(Device, this);
-
-            Threads = new ConcurrentDictionary<long, KThread>();
-
-            Executables = new List<Executable>();
-
-            ImageBase = MemoryManager.CodeRegionStart;
-        }
-
-        public void LoadProgram(IExecutable Program)
-        {
-            if (Disposed)
-            {
-                throw new ObjectDisposedException(nameof(Process));
-            }
-
-            long ImageEnd = LoadProgram(Program, ImageBase);
-
-            ImageBase = IntUtils.AlignUp(ImageEnd, KMemoryManager.PageSize);
-        }
-
-        public long LoadProgram(IExecutable Program, long ExecutableBase)
-        {
-            if (Disposed)
-            {
-                throw new ObjectDisposedException(nameof(Process));
-            }
-
-            Logger.PrintInfo(LogClass.Loader, $"Image base at 0x{ExecutableBase:x16}.");
-
-            Executable Executable = new Executable(Program, MemoryManager, Memory, ExecutableBase);
-
-            Executables.Add(Executable);
-
-            return Executable.ImageEnd;
-        }
-
-        public void RemoveProgram(long ExecutableBase)
-        {
-            foreach (Executable Executable in Executables)
-            {
-                if (Executable.ImageBase == ExecutableBase)
-                {
-                    Executables.Remove(Executable);
-                    break;
-                }
-            }
-        }
-
-        public void SetEmptyArgs()
-        {
-            //TODO: This should be part of Run.
-            ImageBase += KMemoryManager.PageSize;
-        }
-
-        public bool Run(bool NeedsHbAbi = false)
-        {
-            if (Disposed)
-            {
-                throw new ObjectDisposedException(nameof(Process));
-            }
-
-            this.NeedsHbAbi = NeedsHbAbi;
-
-            if (Executables.Count == 0)
-            {
-                return false;
-            }
-
-            long MainStackTop = MemoryManager.CodeRegionEnd - KMemoryManager.PageSize;
-
-            long MainStackSize = 1 * 1024 * 1024;
-
-            long MainStackBottom = MainStackTop - MainStackSize;
-
-            MemoryManager.HleMapCustom(
-                MainStackBottom,
-                MainStackSize,
-                MemoryState.MappedMemory,
-                MemoryPermission.ReadAndWrite);
-
-            int Handle = MakeThread(Executables[0].ImageBase, MainStackTop, 0, 44, 0);
-
-            if (Handle == -1)
-            {
-                return false;
-            }
-
-            KThread MainThread = HandleTable.GetKThread(Handle);
-
-            if (NeedsHbAbi)
-            {
-                HbAbiDataPosition = IntUtils.AlignUp(Executables[0].ImageEnd, KMemoryManager.PageSize);
-
-                const long HbAbiDataSize = KMemoryManager.PageSize;
-
-                MemoryManager.HleMapCustom(
-                    HbAbiDataPosition,
-                    HbAbiDataSize,
-                    MemoryState.MappedMemory,
-                    MemoryPermission.ReadAndWrite);
-
-                string SwitchPath = Device.FileSystem.SystemPathToSwitchPath(Executables[0].FilePath);
-
-                Homebrew.WriteHbAbiData(Memory, HbAbiDataPosition, Handle, SwitchPath);
-
-                MainThread.Context.ThreadState.X0 = (ulong)HbAbiDataPosition;
-                MainThread.Context.ThreadState.X1 = ulong.MaxValue;
-            }
-
-            MainThread.TimeUp();
-
-            return true;
-        }
-
-        private int ThreadIdCtr = 1;
-
-        public int MakeThread(
-            long EntryPoint,
-            long StackTop,
-            long ArgsPtr,
-            int  Priority,
-            int  ProcessorId)
-        {
-            if (Disposed)
-            {
-                throw new ObjectDisposedException(nameof(Process));
-            }
-
-            CpuThread CpuThread = new CpuThread(GetTranslator(), Memory, EntryPoint);
-
-            long Tpidr = GetFreeTls();
-
-            int ThreadId = ThreadIdCtr++; //(int)((Tpidr - MemoryManager.TlsIoRegionStart) / 0x200) + 1;
-
-            KThread Thread = new KThread(CpuThread, this, Device.System, ProcessorId, Priority, ThreadId);
-
-            Thread.LastPc = EntryPoint;
-
-            HandleTable.GenerateHandle(Thread, out int Handle);
-
-            CpuThread.ThreadState.CntfrqEl0 = TickFreq;
-            CpuThread.ThreadState.Tpidr     = Tpidr;
-
-            CpuThread.ThreadState.X0  = (ulong)ArgsPtr;
-            CpuThread.ThreadState.X1  = (ulong)Handle;
-            CpuThread.ThreadState.X31 = (ulong)StackTop;
-
-            CpuThread.ThreadState.Interrupt += InterruptHandler;
-            CpuThread.ThreadState.Break     += BreakHandler;
-            CpuThread.ThreadState.SvcCall   += SvcHandler.SvcCall;
-            CpuThread.ThreadState.Undefined += UndefinedHandler;
-
-            CpuThread.WorkFinished += ThreadFinished;
-
-            Threads.TryAdd(CpuThread.ThreadState.Tpidr, Thread);
-
-            return Handle;
-        }
-
-        private long GetFreeTls()
-        {
-            long Position;
-
-            lock (TlsPages)
-            {
-                for (int Index = 0; Index < TlsPages.Count; Index++)
-                {
-                    if (TlsPages[Index].TryGetFreeTlsAddr(out Position))
-                    {
-                        return Position;
-                    }
-                }
-
-                long PagePosition = MemoryManager.HleMapTlsPage();
-
-                KTlsPageManager TlsPage = new KTlsPageManager(PagePosition);
-
-                TlsPages.Add(TlsPage);
-
-                TlsPage.TryGetFreeTlsAddr(out Position);
-            }
-
-            return Position;
-        }
-
-        private void InterruptHandler(object sender, EventArgs e)
-        {
-            Device.System.Scheduler.ContextSwitch();
-        }
-
-        private void BreakHandler(object sender, InstExceptionEventArgs e)
-        {
-            PrintStackTraceForCurrentThread();
-
-            throw new GuestBrokeExecutionException();
-        }
-
-        private void UndefinedHandler(object sender, InstUndefinedEventArgs e)
-        {
-            PrintStackTraceForCurrentThread();
-
-            throw new UndefinedInstructionException(e.Position, e.RawOpCode);
-        }
-
-        public void EnableCpuTracing()
-        {
-            Translator.EnableCpuTrace = true;
-        }
-
-        public void DisableCpuTracing()
-        {
-            Translator.EnableCpuTrace = false;
-        }
-
-        private void CpuTraceHandler(object sender, CpuTraceEventArgs e)
-        {
-            Executable Exe = GetExecutable(e.Position);
-
-            if (Exe == null)
-            {
-                return;
-            }
-
-            if (!TryGetSubName(Exe, e.Position, out string SubName))
-            {
-                SubName = string.Empty;
-            }
-
-            long Offset = e.Position - Exe.ImageBase;
-
-            string ExeNameWithAddr = $"{Exe.Name}:0x{Offset:x8}";
-
-            Logger.PrintDebug(LogClass.Cpu, ExeNameWithAddr + " " + SubName);
-        }
-
-        private Translator GetTranslator()
-        {
-            if (Translator == null)
-            {
-                Translator = new Translator();
-
-                Translator.CpuTrace += CpuTraceHandler;
-            }
-
-            return Translator;
-        }
-
-        private void CpuInvalidAccessHandler(object sender, InvalidAccessEventArgs e)
-        {
-            PrintStackTraceForCurrentThread();
-        }
-
-        private void PrintStackTraceForCurrentThread()
-        {
-            foreach (KThread Thread in Threads.Values)
-            {
-                if (Thread.Context.IsCurrentThread())
-                {
-                    PrintStackTrace(Thread.Context.ThreadState);
-
-                    break;
-                }
-            }
-        }
-
-        public void PrintStackTrace(CpuThreadState ThreadState)
-        {
-            StringBuilder Trace = new StringBuilder();
-
-            Trace.AppendLine("Guest stack trace:");
-
-            void AppendTrace(long Position)
-            {
-                Executable Exe = GetExecutable(Position);
-
-                if (Exe == null)
-                {
-                    return;
-                }
-
-                if (!TryGetSubName(Exe, Position, out string SubName))
-                {
-                    SubName = $"Sub{Position:x16}";
-                }
-                else if (SubName.StartsWith("_Z"))
-                {
-                    SubName = Demangler.Parse(SubName);
-                }
-
-                long Offset = Position - Exe.ImageBase;
-
-                string ExeNameWithAddr = $"{Exe.Name}:0x{Offset:x8}";
-
-                Trace.AppendLine(" " + ExeNameWithAddr + " " + SubName);
-            }
-
-            long FramePointer = (long)ThreadState.X29;
-
-            while (FramePointer != 0)
-            {
-                AppendTrace(Memory.ReadInt64(FramePointer + 8));
-
-                FramePointer = Memory.ReadInt64(FramePointer);
-            }
-
-            Logger.PrintInfo(LogClass.Cpu, Trace.ToString());
-        }
-
-        private bool TryGetSubName(Executable Exe, long Position, out string Name)
-        {
-            Position -= Exe.ImageBase;
-
-            int Left  = 0;
-            int Right = Exe.SymbolTable.Count - 1;
-
-            while (Left <= Right)
-            {
-                int Size = Right - Left;
-
-                int Middle = Left + (Size >> 1);
-
-                ElfSym Symbol = Exe.SymbolTable[Middle];
-
-                long EndPosition = Symbol.Value + Symbol.Size;
-
-                if ((ulong)Position >= (ulong)Symbol.Value && (ulong)Position < (ulong)EndPosition)
-                {
-                    Name = Symbol.Name;
-
-                    return true;
-                }
-
-                if ((ulong)Position < (ulong)Symbol.Value)
-                {
-                    Right = Middle - 1;
-                }
-                else
-                {
-                    Left = Middle + 1;
-                }
-            }
-
-            Name = null;
-
-            return false;
-        }
-
-        private Executable GetExecutable(long Position)
-        {
-            string Name = string.Empty;
-
-            for (int Index = Executables.Count - 1; Index >= 0; Index--)
-            {
-                if ((ulong)Position >= (ulong)Executables[Index].ImageBase)
-                {
-                    return Executables[Index];
-                }
-            }
-
-            return null;
-        }
-
-        private void ThreadFinished(object sender, EventArgs e)
-        {
-            if (sender is CpuThread Thread)
-            {
-                if (Threads.TryRemove(Thread.ThreadState.Tpidr, out KThread KernelThread))
-                {
-                    Device.System.Scheduler.RemoveThread(KernelThread);
-                }
-            }
-
-            if (Threads.Count == 0)
-            {
-                Device.System.ExitProcess(ProcessId);
-            }
-        }
-
-        public KThread GetThread(long Tpidr)
-        {
-            if (!Threads.TryGetValue(Tpidr, out KThread Thread))
-            {
-                throw new InvalidOperationException();
-            }
-
-            return Thread;
-        }
-
-        private void Unload()
-        {
-            if (Disposed || Threads.Count > 0)
-            {
-                return;
-            }
-
-            Disposed = true;
-
-            HandleTable.Destroy();
-
-            INvDrvServices.UnloadProcess(this);
-
-            if (NeedsHbAbi && Executables.Count > 0 && Executables[0].FilePath.EndsWith(Homebrew.TemporaryNroSuffix))
-            {
-                File.Delete(Executables[0].FilePath);
-            }
-
-            Logger.PrintInfo(LogClass.Loader, $"Process {ProcessId} exiting...");
-        }
-
-        public void Dispose()
-        {
-            Dispose(true);
-        }
-
-        protected virtual void Dispose(bool Disposing)
-        {
-            if (Disposing)
-            {
-                if (Threads.Count > 0)
-                {
-                    foreach (KThread Thread in Threads.Values)
-                    {
-                        Device.System.Scheduler.StopThread(Thread);
-                    }
-                }
-                else
-                {
-                    Unload();
-                }
-            }
-        }
-    }
-}

Ryujinx.HLE/HOS/ProgramLoader.cs

@@ -0,0 +1,292 @@
+using ChocolArm64.Memory;
+using Ryujinx.Common;
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Kernel;
+using Ryujinx.HLE.Loaders.Executables;
+using Ryujinx.HLE.Loaders.Npdm;
+
+namespace Ryujinx.HLE.HOS
+{
+    class ProgramLoader
+    {
+        private const bool AslrEnabled = true;
+
+        private const int ArgsHeaderSize = 8;
+        private const int ArgsDataSize   = 0x9000;
+        private const int ArgsTotalSize  = ArgsHeaderSize + ArgsDataSize;
+
+        public static bool LoadKernelInitalProcess(Horizon System, KernelInitialProcess Kip)
+        {
+            int EndOffset = Kip.DataOffset + Kip.Data.Length;
+
+            if (Kip.BssSize != 0)
+            {
+                EndOffset = Kip.BssOffset + Kip.BssSize;
+            }
+
+            int CodeSize = BitUtils.AlignUp(Kip.TextOffset + EndOffset, KMemoryManager.PageSize);
+
+            int CodePagesCount = CodeSize / KMemoryManager.PageSize;
+
+            ulong CodeBaseAddress = Kip.Addr39Bits ? 0x8000000UL : 0x200000UL;
+
+            ulong CodeAddress = CodeBaseAddress + (ulong)Kip.TextOffset;
+
+            int MmuFlags = 0;
+
+            if (AslrEnabled)
+            {
+                //TODO: Randomization.
+
+                MmuFlags |= 0x20;
+            }
+
+            if (Kip.Addr39Bits)
+            {
+                MmuFlags |= (int)AddressSpaceType.Addr39Bits << 1;
+            }
+
+            if (Kip.Is64Bits)
+            {
+                MmuFlags |= 1;
+            }
+
+            ProcessCreationInfo CreationInfo = new ProcessCreationInfo(
+                Kip.Name,
+                Kip.ProcessCategory,
+                Kip.TitleId,
+                CodeAddress,
+                CodePagesCount,
+                MmuFlags,
+                0,
+                0);
+
+            MemoryRegion MemRegion = Kip.IsService
+                ? MemoryRegion.Service
+                : MemoryRegion.Application;
+
+            KMemoryRegionManager Region = System.MemoryRegions[(int)MemRegion];
+
+            KernelResult Result = Region.AllocatePages((ulong)CodePagesCount, false, out KPageList PageList);
+
+            if (Result != KernelResult.Success)
+            {
+                Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{Result}\".");
+
+                return false;
+            }
+
+            KProcess Process = new KProcess(System);
+
+            Result = Process.InitializeKip(
+                CreationInfo,
+                Kip.Capabilities,
+                PageList,
+                System.ResourceLimit,
+                MemRegion);
+
+            if (Result != KernelResult.Success)
+            {
+                Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{Result}\".");
+
+                return false;
+            }
+
+            Result = LoadIntoMemory(Process, Kip, CodeBaseAddress);
+
+            if (Result != KernelResult.Success)
+            {
+                Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{Result}\".");
+
+                return false;
+            }
+
+            Result = Process.Start(Kip.MainThreadPriority, (ulong)Kip.MainThreadStackSize);
+
+            if (Result != KernelResult.Success)
+            {
+                Logger.PrintError(LogClass.Loader, $"Process start returned error \"{Result}\".");
+
+                return false;
+            }
+
+            System.Processes.Add(Process.Pid, Process);
+
+            return true;
+        }
+
+        public static bool LoadStaticObjects(
+            Horizon       System,
+            Npdm          MetaData,
+            IExecutable[] StaticObjects,
+            byte[]        Arguments = null)
+        {
+            ulong ArgsStart = 0;
+            int   ArgsSize  = 0;
+            ulong CodeStart = 0x8000000;
+            int   CodeSize  = 0;
+
+            ulong[] NsoBase = new ulong[StaticObjects.Length];
+
+            for (int Index = 0; Index < StaticObjects.Length; Index++)
+            {
+                IExecutable StaticObject = StaticObjects[Index];
+
+                int TextEnd = StaticObject.TextOffset + StaticObject.Text.Length;
+                int ROEnd   = StaticObject.ROOffset   + StaticObject.RO.Length;
+                int DataEnd = StaticObject.DataOffset + StaticObject.Data.Length + StaticObject.BssSize;
+
+                int NsoSize = TextEnd;
+
+                if ((uint)NsoSize < (uint)ROEnd)
+                {
+                    NsoSize = ROEnd;
+                }
+
+                if ((uint)NsoSize < (uint)DataEnd)
+                {
+                    NsoSize = DataEnd;
+                }
+
+                NsoSize = BitUtils.AlignUp(NsoSize, KMemoryManager.PageSize);
+
+                NsoBase[Index] = CodeStart + (ulong)CodeSize;
+
+                CodeSize += NsoSize;
+
+                if (Arguments != null && ArgsSize == 0)
+                {
+                    ArgsStart = (ulong)CodeSize;
+
+                    ArgsSize = BitUtils.AlignDown(Arguments.Length * 2 + ArgsTotalSize - 1, KMemoryManager.PageSize);
+
+                    CodeSize += ArgsSize;
+                }
+            }
+
+            int CodePagesCount = CodeSize / KMemoryManager.PageSize;
+
+            int PersonalMmHeapPagesCount = MetaData.PersonalMmHeapSize / KMemoryManager.PageSize;
+
+            ProcessCreationInfo CreationInfo = new ProcessCreationInfo(
+                MetaData.TitleName,
+                MetaData.ProcessCategory,
+                MetaData.ACI0.TitleId,
+                CodeStart,
+                CodePagesCount,
+                MetaData.MmuFlags,
+                0,
+                PersonalMmHeapPagesCount);
+
+            KernelResult Result;
+
+            KResourceLimit ResourceLimit = new KResourceLimit(System);
+
+            long ApplicationRgSize = (long)System.MemoryRegions[(int)MemoryRegion.Application].Size;
+
+            Result  = ResourceLimit.SetLimitValue(LimitableResource.Memory,         ApplicationRgSize);
+            Result |= ResourceLimit.SetLimitValue(LimitableResource.Thread,         608);
+            Result |= ResourceLimit.SetLimitValue(LimitableResource.Event,          700);
+            Result |= ResourceLimit.SetLimitValue(LimitableResource.TransferMemory, 128);
+            Result |= ResourceLimit.SetLimitValue(LimitableResource.Session,        894);
+
+            if (Result != KernelResult.Success)
+            {
+                Logger.PrintError(LogClass.Loader, $"Process initialization failed setting resource limit values.");
+
+                return false;
+            }
+
+            KProcess Process = new KProcess(System);
+
+            Result = Process.Initialize(
+                CreationInfo,
+                MetaData.ACI0.KernelAccessControl.Capabilities,
+                ResourceLimit,
+                MemoryRegion.Application);
+
+            if (Result != KernelResult.Success)
+            {
+                Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{Result}\".");
+
+                return false;
+            }
+
+            for (int Index = 0; Index < StaticObjects.Length; Index++)
+            {
+                Logger.PrintInfo(LogClass.Loader, $"Loading image {Index} at 0x{NsoBase[Index]:x16}...");
+
+                Result = LoadIntoMemory(Process, StaticObjects[Index], NsoBase[Index]);
+
+                if (Result != KernelResult.Success)
+                {
+                    Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{Result}\".");
+
+                    return false;
+                }
+            }
+
+            Result = Process.Start(MetaData.MainThreadPriority, (ulong)MetaData.MainThreadStackSize);
+
+            if (Result != KernelResult.Success)
+            {
+                Logger.PrintError(LogClass.Loader, $"Process start returned error \"{Result}\".");
+
+                return false;
+            }
+
+            System.Processes.Add(Process.Pid, Process);
+
+            return true;
+        }
+
+        private static KernelResult LoadIntoMemory(KProcess Process, IExecutable Image, ulong BaseAddress)
+        {
+            ulong TextStart = BaseAddress + (ulong)Image.TextOffset;
+            ulong ROStart   = BaseAddress + (ulong)Image.ROOffset;
+            ulong DataStart = BaseAddress + (ulong)Image.DataOffset;
+            ulong BssStart  = BaseAddress + (ulong)Image.BssOffset;
+
+            ulong End = DataStart + (ulong)Image.Data.Length;
+
+            if (Image.BssSize != 0)
+            {
+                End = BssStart + (ulong)Image.BssSize;
+            }
+
+            Process.CpuMemory.WriteBytes((long)TextStart, Image.Text);
+            Process.CpuMemory.WriteBytes((long)ROStart,   Image.RO);
+            Process.CpuMemory.WriteBytes((long)DataStart, Image.Data);
+
+            MemoryHelper.FillWithZeros(Process.CpuMemory, (long)BssStart, Image.BssSize);
+
+            KernelResult SetProcessMemoryPermission(ulong Address, ulong Size, MemoryPermission Permission)
+            {
+                if (Size == 0)
+                {
+                    return KernelResult.Success;
+                }
+
+                Size = BitUtils.AlignUp(Size, KMemoryManager.PageSize);
+
+                return Process.MemoryManager.SetProcessMemoryPermission(Address, Size, Permission);
+            }
+
+            KernelResult Result = SetProcessMemoryPermission(TextStart, (ulong)Image.Text.Length, MemoryPermission.ReadAndExecute);
+
+            if (Result != KernelResult.Success)
+            {
+                return Result;
+            }
+
+            Result = SetProcessMemoryPermission(ROStart, (ulong)Image.RO.Length, MemoryPermission.Read);
+
+            if (Result != KernelResult.Success)
+            {
+                return Result;
+            }
+
+            return SetProcessMemoryPermission(DataStart, End - DataStart, MemoryPermission.ReadAndWrite);
+        }
+    }
+}

Ryujinx.HLE/HOS/ServiceCtx.cs

@@ -8,7 +8,7 @@ namespace Ryujinx.HLE.HOS
     class ServiceCtx
     {
         public Switch        Device       { get; private set; }
-        public Process       Process      { get; private set; }
+        public KProcess      Process      { get; private set; }
         public MemoryManager Memory       { get; private set; }
         public KSession      Session      { get; private set; }
         public IpcMessage    Request      { get; private set; }
@@ -18,7 +18,7 @@ namespace Ryujinx.HLE.HOS
 
         public ServiceCtx(
             Switch        Device,
-            Process       Process,
+            KProcess      Process,
             MemoryManager Memory,
             KSession      Session,
             IpcMessage    Request,

Ryujinx.HLE/HOS/Services/Am/ICommonStateGetter.cs

@@ -35,7 +35,7 @@ namespace Ryujinx.HLE.HOS.Services.Am
 
         public long GetEventHandle(ServiceCtx Context)
         {
-            KEvent Event = Context.Process.AppletState.MessageEvent;
+            KEvent Event = Context.Device.System.AppletState.MessageEvent;
 
             if (Context.Process.HandleTable.GenerateHandle(Event.ReadableEvent, out int Handle) != KernelResult.Success)
             {
@@ -49,7 +49,7 @@ namespace Ryujinx.HLE.HOS.Services.Am
 
         public long ReceiveMessage(ServiceCtx Context)
         {
-            if (!Context.Process.AppletState.TryDequeueMessage(out MessageInfo Message))
+            if (!Context.Device.System.AppletState.TryDequeueMessage(out MessageInfo Message))
             {
                 return MakeError(ErrorModule.Am, AmErr.NoMessages);
             }
@@ -92,7 +92,7 @@ namespace Ryujinx.HLE.HOS.Services.Am
 
         public long GetCurrentFocusState(ServiceCtx Context)
         {
-            Context.ResponseData.Write((byte)Context.Process.AppletState.FocusState);
+            Context.ResponseData.Write((byte)Context.Device.System.AppletState.FocusState);
 
             return 0;
         }

Ryujinx.HLE/HOS/Services/Ldr/IRoInterface.cs

@@ -1,4 +1,7 @@
-using Ryujinx.HLE.HOS.Ipc;
+using ChocolArm64.Memory;
+using Ryujinx.Common;
+using Ryujinx.HLE.HOS.Ipc;
+using Ryujinx.HLE.HOS.Kernel;
 using Ryujinx.HLE.Loaders.Executables;
 using Ryujinx.HLE.Utilities;
 using System;
@@ -62,17 +65,32 @@ namespace Ryujinx.HLE.HOS.Services.Ldr
 
     class NroInfo
     {
-        public Nro    Executable       { get; private set; }
-        public byte[] Hash             { get; private set; }
-        public long   NroAddress       { get; private set; }
-        public long   TotalSize        { get; private set; }
-        public long   NroMappedAddress { get; set; }
+        public NxRelocatableObject Executable { get; private set; }
 
-        public NroInfo(Nro Executable, byte[] Hash, long TotalSize)
+        public byte[] Hash             { get; private set; }
+        public ulong  NroAddress       { get; private set; }
+        public ulong  NroSize          { get; private set; }
+        public ulong  BssAddress       { get; private set; }
+        public ulong  BssSize          { get; private set; }
+        public ulong  TotalSize        { get; private set; }
+        public ulong  NroMappedAddress { get; set; }
+
+        public NroInfo(
+            NxRelocatableObject Executable,
+            byte[]              Hash,
+            ulong               NroAddress,
+            ulong               NroSize,
+            ulong               BssAddress,
+            ulong               BssSize,
+            ulong               TotalSize)
         {
             this.Executable = Executable;
             this.Hash       = Hash;
-            this.TotalSize = TotalSize;
+            this.NroAddress = NroAddress;
+            this.NroSize    = NroSize;
+            this.BssAddress = BssAddress;
+            this.BssSize    = BssSize;
+            this.TotalSize  = TotalSize;
         }
     }
 
@@ -174,7 +192,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldr
             return false;
         }
 
-        public long ParseNro(out NroInfo Res, ServiceCtx Context, long NroHeapAddress, long NroSize, long BssHeapAddress, long BssSize)
+        public long ParseNro(out NroInfo Res, ServiceCtx Context, ulong NroAddress, ulong NroSize, ulong BssAddress, ulong BssSize)
         {
             Res = null;
 
@@ -182,28 +200,28 @@ namespace Ryujinx.HLE.HOS.Services.Ldr
             {
                 return MakeError(ErrorModule.Loader, LoaderErr.MaxNro);
             }
-            else if (NroSize == 0 || NroHeapAddress + NroSize <= NroHeapAddress || (NroSize & 0xFFF) != 0)
+            else if (NroSize == 0 || NroAddress + NroSize <= NroAddress || (NroSize & 0xFFF) != 0)
             {
                 return MakeError(ErrorModule.Loader, LoaderErr.BadSize);
             }
-            else if (BssSize != 0 && (BssHeapAddress + BssSize) <= BssHeapAddress)
+            else if (BssSize != 0 && BssAddress + BssSize <= BssAddress)
             {
                 return MakeError(ErrorModule.Loader, LoaderErr.BadSize);
             }
-            else if ((NroHeapAddress & 0xFFF) != 0)
+            else if ((NroAddress & 0xFFF) != 0)
             {
                 return MakeError(ErrorModule.Loader, LoaderErr.UnalignedAddress);
             }
 
-            uint Magic       = Context.Memory.ReadUInt32(NroHeapAddress + 0x10);
-            uint NroFileSize = Context.Memory.ReadUInt32(NroHeapAddress + 0x18);
+            uint Magic       = Context.Memory.ReadUInt32((long)NroAddress + 0x10);
+            uint NroFileSize = Context.Memory.ReadUInt32((long)NroAddress + 0x18);
 
             if (Magic != NroMagic || NroSize != NroFileSize)
             {
                 return MakeError(ErrorModule.Loader, LoaderErr.InvalidNro);
             }
 
-            byte[] NroData = Context.Memory.ReadBytes(NroHeapAddress, NroSize);
+            byte[] NroData = Context.Memory.ReadBytes((long)NroAddress, (long)NroSize);
             byte[] NroHash = null;
 
             MemoryStream Stream = new MemoryStream(NroData);
@@ -225,67 +243,106 @@ namespace Ryujinx.HLE.HOS.Services.Ldr
 
             Stream.Position = 0;
 
-            Nro Executable = new Nro(Stream, "memory", NroHeapAddress, BssHeapAddress);
+            NxRelocatableObject Executable = new NxRelocatableObject(Stream, NroAddress, BssAddress);
 
             // check if everything is page align.
-            if ((Executable.Text.Length & 0xFFF) != 0 || (Executable.RO.Length & 0xFFF) != 0
-                || (Executable.Data.Length & 0xFFF) != 0 || (Executable.BssSize & 0xFFF) !=  0)
+            if ((Executable.Text.Length & 0xFFF) != 0 || (Executable.RO.Length & 0xFFF) != 0 ||
+                (Executable.Data.Length & 0xFFF) != 0 || (Executable.BssSize & 0xFFF)   != 0)
             {
                 return MakeError(ErrorModule.Loader, LoaderErr.InvalidNro);
             }
 
             // check if everything is contiguous.
-            if (Executable.ROOffset != Executable.TextOffset + Executable.Text.Length
-                || Executable.DataOffset != Executable.ROOffset + Executable.RO.Length
-                || NroFileSize != Executable.DataOffset + Executable.Data.Length)
+            if (Executable.ROOffset   != Executable.TextOffset + Executable.Text.Length ||
+                Executable.DataOffset != Executable.ROOffset   + Executable.RO.Length   ||
+                NroFileSize           != Executable.DataOffset + Executable.Data.Length)
             {
                 return MakeError(ErrorModule.Loader, LoaderErr.InvalidNro);
             }
 
             // finally check the bss size match.
-            if (Executable.BssSize != BssSize)
+            if ((ulong)Executable.BssSize != BssSize)
             {
                 return MakeError(ErrorModule.Loader, LoaderErr.InvalidNro);
             }
 
-            Res = new NroInfo(Executable, NroHash, Executable.Text.Length + Executable.RO.Length + Executable.Data.Length + Executable.BssSize);
+            int TotalSize = Executable.Text.Length + Executable.RO.Length + Executable.Data.Length + Executable.BssSize;
+
+            Res = new NroInfo(
+                Executable,
+                NroHash,
+                NroAddress,
+                NroSize,
+                BssAddress,
+                BssSize,
+                (ulong)TotalSize);
 
             return 0;
         }
 
-        private long MapNro(ServiceCtx Context, NroInfo Info, out long NroMappedAddress)
+        private long MapNro(ServiceCtx Context, NroInfo Info, out ulong NroMappedAddress)
         {
             NroMappedAddress = 0;
-            long TargetAddress = Context.Process.MemoryManager.AddrSpaceStart;
 
-            long HeapRegionStart = Context.Process.MemoryManager.HeapRegionStart;
-            long HeapRegionEnd   = Context.Process.MemoryManager.HeapRegionEnd;
+            KMemoryManager MemMgr = Context.Process.MemoryManager;
 
-            long MapRegionStart = Context.Process.MemoryManager.MapRegionStart;
-            long MapRegionEnd   = Context.Process.MemoryManager.MapRegionEnd;
+            ulong TargetAddress = MemMgr.GetAddrSpaceBaseAddr();
 
             while (true)
             {
-                if (TargetAddress + Info.TotalSize >= Context.Process.MemoryManager.AddrSpaceEnd)
+                if (TargetAddress + Info.TotalSize >= MemMgr.AddrSpaceEnd)
                 {
                     return MakeError(ErrorModule.Loader, LoaderErr.InvalidMemoryState);
                 }
 
-                bool IsValidAddress = !(HeapRegionStart > 0 && HeapRegionStart <= TargetAddress + Info.TotalSize - 1
-                    && TargetAddress <= HeapRegionEnd - 1)
-                    && !(MapRegionStart > 0
-                    && MapRegionStart <= TargetAddress + Info.TotalSize - 1
-                    && TargetAddress <= MapRegionEnd - 1);
+                KMemoryInfo MemInfo = MemMgr.QueryMemory(TargetAddress);
 
-                if (IsValidAddress && Context.Process.MemoryManager.HleIsUnmapped(TargetAddress, Info.TotalSize))
+                if (MemInfo.State == MemoryState.Unmapped && MemInfo.Size >= Info.TotalSize)
                 {
-                    break;
+                    if (!MemMgr.InsideHeapRegion (TargetAddress, Info.TotalSize) &&
+                        !MemMgr.InsideAliasRegion(TargetAddress, Info.TotalSize))
+                    {
+                        break;
+                    }
                 }
 
-                TargetAddress += 0x1000;
+                TargetAddress += MemInfo.Size;
             }
 
-            Context.Process.LoadProgram(Info.Executable, TargetAddress);
+            KernelResult Result = MemMgr.MapProcessCodeMemory(TargetAddress, Info.NroAddress, Info.NroSize);
+
+            if (Result != KernelResult.Success)
+            {
+                return MakeError(ErrorModule.Loader, LoaderErr.InvalidMemoryState);
+            }
+
+            ulong BssTargetAddress = TargetAddress + Info.NroSize;
+
+            if (Info.BssSize != 0)
+            {
+                Result = MemMgr.MapProcessCodeMemory(BssTargetAddress, Info.BssAddress, Info.BssSize);
+
+                if (Result != KernelResult.Success)
+                {
+                    MemMgr.UnmapProcessCodeMemory(TargetAddress, Info.NroAddress, Info.NroSize);
+
+                    return MakeError(ErrorModule.Loader, LoaderErr.InvalidMemoryState);
+                }
+            }
+
+            Result = LoadNroIntoMemory(Context.Process, Info.Executable, TargetAddress);
+
+            if (Result != KernelResult.Success)
+            {
+                MemMgr.UnmapProcessCodeMemory(TargetAddress, Info.NroAddress, Info.NroSize);
+
+                if (Info.BssSize != 0)
+                {
+                    MemMgr.UnmapProcessCodeMemory(BssTargetAddress, Info.BssAddress, Info.BssSize);
+                }
+
+                return 0;
+            }
 
             Info.NroMappedAddress = TargetAddress;
             NroMappedAddress      = TargetAddress;
@@ -293,6 +350,41 @@ namespace Ryujinx.HLE.HOS.Services.Ldr
             return 0;
         }
 
+        private KernelResult LoadNroIntoMemory(KProcess Process, IExecutable RelocatableObject, ulong BaseAddress)
+        {
+            ulong TextStart = BaseAddress + (ulong)RelocatableObject.TextOffset;
+            ulong ROStart   = BaseAddress + (ulong)RelocatableObject.ROOffset;
+            ulong DataStart = BaseAddress + (ulong)RelocatableObject.DataOffset;
+
+            ulong BssStart = DataStart + (ulong)RelocatableObject.Data.Length;
+
+            ulong BssEnd = BitUtils.AlignUp(BssStart + (ulong)RelocatableObject.BssSize, KMemoryManager.PageSize);
+
+            Process.CpuMemory.WriteBytes((long)TextStart, RelocatableObject.Text);
+            Process.CpuMemory.WriteBytes((long)ROStart,   RelocatableObject.RO);
+            Process.CpuMemory.WriteBytes((long)DataStart, RelocatableObject.Data);
+
+            MemoryHelper.FillWithZeros(Process.CpuMemory, (long)BssStart, (int)(BssEnd - BssStart));
+
+            KernelResult Result;
+
+            Result = Process.MemoryManager.SetProcessMemoryPermission(TextStart, ROStart - TextStart, MemoryPermission.ReadAndExecute);
+
+            if (Result != KernelResult.Success)
+            {
+                return Result;
+            }
+
+            Result = Process.MemoryManager.SetProcessMemoryPermission(ROStart, DataStart - ROStart, MemoryPermission.Read);
+
+            if (Result != KernelResult.Success)
+            {
+                return Result;
+            }
+
+            return Process.MemoryManager.SetProcessMemoryPermission(DataStart, BssEnd - DataStart, MemoryPermission.ReadAndWrite);
+        }
+
         private long RemoveNrrInfo(long NrrAddress)
         {
             foreach (NrrInfo Info in NrrInfos)
@@ -308,24 +400,46 @@ namespace Ryujinx.HLE.HOS.Services.Ldr
             return MakeError(ErrorModule.Loader, LoaderErr.BadNrrAddress);
         }
 
-        private long RemoveNroInfo(ServiceCtx Context, long NroMappedAddress, long NroHeapAddress)
+        private long RemoveNroInfo(ServiceCtx Context, ulong NroMappedAddress)
         {
             foreach (NroInfo Info in NroInfos)
             {
-                if (Info.NroMappedAddress == NroMappedAddress && Info.Executable.SourceAddress == NroHeapAddress)
+                if (Info.NroMappedAddress == NroMappedAddress)
                 {
                     NroInfos.Remove(Info);
 
-                    Context.Process.RemoveProgram(Info.NroMappedAddress);
+                    ulong TextSize = (ulong)Info.Executable.Text.Length;
+                    ulong ROSize   = (ulong)Info.Executable.RO.Length;
+                    ulong DataSize = (ulong)Info.Executable.Data.Length;
+                    ulong BssSize  = (ulong)Info.Executable.BssSize;
 
-                    long Result = Context.Process.MemoryManager.UnmapProcessCodeMemory(Info.NroMappedAddress, Info.Executable.SourceAddress, Info.TotalSize - Info.Executable.BssSize);
+                    KernelResult Result = KernelResult.Success;
 
-                    if (Result == 0 && Info.Executable.BssSize != 0)
+                    if (Info.Executable.BssSize != 0)
                     {
-                        Result = Context.Process.MemoryManager.UnmapProcessCodeMemory(Info.NroMappedAddress + Info.TotalSize - Info.Executable.BssSize, Info.Executable.BssAddress, Info.Executable.BssSize);
+                        Result = Context.Process.MemoryManager.UnmapProcessCodeMemory(
+                            Info.NroMappedAddress + TextSize + ROSize + DataSize,
+                            Info.Executable.BssAddress,
+                            BssSize);
                     }
 
-                    return Result;
+                    if (Result == KernelResult.Success)
+                    {
+                        Result = Context.Process.MemoryManager.UnmapProcessCodeMemory(
+                            Info.NroMappedAddress         + TextSize + ROSize,
+                            Info.Executable.SourceAddress + TextSize + ROSize,
+                            DataSize);
+
+                        if (Result == KernelResult.Success)
+                        {
+                            Result = Context.Process.MemoryManager.UnmapProcessCodeMemory(
+                                Info.NroMappedAddress,
+                                Info.Executable.SourceAddress,
+                                TextSize + ROSize);
+                        }
+                    }
+
+                    return (long)Result;
                 }
             }
 
@@ -340,12 +454,12 @@ namespace Ryujinx.HLE.HOS.Services.Ldr
             // Zero
             Context.RequestData.ReadUInt64();
 
-            long NroHeapAddress = Context.RequestData.ReadInt64();
-            long NroSize        = Context.RequestData.ReadInt64();
-            long BssHeapAddress = Context.RequestData.ReadInt64();
-            long BssSize        = Context.RequestData.ReadInt64();
+            ulong NroHeapAddress = Context.RequestData.ReadUInt64();
+            ulong NroSize        = Context.RequestData.ReadUInt64();
+            ulong BssHeapAddress = Context.RequestData.ReadUInt64();
+            ulong BssSize        = Context.RequestData.ReadUInt64();
 
-            long NroMappedAddress = 0;
+            ulong NroMappedAddress = 0;
 
             if (IsInitialized)
             {
@@ -374,17 +488,19 @@ namespace Ryujinx.HLE.HOS.Services.Ldr
         {
             long Result = MakeError(ErrorModule.Loader, LoaderErr.BadInitialization);
 
-            long NroMappedAddress = Context.RequestData.ReadInt64();
-            long NroHeapAddress   = Context.RequestData.ReadInt64();
+            // Zero
+            Context.RequestData.ReadUInt64();
+
+            ulong NroMappedAddress = Context.RequestData.ReadUInt64();
 
             if (IsInitialized)
             {
-                if ((NroMappedAddress & 0xFFF) != 0 || (NroHeapAddress & 0xFFF) != 0)
+                if ((NroMappedAddress & 0xFFF) != 0)
                 {
                     return MakeError(ErrorModule.Loader, LoaderErr.UnalignedAddress);
                 }
 
-                Result = RemoveNroInfo(Context, NroMappedAddress, NroHeapAddress);
+                Result = RemoveNroInfo(Context, NroMappedAddress);
             }
 
             return Result;

Ryujinx.HLE/HOS/Services/Nv/INvDrvServices.cs

@@ -205,7 +205,7 @@ namespace Ryujinx.HLE.HOS.Services.Nv
             return ((Cmd >> 31) & 1) != 0;
         }
 
-        public static void UnloadProcess(Process Process)
+        public static void UnloadProcess(KProcess Process)
         {
             Fds.DeleteProcess(Process);
 

Ryujinx.HLE/HOS/Services/Nv/NvGpuAS/NvGpuASIoctl.cs

@@ -1,6 +1,7 @@
 using ChocolArm64.Memory;
 using Ryujinx.Common.Logging;
 using Ryujinx.Graphics.Memory;
+using Ryujinx.HLE.HOS.Kernel;
 using Ryujinx.HLE.HOS.Services.Nv.NvMap;
 using System;
 using System.Collections.Concurrent;
@@ -13,11 +14,11 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvGpuAS
 
         private const int FlagRemapSubRange = 0x100;
 
-        private static ConcurrentDictionary<Process, NvGpuASCtx> ASCtxs;
+        private static ConcurrentDictionary<KProcess, NvGpuASCtx> ASCtxs;
 
         static NvGpuASIoctl()
         {
-            ASCtxs = new ConcurrentDictionary<Process, NvGpuASCtx>();
+            ASCtxs = new ConcurrentDictionary<KProcess, NvGpuASCtx>();
         }
 
         public static int ProcessIoctl(ServiceCtx Context, int Cmd)
@@ -321,7 +322,7 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvGpuAS
             return ASCtxs.GetOrAdd(Context.Process, (Key) => new NvGpuASCtx(Context));
         }
 
-        public static void UnloadProcess(Process Process)
+        public static void UnloadProcess(KProcess Process)
         {
             ASCtxs.TryRemove(Process, out _);
         }

Ryujinx.HLE/HOS/Services/Nv/NvHostChannel/NvHostChannelIoctl.cs

@@ -1,6 +1,7 @@
 using ChocolArm64.Memory;
 using Ryujinx.Common.Logging;
 using Ryujinx.Graphics.Memory;
+using Ryujinx.HLE.HOS.Kernel;
 using Ryujinx.HLE.HOS.Services.Nv.NvGpuAS;
 using System;
 using System.Collections.Concurrent;
@@ -21,11 +22,11 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvHostChannel
             }
         }
 
-        private static ConcurrentDictionary<Process, ChannelsPerProcess> Channels;
+        private static ConcurrentDictionary<KProcess, ChannelsPerProcess> Channels;
 
         static NvHostChannelIoctl()
         {
-            Channels = new ConcurrentDictionary<Process, ChannelsPerProcess>();
+            Channels = new ConcurrentDictionary<KProcess, ChannelsPerProcess>();
         }
 
         public static int ProcessIoctlGpu(ServiceCtx Context, int Cmd)
@@ -194,7 +195,7 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvHostChannel
             return Cpp.Channels[Channel];
         }
 
-        public static void UnloadProcess(Process Process)
+        public static void UnloadProcess(KProcess Process)
         {
             Channels.TryRemove(Process, out _);
         }

Ryujinx.HLE/HOS/Services/Nv/NvHostCtrl/NvHostCtrlIoctl.cs

@@ -1,5 +1,6 @@
 using ChocolArm64.Memory;
 using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Kernel;
 using System;
 using System.Collections.Concurrent;
 using System.Text;
@@ -9,13 +10,13 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvHostCtrl
 {
     class NvHostCtrlIoctl
     {
-        private static ConcurrentDictionary<Process, NvHostCtrlUserCtx> UserCtxs;
+        private static ConcurrentDictionary<KProcess, NvHostCtrlUserCtx> UserCtxs;
 
         private static bool IsProductionMode = true;
 
         static NvHostCtrlIoctl()
         {
-            UserCtxs = new ConcurrentDictionary<Process, NvHostCtrlUserCtx>();
+            UserCtxs = new ConcurrentDictionary<KProcess, NvHostCtrlUserCtx>();
 
             if (Set.NxSettings.Settings.TryGetValue("nv!rmos_set_production_mode", out object ProductionModeSetting))
             {
@@ -390,7 +391,7 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvHostCtrl
             return UserCtxs.GetOrAdd(Context.Process, (Key) => new NvHostCtrlUserCtx());
         }
 
-        public static void UnloadProcess(Process Process)
+        public static void UnloadProcess(KProcess Process)
         {
             UserCtxs.TryRemove(Process, out _);
         }

Ryujinx.HLE/HOS/Services/Nv/NvMap/NvMapIoctl.cs

@@ -1,6 +1,7 @@
 using ChocolArm64.Memory;
 using Ryujinx.Common.Logging;
 using Ryujinx.Graphics.Memory;
+using Ryujinx.HLE.HOS.Kernel;
 using Ryujinx.HLE.Utilities;
 using System.Collections.Concurrent;
 
@@ -10,11 +11,11 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvMap
     {
         private const int FlagNotFreedYet = 1;
 
-        private static ConcurrentDictionary<Process, IdDictionary> Maps;
+        private static ConcurrentDictionary<KProcess, IdDictionary> Maps;
 
         static NvMapIoctl()
         {
-            Maps = new ConcurrentDictionary<Process, IdDictionary>();
+            Maps = new ConcurrentDictionary<KProcess, IdDictionary>();
         }
 
         public static int ProcessIoctl(ServiceCtx Context, int Cmd)
@@ -130,10 +131,7 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvMap
                     //When the address is zero, we need to allocate
                     //our own backing memory for the NvMap.
                     //TODO: Is this allocation inside the transfer memory?
-                    if (!Context.Device.Memory.Allocator.TryAllocate((uint)Size, out Address))
-                    {
-                        Result = NvResult.OutOfMemory;
-                    }
+                    Result = NvResult.OutOfMemory;
                 }
 
                 if (Result == NvResult.Success)
@@ -294,7 +292,7 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvMap
             return null;
         }
 
-        public static void UnloadProcess(Process Process)
+        public static void UnloadProcess(KProcess Process)
         {
             Maps.TryRemove(Process, out _);
         }

Ryujinx.HLE/HOS/Services/Vi/NvFlinger.cs

@@ -275,8 +275,7 @@ namespace Ryujinx.HLE.HOS.Services.Android
 
         private long MakeReplyParcel(ServiceCtx Context, byte[] Data)
         {
-            long ReplyPos  = Context.Request.ReceiveBuff[0].Position;
-            long ReplySize = Context.Request.ReceiveBuff[0].Size;
+            (long ReplyPos, long ReplySize) = Context.Request.GetBufferType0x22();
 
             byte[] Reply = MakeParcel(Data, new byte[0]);
 

Ryujinx.HLE/Loaders/Compression/BackwardsLz.cs

@@ -0,0 +1,105 @@
+using System;
+using System.IO;
+
+namespace Ryujinx.HLE.Loaders.Compression
+{
+    static class BackwardsLz
+    {
+        private class BackwardsReader
+        {
+            private Stream BaseStream;
+
+            public BackwardsReader(Stream BaseStream)
+            {
+                this.BaseStream = BaseStream;
+            }
+
+            public byte ReadByte()
+            {
+                BaseStream.Seek(-1, SeekOrigin.Current);
+
+                byte Value = (byte)BaseStream.ReadByte();
+
+                BaseStream.Seek(-1, SeekOrigin.Current);
+
+                return Value;
+            }
+
+            public short ReadInt16()
+            {
+                return (short)((ReadByte() << 8) | (ReadByte() << 0));
+            }
+
+            public int ReadInt32()
+            {
+                return ((ReadByte() << 24) |
+                        (ReadByte() << 16) |
+                        (ReadByte() << 8)  |
+                        (ReadByte() << 0));
+            }
+        }
+
+        public static byte[] Decompress(Stream Input, int DecompressedLength)
+        {
+            long End = Input.Position;
+
+            BackwardsReader Reader = new BackwardsReader(Input);
+
+            int AdditionalDecLength = Reader.ReadInt32();
+            int StartOffset         = Reader.ReadInt32();
+            int CompressedLength    = Reader.ReadInt32();
+
+            Input.Seek(12 - StartOffset, SeekOrigin.Current);
+
+            byte[] Dec = new byte[DecompressedLength];
+
+            int DecompressedLengthUnpadded = CompressedLength + AdditionalDecLength;
+
+            int DecompressionStart = DecompressedLength - DecompressedLengthUnpadded;
+
+            int DecPos = Dec.Length;
+
+            byte Mask   = 0;
+            byte Header = 0;
+
+            while (DecPos > DecompressionStart)
+            {
+                if ((Mask >>= 1) == 0)
+                {
+                    Header = Reader.ReadByte();
+                    Mask   = 0x80;
+                }
+
+                if ((Header & Mask) == 0)
+                {
+                    Dec[--DecPos] = Reader.ReadByte();
+                }
+                else
+                {
+                    ushort Pair = (ushort)Reader.ReadInt16();
+
+                    int Length   = (Pair >> 12)   + 3;
+                    int Position = (Pair & 0xfff) + 3;
+
+                    DecPos -= Length;
+
+                    if (Length <= Position)
+                    {
+                        int SrcPos = DecPos + Position;
+
+                        Buffer.BlockCopy(Dec, SrcPos, Dec, DecPos, Length);
+                    }
+                    else
+                    {
+                        for (int Offset = 0; Offset < Length; Offset++)
+                        {
+                            Dec[DecPos + Offset] = Dec[DecPos + Position + Offset];
+                        }
+                    }
+                }
+            }
+
+            return Dec;
+        }
+    }
+}

Ryujinx.HLE/Loaders/Elf/ElfDynamic.cs

@@ -0,0 +1,15 @@
+namespace Ryujinx.HLE.Loaders.Elf
+{
+    struct ElfDynamic
+    {
+        public ElfDynamicTag Tag { get; private set; }
+
+        public long Value { get; private set; }
+
+        public ElfDynamic(ElfDynamicTag Tag, long Value)
+        {
+            this.Tag   = Tag;
+            this.Value = Value;
+        }
+    }
+}

Ryujinx.HLE/Loaders/Elf/ElfDynamicTag.cs

@@ -1,6 +1,6 @@
-namespace Ryujinx.HLE.Loaders
+namespace Ryujinx.HLE.Loaders.Elf
 {
-    enum ElfDynTag
+    enum ElfDynamicTag
     {
         DT_NULL            = 0,
         DT_NEEDED          = 1,

Ryujinx.HLE/Loaders/Elf/ElfSymbol.cs

@@ -0,0 +1,40 @@
+namespace Ryujinx.HLE.Loaders.Elf
+{
+    struct ElfSymbol
+    {
+        public string Name { get; private set; }
+
+        public ElfSymbolType       Type       { get; private set; }
+        public ElfSymbolBinding    Binding    { get; private set; }
+        public ElfSymbolVisibility Visibility { get; private set; }
+
+        public bool IsFuncOrObject =>
+            Type == ElfSymbolType.STT_FUNC ||
+            Type == ElfSymbolType.STT_OBJECT;
+
+        public bool IsGlobalOrWeak =>
+            Binding == ElfSymbolBinding.STB_GLOBAL ||
+            Binding == ElfSymbolBinding.STB_WEAK;
+
+        public int  SHIdx { get; private set; }
+        public long Value { get; private set; }
+        public long Size  { get; private set; }
+
+        public ElfSymbol(
+            string Name,
+            int    Info,
+            int    Other,
+            int    SHIdx,
+            long   Value,
+            long   Size)
+        {
+            this.Name       = Name;
+            this.Type       = (ElfSymbolType)(Info & 0xf);
+            this.Binding    = (ElfSymbolBinding)(Info >> 4);
+            this.Visibility = (ElfSymbolVisibility)Other;
+            this.SHIdx      = SHIdx;
+            this.Value      = Value;
+            this.Size       = Size;
+        }
+    }
+}

Ryujinx.HLE/Loaders/Elf/ElfSymbolBinding.cs

@@ -1,6 +1,6 @@
-namespace Ryujinx.HLE.Loaders
+namespace Ryujinx.HLE.Loaders.Elf
 {
-    enum ElfSymBinding
+    enum ElfSymbolBinding
     {
         STB_LOCAL  = 0,
         STB_GLOBAL = 1,

Ryujinx.HLE/Loaders/Elf/ElfSymbolType.cs

@@ -1,6 +1,6 @@
-namespace Ryujinx.HLE.Loaders
+namespace Ryujinx.HLE.Loaders.Elf
 {
-    enum ElfSymType
+    enum ElfSymbolType
     {
         STT_NOTYPE  = 0,
         STT_OBJECT  = 1,

Ryujinx.HLE/Loaders/Elf/ElfSymbolVisibility.cs

@@ -1,6 +1,6 @@
-namespace Ryujinx.HLE.Loaders
+namespace Ryujinx.HLE.Loaders.Elf
 {
-    enum ElfSymVisibility
+    enum ElfSymbolVisibility
     {
         STV_DEFAULT   = 0,
         STV_INTERNAL  = 1,

Ryujinx.HLE/Loaders/ElfDyn.cs

@@ -1,15 +0,0 @@
-namespace Ryujinx.HLE.Loaders
-{
-    struct ElfDyn
-    {
-        public ElfDynTag Tag { get; private set; }
-
-        public long Value { get; private set; }
-
-        public ElfDyn(ElfDynTag Tag, long Value)
-        {
-            this.Tag   = Tag;
-            this.Value = Value;
-        }
-    }
-}

Ryujinx.HLE/Loaders/ElfRel.cs

@@ -1,19 +0,0 @@
-namespace Ryujinx.HLE.Loaders
-{
-    struct ElfRel
-    {
-        public long Offset { get; private set; }
-        public long Addend { get; private set; }
-
-        public ElfSym     Symbol { get; private set; }
-        public ElfRelType Type   { get; private set; }
-
-        public ElfRel(long Offset, long Addend, ElfSym Symbol, ElfRelType Type)
-        {
-            this.Offset = Offset;
-            this.Addend = Addend;
-            this.Symbol = Symbol;
-            this.Type   = Type;
-        }
-    }
-}

Ryujinx.HLE/Loaders/ElfRelType.cs

@@ -1,128 +0,0 @@
-namespace Ryujinx.HLE.Loaders
-{
-    enum ElfRelType
-    {
-        R_AARCH64_NONE                         = 0,
-        R_AARCH64_ABS64                        = 257,
-        R_AARCH64_ABS32                        = 258,
-        R_AARCH64_ABS16                        = 259,
-        R_AARCH64_PREL64                       = 260,
-        R_AARCH64_PREL32                       = 261,
-        R_AARCH64_PREL16                       = 262,
-        R_AARCH64_MOVW_UABS_G0                 = 263,
-        R_AARCH64_MOVW_UABS_G0_NC              = 264,
-        R_AARCH64_MOVW_UABS_G1                 = 265,
-        R_AARCH64_MOVW_UABS_G1_NC              = 266,
-        R_AARCH64_MOVW_UABS_G2                 = 267,
-        R_AARCH64_MOVW_UABS_G2_NC              = 268,
-        R_AARCH64_MOVW_UABS_G3                 = 269,
-        R_AARCH64_MOVW_SABS_G0                 = 270,
-        R_AARCH64_MOVW_SABS_G1                 = 271,
-        R_AARCH64_MOVW_SABS_G2                 = 272,
-        R_AARCH64_LD_PREL_LO19                 = 273,
-        R_AARCH64_ADR_PREL_LO21                = 274,
-        R_AARCH64_ADR_PREL_PG_HI21             = 275,
-        R_AARCH64_ADR_PREL_PG_HI21_NC          = 276,
-        R_AARCH64_ADD_ABS_LO12_NC              = 277,
-        R_AARCH64_LDST8_ABS_LO12_NC            = 278,
-        R_AARCH64_TSTBR14                      = 279,
-        R_AARCH64_CONDBR19                     = 280,
-        R_AARCH64_JUMP26                       = 282,
-        R_AARCH64_CALL26                       = 283,
-        R_AARCH64_LDST16_ABS_LO12_NC           = 284,
-        R_AARCH64_LDST32_ABS_LO12_NC           = 285,
-        R_AARCH64_LDST64_ABS_LO12_NC           = 286,
-        R_AARCH64_MOVW_PREL_G0                 = 287,
-        R_AARCH64_MOVW_PREL_G0_NC              = 288,
-        R_AARCH64_MOVW_PREL_G1                 = 289,
-        R_AARCH64_MOVW_PREL_G1_NC              = 290,
-        R_AARCH64_MOVW_PREL_G2                 = 291,
-        R_AARCH64_MOVW_PREL_G2_NC              = 292,
-        R_AARCH64_MOVW_PREL_G3                 = 293,
-        R_AARCH64_LDST128_ABS_LO12_NC          = 299,
-        R_AARCH64_MOVW_GOTOFF_G0               = 300,
-        R_AARCH64_MOVW_GOTOFF_G0_NC            = 301,
-        R_AARCH64_MOVW_GOTOFF_G1               = 302,
-        R_AARCH64_MOVW_GOTOFF_G1_NC            = 303,
-        R_AARCH64_MOVW_GOTOFF_G2               = 304,
-        R_AARCH64_MOVW_GOTOFF_G2_NC            = 305,
-        R_AARCH64_MOVW_GOTOFF_G3               = 306,
-        R_AARCH64_GOTREL64                     = 307,
-        R_AARCH64_GOTREL32                     = 308,
-        R_AARCH64_GOT_LD_PREL19                = 309,
-        R_AARCH64_LD64_GOTOFF_LO15             = 310,
-        R_AARCH64_ADR_GOT_PAGE                 = 311,
-        R_AARCH64_LD64_GOT_LO12_NC             = 312,
-        R_AARCH64_LD64_GOTPAGE_LO15            = 313,
-        R_AARCH64_TLSGD_ADR_PREL21             = 512,
-        R_AARCH64_TLSGD_ADR_PAGE21             = 513,
-        R_AARCH64_TLSGD_ADD_LO12_NC            = 514,
-        R_AARCH64_TLSGD_MOVW_G1                = 515,
-        R_AARCH64_TLSGD_MOVW_G0_NC             = 516,
-        R_AARCH64_TLSLD_ADR_PREL21             = 517,
-        R_AARCH64_TLSLD_ADR_PAGE21             = 518,
-        R_AARCH64_TLSLD_ADD_LO12_NC            = 519,
-        R_AARCH64_TLSLD_MOVW_G1                = 520,
-        R_AARCH64_TLSLD_MOVW_G0_NC             = 521,
-        R_AARCH64_TLSLD_LD_PREL19              = 522,
-        R_AARCH64_TLSLD_MOVW_DTPREL_G2         = 523,
-        R_AARCH64_TLSLD_MOVW_DTPREL_G1         = 524,
-        R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC      = 525,
-        R_AARCH64_TLSLD_MOVW_DTPREL_G0         = 526,
-        R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC      = 527,
-        R_AARCH64_TLSLD_ADD_DTPREL_HI12        = 528,
-        R_AARCH64_TLSLD_ADD_DTPREL_LO12        = 529,
-        R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC     = 530,
-        R_AARCH64_TLSLD_LDST8_DTPREL_LO12      = 531,
-        R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC   = 532,
-        R_AARCH64_TLSLD_LDST16_DTPREL_LO12     = 533,
-        R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC  = 534,
-        R_AARCH64_TLSLD_LDST32_DTPREL_LO12     = 535,
-        R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC  = 536,
-        R_AARCH64_TLSLD_LDST64_DTPREL_LO12     = 537,
-        R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC  = 538,
-        R_AARCH64_TLSIE_MOVW_GOTTPREL_G1       = 539,
-        R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC    = 540,
-        R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21    = 541,
-        R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC  = 542,
-        R_AARCH64_TLSIE_LD_GOTTPREL_PREL19     = 543,
-        R_AARCH64_TLSLE_MOVW_TPREL_G2          = 544,
-        R_AARCH64_TLSLE_MOVW_TPREL_G1          = 545,
-        R_AARCH64_TLSLE_MOVW_TPREL_G1_NC       = 546,
-        R_AARCH64_TLSLE_MOVW_TPREL_G0          = 547,
-        R_AARCH64_TLSLE_MOVW_TPREL_G0_NC       = 548,
-        R_AARCH64_TLSLE_ADD_TPREL_HI12         = 549,
-        R_AARCH64_TLSLE_ADD_TPREL_LO12         = 550,
-        R_AARCH64_TLSLE_ADD_TPREL_LO12_NC      = 551,
-        R_AARCH64_TLSLE_LDST8_TPREL_LO12       = 552,
-        R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC    = 553,
-        R_AARCH64_TLSLE_LDST16_TPREL_LO12      = 554,
-        R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC   = 555,
-        R_AARCH64_TLSLE_LDST32_TPREL_LO12      = 556,
-        R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC   = 557,
-        R_AARCH64_TLSLE_LDST64_TPREL_LO12      = 558,
-        R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC   = 559,
-        R_AARCH64_TLSDESC_LD_PREL19            = 560,
-        R_AARCH64_TLSDESC_ADR_PREL21           = 561,
-        R_AARCH64_TLSDESC_ADR_PAGE21           = 562,
-        R_AARCH64_TLSDESC_LD64_LO12            = 563,
-        R_AARCH64_TLSDESC_ADD_LO12             = 564,
-        R_AARCH64_TLSDESC_OFF_G1               = 565,
-        R_AARCH64_TLSDESC_OFF_G0_NC            = 566,
-        R_AARCH64_TLSDESC_LDR                  = 567,
-        R_AARCH64_TLSDESC_ADD                  = 568,
-        R_AARCH64_TLSDESC_CALL                 = 569,
-        R_AARCH64_TLSLE_LDST128_TPREL_LO12     = 570,
-        R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC  = 571,
-        R_AARCH64_TLSLD_LDST128_DTPREL_LO12    = 572,
-        R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC = 573,
-        R_AARCH64_COPY                         = 1024,
-        R_AARCH64_GLOB_DAT                     = 1025,
-        R_AARCH64_JUMP_SLOT                    = 1026,
-        R_AARCH64_RELATIVE                     = 1027,
-        R_AARCH64_TLS_DTPMOD64                 = 1028,
-        R_AARCH64_TLS_DTPREL64                 = 1029,
-        R_AARCH64_TLS_TPREL64                  = 1030,
-        R_AARCH64_TLSDESC                      = 1031
-    }
-}

Ryujinx.HLE/Loaders/ElfSym.cs

@@ -1,40 +0,0 @@
-namespace Ryujinx.HLE.Loaders
-{
-    struct ElfSym
-    {
-        public string Name { get; private set; }
-
-        public ElfSymType       Type       { get; private set; }
-        public ElfSymBinding    Binding    { get; private set; }
-        public ElfSymVisibility Visibility { get; private set; }
-
-        public bool IsFuncOrObject =>
-            Type == ElfSymType.STT_FUNC ||
-            Type == ElfSymType.STT_OBJECT;
-
-        public bool IsGlobalOrWeak =>
-            Binding == ElfSymBinding.STB_GLOBAL ||
-            Binding == ElfSymBinding.STB_WEAK;
-
-        public int  SHIdx { get; private set; }
-        public long Value { get; private set; }
-        public long Size  { get; private set; }
-
-        public ElfSym(
-            string Name,
-            int    Info,
-            int    Other,
-            int    SHIdx,
-            long   Value,
-            long   Size)
-        {
-            this.Name       = Name;
-            this.Type       = (ElfSymType)(Info & 0xf);
-            this.Binding    = (ElfSymBinding)(Info >> 4);
-            this.Visibility = (ElfSymVisibility)Other;
-            this.SHIdx      = SHIdx;
-            this.Value      = Value;
-            this.Size       = Size;
-        }
-    }
-}

Ryujinx.HLE/Loaders/Executable.cs

@@ -1,205 +0,0 @@
-using ChocolArm64.Memory;
-using Ryujinx.HLE.HOS;
-using Ryujinx.HLE.HOS.Kernel;
-using Ryujinx.HLE.Loaders.Executables;
-using Ryujinx.HLE.Utilities;
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.IO;
-using System.Linq;
-
-namespace Ryujinx.HLE.Loaders
-{
-    class Executable
-    {
-        private MemoryManager Memory;
-
-        private List<ElfDyn> Dynamic;
-
-        public ReadOnlyCollection<ElfSym> SymbolTable;
-
-        public string Name { get; private set; }
-
-        public string FilePath { get; private set; }
-
-        public long ImageBase { get; private set; }
-        public long ImageEnd  { get; private set; }
-
-        private KMemoryManager MemoryManager;
-
-        public Executable(IExecutable Exe, KMemoryManager MemoryManager, MemoryManager Memory, long ImageBase)
-        {
-            Dynamic = new List<ElfDyn>();
-
-            FilePath = Exe.FilePath;
-
-            if (FilePath != null)
-            {
-                Name = Path.GetFileNameWithoutExtension(FilePath.Replace(Homebrew.TemporaryNroSuffix, ""));
-            }
-
-            this.Memory        = Memory;
-            this.MemoryManager = MemoryManager;
-            this.ImageBase     = ImageBase;
-            this.ImageEnd      = ImageBase;
-
-            long TextPosition = ImageBase + (uint)Exe.TextOffset;
-            long ROPosition   = ImageBase + (uint)Exe.ROOffset;
-            long DataPosition = ImageBase + (uint)Exe.DataOffset;
-
-            long TextSize = (uint)IntUtils.AlignUp(Exe.Text.Length, KMemoryManager.PageSize);
-            long ROSize   = (uint)IntUtils.AlignUp(Exe.RO.Length, KMemoryManager.PageSize);
-            long DataSize = (uint)IntUtils.AlignUp(Exe.Data.Length, KMemoryManager.PageSize);
-            long BssSize  = (uint)IntUtils.AlignUp(Exe.BssSize, KMemoryManager.PageSize);
-
-            long DataAndBssSize = BssSize + DataSize;
-
-            ImageEnd = DataPosition + DataAndBssSize;
-
-            if (Exe.SourceAddress == 0)
-            {
-                MemoryManager.HleMapProcessCode(TextPosition, TextSize + ROSize + DataAndBssSize);
-
-                MemoryManager.SetProcessMemoryPermission(ROPosition, ROSize, MemoryPermission.Read);
-                MemoryManager.SetProcessMemoryPermission(DataPosition, DataAndBssSize, MemoryPermission.ReadAndWrite);
-
-                Memory.WriteBytes(TextPosition, Exe.Text);
-                Memory.WriteBytes(ROPosition, Exe.RO);
-                Memory.WriteBytes(DataPosition, Exe.Data);
-            }
-            else
-            {
-                long Result = MemoryManager.MapProcessCodeMemory(TextPosition, Exe.SourceAddress, TextSize + ROSize + DataSize);
-
-                if (Result != 0)
-                {
-                    throw new InvalidOperationException();
-                }
-
-                MemoryManager.SetProcessMemoryPermission(ROPosition, ROSize, MemoryPermission.Read);
-                MemoryManager.SetProcessMemoryPermission(DataPosition, DataSize, MemoryPermission.ReadAndWrite);
-
-                if (Exe.BssAddress != 0 && Exe.BssSize != 0)
-                {
-                    Result = MemoryManager.MapProcessCodeMemory(DataPosition + DataSize, Exe.BssAddress, BssSize);
-
-                    if (Result != 0)
-                    {
-                        throw new InvalidOperationException();
-                    }
-
-                    MemoryManager.SetProcessMemoryPermission(DataPosition + DataSize, BssSize, MemoryPermission.ReadAndWrite);
-                }
-            }
-
-            if (Exe.Mod0Offset == 0)
-            {
-                return;
-            }
-
-            long Mod0Offset = ImageBase + Exe.Mod0Offset;
-
-            int  Mod0Magic        = Memory.ReadInt32(Mod0Offset + 0x0);
-            long DynamicOffset    = Memory.ReadInt32(Mod0Offset + 0x4)  + Mod0Offset;
-            long BssStartOffset   = Memory.ReadInt32(Mod0Offset + 0x8)  + Mod0Offset;
-            long BssEndOffset     = Memory.ReadInt32(Mod0Offset + 0xc)  + Mod0Offset;
-            long EhHdrStartOffset = Memory.ReadInt32(Mod0Offset + 0x10) + Mod0Offset;
-            long EhHdrEndOffset   = Memory.ReadInt32(Mod0Offset + 0x14) + Mod0Offset;
-            long ModObjOffset     = Memory.ReadInt32(Mod0Offset + 0x18) + Mod0Offset;
-
-            while (true)
-            {
-                long TagVal = Memory.ReadInt64(DynamicOffset + 0);
-                long Value  = Memory.ReadInt64(DynamicOffset + 8);
-
-                DynamicOffset += 0x10;
-
-                ElfDynTag Tag = (ElfDynTag)TagVal;
-
-                if (Tag == ElfDynTag.DT_NULL)
-                {
-                    break;
-                }
-
-                Dynamic.Add(new ElfDyn(Tag, Value));
-            }
-
-            long StrTblAddr = ImageBase + GetFirstValue(ElfDynTag.DT_STRTAB);
-            long SymTblAddr = ImageBase + GetFirstValue(ElfDynTag.DT_SYMTAB);
-
-            long SymEntSize = GetFirstValue(ElfDynTag.DT_SYMENT);
-
-            List<ElfSym> Symbols = new List<ElfSym>();
-
-            while ((ulong)SymTblAddr < (ulong)StrTblAddr)
-            {
-                ElfSym Sym = GetSymbol(SymTblAddr, StrTblAddr);
-
-                Symbols.Add(Sym);
-
-                SymTblAddr += SymEntSize;
-            }
-
-            SymbolTable = Array.AsReadOnly(Symbols.OrderBy(x => x.Value).ToArray());
-        }
-
-        private ElfRel GetRelocation(long Position)
-        {
-            long Offset = Memory.ReadInt64(Position + 0);
-            long Info   = Memory.ReadInt64(Position + 8);
-            long Addend = Memory.ReadInt64(Position + 16);
-
-            int RelType = (int)(Info >> 0);
-            int SymIdx  = (int)(Info >> 32);
-
-            ElfSym Symbol = GetSymbol(SymIdx);
-
-            return new ElfRel(Offset, Addend, Symbol, (ElfRelType)RelType);
-        }
-
-        private ElfSym GetSymbol(int Index)
-        {
-            long StrTblAddr = ImageBase + GetFirstValue(ElfDynTag.DT_STRTAB);
-            long SymTblAddr = ImageBase + GetFirstValue(ElfDynTag.DT_SYMTAB);
-
-            long SymEntSize = GetFirstValue(ElfDynTag.DT_SYMENT);
-
-            long Position = SymTblAddr + Index * SymEntSize;
-
-            return GetSymbol(Position, StrTblAddr);
-        }
-
-        private ElfSym GetSymbol(long Position, long StrTblAddr)
-        {
-            int  NameIndex = Memory.ReadInt32(Position + 0);
-            int  Info      = Memory.ReadByte(Position + 4);
-            int  Other     = Memory.ReadByte(Position + 5);
-            int  SHIdx     = Memory.ReadInt16(Position + 6);
-            long Value     = Memory.ReadInt64(Position + 8);
-            long Size      = Memory.ReadInt64(Position + 16);
-
-            string Name = string.Empty;
-
-            for (int Chr; (Chr = Memory.ReadByte(StrTblAddr + NameIndex++)) != 0;)
-            {
-                Name += (char)Chr;
-            }
-
-            return new ElfSym(Name, Info, Other, SHIdx, Value, Size);
-        }
-
-        private long GetFirstValue(ElfDynTag Tag)
-        {
-            foreach (ElfDyn Entry in Dynamic)
-            {
-                if (Entry.Tag == Tag)
-                {
-                    return Entry.Value;
-                }
-            }
-
-            return 0;
-        }
-    }
-}

Ryujinx.HLE/Loaders/Executables/IExecutable.cs

@@ -1,20 +1,15 @@
 namespace Ryujinx.HLE.Loaders.Executables
 {
-    public interface IExecutable
+    interface IExecutable
     {
-        string FilePath { get; }
-
         byte[] Text { get; }
         byte[] RO   { get; }
         byte[] Data { get; }
 
-        long SourceAddress { get; }
-        long BssAddress    { get; }
-
-        int Mod0Offset { get; }
         int TextOffset { get; }
         int ROOffset   { get; }
         int DataOffset { get; }
+        int BssOffset  { get; }
         int BssSize    { get; }
     }
 }