Code style fixes and nits on the HLE project (#355)

* Some style fixes and nits on ITimeZoneService

* Remove some unneeded usings

* Remove the Ryujinx.HLE.OsHle.Handles namespace

* Remove hbmenu automatic load on process exit

* Rename Ns to Device, rename Os to System, rename SystemState to State

* Move Exceptions and Utilities out of OsHle

* Rename OsHle to HOS

* Rename OsHle folder to HOS

* IManagerDisplayService and ISystemDisplayService style fixes

* BsdError shouldn't be public

* Add a empty new line before using static

* Remove unused file

* Some style fixes on NPDM

* Exit gracefully when the application is closed

* Code style fixes on IGeneralService

* Add 0x prefix on values printed as hex

* Small improvements on finalization code

* Move ProcessId and ThreadId out of AThreadState

* Rename VFs to FileSystem

* FsAccessHeader shouldn't be public. Also fix file names casing

* More case changes on NPDM

* Remove unused files

* Move using to the correct place on NPDM

* Use properties on KernelAccessControlMmio

* Address PR feedback

1 files changed, 111 insertions, 0 deletions

diff --git a/Ryujinx.HLE/HOS/Kernel/AddressArbiter.cs b/Ryujinx.HLE/HOS/Kernel/AddressArbiter.cs
new file mode 100644
index 00000000..d7df0a72
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Kernel/AddressArbiter.cs
@@ -0,0 +1,111 @@
+using ChocolArm64.Memory;
+using ChocolArm64.State;
+
+using static Ryujinx.HLE.HOS.ErrorCode;
+
+namespace Ryujinx.HLE.HOS.Kernel
+{
+    static class AddressArbiter
+    {
+        static ulong WaitForAddress(Process Process, AThreadState ThreadState, long Address, ulong Timeout)
+        {
+            KThread CurrentThread = Process.GetThread(ThreadState.Tpidr);
+
+            Process.Scheduler.SetReschedule(CurrentThread.ProcessorId);
+
+            CurrentThread.ArbiterWaitAddress = Address;
+            CurrentThread.ArbiterSignaled    = false;
+
+            Process.Scheduler.EnterWait(CurrentThread, NsTimeConverter.GetTimeMs(Timeout));
+
+            if (!CurrentThread.ArbiterSignaled)
+            {
+                return MakeError(ErrorModule.Kernel, KernelErr.Timeout);
+            }
+
+            return 0;
+        }
+
+        public static ulong WaitForAddressIfLessThan(Process      Process,
+                                                     AThreadState ThreadState,
+                                                     AMemory      Memory,
+                                                     long         Address,
+                                                     int          Value,
+                                                     ulong        Timeout,
+                                                     bool         ShouldDecrement)
+        {
+            Memory.SetExclusive(ThreadState, Address);
+
+            int CurrentValue = Memory.ReadInt32(Address);
+
+            while (true)
+            {
+                if (Memory.TestExclusive(ThreadState, Address))
+                {
+                    if (CurrentValue < Value)
+                    {
+                        if (ShouldDecrement)
+                        {
+                            Memory.WriteInt32(Address, CurrentValue - 1);
+                        }
+
+                        Memory.ClearExclusiveForStore(ThreadState);
+                    }
+                    else
+                    {
+                        Memory.ClearExclusiveForStore(ThreadState);
+
+                        return MakeError(ErrorModule.Kernel, KernelErr.InvalidState);
+                    }
+
+                    break;
+                }
+
+                Memory.SetExclusive(ThreadState, Address);
+
+                CurrentValue = Memory.ReadInt32(Address);
+            }
+
+            if (Timeout == 0)
+            {
+                return MakeError(ErrorModule.Kernel, KernelErr.Timeout);
+            }
+
+            return WaitForAddress(Process, ThreadState, Address, Timeout);
+        }
+
+        public static ulong WaitForAddressIfEqual(Process      Process,
+                                                  AThreadState ThreadState,
+                                                  AMemory      Memory,
+                                                  long         Address,
+                                                  int          Value,
+                                                  ulong        Timeout)
+        {
+            if (Memory.ReadInt32(Address) != Value)
+            {
+                return MakeError(ErrorModule.Kernel, KernelErr.InvalidState);
+            }
+
+            if (Timeout == 0)
+            {
+                return MakeError(ErrorModule.Kernel, KernelErr.Timeout);
+            }
+
+            return WaitForAddress(Process, ThreadState, Address, Timeout);
+        }
+    }
+
+    enum ArbitrationType : int
+    {
+        WaitIfLessThan,
+        DecrementAndWaitIfLessThan,
+        WaitIfEqual
+    }
+
+    enum SignalType : int
+    {
+        Signal,
+        IncrementAndSignalIfEqual,
+        ModifyByWaitingCountAndSignalIfEqual
+    }
+}