diff options
| author | gdkchan <gab.dark.100@gmail.com> | 2018-12-04 22:52:39 -0200 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2018-12-04 22:52:39 -0200 |
| commit | 3615a70cae3f89197fe185dfc5d0a47fa42151d9 (patch) | |
| tree | 8e4737422fba15199c1a6ce7c6345996c0e907b5 /Ryujinx.HLE/HOS/Kernel | |
| parent | 85dbb9559ad317a657dafd24da27fec4b3f5250f (diff) | |
Revert "Adjust naming conventions and general refactoring in HLE Project (#490)" (#526)
This reverts commit 85dbb9559ad317a657dafd24da27fec4b3f5250f.
Diffstat (limited to 'Ryujinx.HLE/HOS/Kernel')
51 files changed, 4029 insertions, 4029 deletions
diff --git a/Ryujinx.HLE/HOS/Kernel/HleCoreManager.cs b/Ryujinx.HLE/HOS/Kernel/HleCoreManager.cs index cfcda87b..6a424cf2 100644 --- a/Ryujinx.HLE/HOS/Kernel/HleCoreManager.cs +++ b/Ryujinx.HLE/HOS/Kernel/HleCoreManager.cs @@ -7,7 +7,7 @@ namespace Ryujinx.HLE.HOS.Kernel { private class PausableThread { - public ManualResetEvent Event { get; } + public ManualResetEvent Event { get; private set; } public bool IsExiting { get; set; } @@ -17,49 +17,49 @@ namespace Ryujinx.HLE.HOS.Kernel } } - private ConcurrentDictionary<Thread, PausableThread> _threads; + private ConcurrentDictionary<Thread, PausableThread> Threads; public HleCoreManager() { - _threads = new ConcurrentDictionary<Thread, PausableThread>(); + Threads = new ConcurrentDictionary<Thread, PausableThread>(); } - public void Set(Thread thread) + public void Set(Thread Thread) { - GetThread(thread).Event.Set(); + GetThread(Thread).Event.Set(); } - public void Reset(Thread thread) + public void Reset(Thread Thread) { - GetThread(thread).Event.Reset(); + GetThread(Thread).Event.Reset(); } - public void Wait(Thread thread) + public void Wait(Thread Thread) { - PausableThread pausableThread = GetThread(thread); + PausableThread PausableThread = GetThread(Thread); - if (!pausableThread.IsExiting) + if (!PausableThread.IsExiting) { - pausableThread.Event.WaitOne(); + PausableThread.Event.WaitOne(); } } - public void Exit(Thread thread) + public void Exit(Thread Thread) { - GetThread(thread).IsExiting = true; + GetThread(Thread).IsExiting = true; } - private PausableThread GetThread(Thread thread) + private PausableThread GetThread(Thread Thread) { - return _threads.GetOrAdd(thread, (key) => new PausableThread()); + return Threads.GetOrAdd(Thread, (Key) => new PausableThread()); } - public void RemoveThread(Thread thread) + public void RemoveThread(Thread Thread) { - if (_threads.TryRemove(thread, out PausableThread pausableThread)) + if (Threads.TryRemove(Thread, out PausableThread PausableThread)) { - pausableThread.Event.Set(); - pausableThread.Event.Dispose(); + PausableThread.Event.Set(); + PausableThread.Event.Dispose(); } } } diff --git a/Ryujinx.HLE/HOS/Kernel/HleProcessDebugger.cs b/Ryujinx.HLE/HOS/Kernel/HleProcessDebugger.cs index 9ef4ca8f..a6053b1b 100644 --- a/Ryujinx.HLE/HOS/Kernel/HleProcessDebugger.cs +++ b/Ryujinx.HLE/HOS/Kernel/HleProcessDebugger.cs @@ -14,138 +14,138 @@ namespace Ryujinx.HLE.HOS.Kernel { private const int Mod0 = 'M' << 0 | 'O' << 8 | 'D' << 16 | '0' << 24; - private KProcess _owner; + private KProcess Owner; private class Image { - public long BaseAddress { get; } + public long BaseAddress { get; private set; } - public ElfSymbol[] Symbols { get; } + public ElfSymbol[] Symbols { get; private set; } - public Image(long baseAddress, ElfSymbol[] symbols) + public Image(long BaseAddress, ElfSymbol[] Symbols) { - BaseAddress = baseAddress; - Symbols = symbols; + this.BaseAddress = BaseAddress; + this.Symbols = Symbols; } } - private List<Image> _images; + private List<Image> Images; - private int _loaded; + private int Loaded; - public HleProcessDebugger(KProcess owner) + public HleProcessDebugger(KProcess Owner) { - _owner = owner; + this.Owner = Owner; - _images = new List<Image>(); + Images = new List<Image>(); } - public void PrintGuestStackTrace(CpuThreadState threadState) + public void PrintGuestStackTrace(CpuThreadState ThreadState) { EnsureLoaded(); - StringBuilder trace = new StringBuilder(); + StringBuilder Trace = new StringBuilder(); - trace.AppendLine("Guest stack trace:"); + Trace.AppendLine("Guest stack trace:"); - void AppendTrace(long address) + void AppendTrace(long Address) { - Image image = GetImage(address, out int imageIndex); + Image Image = GetImage(Address, out int ImageIndex); - if (image == null || !TryGetSubName(image, address, out string subName)) + if (Image == null || !TryGetSubName(Image, Address, out string SubName)) { - subName = $"Sub{address:x16}"; + SubName = $"Sub{Address:x16}"; } - else if (subName.StartsWith("_Z")) + else if (SubName.StartsWith("_Z")) { - subName = Demangler.Parse(subName); + SubName = Demangler.Parse(SubName); } - if (image != null) + if (Image != null) { - long offset = address - image.BaseAddress; + long Offset = Address - Image.BaseAddress; - string imageName = GetGuessedNsoNameFromIndex(imageIndex); + string ImageName = GetGuessedNsoNameFromIndex(ImageIndex); - string imageNameAndOffset = $"[{_owner.Name}] {imageName}:0x{offset:x8}"; + string ImageNameAndOffset = $"[{Owner.Name}] {ImageName}:0x{Offset:x8}"; - trace.AppendLine($" {imageNameAndOffset} {subName}"); + Trace.AppendLine($" {ImageNameAndOffset} {SubName}"); } else { - trace.AppendLine($" [{_owner.Name}] ??? {subName}"); + Trace.AppendLine($" [{Owner.Name}] ??? {SubName}"); } } - long framePointer = (long)threadState.X29; + long FramePointer = (long)ThreadState.X29; - while (framePointer != 0) + while (FramePointer != 0) { - if ((framePointer & 7) != 0 || - !_owner.CpuMemory.IsMapped(framePointer) || - !_owner.CpuMemory.IsMapped(framePointer + 8)) + 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); + AppendTrace(Owner.CpuMemory.ReadInt64(FramePointer + 8) - 4); - framePointer = _owner.CpuMemory.ReadInt64(framePointer); + FramePointer = Owner.CpuMemory.ReadInt64(FramePointer); } - Logger.PrintInfo(LogClass.Cpu, trace.ToString()); + Logger.PrintInfo(LogClass.Cpu, Trace.ToString()); } - private bool TryGetSubName(Image image, long address, out string name) + private bool TryGetSubName(Image Image, long Address, out string Name) { - address -= image.BaseAddress; + Address -= Image.BaseAddress; - int left = 0; - int right = image.Symbols.Length - 1; + int Left = 0; + int Right = Image.Symbols.Length - 1; - while (left <= right) + while (Left <= Right) { - int size = right - left; + int Size = Right - Left; - int middle = left + (size >> 1); + int Middle = Left + (Size >> 1); - ElfSymbol symbol = image.Symbols[middle]; + ElfSymbol Symbol = Image.Symbols[Middle]; - long endAddr = symbol.Value + symbol.Size; + long EndAddr = Symbol.Value + Symbol.Size; - if ((ulong)address >= (ulong)symbol.Value && (ulong)address < (ulong)endAddr) + if ((ulong)Address >= (ulong)Symbol.Value && (ulong)Address < (ulong)EndAddr) { - name = symbol.Name; + Name = Symbol.Name; return true; } - if ((ulong)address < (ulong)symbol.Value) + if ((ulong)Address < (ulong)Symbol.Value) { - right = middle - 1; + Right = Middle - 1; } else { - left = middle + 1; + Left = Middle + 1; } } - name = null; + Name = null; return false; } - private Image GetImage(long address, out int index) + private Image GetImage(long Address, out int Index) { - lock (_images) + lock (Images) { - for (index = _images.Count - 1; index >= 0; index--) + for (Index = Images.Count - 1; Index >= 0; Index--) { - if ((ulong)address >= (ulong)_images[index].BaseAddress) + if ((ulong)Address >= (ulong)Images[Index].BaseAddress) { - return _images[index]; + return Images[Index]; } } } @@ -153,42 +153,42 @@ namespace Ryujinx.HLE.HOS.Kernel return null; } - private string GetGuessedNsoNameFromIndex(int index) + private string GetGuessedNsoNameFromIndex(int Index) { - if ((uint)index > 11) + if ((uint)Index > 11) { return "???"; } - if (index == 0) + if (Index == 0) { return "rtld"; } - else if (index == 1) + else if (Index == 1) { return "main"; } - else if (index == GetImagesCount() - 1) + else if (Index == GetImagesCount() - 1) { return "sdk"; } else { - return "subsdk" + (index - 2); + return "subsdk" + (Index - 2); } } private int GetImagesCount() { - lock (_images) + lock (Images) { - return _images.Count; + return Images.Count; } } private void EnsureLoaded() { - if (Interlocked.CompareExchange(ref _loaded, 1, 0) == 0) + if (Interlocked.CompareExchange(ref Loaded, 1, 0) == 0) { ScanMemoryForTextSegments(); } @@ -196,115 +196,115 @@ namespace Ryujinx.HLE.HOS.Kernel private void ScanMemoryForTextSegments() { - ulong oldAddress = 0; - ulong address = 0; + ulong OldAddress = 0; + ulong Address = 0; - while (address >= oldAddress) + while (Address >= OldAddress) { - KMemoryInfo info = _owner.MemoryManager.QueryMemory(address); + KMemoryInfo Info = Owner.MemoryManager.QueryMemory(Address); - if (info.State == MemoryState.Reserved) + if (Info.State == MemoryState.Reserved) { break; } - if (info.State == MemoryState.CodeStatic && info.Permission == MemoryPermission.ReadAndExecute) + if (Info.State == MemoryState.CodeStatic && Info.Permission == MemoryPermission.ReadAndExecute) { - LoadMod0Symbols(_owner.CpuMemory, (long)info.Address); + LoadMod0Symbols(Owner.CpuMemory, (long)Info.Address); } - oldAddress = address; + OldAddress = Address; - address = info.Address + info.Size; + Address = Info.Address + Info.Size; } } - private void LoadMod0Symbols(MemoryManager memory, long textOffset) + private void LoadMod0Symbols(MemoryManager Memory, long TextOffset) { - long mod0Offset = textOffset + memory.ReadUInt32(textOffset + 4); + long Mod0Offset = TextOffset + Memory.ReadUInt32(TextOffset + 4); - if (mod0Offset < textOffset || !memory.IsMapped(mod0Offset) || (mod0Offset & 3) != 0) + if (Mod0Offset < TextOffset || !Memory.IsMapped(Mod0Offset) || (Mod0Offset & 3) != 0) { return; } - Dictionary<ElfDynamicTag, long> dynamic = new Dictionary<ElfDynamicTag, long>(); + Dictionary<ElfDynamicTag, long> Dynamic = new Dictionary<ElfDynamicTag, long>(); - int mod0Magic = memory.ReadInt32(mod0Offset + 0x0); + int Mod0Magic = Memory.ReadInt32(Mod0Offset + 0x0); - if (mod0Magic != Mod0) + 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; + 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); + long TagVal = Memory.ReadInt64(DynamicOffset + 0); + long Value = Memory.ReadInt64(DynamicOffset + 8); - dynamicOffset += 0x10; + DynamicOffset += 0x10; - ElfDynamicTag tag = (ElfDynamicTag)tagVal; + ElfDynamicTag Tag = (ElfDynamicTag)TagVal; - if (tag == ElfDynamicTag.DT_NULL) + if (Tag == ElfDynamicTag.DT_NULL) { break; } - dynamic[tag] = value; + 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)) + 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; + long StrTblAddr = TextOffset + StrTab; + long SymTblAddr = TextOffset + SymTab; - List<ElfSymbol> symbols = new List<ElfSymbol>(); + List<ElfSymbol> Symbols = new List<ElfSymbol>(); - while ((ulong)symTblAddr < (ulong)strTblAddr) + while ((ulong)SymTblAddr < (ulong)StrTblAddr) { - ElfSymbol sym = GetSymbol(memory, symTblAddr, strTblAddr); + ElfSymbol Sym = GetSymbol(Memory, SymTblAddr, StrTblAddr); - symbols.Add(sym); + Symbols.Add(Sym); - symTblAddr += symEntSize; + SymTblAddr += SymEntSize; } - lock (_images) + lock (Images) { - _images.Add(new Image(textOffset, symbols.OrderBy(x => x.Value).ToArray())); + Images.Add(new Image(TextOffset, Symbols.OrderBy(x => x.Value).ToArray())); } } - private ElfSymbol GetSymbol(MemoryManager memory, long address, long strTblAddr) + 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); + 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; + string Name = string.Empty; - for (int chr; (chr = memory.ReadByte(strTblAddr + nameIndex++)) != 0;) + for (int Chr; (Chr = Memory.ReadByte(StrTblAddr + NameIndex++)) != 0;) { - name += (char)chr; + Name += (char)Chr; } - return new ElfSymbol(name, info, other, shIdx, value, size); + return new ElfSymbol(Name, Info, Other, SHIdx, Value, Size); } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/HleScheduler.cs b/Ryujinx.HLE/HOS/Kernel/HleScheduler.cs index 4afc48ba..87dbe553 100644 --- a/Ryujinx.HLE/HOS/Kernel/HleScheduler.cs +++ b/Ryujinx.HLE/HOS/Kernel/HleScheduler.cs @@ -7,21 +7,21 @@ namespace Ryujinx.HLE.HOS.Kernel { private const int RoundRobinTimeQuantumMs = 10; - private int _currentCore; + private int CurrentCore; public bool MultiCoreScheduling { get; set; } - public HleCoreManager CoreManager { get; } + public HleCoreManager CoreManager { get; private set; } - private bool _keepPreempting; + private bool KeepPreempting; public void StartAutoPreemptionThread() { - Thread preemptionThread = new Thread(PreemptCurrentThread); + Thread PreemptionThread = new Thread(PreemptCurrentThread); - _keepPreempting = true; + KeepPreempting = true; - preemptionThread.Start(); + PreemptionThread.Start(); } public void ContextSwitch() @@ -30,28 +30,28 @@ namespace Ryujinx.HLE.HOS.Kernel { if (MultiCoreScheduling) { - int selectedCount = 0; + int SelectedCount = 0; - for (int core = 0; core < CpuCoresCount; core++) + for (int Core = 0; Core < KScheduler.CpuCoresCount; Core++) { - KCoreContext coreContext = CoreContexts[core]; + KCoreContext CoreContext = CoreContexts[Core]; - if (coreContext.ContextSwitchNeeded && (coreContext.CurrentThread?.Context.IsCurrentThread() ?? false)) + if (CoreContext.ContextSwitchNeeded && (CoreContext.CurrentThread?.Context.IsCurrentThread() ?? false)) { - coreContext.ContextSwitch(); + CoreContext.ContextSwitch(); } - if (coreContext.CurrentThread?.Context.IsCurrentThread() ?? false) + if (CoreContext.CurrentThread?.Context.IsCurrentThread() ?? false) { - selectedCount++; + SelectedCount++; } } - if (selectedCount == 0) + if (SelectedCount == 0) { CoreManager.Reset(Thread.CurrentThread); } - else if (selectedCount == 1) + else if (SelectedCount == 1) { CoreManager.Set(Thread.CurrentThread); } @@ -62,41 +62,41 @@ namespace Ryujinx.HLE.HOS.Kernel } else { - KThread currentThread = CoreContexts[_currentCore].CurrentThread; + KThread CurrentThread = CoreContexts[CurrentCore].CurrentThread; - bool hasThreadExecuting = currentThread != null; + bool HasThreadExecuting = CurrentThread != null; - if (hasThreadExecuting) + if (HasThreadExecuting) { //If this is not the thread that is currently executing, we need //to request an interrupt to allow safely starting another thread. - if (!currentThread.Context.IsCurrentThread()) + if (!CurrentThread.Context.IsCurrentThread()) { - currentThread.Context.RequestInterrupt(); + CurrentThread.Context.RequestInterrupt(); return; } - CoreManager.Reset(currentThread.Context.Work); + CoreManager.Reset(CurrentThread.Context.Work); } //Advance current core and try picking a thread, //keep advancing if it is null. - for (int core = 0; core < 4; core++) + for (int Core = 0; Core < 4; Core++) { - _currentCore = (_currentCore + 1) % CpuCoresCount; + CurrentCore = (CurrentCore + 1) % CpuCoresCount; - KCoreContext coreContext = CoreContexts[_currentCore]; + KCoreContext CoreContext = CoreContexts[CurrentCore]; - coreContext.UpdateCurrentThread(); + CoreContext.UpdateCurrentThread(); - if (coreContext.CurrentThread != null) + if (CoreContext.CurrentThread != null) { - coreContext.CurrentThread.ClearExclusive(); + CoreContext.CurrentThread.ClearExclusive(); - CoreManager.Set(coreContext.CurrentThread.Context.Work); + CoreManager.Set(CoreContext.CurrentThread.Context.Work); - coreContext.CurrentThread.Context.Execute(); + CoreContext.CurrentThread.Context.Execute(); break; } @@ -104,7 +104,7 @@ namespace Ryujinx.HLE.HOS.Kernel //If nothing was running before, then we are on a "external" //HLE thread, we don't need to wait. - if (!hasThreadExecuting) + if (!HasThreadExecuting) { return; } @@ -119,13 +119,13 @@ namespace Ryujinx.HLE.HOS.Kernel //Preempts current thread every 10 milliseconds on a round-robin fashion, //when multi core scheduling is disabled, to try ensuring that all threads //gets a chance to run. - while (_keepPreempting) + while (KeepPreempting) { lock (CoreContexts) { - KThread currentThread = CoreContexts[_currentCore].CurrentThread; + KThread CurrentThread = CoreContexts[CurrentCore].CurrentThread; - currentThread?.Context.RequestInterrupt(); + CurrentThread?.Context.RequestInterrupt(); } PreemptThreads(); @@ -134,16 +134,16 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public void ExitThread(KThread thread) + public void ExitThread(KThread Thread) { - thread.Context.StopExecution(); + Thread.Context.StopExecution(); - CoreManager.Exit(thread.Context.Work); + CoreManager.Exit(Thread.Context.Work); } - public void RemoveThread(KThread thread) + public void RemoveThread(KThread Thread) { - CoreManager.RemoveThread(thread.Context.Work); + CoreManager.RemoveThread(Thread.Context.Work); } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KAddressArbiter.cs b/Ryujinx.HLE/HOS/Kernel/KAddressArbiter.cs index b4352485..cc637be0 100644 --- a/Ryujinx.HLE/HOS/Kernel/KAddressArbiter.cs +++ b/Ryujinx.HLE/HOS/Kernel/KAddressArbiter.cs @@ -9,641 +9,641 @@ namespace Ryujinx.HLE.HOS.Kernel { private const int HasListenersMask = 0x40000000; - private Horizon _system; + private Horizon System; public List<KThread> CondVarThreads; public List<KThread> ArbiterThreads; - public KAddressArbiter(Horizon system) + public KAddressArbiter(Horizon System) { - _system = system; + this.System = System; CondVarThreads = new List<KThread>(); ArbiterThreads = new List<KThread>(); } - public long ArbitrateLock(int ownerHandle, long mutexAddress, int requesterHandle) + public long ArbitrateLock(int OwnerHandle, long MutexAddress, int RequesterHandle) { - KThread currentThread = _system.Scheduler.GetCurrentThread(); + KThread CurrentThread = System.Scheduler.GetCurrentThread(); - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - currentThread.SignaledObj = null; - currentThread.ObjSyncResult = 0; + CurrentThread.SignaledObj = null; + CurrentThread.ObjSyncResult = 0; - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - if (!KernelTransfer.UserToKernelInt32(_system, mutexAddress, out int mutexValue)) + if (!KernelTransfer.UserToKernelInt32(System, MutexAddress, out int MutexValue)) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - return MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + return MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm);; } - if (mutexValue != (ownerHandle | HasListenersMask)) + if (MutexValue != (OwnerHandle | HasListenersMask)) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return 0; } - KThread mutexOwner = currentProcess.HandleTable.GetObject<KThread>(ownerHandle); + KThread MutexOwner = CurrentProcess.HandleTable.GetObject<KThread>(OwnerHandle); - if (mutexOwner == null) + if (MutexOwner == null) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); } - currentThread.MutexAddress = mutexAddress; - currentThread.ThreadHandleForUserMutex = requesterHandle; + CurrentThread.MutexAddress = MutexAddress; + CurrentThread.ThreadHandleForUserMutex = RequesterHandle; - mutexOwner.AddMutexWaiter(currentThread); + MutexOwner.AddMutexWaiter(CurrentThread); - currentThread.Reschedule(ThreadSchedState.Paused); + CurrentThread.Reschedule(ThreadSchedState.Paused); - _system.CriticalSection.Leave(); - _system.CriticalSection.Enter(); + System.CriticalSection.Leave(); + System.CriticalSection.Enter(); - if (currentThread.MutexOwner != null) + if (CurrentThread.MutexOwner != null) { - currentThread.MutexOwner.RemoveMutexWaiter(currentThread); + CurrentThread.MutexOwner.RemoveMutexWaiter(CurrentThread); } - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - return (uint)currentThread.ObjSyncResult; + return (uint)CurrentThread.ObjSyncResult; } - public long ArbitrateUnlock(long mutexAddress) + public long ArbitrateUnlock(long MutexAddress) { - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - KThread currentThread = _system.Scheduler.GetCurrentThread(); + KThread CurrentThread = System.Scheduler.GetCurrentThread(); - (long result, KThread newOwnerThread) = MutexUnlock(currentThread, mutexAddress); + (long Result, KThread NewOwnerThread) = MutexUnlock(CurrentThread, MutexAddress); - if (result != 0 && newOwnerThread != null) + if (Result != 0 && NewOwnerThread != null) { - newOwnerThread.SignaledObj = null; - newOwnerThread.ObjSyncResult = (int)result; + NewOwnerThread.SignaledObj = null; + NewOwnerThread.ObjSyncResult = (int)Result; } - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - return result; + return Result; } public long WaitProcessWideKeyAtomic( - long mutexAddress, - long condVarAddress, - int threadHandle, - long timeout) + long MutexAddress, + long CondVarAddress, + int ThreadHandle, + long Timeout) { - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - KThread currentThread = _system.Scheduler.GetCurrentThread(); + KThread CurrentThread = System.Scheduler.GetCurrentThread(); - currentThread.SignaledObj = null; - currentThread.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.Timeout); + CurrentThread.SignaledObj = null; + CurrentThread.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.Timeout); - if (currentThread.ShallBeTerminated || - currentThread.SchedFlags == ThreadSchedState.TerminationPending) + if (CurrentThread.ShallBeTerminated || + CurrentThread.SchedFlags == ThreadSchedState.TerminationPending) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return MakeError(ErrorModule.Kernel, KernelErr.ThreadTerminating); } - (long result, _) = MutexUnlock(currentThread, mutexAddress); + (long Result, _) = MutexUnlock(CurrentThread, MutexAddress); - if (result != 0) + if (Result != 0) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - return result; + return Result; } - currentThread.MutexAddress = mutexAddress; - currentThread.ThreadHandleForUserMutex = threadHandle; - currentThread.CondVarAddress = condVarAddress; + CurrentThread.MutexAddress = MutexAddress; + CurrentThread.ThreadHandleForUserMutex = ThreadHandle; + CurrentThread.CondVarAddress = CondVarAddress; - CondVarThreads.Add(currentThread); + CondVarThreads.Add(CurrentThread); - if (timeout != 0) + if (Timeout != 0) { - currentThread.Reschedule(ThreadSchedState.Paused); + CurrentThread.Reschedule(ThreadSchedState.Paused); - if (timeout > 0) + if (Timeout > 0) { - _system.TimeManager.ScheduleFutureInvocation(currentThread, timeout); + System.TimeManager.ScheduleFutureInvocation(CurrentThread, Timeout); } } - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - if (timeout > 0) + if (Timeout > 0) { - _system.TimeManager.UnscheduleFutureInvocation(currentThread); + System.TimeManager.UnscheduleFutureInvocation(CurrentThread); } - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - if (currentThread.MutexOwner != null) + if (CurrentThread.MutexOwner != null) { - currentThread.MutexOwner.RemoveMutexWaiter(currentThread); + CurrentThread.MutexOwner.RemoveMutexWaiter(CurrentThread); } - CondVarThreads.Remove(currentThread); + CondVarThreads.Remove(CurrentThread); - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - return (uint)currentThread.ObjSyncResult; + return (uint)CurrentThread.ObjSyncResult; } - private (long, KThread) MutexUnlock(KThread currentThread, long mutexAddress) + private (long, KThread) MutexUnlock(KThread CurrentThread, long MutexAddress) { - KThread newOwnerThread = currentThread.RelinquishMutex(mutexAddress, out int count); + KThread NewOwnerThread = CurrentThread.RelinquishMutex(MutexAddress, out int Count); - int mutexValue = 0; + int MutexValue = 0; - if (newOwnerThread != null) + if (NewOwnerThread != null) { - mutexValue = newOwnerThread.ThreadHandleForUserMutex; + MutexValue = NewOwnerThread.ThreadHandleForUserMutex; - if (count >= 2) + if (Count >= 2) { - mutexValue |= HasListenersMask; + MutexValue |= HasListenersMask; } - newOwnerThread.SignaledObj = null; - newOwnerThread.ObjSyncResult = 0; + NewOwnerThread.SignaledObj = null; + NewOwnerThread.ObjSyncResult = 0; - newOwnerThread.ReleaseAndResume(); + NewOwnerThread.ReleaseAndResume(); } - long result = 0; + long Result = 0; - if (!KernelTransfer.KernelToUserInt32(_system, mutexAddress, mutexValue)) + if (!KernelTransfer.KernelToUserInt32(System, MutexAddress, MutexValue)) { - result = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + Result = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); } - return (result, newOwnerThread); + return (Result, NewOwnerThread); } - public void SignalProcessWideKey(long address, int count) + public void SignalProcessWideKey(long Address, int Count) { - Queue<KThread> signaledThreads = new Queue<KThread>(); + Queue<KThread> SignaledThreads = new Queue<KThread>(); - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - IOrderedEnumerable<KThread> sortedThreads = CondVarThreads.OrderBy(x => x.DynamicPriority); + IOrderedEnumerable<KThread> SortedThreads = CondVarThreads.OrderBy(x => x.DynamicPriority); - foreach (KThread thread in sortedThreads.Where(x => x.CondVarAddress == address)) + foreach (KThread Thread in SortedThreads.Where(x => x.CondVarAddress == Address)) { - TryAcquireMutex(thread); + TryAcquireMutex(Thread); - signaledThreads.Enqueue(thread); + SignaledThreads.Enqueue(Thread); //If the count is <= 0, we should signal all threads waiting. - if (count >= 1 && --count == 0) + if (Count >= 1 && --Count == 0) { break; } } - while (signaledThreads.TryDequeue(out KThread thread)) + while (SignaledThreads.TryDequeue(out KThread Thread)) { - CondVarThreads.Remove(thread); + CondVarThreads.Remove(Thread); } - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); } - private KThread TryAcquireMutex(KThread requester) + private KThread TryAcquireMutex(KThread Requester) { - long address = requester.MutexAddress; + long Address = Requester.MutexAddress; - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - currentProcess.CpuMemory.SetExclusive(0, address); + CurrentProcess.CpuMemory.SetExclusive(0, Address); - if (!KernelTransfer.UserToKernelInt32(_system, address, out int mutexValue)) + if (!KernelTransfer.UserToKernelInt32(System, Address, out int MutexValue)) { //Invalid address. - currentProcess.CpuMemory.ClearExclusive(0); + CurrentProcess.CpuMemory.ClearExclusive(0); - requester.SignaledObj = null; - requester.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + Requester.SignaledObj = null; + Requester.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return null; } while (true) { - if (currentProcess.CpuMemory.TestExclusive(0, address)) + if (CurrentProcess.CpuMemory.TestExclusive(0, Address)) { - if (mutexValue != 0) + if (MutexValue != 0) { //Update value to indicate there is a mutex waiter now. - currentProcess.CpuMemory.WriteInt32(address, mutexValue | HasListenersMask); + CurrentProcess.CpuMemory.WriteInt32(Address, MutexValue | HasListenersMask); } else { //No thread owning the mutex, assign to requesting thread. - currentProcess.CpuMemory.WriteInt32(address, requester.ThreadHandleForUserMutex); + CurrentProcess.CpuMemory.WriteInt32(Address, Requester.ThreadHandleForUserMutex); } - currentProcess.CpuMemory.ClearExclusiveForStore(0); + CurrentProcess.CpuMemory.ClearExclusiveForStore(0); break; } - currentProcess.CpuMemory.SetExclusive(0, address); + CurrentProcess.CpuMemory.SetExclusive(0, Address); - mutexValue = currentProcess.CpuMemory.ReadInt32(address); + MutexValue = CurrentProcess.CpuMemory.ReadInt32(Address); } - if (mutexValue == 0) + if (MutexValue == 0) { //We now own the mutex. - requester.SignaledObj = null; - requester.ObjSyncResult = 0; + Requester.SignaledObj = null; + Requester.ObjSyncResult = 0; - requester.ReleaseAndResume(); + Requester.ReleaseAndResume(); return null; } - mutexValue &= ~HasListenersMask; + MutexValue &= ~HasListenersMask; - KThread mutexOwner = currentProcess.HandleTable.GetObject<KThread>(mutexValue); + KThread MutexOwner = CurrentProcess.HandleTable.GetObject<KThread>(MutexValue); - if (mutexOwner != null) + if (MutexOwner != null) { //Mutex already belongs to another thread, wait for it. - mutexOwner.AddMutexWaiter(requester); + MutexOwner.AddMutexWaiter(Requester); } else { //Invalid mutex owner. - requester.SignaledObj = null; - requester.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + Requester.SignaledObj = null; + Requester.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); - requester.ReleaseAndResume(); + Requester.ReleaseAndResume(); } - return mutexOwner; + return MutexOwner; } - public long WaitForAddressIfEqual(long address, int value, long timeout) + public long WaitForAddressIfEqual(long Address, int Value, long Timeout) { - KThread currentThread = _system.Scheduler.GetCurrentThread(); + KThread CurrentThread = System.Scheduler.GetCurrentThread(); - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - if (currentThread.ShallBeTerminated || - currentThread.SchedFlags == ThreadSchedState.TerminationPending) + if (CurrentThread.ShallBeTerminated || + CurrentThread.SchedFlags == ThreadSchedState.TerminationPending) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return MakeError(ErrorModule.Kernel, KernelErr.ThreadTerminating); } - currentThread.SignaledObj = null; - currentThread.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.Timeout); + CurrentThread.SignaledObj = null; + CurrentThread.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.Timeout); - if (!KernelTransfer.UserToKernelInt32(_system, address, out int currentValue)) + if (!KernelTransfer.UserToKernelInt32(System, Address, out int CurrentValue)) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); } - if (currentValue == value) + if (CurrentValue == Value) { - if (timeout == 0) + if (Timeout == 0) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return MakeError(ErrorModule.Kernel, KernelErr.Timeout); } - currentThread.MutexAddress = address; - currentThread.WaitingInArbitration = true; + CurrentThread.MutexAddress = Address; + CurrentThread.WaitingInArbitration = true; - InsertSortedByPriority(ArbiterThreads, currentThread); + InsertSortedByPriority(ArbiterThreads, CurrentThread); - currentThread.Reschedule(ThreadSchedState.Paused); + CurrentThread.Reschedule(ThreadSchedState.Paused); - if (timeout > 0) + if (Timeout > 0) { - _system.TimeManager.ScheduleFutureInvocation(currentThread, timeout); + System.TimeManager.ScheduleFutureInvocation(CurrentThread, Timeout); } - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - if (timeout > 0) + if (Timeout > 0) { - _system.TimeManager.UnscheduleFutureInvocation(currentThread); + System.TimeManager.UnscheduleFutureInvocation(CurrentThread); } - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - if (currentThread.WaitingInArbitration) + if (CurrentThread.WaitingInArbitration) { - ArbiterThreads.Remove(currentThread); + ArbiterThreads.Remove(CurrentThread); - currentThread.WaitingInArbitration = false; + CurrentThread.WaitingInArbitration = false; } - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - return currentThread.ObjSyncResult; + return CurrentThread.ObjSyncResult; } - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return MakeError(ErrorModule.Kernel, KernelErr.InvalidState); } - public long WaitForAddressIfLessThan(long address, int value, bool shouldDecrement, long timeout) + public long WaitForAddressIfLessThan(long Address, int Value, bool ShouldDecrement, long Timeout) { - KThread currentThread = _system.Scheduler.GetCurrentThread(); + KThread CurrentThread = System.Scheduler.GetCurrentThread(); - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - if (currentThread.ShallBeTerminated || - currentThread.SchedFlags == ThreadSchedState.TerminationPending) + if (CurrentThread.ShallBeTerminated || + CurrentThread.SchedFlags == ThreadSchedState.TerminationPending) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return MakeError(ErrorModule.Kernel, KernelErr.ThreadTerminating); } - currentThread.SignaledObj = null; - currentThread.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.Timeout); + CurrentThread.SignaledObj = null; + CurrentThread.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.Timeout); - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); //If ShouldDecrement is true, do atomic decrement of the value at Address. - currentProcess.CpuMemory.SetExclusive(0, address); + CurrentProcess.CpuMemory.SetExclusive(0, Address); - if (!KernelTransfer.UserToKernelInt32(_system, address, out int currentValue)) + if (!KernelTransfer.UserToKernelInt32(System, Address, out int CurrentValue)) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); } - if (shouldDecrement) + if (ShouldDecrement) { - while (currentValue < value) + while (CurrentValue < Value) { - if (currentProcess.CpuMemory.TestExclusive(0, address)) + if (CurrentProcess.CpuMemory.TestExclusive(0, Address)) { - currentProcess.CpuMemory.WriteInt32(address, currentValue - 1); + CurrentProcess.CpuMemory.WriteInt32(Address, CurrentValue - 1); - currentProcess.CpuMemory.ClearExclusiveForStore(0); + CurrentProcess.CpuMemory.ClearExclusiveForStore(0); break; } - currentProcess.CpuMemory.SetExclusive(0, address); + CurrentProcess.CpuMemory.SetExclusive(0, Address); - currentValue = currentProcess.CpuMemory.ReadInt32(address); + CurrentValue = CurrentProcess.CpuMemory.ReadInt32(Address); } } - currentProcess.CpuMemory.ClearExclusive(0); + CurrentProcess.CpuMemory.ClearExclusive(0); - if (currentValue < value) + if (CurrentValue < Value) { - if (timeout == 0) + if (Timeout == 0) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return MakeError(ErrorModule.Kernel, KernelErr.Timeout); } - currentThread.MutexAddress = address; - currentThread.WaitingInArbitration = true; + CurrentThread.MutexAddress = Address; + CurrentThread.WaitingInArbitration = true; - InsertSortedByPriority(ArbiterThreads, currentThread); + InsertSortedByPriority(ArbiterThreads, CurrentThread); - currentThread.Reschedule(ThreadSchedState.Paused); + CurrentThread.Reschedule(ThreadSchedState.Paused); - if (timeout > 0) + if (Timeout > 0) { - _system.TimeManager.ScheduleFutureInvocation(currentThread, timeout); + System.TimeManager.ScheduleFutureInvocation(CurrentThread, Timeout); } - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - if (timeout > 0) + if (Timeout > 0) { - _system.TimeManager.UnscheduleFutureInvocation(currentThread); + System.TimeManager.UnscheduleFutureInvocation(CurrentThread); } - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - if (currentThread.WaitingInArbitration) + if (CurrentThread.WaitingInArbitration) { - ArbiterThreads.Remove(currentThread); + ArbiterThreads.Remove(CurrentThread); - currentThread.WaitingInArbitration = false; + CurrentThread.WaitingInArbitration = false; } - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - return currentThread.ObjSyncResult; + return CurrentThread.ObjSyncResult; } - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return MakeError(ErrorModule.Kernel, KernelErr.InvalidState); } - private void InsertSortedByPriority(List<KThread> threads, KThread thread) + private void InsertSortedByPriority(List<KThread> Threads, KThread Thread) { - int nextIndex = -1; + int NextIndex = -1; - for (int index = 0; index < threads.Count; index++) + for (int Index = 0; Index < Threads.Count; Index++) { - if (threads[index].DynamicPriority > thread.DynamicPriority) + if (Threads[Index].DynamicPriority > Thread.DynamicPriority) { - nextIndex = index; + NextIndex = Index; break; } } - if (nextIndex != -1) + if (NextIndex != -1) { - threads.Insert(nextIndex, thread); + Threads.Insert(NextIndex, Thread); } else { - threads.Add(thread); + Threads.Add(Thread); } } - public long Signal(long address, int count) + public long Signal(long Address, int Count) { - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - WakeArbiterThreads(address, count); + WakeArbiterThreads(Address, Count); - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return 0; } - public long SignalAndIncrementIfEqual(long address, int value, int count) + public long SignalAndIncrementIfEqual(long Address, int Value, int Count) { - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - currentProcess.CpuMemory.SetExclusive(0, address); + CurrentProcess.CpuMemory.SetExclusive(0, Address); - if (!KernelTransfer.UserToKernelInt32(_system, address, out int currentValue)) + if (!KernelTransfer.UserToKernelInt32(System, Address, out int CurrentValue)) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); } - while (currentValue == value) + while (CurrentValue == Value) { - if (currentProcess.CpuMemory.TestExclusive(0, address)) + if (CurrentProcess.CpuMemory.TestExclusive(0, Address)) { - currentProcess.CpuMemory.WriteInt32(address, currentValue + 1); + CurrentProcess.CpuMemory.WriteInt32(Address, CurrentValue + 1); - currentProcess.CpuMemory.ClearExclusiveForStore(0); + CurrentProcess.CpuMemory.ClearExclusiveForStore(0); break; } - currentProcess.CpuMemory.SetExclusive(0, address); + CurrentProcess.CpuMemory.SetExclusive(0, Address); - currentValue = currentProcess.CpuMemory.ReadInt32(address); + CurrentValue = CurrentProcess.CpuMemory.ReadInt32(Address); } - currentProcess.CpuMemory.ClearExclusive(0); + CurrentProcess.CpuMemory.ClearExclusive(0); - if (currentValue != value) + if (CurrentValue != Value) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return MakeError(ErrorModule.Kernel, KernelErr.InvalidState); } - WakeArbiterThreads(address, count); + WakeArbiterThreads(Address, Count); - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return 0; } - public long SignalAndModifyIfEqual(long address, int value, int count) + public long SignalAndModifyIfEqual(long Address, int Value, int Count) { - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - int offset; + int Offset; //The value is decremented if the number of threads waiting is less //or equal to the Count of threads to be signaled, or Count is zero //or negative. It is incremented if there are no threads waiting. - int waitingCount = 0; + int WaitingCount = 0; - foreach (KThread thread in ArbiterThreads.Where(x => x.MutexAddress == address)) + foreach (KThread Thread in ArbiterThreads.Where(x => x.MutexAddress == Address)) { - if (++waitingCount > count) + if (++WaitingCount > Count) { break; } } - if (waitingCount > 0) + if (WaitingCount > 0) { - offset = waitingCount <= count || count <= 0 ? -1 : 0; + Offset = WaitingCount <= Count || Count <= 0 ? -1 : 0; } else { - offset = 1; + Offset = 1; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - currentProcess.CpuMemory.SetExclusive(0, address); + CurrentProcess.CpuMemory.SetExclusive(0, Address); - if (!KernelTransfer.UserToKernelInt32(_system, address, out int currentValue)) + if (!KernelTransfer.UserToKernelInt32(System, Address, out int CurrentValue)) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); } - while (currentValue == value) + while (CurrentValue == Value) { - if (currentProcess.CpuMemory.TestExclusive(0, address)) + if (CurrentProcess.CpuMemory.TestExclusive(0, Address)) { - currentProcess.CpuMemory.WriteInt32(address, currentValue + offset); + CurrentProcess.CpuMemory.WriteInt32(Address, CurrentValue + Offset); - currentProcess.CpuMemory.ClearExclusiveForStore(0); + CurrentProcess.CpuMemory.ClearExclusiveForStore(0); break; } - currentProcess.CpuMemory.SetExclusive(0, address); + CurrentProcess.CpuMemory.SetExclusive(0, Address); - currentValue = currentProcess.CpuMemory.ReadInt32(address); + CurrentValue = CurrentProcess.CpuMemory.ReadInt32(Address); } - currentProcess.CpuMemory.ClearExclusive(0); + CurrentProcess.CpuMemory.ClearExclusive(0); - if (currentValue != value) + if (CurrentValue != Value) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return MakeError(ErrorModule.Kernel, KernelErr.InvalidState); } - WakeArbiterThreads(address, count); + WakeArbiterThreads(Address, Count); - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return 0; } - private void WakeArbiterThreads(long address, int count) + private void WakeArbiterThreads(long Address, int Count) { - Queue<KThread> signaledThreads = new Queue<KThread>(); + Queue<KThread> SignaledThreads = new Queue<KThread>(); - foreach (KThread thread in ArbiterThreads.Where(x => x.MutexAddress == address)) + foreach (KThread Thread in ArbiterThreads.Where(x => x.MutexAddress == Address)) { - signaledThreads.Enqueue(thread); + SignaledThreads.Enqueue(Thread); //If the count is <= 0, we should signal all threads waiting. - if (count >= 1 && --count == 0) + if (Count >= 1 && --Count == 0) { break; } } - while (signaledThreads.TryDequeue(out KThread thread)) + while (SignaledThreads.TryDequeue(out KThread Thread)) { - thread.SignaledObj = null; - thread.ObjSyncResult = 0; + Thread.SignaledObj = null; + Thread.ObjSyncResult = 0; - thread.ReleaseAndResume(); + Thread.ReleaseAndResume(); - thread.WaitingInArbitration = false; + Thread.WaitingInArbitration = false; - ArbiterThreads.Remove(thread); + ArbiterThreads.Remove(Thread); } } } diff --git a/Ryujinx.HLE/HOS/Kernel/KAutoObject.cs b/Ryujinx.HLE/HOS/Kernel/KAutoObject.cs index f49beaac..a91bf9a8 100644 --- a/Ryujinx.HLE/HOS/Kernel/KAutoObject.cs +++ b/Ryujinx.HLE/HOS/Kernel/KAutoObject.cs @@ -4,14 +4,14 @@ namespace Ryujinx.HLE.HOS.Kernel { protected Horizon System; - public KAutoObject(Horizon system) + public KAutoObject(Horizon System) { - System = system; + this.System = System; } - public virtual KernelResult SetName(string name) + public virtual KernelResult SetName(string Name) { - if (!System.AutoObjectNames.TryAdd(name, this)) + if (!System.AutoObjectNames.TryAdd(Name, this)) { return KernelResult.InvalidState; } @@ -19,9 +19,9 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } - public static KernelResult RemoveName(Horizon system, string name) + public static KernelResult RemoveName(Horizon System, string Name) { - if (!system.AutoObjectNames.TryRemove(name, out _)) + if (!System.AutoObjectNames.TryRemove(Name, out _)) { return KernelResult.NotFound; } @@ -29,11 +29,11 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } - public static KAutoObject FindNamedObject(Horizon system, string name) + public static KAutoObject FindNamedObject(Horizon System, string Name) { - if (system.AutoObjectNames.TryGetValue(name, out KAutoObject obj)) + if (System.AutoObjectNames.TryGetValue(Name, out KAutoObject Obj)) { - return obj; + return Obj; } return null; diff --git a/Ryujinx.HLE/HOS/Kernel/KClientPort.cs b/Ryujinx.HLE/HOS/Kernel/KClientPort.cs index 57547627..e3f8128b 100644 --- a/Ryujinx.HLE/HOS/Kernel/KClientPort.cs +++ b/Ryujinx.HLE/HOS/Kernel/KClientPort.cs @@ -2,30 +2,30 @@ namespace Ryujinx.HLE.HOS.Kernel { class KClientPort : KSynchronizationObject { - private int _sessionsCount; - private int _currentCapacity; - private int _maxSessions; + private int SessionsCount; + private int CurrentCapacity; + private int MaxSessions; - private KPort _parent; + private KPort Parent; - public KClientPort(Horizon system) : base(system) { } + public KClientPort(Horizon System) : base(System) { } - public void Initialize(KPort parent, int maxSessions) + public void Initialize(KPort Parent, int MaxSessions) { - _maxSessions = maxSessions; - _parent = parent; + this.MaxSessions = MaxSessions; + this.Parent = Parent; } - public new static KernelResult RemoveName(Horizon system, string name) + public new static KernelResult RemoveName(Horizon System, string Name) { - KAutoObject foundObj = FindNamedObject(system, name); + KAutoObject FoundObj = KAutoObject.FindNamedObject(System, Name); - if (!(foundObj is KClientPort)) + if (!(FoundObj is KClientPort)) { return KernelResult.NotFound; } - return KAutoObject.RemoveName(system, name); + return KAutoObject.RemoveName(System, Name); } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KConditionVariable.cs b/Ryujinx.HLE/HOS/Kernel/KConditionVariable.cs index 15c96c24..1c95f811 100644 --- a/Ryujinx.HLE/HOS/Kernel/KConditionVariable.cs +++ b/Ryujinx.HLE/HOS/Kernel/KConditionVariable.cs @@ -5,67 +5,67 @@ namespace Ryujinx.HLE.HOS.Kernel { static class KConditionVariable { - public static void Wait(Horizon system, LinkedList<KThread> threadList, object mutex, long timeout) + public static void Wait(Horizon System, LinkedList<KThread> ThreadList, object Mutex, long Timeout) { - KThread currentThread = system.Scheduler.GetCurrentThread(); + KThread CurrentThread = System.Scheduler.GetCurrentThread(); - system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - Monitor.Exit(mutex); + Monitor.Exit(Mutex); - currentThread.Withholder = threadList; + CurrentThread.Withholder = ThreadList; - currentThread.Reschedule(ThreadSchedState.Paused); + CurrentThread.Reschedule(ThreadSchedState.Paused); - currentThread.WithholderNode = threadList.AddLast(currentThread); + CurrentThread.WithholderNode = ThreadList.AddLast(CurrentThread); - if (currentThread.ShallBeTerminated || - currentThread.SchedFlags == ThreadSchedState.TerminationPending) + if (CurrentThread.ShallBeTerminated || + CurrentThread.SchedFlags == ThreadSchedState.TerminationPending) { - threadList.Remove(currentThread.WithholderNode); + ThreadList.Remove(CurrentThread.WithholderNode); - currentThread.Reschedule(ThreadSchedState.Running); + CurrentThread.Reschedule(ThreadSchedState.Running); - currentThread.Withholder = null; + CurrentThread.Withholder = null; - system.CriticalSection.Leave(); + System.CriticalSection.Leave(); } else { - if (timeout > 0) + if (Timeout > 0) { - system.TimeManager.ScheduleFutureInvocation(currentThread, timeout); + System.TimeManager.ScheduleFutureInvocation(CurrentThread, Timeout); } - system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - if (timeout > 0) + if (Timeout > 0) { - system.TimeManager.UnscheduleFutureInvocation(currentThread); + System.TimeManager.UnscheduleFutureInvocation(CurrentThread); } } - Monitor.Enter(mutex); + Monitor.Enter(Mutex); } - public static void NotifyAll(Horizon system, LinkedList<KThread> threadList) + public static void NotifyAll(Horizon System, LinkedList<KThread> ThreadList) { - system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - LinkedListNode<KThread> node = threadList.First; + LinkedListNode<KThread> Node = ThreadList.First; - for (; node != null; node = threadList.First) + for (; Node != null; Node = ThreadList.First) { - KThread thread = node.Value; + KThread Thread = Node.Value; - threadList.Remove(thread.WithholderNode); + ThreadList.Remove(Thread.WithholderNode); - thread.Withholder = null; + Thread.Withholder = null; - thread.Reschedule(ThreadSchedState.Running); + Thread.Reschedule(ThreadSchedState.Running); } - system.CriticalSection.Leave(); + System.CriticalSection.Leave(); } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KContextIdManager.cs b/Ryujinx.HLE/HOS/Kernel/KContextIdManager.cs index 80a1c1c7..03e7dddf 100644 --- a/Ryujinx.HLE/HOS/Kernel/KContextIdManager.cs +++ b/Ryujinx.HLE/HOS/Kernel/KContextIdManager.cs @@ -7,77 +7,77 @@ namespace Ryujinx.HLE.HOS.Kernel { private const int IdMasksCount = 8; - private int[] _idMasks; + private int[] IdMasks; - private int _nextFreeBitHint; + private int NextFreeBitHint; public KContextIdManager() { - _idMasks = new int[IdMasksCount]; + IdMasks = new int[IdMasksCount]; } public int GetId() { - lock (_idMasks) + lock (IdMasks) { - int id = 0; + int Id = 0; - if (!TestBit(_nextFreeBitHint)) + if (!TestBit(NextFreeBitHint)) { - id = _nextFreeBitHint; + Id = NextFreeBitHint; } else { - for (int index = 0; index < IdMasksCount; index++) + for (int Index = 0; Index < IdMasksCount; Index++) { - int mask = _idMasks[index]; + int Mask = IdMasks[Index]; - int firstFreeBit = BitUtils.CountLeadingZeros32((mask + 1) & ~mask); + int FirstFreeBit = BitUtils.CountLeadingZeros32((Mask + 1) & ~Mask); - if (firstFreeBit < 32) + if (FirstFreeBit < 32) { - int baseBit = index * 32 + 31; + int BaseBit = Index * 32 + 31; - id = baseBit - firstFreeBit; + Id = BaseBit - FirstFreeBit; break; } - else if (index == IdMasksCount - 1) + else if (Index == IdMasksCount - 1) { throw new InvalidOperationException("Maximum number of Ids reached!"); } } } - _nextFreeBitHint = id + 1; + NextFreeBitHint = Id + 1; - SetBit(id); + SetBit(Id); - return id; + return Id; } } - public void PutId(int id) + public void PutId(int Id) { - lock (_idMasks) + lock (IdMasks) { - ClearBit(id); + ClearBit(Id); } } - private bool TestBit(int bit) + private bool TestBit(int Bit) { - return (_idMasks[_nextFreeBitHint / 32] & (1 << (_nextFreeBitHint & 31))) != 0; + return (IdMasks[NextFreeBitHint / 32] & (1 << (NextFreeBitHint & 31))) != 0; } - private void SetBit(int bit) + private void SetBit(int Bit) { - _idMasks[_nextFreeBitHint / 32] |= (1 << (_nextFreeBitHint & 31)); + IdMasks[NextFreeBitHint / 32] |= (1 << (NextFreeBitHint & 31)); } - private void ClearBit(int bit) + private void ClearBit(int Bit) { - _idMasks[_nextFreeBitHint / 32] &= ~(1 << (_nextFreeBitHint & 31)); + IdMasks[NextFreeBitHint / 32] &= ~(1 << (NextFreeBitHint & 31)); } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KCoreContext.cs b/Ryujinx.HLE/HOS/Kernel/KCoreContext.cs index 4ca3c25a..638dde9e 100644 --- a/Ryujinx.HLE/HOS/Kernel/KCoreContext.cs +++ b/Ryujinx.HLE/HOS/Kernel/KCoreContext.cs @@ -4,9 +4,9 @@ namespace Ryujinx.HLE.HOS.Kernel { class KCoreContext { - private KScheduler _scheduler; + private KScheduler Scheduler; - private HleCoreManager _coreManager; + private HleCoreManager CoreManager; public bool ContextSwitchNeeded { get; private set; } @@ -17,15 +17,15 @@ namespace Ryujinx.HLE.HOS.Kernel public KThread CurrentThread { get; private set; } public KThread SelectedThread { get; private set; } - public KCoreContext(KScheduler scheduler, HleCoreManager coreManager) + public KCoreContext(KScheduler Scheduler, HleCoreManager CoreManager) { - _scheduler = scheduler; - _coreManager = coreManager; + this.Scheduler = Scheduler; + this.CoreManager = CoreManager; } - public void SelectThread(KThread thread) + public void SelectThread(KThread Thread) { - SelectedThread = thread; + SelectedThread = Thread; if (SelectedThread != CurrentThread) { @@ -43,10 +43,10 @@ namespace Ryujinx.HLE.HOS.Kernel if (CurrentThread != null) { - long currentTime = PerformanceCounter.ElapsedMilliseconds; + long CurrentTime = PerformanceCounter.ElapsedMilliseconds; - CurrentThread.TotalTimeRunning += currentTime - CurrentThread.LastScheduledTime; - CurrentThread.LastScheduledTime = currentTime; + CurrentThread.TotalTimeRunning += CurrentTime - CurrentThread.LastScheduledTime; + CurrentThread.LastScheduledTime = CurrentTime; } } @@ -58,21 +58,21 @@ namespace Ryujinx.HLE.HOS.Kernel if (CurrentThread != null) { - _coreManager.Reset(CurrentThread.Context.Work); + CoreManager.Reset(CurrentThread.Context.Work); } CurrentThread = SelectedThread; if (CurrentThread != null) { - long currentTime = PerformanceCounter.ElapsedMilliseconds; + long CurrentTime = PerformanceCounter.ElapsedMilliseconds; - CurrentThread.TotalTimeRunning += currentTime - CurrentThread.LastScheduledTime; - CurrentThread.LastScheduledTime = currentTime; + CurrentThread.TotalTimeRunning += CurrentTime - CurrentThread.LastScheduledTime; + CurrentThread.LastScheduledTime = CurrentTime; CurrentThread.ClearExclusive(); - _coreManager.Set(CurrentThread.Context.Work); + CoreManager.Set(CurrentThread.Context.Work); CurrentThread.Context.Execute(); } diff --git a/Ryujinx.HLE/HOS/Kernel/KCriticalSection.cs b/Ryujinx.HLE/HOS/Kernel/KCriticalSection.cs index 4bafa69d..b02a1195 100644 --- a/Ryujinx.HLE/HOS/Kernel/KCriticalSection.cs +++ b/Ryujinx.HLE/HOS/Kernel/KCriticalSection.cs @@ -5,15 +5,15 @@ namespace Ryujinx.HLE.HOS.Kernel { class KCriticalSection { - private Horizon _system; + private Horizon System; - public object LockObj { get; } + public object LockObj { get; private set; } - private int _recursionCount; + private int RecursionCount; - public KCriticalSection(Horizon system) + public KCriticalSection(Horizon System) { - _system = system; + this.System = System; LockObj = new object(); } @@ -22,53 +22,53 @@ namespace Ryujinx.HLE.HOS.Kernel { Monitor.Enter(LockObj); - _recursionCount++; + RecursionCount++; } public void Leave() { - if (_recursionCount == 0) + if (RecursionCount == 0) { return; } - bool doContextSwitch = false; + bool DoContextSwitch = false; - if (--_recursionCount == 0) + if (--RecursionCount == 0) { - if (_system.Scheduler.ThreadReselectionRequested) + if (System.Scheduler.ThreadReselectionRequested) { - _system.Scheduler.SelectThreads(); + System.Scheduler.SelectThreads(); } Monitor.Exit(LockObj); - if (_system.Scheduler.MultiCoreScheduling) + if (System.Scheduler.MultiCoreScheduling) { - lock (_system.Scheduler.CoreContexts) + lock (System.Scheduler.CoreContexts) { - for (int core = 0; core < KScheduler.CpuCoresCount; core++) + for (int Core = 0; Core < KScheduler.CpuCoresCount; Core++) { - KCoreContext coreContext = _system.Scheduler.CoreContexts[core]; + KCoreContext CoreContext = System.Scheduler.CoreContexts[Core]; - if (coreContext.ContextSwitchNeeded) + if (CoreContext.ContextSwitchNeeded) { - CpuThread currentHleThread = coreContext.CurrentThread?.Context; + CpuThread CurrentHleThread = CoreContext.CurrentThread?.Context; - if (currentHleThread == null) + if (CurrentHleThread == null) { //Nothing is running, we can perform the context switch immediately. - coreContext.ContextSwitch(); + CoreContext.ContextSwitch(); } - else if (currentHleThread.IsCurrentThread()) + else if (CurrentHleThread.IsCurrentThread()) { //Thread running on the current core, context switch will block. - doContextSwitch = true; + DoContextSwitch = true; } else { //Thread running on another core, request a interrupt. - currentHleThread.RequestInterrupt(); + CurrentHleThread.RequestInterrupt(); } } } @@ -76,7 +76,7 @@ namespace Ryujinx.HLE.HOS.Kernel } else { - doContextSwitch = true; + DoContextSwitch = true; } } else @@ -84,9 +84,9 @@ namespace Ryujinx.HLE.HOS.Kernel Monitor.Exit(LockObj); } - if (doContextSwitch) + if (DoContextSwitch) { - _system.Scheduler.ContextSwitch(); + System.Scheduler.ContextSwitch(); } } } diff --git a/Ryujinx.HLE/HOS/Kernel/KEvent.cs b/Ryujinx.HLE/HOS/Kernel/KEvent.cs index 032e2a4c..106d1b40 100644 --- a/Ryujinx.HLE/HOS/Kernel/KEvent.cs +++ b/Ryujinx.HLE/HOS/Kernel/KEvent.cs @@ -2,12 +2,12 @@ namespace Ryujinx.HLE.HOS.Kernel { class KEvent { - public KReadableEvent ReadableEvent { get; } - public KWritableEvent WritableEvent { get; } + public KReadableEvent ReadableEvent { get; private set; } + public KWritableEvent WritableEvent { get; private set; } - public KEvent(Horizon system) + public KEvent(Horizon System) { - ReadableEvent = new KReadableEvent(system, this); + ReadableEvent = new KReadableEvent(System, this); WritableEvent = new KWritableEvent(this); } } diff --git a/Ryujinx.HLE/HOS/Kernel/KHandleEntry.cs b/Ryujinx.HLE/HOS/Kernel/KHandleEntry.cs index 1799e964..9863a374 100644 --- a/Ryujinx.HLE/HOS/Kernel/KHandleEntry.cs +++ b/Ryujinx.HLE/HOS/Kernel/KHandleEntry.cs @@ -4,14 +4,14 @@ namespace Ryujinx.HLE.HOS.Kernel { public KHandleEntry Next { get; set; } - public int Index { get; } + public int Index { get; private set; } public ushort HandleId { get; set; } public object Obj { get; set; } - public KHandleEntry(int index) + public KHandleEntry(int Index) { - Index = index; + this.Index = Index; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KHandleTable.cs b/Ryujinx.HLE/HOS/Kernel/KHandleTable.cs index 88d0c513..e39dfb67 100644 --- a/Ryujinx.HLE/HOS/Kernel/KHandleTable.cs +++ b/Ryujinx.HLE/HOS/Kernel/KHandleTable.cs @@ -7,148 +7,148 @@ namespace Ryujinx.HLE.HOS.Kernel private const int SelfThreadHandle = (0x1ffff << 15) | 0; private const int SelfProcessHandle = (0x1ffff << 15) | 1; - private Horizon _system; + private Horizon System; - private KHandleEntry[] _table; + private KHandleEntry[] Table; - private KHandleEntry _tableHead; - private KHandleEntry _nextFreeEntry; + private KHandleEntry TableHead; + private KHandleEntry NextFreeEntry; - private int _activeSlotsCount; + private int ActiveSlotsCount; - private int _size; + private int Size; - private ushort _idCounter; + private ushort IdCounter; - public KHandleTable(Horizon system) + public KHandleTable(Horizon System) { - _system = system; + this.System = System; } - public KernelResult Initialize(int size) + public KernelResult Initialize(int Size) { - if ((uint)size > 1024) + if ((uint)Size > 1024) { return KernelResult.OutOfMemory; } - if (size < 1) + if (Size < 1) { - size = 1024; + Size = 1024; } - _size = size; + this.Size = Size; - _idCounter = 1; + IdCounter = 1; - _table = new KHandleEntry[size]; + Table = new KHandleEntry[Size]; - _tableHead = new KHandleEntry(0); + TableHead = new KHandleEntry(0); - KHandleEntry entry = _tableHead; + KHandleEntry Entry = TableHead; - for (int index = 0; index < size; index++) + for (int Index = 0; Index < Size; Index++) { - _table[index] = entry; + Table[Index] = Entry; - entry.Next = new KHandleEntry(index + 1); + Entry.Next = new KHandleEntry(Index + 1); - entry = entry.Next; + Entry = Entry.Next; } - _table[size - 1].Next = null; + Table[Size - 1].Next = null; - _nextFreeEntry = _tableHead; + NextFreeEntry = TableHead; return KernelResult.Success; } - public KernelResult GenerateHandle(object obj, out int handle) + public KernelResult GenerateHandle(object Obj, out int Handle) { - handle = 0; + Handle = 0; - lock (_table) + lock (Table) { - if (_activeSlotsCount >= _size) + if (ActiveSlotsCount >= Size) { return KernelResult.HandleTableFull; } - KHandleEntry entry = _nextFreeEntry; + KHandleEntry Entry = NextFreeEntry; - _nextFreeEntry = entry.Next; + NextFreeEntry = Entry.Next; - entry.Obj = obj; - entry.HandleId = _idCounter; + Entry.Obj = Obj; + Entry.HandleId = IdCounter; - _activeSlotsCount++; + ActiveSlotsCount++; - handle = (int)((_idCounter << 15) & 0xffff8000) | entry.Index; + Handle = (int)((IdCounter << 15) & (uint)0xffff8000) | Entry.Index; - if ((short)(_idCounter + 1) >= 0) + if ((short)(IdCounter + 1) >= 0) { - _idCounter++; + IdCounter++; } else { - _idCounter = 1; + IdCounter = 1; } } return KernelResult.Success; } - public bool CloseHandle(int handle) + public bool CloseHandle(int Handle) { - if ((handle >> 30) != 0 || - handle == SelfThreadHandle || - handle == SelfProcessHandle) + if ((Handle >> 30) != 0 || + Handle == SelfThreadHandle || + Handle == SelfProcessHandle) { return false; } - int index = (handle >> 0) & 0x7fff; - int handleId = (handle >> 15); + int Index = (Handle >> 0) & 0x7fff; + int HandleId = (Handle >> 15); - bool result = false; + bool Result = false; - lock (_table) + lock (Table) { - if (handleId != 0 && index < _size) + if (HandleId != 0 && Index < Size) { - KHandleEntry entry = _table[index]; + KHandleEntry Entry = Table[Index]; - if (entry.Obj != null && entry.HandleId == handleId) + if (Entry.Obj != null && Entry.HandleId == HandleId) { - entry.Obj = null; - entry.Next = _nextFreeEntry; + Entry.Obj = null; + Entry.Next = NextFreeEntry; - _nextFreeEntry = entry; + NextFreeEntry = Entry; - _activeSlotsCount--; + ActiveSlotsCount--; - result = true; + Result = true; } } } - return result; + return Result; } - public T GetObject<T>(int handle) + public T GetObject<T>(int Handle) { - int index = (handle >> 0) & 0x7fff; - int handleId = (handle >> 15); + int Index = (Handle >> 0) & 0x7fff; + int HandleId = (Handle >> 15); - lock (_table) + lock (Table) { - if ((handle >> 30) == 0 && handleId != 0) + if ((Handle >> 30) == 0 && HandleId != 0) { - KHandleEntry entry = _table[index]; + KHandleEntry Entry = Table[Index]; - if (entry.HandleId == handleId && entry.Obj is T obj) + if (Entry.HandleId == HandleId && Entry.Obj is T Obj) { - return obj; + return Obj; } } } @@ -156,49 +156,49 @@ namespace Ryujinx.HLE.HOS.Kernel return default(T); } - public KThread GetKThread(int handle) + public KThread GetKThread(int Handle) { - if (handle == SelfThreadHandle) + if (Handle == SelfThreadHandle) { - return _system.Scheduler.GetCurrentThread(); + return System.Scheduler.GetCurrentThread(); } else { - return GetObject<KThread>(handle); + return GetObject<KThread>(Handle); } } - public KProcess GetKProcess(int handle) + public KProcess GetKProcess(int Handle) { - if (handle == SelfProcessHandle) + if (Handle == SelfProcessHandle) { - return _system.Scheduler.GetCurrentProcess(); + return System.Scheduler.GetCurrentProcess(); } else { - return GetObject<KProcess>(handle); + return GetObject<KProcess>(Handle); } } public void Destroy() { - lock (_table) + lock (Table) { - for (int index = 0; index < _size; index++) + for (int Index = 0; Index < Size; Index++) { - KHandleEntry entry = _table[index]; + KHandleEntry Entry = Table[Index]; - if (entry.Obj != null) + if (Entry.Obj != null) { - if (entry.Obj is IDisposable disposableObj) + if (Entry.Obj is IDisposable DisposableObj) { - disposableObj.Dispose(); + DisposableObj.Dispose(); } - entry.Obj = null; - entry.Next = _nextFreeEntry; + Entry.Obj = null; + Entry.Next = NextFreeEntry; - _nextFreeEntry = entry; + NextFreeEntry = Entry; } } } diff --git a/Ryujinx.HLE/HOS/Kernel/KMemoryArrange.cs b/Ryujinx.HLE/HOS/Kernel/KMemoryArrange.cs index 853c6ab1..af393b68 100644 --- a/Ryujinx.HLE/HOS/Kernel/KMemoryArrange.cs +++ b/Ryujinx.HLE/HOS/Kernel/KMemoryArrange.cs @@ -2,21 +2,21 @@ namespace Ryujinx.HLE.HOS.Kernel { class KMemoryArrange { - public KMemoryArrangeRegion Service { get; } - public KMemoryArrangeRegion NvServices { get; } - public KMemoryArrangeRegion Applet { get; } - public KMemoryArrangeRegion Application { get; } + 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) + KMemoryArrangeRegion Service, + KMemoryArrangeRegion NvServices, + KMemoryArrangeRegion Applet, + KMemoryArrangeRegion Application) { - Service = service; - NvServices = nvServices; - Applet = applet; - Application = application; + this.Service = Service; + this.NvServices = NvServices; + this.Applet = Applet; + this.Application = Application; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KMemoryArrangeRegion.cs b/Ryujinx.HLE/HOS/Kernel/KMemoryArrangeRegion.cs index c76cf42e..7d66e291 100644 --- a/Ryujinx.HLE/HOS/Kernel/KMemoryArrangeRegion.cs +++ b/Ryujinx.HLE/HOS/Kernel/KMemoryArrangeRegion.cs @@ -2,15 +2,15 @@ namespace Ryujinx.HLE.HOS.Kernel { struct KMemoryArrangeRegion { - public ulong Address { get; } - public ulong Size { get; } + public ulong Address { get; private set; } + public ulong Size { get; private set; } public ulong EndAddr => Address + Size; - public KMemoryArrangeRegion(ulong address, ulong size) + public KMemoryArrangeRegion(ulong Address, ulong Size) { - Address = address; - Size = size; + this.Address = Address; + this.Size = Size; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KMemoryBlock.cs b/Ryujinx.HLE/HOS/Kernel/KMemoryBlock.cs index 44b7a683..08190236 100644 --- a/Ryujinx.HLE/HOS/Kernel/KMemoryBlock.cs +++ b/Ryujinx.HLE/HOS/Kernel/KMemoryBlock.cs @@ -13,26 +13,26 @@ namespace Ryujinx.HLE.HOS.Kernel public int DeviceRefCount { get; set; } public KMemoryBlock( - ulong baseAddress, - ulong pagesCount, - MemoryState state, - MemoryPermission permission, - MemoryAttribute attribute) + ulong BaseAddress, + ulong PagesCount, + MemoryState State, + MemoryPermission Permission, + MemoryAttribute Attribute) { - BaseAddress = baseAddress; - PagesCount = pagesCount; - State = state; - Attribute = attribute; - Permission = permission; + this.BaseAddress = BaseAddress; + this.PagesCount = PagesCount; + this.State = State; + this.Attribute = Attribute; + this.Permission = Permission; } public KMemoryInfo GetInfo() { - ulong size = PagesCount * KMemoryManager.PageSize; + ulong Size = PagesCount * KMemoryManager.PageSize; return new KMemoryInfo( BaseAddress, - size, + Size, State, Permission, Attribute, diff --git a/Ryujinx.HLE/HOS/Kernel/KMemoryBlockAllocator.cs b/Ryujinx.HLE/HOS/Kernel/KMemoryBlockAllocator.cs index 375685e6..08512e12 100644 --- a/Ryujinx.HLE/HOS/Kernel/KMemoryBlockAllocator.cs +++ b/Ryujinx.HLE/HOS/Kernel/KMemoryBlockAllocator.cs @@ -2,18 +2,18 @@ namespace Ryujinx.HLE.HOS.Kernel { class KMemoryBlockAllocator { - private ulong _capacityElements; + private ulong CapacityElements; public int Count { get; set; } - public KMemoryBlockAllocator(ulong capacityElements) + public KMemoryBlockAllocator(ulong CapacityElements) { - _capacityElements = capacityElements; + this.CapacityElements = CapacityElements; } - public bool CanAllocate(int count) + public bool CanAllocate(int Count) { - return (ulong)(Count + count) <= _capacityElements; + return (ulong)(this.Count + Count) <= CapacityElements; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KMemoryInfo.cs b/Ryujinx.HLE/HOS/Kernel/KMemoryInfo.cs index 8ae522d4..09ba88f2 100644 --- a/Ryujinx.HLE/HOS/Kernel/KMemoryInfo.cs +++ b/Ryujinx.HLE/HOS/Kernel/KMemoryInfo.cs @@ -2,32 +2,32 @@ namespace Ryujinx.HLE.HOS.Kernel { class KMemoryInfo { - public ulong Address { get; } - public ulong Size { get; } + public ulong Address { get; private set; } + public ulong Size { get; private set; } - public MemoryState State { get; } - public MemoryPermission Permission { get; } - public MemoryAttribute Attribute { get; } + public MemoryState State { get; private set; } + public MemoryPermission Permission { get; private set; } + public MemoryAttribute Attribute { get; private set; } - public int IpcRefCount { get; } - public int DeviceRefCount { get; } + public int IpcRefCount { get; private set; } + public int DeviceRefCount { get; private set; } public KMemoryInfo( - ulong address, - ulong size, - MemoryState state, - MemoryPermission permission, - MemoryAttribute attribute, - int ipcRefCount, - int deviceRefCount) + ulong Address, + ulong Size, + MemoryState State, + MemoryPermission Permission, + MemoryAttribute Attribute, + int IpcRefCount, + int DeviceRefCount) { - Address = address; - Size = size; - State = state; - Attribute = attribute; - Permission = permission; - IpcRefCount = ipcRefCount; - DeviceRefCount = deviceRefCount; + this.Address = Address; + this.Size = Size; + this.State = State; + this.Attribute = Attribute; + this.Permission = Permission; + this.IpcRefCount = IpcRefCount; + this.DeviceRefCount = DeviceRefCount; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KMemoryManager.cs b/Ryujinx.HLE/HOS/Kernel/KMemoryManager.cs index 831844c7..0aa21e3f 100644 --- a/Ryujinx.HLE/HOS/Kernel/KMemoryManager.cs +++ b/Ryujinx.HLE/HOS/Kernel/KMemoryManager.cs @@ -15,11 +15,11 @@ namespace Ryujinx.HLE.HOS.Kernel //needs to be split in 2, plus one block that will be the new one inserted. private const int MaxBlocksNeededForInsertion = 2; - private LinkedList<KMemoryBlock> _blocks; + private LinkedList<KMemoryBlock> Blocks; - private MemoryManager _cpuMemory; + private MemoryManager CpuMemory; - private Horizon _system; + private Horizon System; public ulong AddrSpaceStart { get; private set; } public ulong AddrSpaceEnd { get; private set; } @@ -30,7 +30,7 @@ namespace Ryujinx.HLE.HOS.Kernel public ulong HeapRegionStart { get; private set; } public ulong HeapRegionEnd { get; private set; } - private ulong _currentHeapAddr; + private ulong CurrentHeapAddr; public ulong AliasRegionStart { get; private set; } public ulong AliasRegionEnd { get; private set; } @@ -41,71 +41,71 @@ namespace Ryujinx.HLE.HOS.Kernel public ulong TlsIoRegionStart { get; private set; } public ulong TlsIoRegionEnd { get; private set; } - private ulong _heapCapacity; + private ulong HeapCapacity; public ulong PhysicalMemoryUsage { get; private set; } - private MemoryRegion _memRegion; + private MemoryRegion MemRegion; - private bool _aslrDisabled; + private bool AslrDisabled; public int AddrSpaceWidth { get; private set; } - private bool _isKernel; - private bool _aslrEnabled; + private bool IsKernel; + private bool AslrEnabled; - private KMemoryBlockAllocator _blockAllocator; + private KMemoryBlockAllocator BlockAllocator; - private int _contextId; + private int ContextId; - private MersenneTwister _randomNumberGenerator; + private MersenneTwister RandomNumberGenerator; - public KMemoryManager(Horizon system, MemoryManager cpuMemory) + public KMemoryManager(Horizon System, MemoryManager CpuMemory) { - _system = system; - _cpuMemory = cpuMemory; + this.System = System; + this.CpuMemory = CpuMemory; - _blocks = new LinkedList<KMemoryBlock>(); + Blocks = new LinkedList<KMemoryBlock>(); } private static readonly int[] AddrSpaceSizes = new int[] { 32, 36, 32, 39 }; public KernelResult InitializeForProcess( - AddressSpaceType addrSpaceType, - bool aslrEnabled, - bool aslrDisabled, - MemoryRegion memRegion, - ulong address, - ulong size, - KMemoryBlockAllocator blockAllocator) + AddressSpaceType AddrSpaceType, + bool AslrEnabled, + bool AslrDisabled, + MemoryRegion MemRegion, + ulong Address, + ulong Size, + KMemoryBlockAllocator BlockAllocator) { - if ((uint)addrSpaceType > (uint)AddressSpaceType.Addr39Bits) + if ((uint)AddrSpaceType > (uint)AddressSpaceType.Addr39Bits) { - throw new ArgumentException(nameof(addrSpaceType)); + throw new ArgumentException(nameof(AddrSpaceType)); } - _contextId = _system.ContextIdManager.GetId(); + ContextId = System.ContextIdManager.GetId(); - ulong addrSpaceBase = 0; - ulong addrSpaceSize = 1UL << AddrSpaceSizes[(int)addrSpaceType]; + ulong AddrSpaceBase = 0; + ulong AddrSpaceSize = 1UL << AddrSpaceSizes[(int)AddrSpaceType]; - KernelResult result = CreateUserAddressSpace( - addrSpaceType, - aslrEnabled, - aslrDisabled, - addrSpaceBase, - addrSpaceSize, - memRegion, - address, - size, - blockAllocator); + KernelResult Result = CreateUserAddressSpace( + AddrSpaceType, + AslrEnabled, + AslrDisabled, + AddrSpaceBase, + AddrSpaceSize, + MemRegion, + Address, + Size, + BlockAllocator); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - _system.ContextIdManager.PutId(_contextId); + System.ContextIdManager.PutId(ContextId); } - return result; + return Result; } private class Region @@ -117,328 +117,328 @@ namespace Ryujinx.HLE.HOS.Kernel } private KernelResult CreateUserAddressSpace( - AddressSpaceType addrSpaceType, - bool aslrEnabled, - bool aslrDisabled, - ulong addrSpaceStart, - ulong addrSpaceEnd, - MemoryRegion memRegion, - ulong address, - ulong size, - KMemoryBlockAllocator blockAllocator) - { - ulong endAddr = address + size; - - Region aliasRegion = new Region(); - Region heapRegion = new Region(); - Region stackRegion = new Region(); - Region tlsIoRegion = new Region(); - - ulong codeRegionSize; - ulong stackAndTlsIoStart; - ulong stackAndTlsIoEnd; - ulong baseAddress; - - switch (addrSpaceType) + AddressSpaceType AddrSpaceType, + bool AslrEnabled, + bool AslrDisabled, + ulong AddrSpaceStart, + ulong AddrSpaceEnd, + MemoryRegion MemRegion, + ulong Address, + ulong Size, + KMemoryBlockAllocator BlockAllocator) + { + ulong EndAddr = Address + Size; + + Region AliasRegion = new Region(); + Region HeapRegion = new Region(); + Region StackRegion = new Region(); + Region TlsIoRegion = new Region(); + + ulong CodeRegionSize; + ulong StackAndTlsIoStart; + ulong StackAndTlsIoEnd; + ulong BaseAddress; + + switch (AddrSpaceType) { case AddressSpaceType.Addr32Bits: - aliasRegion.Size = 0x40000000; - heapRegion.Size = 0x40000000; - stackRegion.Size = 0; - tlsIoRegion.Size = 0; + AliasRegion.Size = 0x40000000; + HeapRegion.Size = 0x40000000; + StackRegion.Size = 0; + TlsIoRegion.Size = 0; CodeRegionStart = 0x200000; - codeRegionSize = 0x3fe00000; - stackAndTlsIoStart = 0x200000; - stackAndTlsIoEnd = 0x40000000; - baseAddress = 0x200000; + CodeRegionSize = 0x3fe00000; + StackAndTlsIoStart = 0x200000; + StackAndTlsIoEnd = 0x40000000; + BaseAddress = 0x200000; AddrSpaceWidth = 32; break; case AddressSpaceType.Addr36Bits: - aliasRegion.Size = 0x180000000; - heapRegion.Size = 0x180000000; - stackRegion.Size = 0; - tlsIoRegion.Size = 0; + AliasRegion.Size = 0x180000000; + HeapRegion.Size = 0x180000000; + StackRegion.Size = 0; + TlsIoRegion.Size = 0; CodeRegionStart = 0x8000000; - codeRegionSize = 0x78000000; - stackAndTlsIoStart = 0x8000000; - stackAndTlsIoEnd = 0x80000000; - baseAddress = 0x8000000; + CodeRegionSize = 0x78000000; + StackAndTlsIoStart = 0x8000000; + StackAndTlsIoEnd = 0x80000000; + BaseAddress = 0x8000000; AddrSpaceWidth = 36; break; case AddressSpaceType.Addr32BitsNoMap: - aliasRegion.Size = 0; - heapRegion.Size = 0x80000000; - stackRegion.Size = 0; - tlsIoRegion.Size = 0; + AliasRegion.Size = 0; + HeapRegion.Size = 0x80000000; + StackRegion.Size = 0; + TlsIoRegion.Size = 0; CodeRegionStart = 0x200000; - codeRegionSize = 0x3fe00000; - stackAndTlsIoStart = 0x200000; - stackAndTlsIoEnd = 0x40000000; - baseAddress = 0x200000; + CodeRegionSize = 0x3fe00000; + StackAndTlsIoStart = 0x200000; + StackAndTlsIoEnd = 0x40000000; + BaseAddress = 0x200000; AddrSpaceWidth = 32; break; case AddressSpaceType.Addr39Bits: - aliasRegion.Size = 0x1000000000; - heapRegion.Size = 0x180000000; - stackRegion.Size = 0x80000000; - tlsIoRegion.Size = 0x1000000000; - CodeRegionStart = BitUtils.AlignDown(address, 0x200000); - codeRegionSize = BitUtils.AlignUp (endAddr, 0x200000) - CodeRegionStart; - stackAndTlsIoStart = 0; - stackAndTlsIoEnd = 0; - baseAddress = 0x8000000; + AliasRegion.Size = 0x1000000000; + HeapRegion.Size = 0x180000000; + StackRegion.Size = 0x80000000; + TlsIoRegion.Size = 0x1000000000; + CodeRegionStart = BitUtils.AlignDown(Address, 0x200000); + CodeRegionSize = BitUtils.AlignUp (EndAddr, 0x200000) - CodeRegionStart; + StackAndTlsIoStart = 0; + StackAndTlsIoEnd = 0; + BaseAddress = 0x8000000; AddrSpaceWidth = 39; break; - default: throw new ArgumentException(nameof(addrSpaceType)); + default: throw new ArgumentException(nameof(AddrSpaceType)); } - CodeRegionEnd = CodeRegionStart + codeRegionSize; + CodeRegionEnd = CodeRegionStart + CodeRegionSize; - ulong mapBaseAddress; - ulong mapAvailableSize; + ulong MapBaseAddress; + ulong MapAvailableSize; - if (CodeRegionStart - baseAddress >= addrSpaceEnd - CodeRegionEnd) + if (CodeRegionStart - BaseAddress >= AddrSpaceEnd - CodeRegionEnd) { //Has more space before the start of the code region. - mapBaseAddress = baseAddress; - mapAvailableSize = CodeRegionStart - baseAddress; + MapBaseAddress = BaseAddress; + MapAvailableSize = CodeRegionStart - BaseAddress; } else { //Has more space after the end of the code region. - mapBaseAddress = CodeRegionEnd; - mapAvailableSize = addrSpaceEnd - CodeRegionEnd; + MapBaseAddress = CodeRegionEnd; + MapAvailableSize = AddrSpaceEnd - CodeRegionEnd; } - ulong mapTotalSize = aliasRegion.Size + heapRegion.Size + stackRegion.Size + tlsIoRegion.Size; + ulong MapTotalSize = AliasRegion.Size + HeapRegion.Size + StackRegion.Size + TlsIoRegion.Size; - ulong aslrMaxOffset = mapAvailableSize - mapTotalSize; + ulong AslrMaxOffset = MapAvailableSize - MapTotalSize; - _aslrEnabled = aslrEnabled; + this.AslrEnabled = AslrEnabled; - AddrSpaceStart = addrSpaceStart; - AddrSpaceEnd = addrSpaceEnd; + this.AddrSpaceStart = AddrSpaceStart; + this.AddrSpaceEnd = AddrSpaceEnd; - _blockAllocator = blockAllocator; + this.BlockAllocator = BlockAllocator; - if (mapAvailableSize < mapTotalSize) + if (MapAvailableSize < MapTotalSize) { return KernelResult.OutOfMemory; } - if (aslrEnabled) + if (AslrEnabled) { - aliasRegion.AslrOffset = GetRandomValue(0, aslrMaxOffset >> 21) << 21; - heapRegion.AslrOffset = GetRandomValue(0, aslrMaxOffset >> 21) << 21; - stackRegion.AslrOffset = GetRandomValue(0, aslrMaxOffset >> 21) << 21; - tlsIoRegion.AslrOffset = GetRandomValue(0, aslrMaxOffset >> 21) << 21; + AliasRegion.AslrOffset = GetRandomValue(0, AslrMaxOffset >> 21) << 21; + HeapRegion.AslrOffset = GetRandomValue(0, AslrMaxOffset >> 21) << 21; + StackRegion.AslrOffset = GetRandomValue(0, AslrMaxOffset >> 21) << 21; + TlsIoRegion.AslrOffset = GetRandomValue(0, AslrMaxOffset >> 21) << 21; } //Regions are sorted based on ASLR offset. //When ASLR is disabled, the order is Map, Heap, NewMap and TlsIo. - aliasRegion.Start = mapBaseAddress + aliasRegion.AslrOffset; - aliasRegion.End = aliasRegion.Start + aliasRegion.Size; - heapRegion.Start = mapBaseAddress + heapRegion.AslrOffset; - heapRegion.End = heapRegion.Start + heapRegion.Size; - stackRegion.Start = mapBaseAddress + stackRegion.AslrOffset; - stackRegion.End = stackRegion.Start + stackRegion.Size; - tlsIoRegion.Start = mapBaseAddress + tlsIoRegion.AslrOffset; - tlsIoRegion.End = tlsIoRegion.Start + tlsIoRegion.Size; + AliasRegion.Start = MapBaseAddress + AliasRegion.AslrOffset; + AliasRegion.End = AliasRegion.Start + AliasRegion.Size; + HeapRegion.Start = MapBaseAddress + HeapRegion.AslrOffset; + HeapRegion.End = HeapRegion.Start + HeapRegion.Size; + StackRegion.Start = MapBaseAddress + StackRegion.AslrOffset; + StackRegion.End = StackRegion.Start + StackRegion.Size; + TlsIoRegion.Start = MapBaseAddress + TlsIoRegion.AslrOffset; + TlsIoRegion.End = TlsIoRegion.Start + TlsIoRegion.Size; - SortRegion(heapRegion, aliasRegion); + SortRegion(HeapRegion, AliasRegion); - if (stackRegion.Size != 0) + if (StackRegion.Size != 0) { - SortRegion(stackRegion, aliasRegion); - SortRegion(stackRegion, heapRegion); + SortRegion(StackRegion, AliasRegion); + SortRegion(StackRegion, HeapRegion); } else { - stackRegion.Start = stackAndTlsIoStart; - stackRegion.End = stackAndTlsIoEnd; + StackRegion.Start = StackAndTlsIoStart; + StackRegion.End = StackAndTlsIoEnd; } - if (tlsIoRegion.Size != 0) + if (TlsIoRegion.Size != 0) { - SortRegion(tlsIoRegion, aliasRegion); - SortRegion(tlsIoRegion, heapRegion); - SortRegion(tlsIoRegion, stackRegion); + SortRegion(TlsIoRegion, AliasRegion); + SortRegion(TlsIoRegion, HeapRegion); + SortRegion(TlsIoRegion, StackRegion); } else { - tlsIoRegion.Start = stackAndTlsIoStart; - tlsIoRegion.End = stackAndTlsIoEnd; + TlsIoRegion.Start = StackAndTlsIoStart; + TlsIoRegion.End = StackAndTlsIoEnd; } - AliasRegionStart = aliasRegion.Start; - AliasRegionEnd = aliasRegion.End; - HeapRegionStart = heapRegion.Start; - HeapRegionEnd = heapRegion.End; - StackRegionStart = stackRegion.Start; - StackRegionEnd = stackRegion.End; - TlsIoRegionStart = tlsIoRegion.Start; - TlsIoRegionEnd = tlsIoRegion.End; + AliasRegionStart = AliasRegion.Start; + AliasRegionEnd = AliasRegion.End; + HeapRegionStart = HeapRegion.Start; + HeapRegionEnd = HeapRegion.End; + StackRegionStart = StackRegion.Start; + StackRegionEnd = StackRegion.End; + TlsIoRegionStart = TlsIoRegion.Start; + TlsIoRegionEnd = TlsIoRegion.End; - _currentHeapAddr = HeapRegionStart; - _heapCapacity = 0; + CurrentHeapAddr = HeapRegionStart; + HeapCapacity = 0; PhysicalMemoryUsage = 0; - _memRegion = memRegion; - _aslrDisabled = aslrDisabled; + this.MemRegion = MemRegion; + this.AslrDisabled = AslrDisabled; - return InitializeBlocks(addrSpaceStart, addrSpaceEnd); + return InitializeBlocks(AddrSpaceStart, AddrSpaceEnd); } - private ulong GetRandomValue(ulong min, ulong max) + private ulong GetRandomValue(ulong Min, ulong Max) { - return (ulong)GetRandomValue((long)min, (long)max); + return (ulong)GetRandomValue((long)Min, (long)Max); } - private long GetRandomValue(long min, long max) + private long GetRandomValue(long Min, long Max) { - if (_randomNumberGenerator == null) + if (RandomNumberGenerator == null) { - _randomNumberGenerator = new MersenneTwister(0); + RandomNumberGenerator = new MersenneTwister(0); } - return _randomNumberGenerator.GenRandomNumber(min, max); + return RandomNumberGenerator.GenRandomNumber(Min, Max); } - private static void SortRegion(Region lhs, Region rhs) + private static void SortRegion(Region Lhs, Region Rhs) { - if (lhs.AslrOffset < rhs.AslrOffset) + if (Lhs.AslrOffset < Rhs.AslrOffset) { - rhs.Start += lhs.Size; - rhs.End += lhs.Size; + Rhs.Start += Lhs.Size; + Rhs.End += Lhs.Size; } else { - lhs.Start += rhs.Size; - lhs.End += rhs.Size; + Lhs.Start += Rhs.Size; + Lhs.End += Rhs.Size; } } - private KernelResult InitializeBlocks(ulong addrSpaceStart, ulong addrSpaceEnd) + private KernelResult InitializeBlocks(ulong AddrSpaceStart, ulong AddrSpaceEnd) { //First insertion will always need only a single block, //because there's nothing else to split. - if (!_blockAllocator.CanAllocate(1)) + if (!BlockAllocator.CanAllocate(1)) { return KernelResult.OutOfResource; } - ulong addrSpacePagesCount = (addrSpaceEnd - addrSpaceStart) / PageSize; + ulong AddrSpacePagesCount = (AddrSpaceEnd - AddrSpaceStart) / PageSize; - InsertBlock(addrSpaceStart, addrSpacePagesCount, MemoryState.Unmapped); + InsertBlock(AddrSpaceStart, AddrSpacePagesCount, MemoryState.Unmapped); return KernelResult.Success; } public KernelResult MapPages( - ulong address, - KPageList pageList, - MemoryState state, - MemoryPermission permission) + ulong Address, + KPageList PageList, + MemoryState State, + MemoryPermission Permission) { - ulong pagesCount = pageList.GetPagesCount(); + ulong PagesCount = PageList.GetPagesCount(); - ulong size = pagesCount * PageSize; + ulong Size = PagesCount * PageSize; - if (!ValidateRegionForState(address, size, state)) + if (!ValidateRegionForState(Address, Size, State)) { return KernelResult.InvalidMemState; } - lock (_blocks) + lock (Blocks) { - if (!IsUnmapped(address, pagesCount * PageSize)) + if (!IsUnmapped(Address, PagesCount * PageSize)) { return KernelResult.InvalidMemState; } - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) { return KernelResult.OutOfResource; } - KernelResult result = MapPages(address, pageList, permission); + KernelResult Result = MapPages(Address, PageList, Permission); - if (result == KernelResult.Success) + if (Result == KernelResult.Success) { - InsertBlock(address, pagesCount, state, permission); + InsertBlock(Address, PagesCount, State, Permission); } - return result; + return Result; } } - public KernelResult UnmapPages(ulong address, KPageList pageList, MemoryState stateExpected) + public KernelResult UnmapPages(ulong Address, KPageList PageList, MemoryState StateExpected) { - ulong pagesCount = pageList.GetPagesCount(); + ulong PagesCount = PageList.GetPagesCount(); - ulong size = pagesCount * PageSize; + ulong Size = PagesCount * PageSize; - ulong endAddr = address + size; + ulong EndAddr = Address + Size; - ulong addrSpacePagesCount = (AddrSpaceEnd - AddrSpaceStart) / PageSize; + ulong AddrSpacePagesCount = (AddrSpaceEnd - AddrSpaceStart) / PageSize; - if (AddrSpaceStart > address) + if (AddrSpaceStart > Address) { return KernelResult.InvalidMemState; } - if (addrSpacePagesCount < pagesCount) + if (AddrSpacePagesCount < PagesCount) { return KernelResult.InvalidMemState; } - if (endAddr - 1 > AddrSpaceEnd - 1) + if (EndAddr - 1 > AddrSpaceEnd - 1) { return KernelResult.InvalidMemState; } - lock (_blocks) + lock (Blocks) { - KPageList currentPageList = new KPageList(); + KPageList CurrentPageList = new KPageList(); - AddVaRangeToPageList(currentPageList, address, pagesCount); + AddVaRangeToPageList(CurrentPageList, Address, PagesCount); - if (!currentPageList.IsEqual(pageList)) + if (!CurrentPageList.IsEqual(PageList)) { return KernelResult.InvalidMemRange; } if (CheckRange( - address, - size, + Address, + Size, MemoryState.Mask, - stateExpected, + StateExpected, MemoryPermission.None, MemoryPermission.None, MemoryAttribute.Mask, MemoryAttribute.None, MemoryAttribute.IpcAndDeviceMapped, - out MemoryState state, + out MemoryState State, out _, out _)) { - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) { return KernelResult.OutOfResource; } - KernelResult result = MmuUnmap(address, pagesCount); + KernelResult Result = MmuUnmap(Address, PagesCount); - if (result == KernelResult.Success) + if (Result == KernelResult.Success) { - InsertBlock(address, pagesCount, MemoryState.Unmapped); + InsertBlock(Address, PagesCount, MemoryState.Unmapped); } - return result; + return Result; } else { @@ -447,191 +447,191 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult MapNormalMemory(long address, long size, MemoryPermission permission) + public KernelResult MapNormalMemory(long Address, long Size, MemoryPermission Permission) { //TODO. return KernelResult.Success; } - public KernelResult MapIoMemory(long address, long size, MemoryPermission permission) + public KernelResult MapIoMemory(long Address, long Size, MemoryPermission Permission) { //TODO. return KernelResult.Success; } public KernelResult AllocateOrMapPa( - ulong neededPagesCount, - int alignment, - ulong srcPa, - bool map, - ulong regionStart, - ulong regionPagesCount, - MemoryState state, - MemoryPermission permission, - out ulong address) + ulong NeededPagesCount, + int Alignment, + ulong SrcPa, + bool Map, + ulong RegionStart, + ulong RegionPagesCount, + MemoryState State, + MemoryPermission Permission, + out ulong Address) { - address = 0; + Address = 0; - ulong regionSize = regionPagesCount * PageSize; + ulong RegionSize = RegionPagesCount * PageSize; - ulong regionEndAddr = regionStart + regionSize; + ulong RegionEndAddr = RegionStart + RegionSize; - if (!ValidateRegionForState(regionStart, regionSize, state)) + if (!ValidateRegionForState(RegionStart, RegionSize, State)) { return KernelResult.InvalidMemState; } - if (regionPagesCount <= neededPagesCount) + if (RegionPagesCount <= NeededPagesCount) { return KernelResult.OutOfMemory; } - ulong reservedPagesCount = _isKernel ? 1UL : 4UL; + ulong ReservedPagesCount = IsKernel ? 1UL : 4UL; - lock (_blocks) + lock (Blocks) { - if (_aslrEnabled) + if (AslrEnabled) { - ulong totalNeededSize = (reservedPagesCount + neededPagesCount) * PageSize; + ulong TotalNeededSize = (ReservedPagesCount + NeededPagesCount) * PageSize; - ulong remainingPages = regionPagesCount - neededPagesCount; + ulong RemainingPages = RegionPagesCount - NeededPagesCount; - ulong aslrMaxOffset = ((remainingPages + reservedPagesCount) * PageSize) / (ulong)alignment; + ulong AslrMaxOffset = ((RemainingPages + ReservedPagesCount) * PageSize) / (ulong)Alignment; - for (int attempt = 0; attempt < 8; attempt++) + for (int Attempt = 0; Attempt < 8; Attempt++) { - address = BitUtils.AlignDown(regionStart + GetRandomValue(0, aslrMaxOffset) * (ulong)alignment, alignment); + Address = BitUtils.AlignDown(RegionStart + GetRandomValue(0, AslrMaxOffset) * (ulong)Alignment, Alignment); - ulong endAddr = address + totalNeededSize; + ulong EndAddr = Address + TotalNeededSize; - KMemoryInfo info = FindBlock(address).GetInfo(); + KMemoryInfo Info = FindBlock(Address).GetInfo(); - if (info.State != MemoryState.Unmapped) + if (Info.State != MemoryState.Unmapped) { continue; } - ulong currBaseAddr = info.Address + reservedPagesCount * PageSize; - ulong currEndAddr = info.Address + info.Size; + ulong CurrBaseAddr = Info.Address + ReservedPagesCount * PageSize; + ulong CurrEndAddr = Info.Address + Info.Size; - if (address >= regionStart && - address >= currBaseAddr && - endAddr - 1 <= regionEndAddr - 1 && - endAddr - 1 <= currEndAddr - 1) + if (Address >= RegionStart && + Address >= CurrBaseAddr && + EndAddr - 1 <= RegionEndAddr - 1 && + EndAddr - 1 <= CurrEndAddr - 1) { break; } } - if (address == 0) + if (Address == 0) { - ulong aslrPage = GetRandomValue(0, aslrMaxOffset); + ulong AslrPage = GetRandomValue(0, AslrMaxOffset); - address = FindFirstFit( - regionStart + aslrPage * PageSize, - regionPagesCount - aslrPage, - neededPagesCount, - alignment, + Address = FindFirstFit( + RegionStart + AslrPage * PageSize, + RegionPagesCount - AslrPage, + NeededPagesCount, + Alignment, 0, - reservedPagesCount); + ReservedPagesCount); } } - if (address == 0) + if (Address == 0) { - address = FindFirstFit( - regionStart, - regionPagesCount, - neededPagesCount, - alignment, + Address = FindFirstFit( + RegionStart, + RegionPagesCount, + NeededPagesCount, + Alignment, 0, - reservedPagesCount); + ReservedPagesCount); } - if (address == 0) + if (Address == 0) { return KernelResult.OutOfMemory; } - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) { return KernelResult.OutOfResource; } - MemoryOperation operation = map + MemoryOperation Operation = Map ? MemoryOperation.MapPa : MemoryOperation.Allocate; - KernelResult result = DoMmuOperation( - address, - neededPagesCount, - srcPa, - map, - permission, - operation); + KernelResult Result = DoMmuOperation( + Address, + NeededPagesCount, + SrcPa, + Map, + Permission, + Operation); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } - InsertBlock(address, neededPagesCount, state, permission); + InsertBlock(Address, NeededPagesCount, State, Permission); } return KernelResult.Success; } public KernelResult MapNewProcessCode( - ulong address, - ulong pagesCount, - MemoryState state, - MemoryPermission permission) + ulong Address, + ulong PagesCount, + MemoryState State, + MemoryPermission Permission) { - ulong size = pagesCount * PageSize; + ulong Size = PagesCount * PageSize; - if (!ValidateRegionForState(address, size, state)) + if (!ValidateRegionForState(Address, Size, State)) { return KernelResult.InvalidMemState; } - lock (_blocks) + lock (Blocks) { - if (!IsUnmapped(address, size)) + if (!IsUnmapped(Address, Size)) { return KernelResult.InvalidMemState; } - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) { return KernelResult.OutOfResource; } - KernelResult result = DoMmuOperation( - address, - pagesCount, + KernelResult Result = DoMmuOperation( + Address, + PagesCount, 0, false, - permission, + Permission, MemoryOperation.Allocate); - if (result == KernelResult.Success) + if (Result == KernelResult.Success) { - InsertBlock(address, pagesCount, state, permission); + InsertBlock(Address, PagesCount, State, Permission); } - return result; + return Result; } } - public KernelResult MapProcessCodeMemory(ulong dst, ulong src, ulong size) + public KernelResult MapProcessCodeMemory(ulong Dst, ulong Src, ulong Size) { - ulong pagesCount = size / PageSize; + ulong PagesCount = Size / PageSize; - lock (_blocks) + lock (Blocks) { - bool success = CheckRange( - src, - size, + bool Success = CheckRange( + Src, + Size, MemoryState.Mask, MemoryState.Heap, MemoryPermission.Mask, @@ -639,41 +639,41 @@ namespace Ryujinx.HLE.HOS.Kernel MemoryAttribute.Mask, MemoryAttribute.None, MemoryAttribute.IpcAndDeviceMapped, - out MemoryState state, - out MemoryPermission permission, + out MemoryState State, + out MemoryPermission Permission, out _); - success &= IsUnmapped(dst, size); + Success &= IsUnmapped(Dst, Size); - if (success) + if (Success) { - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion * 2)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion * 2)) { return KernelResult.OutOfResource; } - KPageList pageList = new KPageList(); + KPageList PageList = new KPageList(); - AddVaRangeToPageList(pageList, src, pagesCount); + AddVaRangeToPageList(PageList, Src, PagesCount); - KernelResult result = MmuChangePermission(src, pagesCount, MemoryPermission.None); + KernelResult Result = MmuChangePermission(Src, PagesCount, MemoryPermission.None); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } - result = MapPages(dst, pageList, MemoryPermission.None); + Result = MapPages(Dst, PageList, MemoryPermission.None); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - MmuChangePermission(src, pagesCount, permission); + MmuChangePermission(Src, PagesCount, Permission); - return result; + return Result; } - InsertBlock(src, pagesCount, state, MemoryPermission.None, MemoryAttribute.Borrowed); - InsertBlock(dst, pagesCount, MemoryState.ModCodeStatic); + InsertBlock(Src, PagesCount, State, MemoryPermission.None, MemoryAttribute.Borrowed); + InsertBlock(Dst, PagesCount, MemoryState.ModCodeStatic); return KernelResult.Success; } @@ -684,15 +684,15 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult UnmapProcessCodeMemory(ulong dst, ulong src, ulong size) + public KernelResult UnmapProcessCodeMemory(ulong Dst, ulong Src, ulong Size) { - ulong pagesCount = size / PageSize; + ulong PagesCount = Size / PageSize; - lock (_blocks) + lock (Blocks) { - bool success = CheckRange( - src, - size, + bool Success = CheckRange( + Src, + Size, MemoryState.Mask, MemoryState.Heap, MemoryPermission.None, @@ -704,8 +704,8 @@ namespace Ryujinx.HLE.HOS.Kernel out _, out _); - success &= CheckRange( - dst, + Success &= CheckRange( + Dst, PageSize, MemoryState.UnmapProcessCodeMemoryAllowed, MemoryState.UnmapProcessCodeMemoryAllowed, @@ -714,38 +714,38 @@ namespace Ryujinx.HLE.HOS.Kernel MemoryAttribute.Mask, MemoryAttribute.None, MemoryAttribute.IpcAndDeviceMapped, - out MemoryState state, + out MemoryState State, out _, out _); - success &= CheckRange( - dst, - size, + Success &= CheckRange( + Dst, + Size, MemoryState.Mask, - state, + State, MemoryPermission.None, MemoryPermission.None, MemoryAttribute.Mask, MemoryAttribute.None); - if (success) + if (Success) { - KernelResult result = MmuUnmap(dst, pagesCount); + KernelResult Result = MmuUnmap(Dst, PagesCount); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } //TODO: Missing some checks here. - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion * 2)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion * 2)) { return KernelResult.OutOfResource; } - InsertBlock(dst, pagesCount, MemoryState.Unmapped); - InsertBlock(src, pagesCount, MemoryState.Heap, MemoryPermission.ReadAndWrite); + InsertBlock(Dst, PagesCount, MemoryState.Unmapped); + InsertBlock(Src, PagesCount, MemoryState.Heap, MemoryPermission.ReadAndWrite); return KernelResult.Success; } @@ -756,105 +756,105 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult SetHeapSize(ulong size, out ulong address) + public KernelResult SetHeapSize(ulong Size, out ulong Address) { - address = 0; + Address = 0; - if (size > HeapRegionEnd - HeapRegionStart) + if (Size > HeapRegionEnd - HeapRegionStart) { return KernelResult.OutOfMemory; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - ulong currentHeapSize = GetHeapSize(); + ulong CurrentHeapSize = GetHeapSize(); - if (currentHeapSize <= size) + if (CurrentHeapSize <= Size) { //Expand. - ulong diffSize = size - currentHeapSize; + ulong DiffSize = Size - CurrentHeapSize; - lock (_blocks) + lock (Blocks) { - if (currentProcess.ResourceLimit != null && diffSize != 0 && - !currentProcess.ResourceLimit.Reserve(LimitableResource.Memory, diffSize)) + if (CurrentProcess.ResourceLimit != null && DiffSize != 0 && + !CurrentProcess.ResourceLimit.Reserve(LimitableResource.Memory, DiffSize)) { return KernelResult.ResLimitExceeded; } - ulong pagesCount = diffSize / PageSize; + ulong PagesCount = DiffSize / PageSize; - KMemoryRegionManager region = GetMemoryRegionManager(); + KMemoryRegionManager Region = GetMemoryRegionManager(); - KernelResult result = region.AllocatePages(pagesCount, _aslrDisabled, out KPageList pageList); + KernelResult Result = Region.AllocatePages(PagesCount, AslrDisabled, out KPageList PageList); void CleanUpForError() { - if (pageList != null) + if (PageList != null) { - region.FreePages(pageList); + Region.FreePages(PageList); } - if (currentProcess.ResourceLimit != null && diffSize != 0) + if (CurrentProcess.ResourceLimit != null && DiffSize != 0) { - currentProcess.ResourceLimit.Release(LimitableResource.Memory, diffSize); + CurrentProcess.ResourceLimit.Release(LimitableResource.Memory, DiffSize); } } - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { CleanUpForError(); - return result; + return Result; } - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) { CleanUpForError(); return KernelResult.OutOfResource; } - if (!IsUnmapped(_currentHeapAddr, diffSize)) + if (!IsUnmapped(CurrentHeapAddr, DiffSize)) { CleanUpForError(); return KernelResult.InvalidMemState; } - result = DoMmuOperation( - _currentHeapAddr, - pagesCount, - pageList, + Result = DoMmuOperation( + CurrentHeapAddr, + PagesCount, + PageList, MemoryPermission.ReadAndWrite, MemoryOperation.MapVa); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { CleanUpForError(); - return result; + return Result; } - InsertBlock(_currentHeapAddr, pagesCount, MemoryState.Heap, MemoryPermission.ReadAndWrite); + InsertBlock(CurrentHeapAddr, PagesCount, MemoryState.Heap, MemoryPermission.ReadAndWrite); } } else { //Shrink. - ulong freeAddr = HeapRegionStart + size; - ulong diffSize = currentHeapSize - size; + ulong FreeAddr = HeapRegionStart + Size; + ulong DiffSize = CurrentHeapSize - Size; - lock (_blocks) + lock (Blocks) { - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) { return KernelResult.OutOfResource; } if (!CheckRange( - freeAddr, - diffSize, + FreeAddr, + DiffSize, MemoryState.Mask, MemoryState.Heap, MemoryPermission.Mask, @@ -869,31 +869,31 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.InvalidMemState; } - ulong pagesCount = diffSize / PageSize; + ulong PagesCount = DiffSize / PageSize; - KernelResult result = MmuUnmap(freeAddr, pagesCount); + KernelResult Result = MmuUnmap(FreeAddr, PagesCount); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } - currentProcess.ResourceLimit?.Release(LimitableResource.Memory, BitUtils.AlignDown(diffSize, PageSize)); + CurrentProcess.ResourceLimit?.Release(LimitableResource.Memory, BitUtils.AlignDown(DiffSize, PageSize)); - InsertBlock(freeAddr, pagesCount, MemoryState.Unmapped); + InsertBlock(FreeAddr, PagesCount, MemoryState.Unmapped); } } - _currentHeapAddr = HeapRegionStart + size; + CurrentHeapAddr = HeapRegionStart + Size; - address = HeapRegionStart; + Address = HeapRegionStart; return KernelResult.Success; } public ulong GetTotalHeapSize() { - lock (_blocks) + lock (Blocks) { return GetHeapSize() + PhysicalMemoryUsage; } @@ -901,30 +901,30 @@ namespace Ryujinx.HLE.HOS.Kernel private ulong GetHeapSize() { - return _currentHeapAddr - HeapRegionStart; + return CurrentHeapAddr - HeapRegionStart; } - public KernelResult SetHeapCapacity(ulong capacity) + public KernelResult SetHeapCapacity(ulong Capacity) { - lock (_blocks) + lock (Blocks) { - _heapCapacity = capacity; + HeapCapacity = Capacity; } return KernelResult.Success; } public KernelResult SetMemoryAttribute( - ulong address, - ulong size, - MemoryAttribute attributeMask, - MemoryAttribute attributeValue) + ulong Address, + ulong Size, + MemoryAttribute AttributeMask, + MemoryAttribute AttributeValue) { - lock (_blocks) + lock (Blocks) { if (CheckRange( - address, - size, + Address, + Size, MemoryState.AttributeChangeAllowed, MemoryState.AttributeChangeAllowed, MemoryPermission.None, @@ -932,21 +932,21 @@ namespace Ryujinx.HLE.HOS.Kernel MemoryAttribute.BorrowedAndIpcMapped, MemoryAttribute.None, MemoryAttribute.DeviceMappedAndUncached, - out MemoryState state, - out MemoryPermission permission, - out MemoryAttribute attribute)) + out MemoryState State, + out MemoryPermission Permission, + out MemoryAttribute Attribute)) { - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) { return KernelResult.OutOfResource; } - ulong pagesCount = size / PageSize; + ulong PagesCount = Size / PageSize; - attribute &= ~attributeMask; - attribute |= attributeMask & attributeValue; + Attribute &= ~AttributeMask; + Attribute |= AttributeMask & AttributeValue; - InsertBlock(address, pagesCount, state, permission, attribute); + InsertBlock(Address, PagesCount, State, Permission, Attribute); return KernelResult.Success; } @@ -957,14 +957,14 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KMemoryInfo QueryMemory(ulong address) + public KMemoryInfo QueryMemory(ulong Address) { - if (address >= AddrSpaceStart && - address < AddrSpaceEnd) + if (Address >= AddrSpaceStart && + Address < AddrSpaceEnd) { - lock (_blocks) + lock (Blocks) { - return FindBlock(address).GetInfo(); + return FindBlock(Address).GetInfo(); } } else @@ -980,15 +980,15 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult Map(ulong dst, ulong src, ulong size) + public KernelResult Map(ulong Dst, ulong Src, ulong Size) { - bool success; + bool Success; - lock (_blocks) + lock (Blocks) { - success = CheckRange( - src, - size, + Success = CheckRange( + Src, + Size, MemoryState.MapAllowed, MemoryState.MapAllowed, MemoryPermission.Mask, @@ -996,46 +996,46 @@ namespace Ryujinx.HLE.HOS.Kernel MemoryAttribute.Mask, MemoryAttribute.None, MemoryAttribute.IpcAndDeviceMapped, - out MemoryState srcState, + out MemoryState SrcState, out _, out _); - success &= IsUnmapped(dst, size); + Success &= IsUnmapped(Dst, Size); - if (success) + if (Success) { - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion * 2)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion * 2)) { return KernelResult.OutOfResource; } - ulong pagesCount = size / PageSize; + ulong PagesCount = Size / PageSize; - KPageList pageList = new KPageList(); + KPageList PageList = new KPageList(); - AddVaRangeToPageList(pageList, src, pagesCount); + AddVaRangeToPageList(PageList, Src, PagesCount); - KernelResult result = MmuChangePermission(src, pagesCount, MemoryPermission.None); + KernelResult Result = MmuChangePermission(Src, PagesCount, MemoryPermission.None); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } - result = MapPages(dst, pageList, MemoryPermission.ReadAndWrite); + Result = MapPages(Dst, PageList, MemoryPermission.ReadAndWrite); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - if (MmuChangePermission(src, pagesCount, MemoryPermission.ReadAndWrite) != KernelResult.Success) + if (MmuChangePermission(Src, PagesCount, MemoryPermission.ReadAndWrite) != KernelResult.Success) { throw new InvalidOperationException("Unexpected failure reverting memory permission."); } - return result; + return Result; } - InsertBlock(src, pagesCount, srcState, MemoryPermission.None, MemoryAttribute.Borrowed); - InsertBlock(dst, pagesCount, MemoryState.Stack, MemoryPermission.ReadAndWrite); + InsertBlock(Src, PagesCount, SrcState, MemoryPermission.None, MemoryAttribute.Borrowed); + InsertBlock(Dst, PagesCount, MemoryState.Stack, MemoryPermission.ReadAndWrite); return KernelResult.Success; } @@ -1046,17 +1046,17 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult UnmapForKernel(ulong address, ulong pagesCount, MemoryState stateExpected) + public KernelResult UnmapForKernel(ulong Address, ulong PagesCount, MemoryState StateExpected) { - ulong size = pagesCount * PageSize; + ulong Size = PagesCount * PageSize; - lock (_blocks) + lock (Blocks) { if (CheckRange( - address, - size, + Address, + Size, MemoryState.Mask, - stateExpected, + StateExpected, MemoryPermission.None, MemoryPermission.None, MemoryAttribute.Mask, @@ -1066,16 +1066,16 @@ namespace Ryujinx.HLE.HOS.Kernel out _, out _)) { - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) { return KernelResult.OutOfResource; } - KernelResult result = MmuUnmap(address, pagesCount); + KernelResult Result = MmuUnmap(Address, PagesCount); - if (result == KernelResult.Success) + if (Result == KernelResult.Success) { - InsertBlock(address, pagesCount, MemoryState.Unmapped); + InsertBlock(Address, PagesCount, MemoryState.Unmapped); } return KernelResult.Success; @@ -1087,15 +1087,15 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult Unmap(ulong dst, ulong src, ulong size) + public KernelResult Unmap(ulong Dst, ulong Src, ulong Size) { - bool success; + bool Success; - lock (_blocks) + lock (Blocks) { - success = CheckRange( - src, - size, + Success = CheckRange( + Src, + Size, MemoryState.MapAllowed, MemoryState.MapAllowed, MemoryPermission.Mask, @@ -1103,13 +1103,13 @@ namespace Ryujinx.HLE.HOS.Kernel MemoryAttribute.Mask, MemoryAttribute.Borrowed, MemoryAttribute.IpcAndDeviceMapped, - out MemoryState srcState, + out MemoryState SrcState, out _, out _); - success &= CheckRange( - dst, - size, + Success &= CheckRange( + Dst, + Size, MemoryState.Mask, MemoryState.Stack, MemoryPermission.None, @@ -1118,47 +1118,47 @@ namespace Ryujinx.HLE.HOS.Kernel MemoryAttribute.None, MemoryAttribute.IpcAndDeviceMapped, out _, - out MemoryPermission dstPermission, + out MemoryPermission DstPermission, out _); - if (success) + if (Success) { - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion * 2)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion * 2)) { return KernelResult.OutOfResource; } - ulong pagesCount = size / PageSize; + ulong PagesCount = Size / PageSize; - KPageList srcPageList = new KPageList(); - KPageList dstPageList = new KPageList(); + KPageList SrcPageList = new KPageList(); + KPageList DstPageList = new KPageList(); - AddVaRangeToPageList(srcPageList, src, pagesCount); - AddVaRangeToPageList(dstPageList, dst, pagesCount); + AddVaRangeToPageList(SrcPageList, Src, PagesCount); + AddVaRangeToPageList(DstPageList, Dst, PagesCount); - if (!dstPageList.IsEqual(srcPageList)) + if (!DstPageList.IsEqual(SrcPageList)) { return KernelResult.InvalidMemRange; } - KernelResult result = MmuUnmap(dst, pagesCount); + KernelResult Result = MmuUnmap(Dst, PagesCount); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } - result = MmuChangePermission(src, pagesCount, MemoryPermission.ReadAndWrite); + Result = MmuChangePermission(Src, PagesCount, MemoryPermission.ReadAndWrite); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - MapPages(dst, dstPageList, dstPermission); + MapPages(Dst, DstPageList, DstPermission); - return result; + return Result; } - InsertBlock(src, pagesCount, srcState, MemoryPermission.ReadAndWrite); - InsertBlock(dst, pagesCount, MemoryState.Unmapped); + InsertBlock(Src, PagesCount, SrcState, MemoryPermission.ReadAndWrite); + InsertBlock(Dst, PagesCount, MemoryState.Unmapped); return KernelResult.Success; } @@ -1169,13 +1169,13 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult ReserveTransferMemory(ulong address, ulong size, MemoryPermission permission) + public KernelResult ReserveTransferMemory(ulong Address, ulong Size, MemoryPermission Permission) { - lock (_blocks) + lock (Blocks) { if (CheckRange( - address, - size, + Address, + Size, MemoryState.TransferMemoryAllowed | MemoryState.IsPoolAllocated, MemoryState.TransferMemoryAllowed | MemoryState.IsPoolAllocated, MemoryPermission.Mask, @@ -1183,22 +1183,22 @@ namespace Ryujinx.HLE.HOS.Kernel MemoryAttribute.Mask, MemoryAttribute.None, MemoryAttribute.IpcAndDeviceMapped, - out MemoryState state, + out MemoryState State, out _, - out MemoryAttribute attribute)) + out MemoryAttribute Attribute)) { //TODO: Missing checks. - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) { return KernelResult.OutOfResource; } - ulong pagesCount = size / PageSize; + ulong PagesCount = Size / PageSize; - attribute |= MemoryAttribute.Borrowed; + Attribute |= MemoryAttribute.Borrowed; - InsertBlock(address, pagesCount, state, permission, attribute); + InsertBlock(Address, PagesCount, State, Permission, Attribute); return KernelResult.Success; } @@ -1209,13 +1209,13 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult ResetTransferMemory(ulong address, ulong size) + public KernelResult ResetTransferMemory(ulong Address, ulong Size) { - lock (_blocks) + lock (Blocks) { if (CheckRange( - address, - size, + Address, + Size, MemoryState.TransferMemoryAllowed | MemoryState.IsPoolAllocated, MemoryState.TransferMemoryAllowed | MemoryState.IsPoolAllocated, MemoryPermission.None, @@ -1223,18 +1223,18 @@ namespace Ryujinx.HLE.HOS.Kernel MemoryAttribute.Mask, MemoryAttribute.Borrowed, MemoryAttribute.IpcAndDeviceMapped, - out MemoryState state, + out MemoryState State, out _, out _)) { - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) { return KernelResult.OutOfResource; } - ulong pagesCount = size / PageSize; + ulong PagesCount = Size / PageSize; - InsertBlock(address, pagesCount, state, MemoryPermission.ReadAndWrite); + InsertBlock(Address, PagesCount, State, MemoryPermission.ReadAndWrite); return KernelResult.Success; } @@ -1245,13 +1245,13 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult SetProcessMemoryPermission(ulong address, ulong size, MemoryPermission permission) + public KernelResult SetProcessMemoryPermission(ulong Address, ulong Size, MemoryPermission Permission) { - lock (_blocks) + lock (Blocks) { if (CheckRange( - address, - size, + Address, + Size, MemoryState.ProcessPermissionChangeAllowed, MemoryState.ProcessPermissionChangeAllowed, MemoryPermission.None, @@ -1259,51 +1259,51 @@ namespace Ryujinx.HLE.HOS.Kernel MemoryAttribute.Mask, MemoryAttribute.None, MemoryAttribute.IpcAndDeviceMapped, - out MemoryState oldState, - out MemoryPermission oldPermission, + out MemoryState OldState, + out MemoryPermission OldPermission, out _)) { - MemoryState newState = oldState; + MemoryState NewState = OldState; //If writing into the code region is allowed, then we need //to change it to mutable. - if ((permission & MemoryPermission.Write) != 0) + if ((Permission & MemoryPermission.Write) != 0) { - if (oldState == MemoryState.CodeStatic) + if (OldState == MemoryState.CodeStatic) { - newState = MemoryState.CodeMutable; + NewState = MemoryState.CodeMutable; } - else if (oldState == MemoryState.ModCodeStatic) + else if (OldState == MemoryState.ModCodeStatic) { - newState = MemoryState.ModCodeMutable; + NewState = MemoryState.ModCodeMutable; } else { - throw new InvalidOperationException($"Memory state \"{oldState}\" not valid for this operation."); + throw new InvalidOperationException($"Memory state \"{OldState}\" not valid for this operation."); } } - if (newState != oldState || permission != oldPermission) + if (NewState != OldState || Permission != OldPermission) { - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) { return KernelResult.OutOfResource; } - ulong pagesCount = size / PageSize; + ulong PagesCount = Size / PageSize; - MemoryOperation operation = (permission & MemoryPermission.Execute) != 0 + MemoryOperation Operation = (Permission & MemoryPermission.Execute) != 0 ? MemoryOperation.ChangePermsAndAttributes : MemoryOperation.ChangePermRw; - KernelResult result = DoMmuOperation(address, pagesCount, 0, false, permission, operation); + KernelResult Result = DoMmuOperation(Address, PagesCount, 0, false, Permission, Operation); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } - InsertBlock(address, pagesCount, newState, permission); + InsertBlock(Address, PagesCount, NewState, Permission); } return KernelResult.Success; @@ -1315,85 +1315,85 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult MapPhysicalMemory(ulong address, ulong size) + public KernelResult MapPhysicalMemory(ulong Address, ulong Size) { - ulong endAddr = address + size; + ulong EndAddr = Address + Size; - lock (_blocks) + lock (Blocks) { - ulong mappedSize = 0; + ulong MappedSize = 0; - KMemoryInfo info; + KMemoryInfo Info; - LinkedListNode<KMemoryBlock> node = FindBlockNode(address); + LinkedListNode<KMemoryBlock> Node = FindBlockNode(Address); do { - info = node.Value.GetInfo(); + Info = Node.Value.GetInfo(); - if (info.State != MemoryState.Unmapped) + if (Info.State != MemoryState.Unmapped) { - mappedSize += GetSizeInRange(info, address, endAddr); + MappedSize += GetSizeInRange(Info, Address, EndAddr); } - node = node.Next; + Node = Node.Next; } - while (info.Address + info.Size < endAddr && node != null); + while (Info.Address + Info.Size < EndAddr && Node != null); - if (mappedSize == size) + if (MappedSize == Size) { return KernelResult.Success; } - ulong remainingSize = size - mappedSize; + ulong RemainingSize = Size - MappedSize; - ulong remainingPages = remainingSize / PageSize; + ulong RemainingPages = RemainingSize / PageSize; - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - if (currentProcess.ResourceLimit != null && - !currentProcess.ResourceLimit.Reserve(LimitableResource.Memory, remainingSize)) + if (CurrentProcess.ResourceLimit != null && + !CurrentProcess.ResourceLimit.Reserve(LimitableResource.Memory, RemainingSize)) { return KernelResult.ResLimitExceeded; } - KMemoryRegionManager region = GetMemoryRegionManager(); + KMemoryRegionManager Region = GetMemoryRegionManager(); - KernelResult result = region.AllocatePages(remainingPages, _aslrDisabled, out KPageList pageList); + KernelResult Result = Region.AllocatePages(RemainingPages, AslrDisabled, out KPageList PageList); void CleanUpForError() { - if (pageList != null) + if (PageList != null) { - region.FreePages(pageList); + Region.FreePages(PageList); } - currentProcess.ResourceLimit?.Release(LimitableResource.Memory, remainingSize); + CurrentProcess.ResourceLimit?.Release(LimitableResource.Memory, RemainingSize); } - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { CleanUpForError(); - return result; + return Result; } - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) { CleanUpForError(); return KernelResult.OutOfResource; } - MapPhysicalMemory(pageList, address, endAddr); + MapPhysicalMemory(PageList, Address, EndAddr); - PhysicalMemoryUsage += remainingSize; + PhysicalMemoryUsage += RemainingSize; - ulong pagesCount = size / PageSize; + ulong PagesCount = Size / PageSize; InsertBlock( - address, - pagesCount, + Address, + PagesCount, MemoryState.Unmapped, MemoryPermission.None, MemoryAttribute.None, @@ -1405,227 +1405,227 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } - public KernelResult UnmapPhysicalMemory(ulong address, ulong size) + public KernelResult UnmapPhysicalMemory(ulong Address, ulong Size) { - ulong endAddr = address + size; + ulong EndAddr = Address + Size; - lock (_blocks) + lock (Blocks) { //Scan, ensure that the region can be unmapped (all blocks are heap or //already unmapped), fill pages list for freeing memory. - ulong heapMappedSize = 0; + ulong HeapMappedSize = 0; - KPageList pageList = new KPageList(); + KPageList PageList = new KPageList(); - KMemoryInfo info; + KMemoryInfo Info; - LinkedListNode<KMemoryBlock> baseNode = FindBlockNode(address); + LinkedListNode<KMemoryBlock> BaseNode = FindBlockNode(Address); - LinkedListNode<KMemoryBlock> node = baseNode; + LinkedListNode<KMemoryBlock> Node = BaseNode; do { - info = node.Value.GetInfo(); + Info = Node.Value.GetInfo(); - if (info.State == MemoryState.Heap) + if (Info.State == MemoryState.Heap) { - if (info.Attribute != MemoryAttribute.None) + if (Info.Attribute != MemoryAttribute.None) { return KernelResult.InvalidMemState; } - ulong blockSize = GetSizeInRange(info, address, endAddr); - ulong blockAddress = GetAddrInRange(info, address); + ulong BlockSize = GetSizeInRange(Info, Address, EndAddr); + ulong BlockAddress = GetAddrInRange(Info, Address); - AddVaRangeToPageList(pageList, blockAddress, blockSize / PageSize); + AddVaRangeToPageList(PageList, BlockAddress, BlockSize / PageSize); - heapMappedSize += blockSize; + HeapMappedSize += BlockSize; } - else if (info.State != MemoryState.Unmapped) + else if (Info.State != MemoryState.Unmapped) { return KernelResult.InvalidMemState; } - node = node.Next; + Node = Node.Next; } - while (info.Address + info.Size < endAddr && node != null); + while (Info.Address + Info.Size < EndAddr && Node != null); - if (heapMappedSize == 0) + if (HeapMappedSize == 0) { return KernelResult.Success; } - if (!_blockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) + if (!BlockAllocator.CanAllocate(MaxBlocksNeededForInsertion)) { return KernelResult.OutOfResource; } //Try to unmap all the heap mapped memory inside range. - KernelResult result = KernelResult.Success; + KernelResult Result = KernelResult.Success; - node = baseNode; + Node = BaseNode; do { - info = node.Value.GetInfo(); + Info = Node.Value.GetInfo(); - if (info.State == MemoryState.Heap) + if (Info.State == MemoryState.Heap) { - ulong blockSize = GetSizeInRange(info, address, endAddr); - ulong blockAddress = GetAddrInRange(info, address); + ulong BlockSize = GetSizeInRange(Info, Address, EndAddr); + ulong BlockAddress = GetAddrInRange(Info, Address); - ulong blockPagesCount = blockSize / PageSize; + ulong BlockPagesCount = BlockSize / PageSize; - result = MmuUnmap(blockAddress, blockPagesCount); + Result = MmuUnmap(BlockAddress, BlockPagesCount); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { //If we failed to unmap, we need to remap everything back again. - MapPhysicalMemory(pageList, address, blockAddress + blockSize); + MapPhysicalMemory(PageList, Address, BlockAddress + BlockSize); break; } } - node = node.Next; + Node = Node.Next; } - while (info.Address + info.Size < endAddr && node != null); + while (Info.Address + Info.Size < EndAddr && Node != null); - if (result == KernelResult.Success) + if (Result == KernelResult.Success) { - GetMemoryRegionManager().FreePages(pageList); + GetMemoryRegionManager().FreePages(PageList); - PhysicalMemoryUsage -= heapMappedSize; + PhysicalMemoryUsage -= HeapMappedSize; - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - currentProcess.ResourceLimit?.Release(LimitableResource.Memory, heapMappedSize); + CurrentProcess.ResourceLimit?.Release(LimitableResource.Memory, HeapMappedSize); - ulong pagesCount = size / PageSize; + ulong PagesCount = Size / PageSize; - InsertBlock(address, pagesCount, MemoryState.Unmapped); + InsertBlock(Address, PagesCount, MemoryState.Unmapped); } - return result; + return Result; } } - private void MapPhysicalMemory(KPageList pageList, ulong address, ulong endAddr) + private void MapPhysicalMemory(KPageList PageList, ulong Address, ulong EndAddr) { - KMemoryInfo info; + KMemoryInfo Info; - LinkedListNode<KMemoryBlock> node = FindBlockNode(address); + LinkedListNode<KMemoryBlock> Node = FindBlockNode(Address); - LinkedListNode<KPageNode> pageListNode = pageList.Nodes.First; + LinkedListNode<KPageNode> PageListNode = PageList.Nodes.First; - KPageNode pageNode = pageListNode.Value; + KPageNode PageNode = PageListNode.Value; - ulong srcPa = pageNode.Address; - ulong srcPaPages = pageNode.PagesCount; + ulong SrcPa = PageNode.Address; + ulong SrcPaPages = PageNode.PagesCount; do { - info = node.Value.GetInfo(); + Info = Node.Value.GetInfo(); - if (info.State == MemoryState.Unmapped) + if (Info.State == MemoryState.Unmapped) { - ulong blockSize = GetSizeInRange(info, address, endAddr); + ulong BlockSize = GetSizeInRange(Info, Address, EndAddr); - ulong dstVaPages = blockSize / PageSize; + ulong DstVaPages = BlockSize / PageSize; - ulong dstVa = GetAddrInRange(info, address); + ulong DstVa = GetAddrInRange(Info, Address); - while (dstVaPages > 0) + while (DstVaPages > 0) { - if (srcPaPages == 0) + if (SrcPaPages == 0) { - pageListNode = pageListNode.Next; + PageListNode = PageListNode.Next; - pageNode = pageListNode.Value; + PageNode = PageListNode.Value; - srcPa = pageNode.Address; - srcPaPages = pageNode.PagesCount; + SrcPa = PageNode.Address; + SrcPaPages = PageNode.PagesCount; } - ulong pagesCount = srcPaPages; + ulong PagesCount = SrcPaPages; - if (pagesCount > dstVaPages) + if (PagesCount > DstVaPages) { - pagesCount = dstVaPages; + PagesCount = DstVaPages; } DoMmuOperation( - dstVa, - pagesCount, - srcPa, + DstVa, + PagesCount, + SrcPa, true, MemoryPermission.ReadAndWrite, MemoryOperation.MapPa); - dstVa += pagesCount * PageSize; - srcPa += pagesCount * PageSize; - srcPaPages -= pagesCount; - dstVaPages -= pagesCount; + DstVa += PagesCount * PageSize; + SrcPa += PagesCount * PageSize; + SrcPaPages -= PagesCount; + DstVaPages -= PagesCount; } } - node = node.Next; + Node = Node.Next; } - while (info.Address + info.Size < endAddr && node != null); + while (Info.Address + Info.Size < EndAddr && Node != null); } - private static ulong GetSizeInRange(KMemoryInfo info, ulong start, ulong end) + private static ulong GetSizeInRange(KMemoryInfo Info, ulong Start, ulong End) { - ulong endAddr = info.Size + info.Address; - ulong size = info.Size; + ulong EndAddr = Info.Size + Info.Address; + ulong Size = Info.Size; - if (info.Address < start) + if (Info.Address < Start) { - size -= start - info.Address; + Size -= Start - Info.Address; } - if (endAddr > end) + if (EndAddr > End) { - size -= endAddr - end; + Size -= EndAddr - End; } - return size; + return Size; } - private static ulong GetAddrInRange(KMemoryInfo info, ulong start) + private static ulong GetAddrInRange(KMemoryInfo Info, ulong Start) { - if (info.Address < start) + if (Info.Address < Start) { - return start; + return Start; } - return info.Address; + return Info.Address; } - private void AddVaRangeToPageList(KPageList pageList, ulong start, ulong pagesCount) + private void AddVaRangeToPageList(KPageList PageList, ulong Start, ulong PagesCount) { - ulong address = start; + ulong Address = Start; - while (address < start + pagesCount * PageSize) + while (Address < Start + PagesCount * PageSize) { - KernelResult result = ConvertVaToPa(address, out ulong pa); + KernelResult Result = ConvertVaToPa(Address, out ulong Pa); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { throw new InvalidOperationException("Unexpected failure translating virtual address."); } - pageList.AddRange(pa, 1); + PageList.AddRange(Pa, 1); - address += PageSize; + Address += PageSize; } } - private bool IsUnmapped(ulong address, ulong size) + private bool IsUnmapped(ulong Address, ulong Size) { return CheckRange( - address, - size, + Address, + Size, MemoryState.Mask, MemoryState.Unmapped, MemoryPermission.Mask, @@ -1639,465 +1639,465 @@ namespace Ryujinx.HLE.HOS.Kernel } private bool CheckRange( - ulong address, - ulong size, - MemoryState stateMask, - MemoryState stateExpected, - MemoryPermission permissionMask, - MemoryPermission permissionExpected, - MemoryAttribute attributeMask, - MemoryAttribute attributeExpected, - MemoryAttribute attributeIgnoreMask, - out MemoryState outState, - out MemoryPermission outPermission, - out MemoryAttribute outAttribute) + ulong Address, + ulong Size, + MemoryState StateMask, + MemoryState StateExpected, + MemoryPermission PermissionMask, + MemoryPermission PermissionExpected, + MemoryAttribute AttributeMask, + MemoryAttribute AttributeExpected, + MemoryAttribute AttributeIgnoreMask, + out MemoryState OutState, + out MemoryPermission OutPermission, + out MemoryAttribute OutAttribute) { - ulong endAddr = address + size - 1; + ulong EndAddr = Address + Size - 1; - LinkedListNode<KMemoryBlock> node = FindBlockNode(address); + LinkedListNode<KMemoryBlock> Node = FindBlockNode(Address); - KMemoryInfo info = node.Value.GetInfo(); + KMemoryInfo Info = Node.Value.GetInfo(); - MemoryState firstState = info.State; - MemoryPermission firstPermission = info.Permission; - MemoryAttribute firstAttribute = info.Attribute; + MemoryState FirstState = Info.State; + MemoryPermission FirstPermission = Info.Permission; + MemoryAttribute FirstAttribute = Info.Attribute; do { - info = node.Value.GetInfo(); + Info = Node.Value.GetInfo(); //Check if the block state matches what we expect. - if ( firstState != info.State || - firstPermission != info.Permission || - (info.Attribute & attributeMask) != attributeExpected || - (firstAttribute | attributeIgnoreMask) != (info.Attribute | attributeIgnoreMask) || - (firstState & stateMask) != stateExpected || - (firstPermission & permissionMask) != permissionExpected) + if ( FirstState != Info.State || + FirstPermission != Info.Permission || + (Info.Attribute & AttributeMask) != AttributeExpected || + (FirstAttribute | AttributeIgnoreMask) != (Info.Attribute | AttributeIgnoreMask) || + (FirstState & StateMask) != StateExpected || + (FirstPermission & PermissionMask) != PermissionExpected) { break; } //Check if this is the last block on the range, if so return success. - if (endAddr <= info.Address + info.Size - 1) + if (EndAddr <= Info.Address + Info.Size - 1) { - outState = firstState; - outPermission = firstPermission; - outAttribute = firstAttribute & ~attributeIgnoreMask; + OutState = FirstState; + OutPermission = FirstPermission; + OutAttribute = FirstAttribute & ~AttributeIgnoreMask; return true; } - node = node.Next; + Node = Node.Next; } - while (node != null); + while (Node != null); - outState = MemoryState.Unmapped; - outPermission = MemoryPermission.None; - outAttribute = MemoryAttribute.None; + OutState = MemoryState.Unmapped; + OutPermission = MemoryPermission.None; + OutAttribute = MemoryAttribute.None; return false; } private bool CheckRange( - ulong address, - ulong size, - MemoryState stateMask, - MemoryState stateExpected, - MemoryPermission permissionMask, - MemoryPermission permissionExpected, - MemoryAttribute attributeMask, - MemoryAttribute attributeExpected) + ulong Address, + ulong Size, + MemoryState StateMask, + MemoryState StateExpected, + MemoryPermission PermissionMask, + MemoryPermission PermissionExpected, + MemoryAttribute AttributeMask, + MemoryAttribute AttributeExpected) { - ulong endAddr = address + size - 1; + ulong EndAddr = Address + Size - 1; - LinkedListNode<KMemoryBlock> node = FindBlockNode(address); + LinkedListNode<KMemoryBlock> Node = FindBlockNode(Address); do { - KMemoryInfo info = node.Value.GetInfo(); + KMemoryInfo Info = Node.Value.GetInfo(); //Check if the block state matches what we expect. - if ((info.State & stateMask) != stateExpected || - (info.Permission & permissionMask) != permissionExpected || - (info.Attribute & attributeMask) != attributeExpected) + if ((Info.State & StateMask) != StateExpected || + (Info.Permission & PermissionMask) != PermissionExpected || + (Info.Attribute & AttributeMask) != AttributeExpected) { break; } //Check if this is the last block on the range, if so return success. - if (endAddr <= info.Address + info.Size - 1) + if (EndAddr <= Info.Address + Info.Size - 1) { return true; } - node = node.Next; + Node = Node.Next; } - while (node != null); + while (Node != null); return false; } private void InsertBlock( - ulong baseAddress, - ulong pagesCount, - MemoryState oldState, - MemoryPermission oldPermission, - MemoryAttribute oldAttribute, - MemoryState newState, - MemoryPermission newPermission, - MemoryAttribute newAttribute) + ulong BaseAddress, + ulong PagesCount, + MemoryState OldState, + MemoryPermission OldPermission, + MemoryAttribute OldAttribute, + MemoryState NewState, + MemoryPermission NewPermission, + MemoryAttribute NewAttribute) { //Insert new block on the list only on areas where the state //of the block matches the state specified on the Old* state //arguments, otherwise leave it as is. - int oldCount = _blocks.Count; + int OldCount = Blocks.Count; - oldAttribute |= MemoryAttribute.IpcAndDeviceMapped; + OldAttribute |= MemoryAttribute.IpcAndDeviceMapped; - ulong endAddr = pagesCount * PageSize + baseAddress; + ulong EndAddr = PagesCount * PageSize + BaseAddress; - LinkedListNode<KMemoryBlock> node = _blocks.First; + LinkedListNode<KMemoryBlock> Node = Blocks.First; - while (node != null) + while (Node != null) { - LinkedListNode<KMemoryBlock> newNode = node; - LinkedListNode<KMemoryBlock> nextNode = node.Next; + LinkedListNode<KMemoryBlock> NewNode = Node; + LinkedListNode<KMemoryBlock> NextNode = Node.Next; - KMemoryBlock currBlock = node.Value; + KMemoryBlock CurrBlock = Node.Value; - ulong currBaseAddr = currBlock.BaseAddress; - ulong currEndAddr = currBlock.PagesCount * PageSize + currBaseAddr; + ulong CurrBaseAddr = CurrBlock.BaseAddress; + ulong CurrEndAddr = CurrBlock.PagesCount * PageSize + CurrBaseAddr; - if (baseAddress < currEndAddr && currBaseAddr < endAddr) + if (BaseAddress < CurrEndAddr && CurrBaseAddr < EndAddr) { - MemoryAttribute currBlockAttr = currBlock.Attribute | MemoryAttribute.IpcAndDeviceMapped; + MemoryAttribute CurrBlockAttr = CurrBlock.Attribute | MemoryAttribute.IpcAndDeviceMapped; - if (currBlock.State != oldState || - currBlock.Permission != oldPermission || - currBlockAttr != oldAttribute) + if (CurrBlock.State != OldState || + CurrBlock.Permission != OldPermission || + CurrBlockAttr != OldAttribute) { - node = nextNode; + Node = NextNode; continue; } - if (currBaseAddr >= baseAddress && currEndAddr <= endAddr) + if (CurrBaseAddr >= BaseAddress && CurrEndAddr <= EndAddr) { - currBlock.State = newState; - currBlock.Permission = newPermission; - currBlock.Attribute &= ~MemoryAttribute.IpcAndDeviceMapped; - currBlock.Attribute |= newAttribute; + CurrBlock.State = NewState; + CurrBlock.Permission = NewPermission; + CurrBlock.Attribute &= ~MemoryAttribute.IpcAndDeviceMapped; + CurrBlock.Attribute |= NewAttribute; } - else if (currBaseAddr >= baseAddress) + else if (CurrBaseAddr >= BaseAddress) { - currBlock.BaseAddress = endAddr; + CurrBlock.BaseAddress = EndAddr; - currBlock.PagesCount = (currEndAddr - endAddr) / PageSize; + CurrBlock.PagesCount = (CurrEndAddr - EndAddr) / PageSize; - ulong newPagesCount = (endAddr - currBaseAddr) / PageSize; + ulong NewPagesCount = (EndAddr - CurrBaseAddr) / PageSize; - newNode = _blocks.AddBefore(node, new KMemoryBlock( - currBaseAddr, - newPagesCount, - newState, - newPermission, - newAttribute)); + NewNode = Blocks.AddBefore(Node, new KMemoryBlock( + CurrBaseAddr, + NewPagesCount, + NewState, + NewPermission, + NewAttribute)); } - else if (currEndAddr <= endAddr) + else if (CurrEndAddr <= EndAddr) { - currBlock.PagesCount = (baseAddress - currBaseAddr) / PageSize; + CurrBlock.PagesCount = (BaseAddress - CurrBaseAddr) / PageSize; - ulong newPagesCount = (currEndAddr - baseAddress) / PageSize; + ulong NewPagesCount = (CurrEndAddr - BaseAddress) / PageSize; - newNode = _blocks.AddAfter(node, new KMemoryBlock( - baseAddress, - newPagesCount, - newState, - newPermission, - newAttribute)); + NewNode = Blocks.AddAfter(Node, new KMemoryBlock( + BaseAddress, + NewPagesCount, + NewState, + NewPermission, + NewAttribute)); } else { - currBlock.PagesCount = (baseAddress - currBaseAddr) / PageSize; + CurrBlock.PagesCount = (BaseAddress - CurrBaseAddr) / PageSize; - ulong nextPagesCount = (currEndAddr - endAddr) / PageSize; + ulong NextPagesCount = (CurrEndAddr - EndAddr) / PageSize; - newNode = _blocks.AddAfter(node, new KMemoryBlock( - baseAddress, - pagesCount, - newState, - newPermission, - newAttribute)); + NewNode = Blocks.AddAfter(Node, new KMemoryBlock( + BaseAddress, + PagesCount, + NewState, + NewPermission, + NewAttribute)); - _blocks.AddAfter(newNode, new KMemoryBlock( - endAddr, - nextPagesCount, - currBlock.State, - currBlock.Permission, - currBlock.Attribute)); + Blocks.AddAfter(NewNode, new KMemoryBlock( + EndAddr, + NextPagesCount, + CurrBlock.State, + CurrBlock.Permission, + CurrBlock.Attribute)); - nextNode = null; + NextNode = null; } - MergeEqualStateNeighbours(newNode); + MergeEqualStateNeighbours(NewNode); } - node = nextNode; + Node = NextNode; } - _blockAllocator.Count += _blocks.Count - oldCount; + BlockAllocator.Count += Blocks.Count - OldCount; } private void InsertBlock( - ulong baseAddress, - ulong pagesCount, - MemoryState state, - MemoryPermission permission = MemoryPermission.None, - MemoryAttribute attribute = MemoryAttribute.None) + ulong BaseAddress, + ulong PagesCount, + MemoryState State, + MemoryPermission Permission = MemoryPermission.None, + MemoryAttribute Attribute = MemoryAttribute.None) { //Inserts new block at the list, replacing and spliting //existing blocks as needed. - KMemoryBlock block = new KMemoryBlock(baseAddress, pagesCount, state, permission, attribute); + KMemoryBlock Block = new KMemoryBlock(BaseAddress, PagesCount, State, Permission, Attribute); - int oldCount = _blocks.Count; + int OldCount = Blocks.Count; - ulong endAddr = pagesCount * PageSize + baseAddress; + ulong EndAddr = PagesCount * PageSize + BaseAddress; - LinkedListNode<KMemoryBlock> newNode = null; + LinkedListNode<KMemoryBlock> NewNode = null; - LinkedListNode<KMemoryBlock> node = _blocks.First; + LinkedListNode<KMemoryBlock> Node = Blocks.First; - while (node != null) + while (Node != null) { - KMemoryBlock currBlock = node.Value; + KMemoryBlock CurrBlock = Node.Value; - LinkedListNode<KMemoryBlock> nextNode = node.Next; + LinkedListNode<KMemoryBlock> NextNode = Node.Next; - ulong currBaseAddr = currBlock.BaseAddress; - ulong currEndAddr = currBlock.PagesCount * PageSize + currBaseAddr; + ulong CurrBaseAddr = CurrBlock.BaseAddress; + ulong CurrEndAddr = CurrBlock.PagesCount * PageSize + CurrBaseAddr; - if (baseAddress < currEndAddr && currBaseAddr < endAddr) + if (BaseAddress < CurrEndAddr && CurrBaseAddr < EndAddr) { - if (baseAddress >= currBaseAddr && endAddr <= currEndAddr) + if (BaseAddress >= CurrBaseAddr && EndAddr <= CurrEndAddr) { - block.Attribute |= currBlock.Attribute & MemoryAttribute.IpcAndDeviceMapped; + Block.Attribute |= CurrBlock.Attribute & MemoryAttribute.IpcAndDeviceMapped; } - if (baseAddress > currBaseAddr && endAddr < currEndAddr) + if (BaseAddress > CurrBaseAddr && EndAddr < CurrEndAddr) { - currBlock.PagesCount = (baseAddress - currBaseAddr) / PageSize; + CurrBlock.PagesCount = (BaseAddress - CurrBaseAddr) / PageSize; - ulong nextPagesCount = (currEndAddr - endAddr) / PageSize; + ulong NextPagesCount = (CurrEndAddr - EndAddr) / PageSize; - newNode = _blocks.AddAfter(node, block); + NewNode = Blocks.AddAfter(Node, Block); - _blocks.AddAfter(newNode, new KMemoryBlock( - endAddr, - nextPagesCount, - currBlock.State, - currBlock.Permission, - currBlock.Attribute)); + Blocks.AddAfter(NewNode, new KMemoryBlock( + EndAddr, + NextPagesCount, + CurrBlock.State, + CurrBlock.Permission, + CurrBlock.Attribute)); break; } - else if (baseAddress <= currBaseAddr && endAddr < currEndAddr) + else if (BaseAddress <= CurrBaseAddr && EndAddr < CurrEndAddr) { - currBlock.BaseAddress = endAddr; + CurrBlock.BaseAddress = EndAddr; - currBlock.PagesCount = (currEndAddr - endAddr) / PageSize; + CurrBlock.PagesCount = (CurrEndAddr - EndAddr) / PageSize; - if (newNode == null) + if (NewNode == null) { - newNode = _blocks.AddBefore(node, block); + NewNode = Blocks.AddBefore(Node, Block); } } - else if (baseAddress > currBaseAddr && endAddr >= currEndAddr) + else if (BaseAddress > CurrBaseAddr && EndAddr >= CurrEndAddr) { - currBlock.PagesCount = (baseAddress - currBaseAddr) / PageSize; + CurrBlock.PagesCount = (BaseAddress - CurrBaseAddr) / PageSize; - if (newNode == null) + if (NewNode == null) { - newNode = _blocks.AddAfter(node, block); + NewNode = Blocks.AddAfter(Node, Block); } } else { - if (newNode == null) + if (NewNode == null) { - newNode = _blocks.AddBefore(node, block); + NewNode = Blocks.AddBefore(Node, Block); } - _blocks.Remove(node); + Blocks.Remove(Node); } } - node = nextNode; + Node = NextNode; } - if (newNode == null) + if (NewNode == null) { - newNode = _blocks.AddFirst(block); + NewNode = Blocks.AddFirst(Block); } - MergeEqualStateNeighbours(newNode); + MergeEqualStateNeighbours(NewNode); - _blockAllocator.Count += _blocks.Count - oldCount; + BlockAllocator.Count += Blocks.Count - OldCount; } - private void MergeEqualStateNeighbours(LinkedListNode<KMemoryBlock> node) + private void MergeEqualStateNeighbours(LinkedListNode<KMemoryBlock> Node) { - KMemoryBlock block = node.Value; + KMemoryBlock Block = Node.Value; - ulong endAddr = block.PagesCount * PageSize + block.BaseAddress; + ulong EndAddr = Block.PagesCount * PageSize + Block.BaseAddress; - if (node.Previous != null) + if (Node.Previous != null) { - KMemoryBlock previous = node.Previous.Value; + KMemoryBlock Previous = Node.Previous.Value; - if (BlockStateEquals(block, previous)) + if (BlockStateEquals(Block, Previous)) { - _blocks.Remove(node.Previous); + Blocks.Remove(Node.Previous); - block.BaseAddress = previous.BaseAddress; + Block.BaseAddress = Previous.BaseAddress; } } - if (node.Next != null) + if (Node.Next != null) { - KMemoryBlock next = node.Next.Value; + KMemoryBlock Next = Node.Next.Value; - if (BlockStateEquals(block, next)) + if (BlockStateEquals(Block, Next)) { - _blocks.Remove(node.Next); + Blocks.Remove(Node.Next); - endAddr = next.BaseAddress + next.PagesCount * PageSize; + EndAddr = Next.BaseAddress + Next.PagesCount * PageSize; } } - block.PagesCount = (endAddr - block.BaseAddress) / PageSize; + Block.PagesCount = (EndAddr - Block.BaseAddress) / PageSize; } - private static bool BlockStateEquals(KMemoryBlock lhs, KMemoryBlock rhs) + private static bool BlockStateEquals(KMemoryBlock Lhs, KMemoryBlock Rhs) { - return lhs.State == rhs.State && - lhs.Permission == rhs.Permission && - lhs.Attribute == rhs.Attribute && - lhs.DeviceRefCount == rhs.DeviceRefCount && - lhs.IpcRefCount == rhs.IpcRefCount; + return Lhs.State == Rhs.State && + Lhs.Permission == Rhs.Permission && + Lhs.Attribute == Rhs.Attribute && + Lhs.DeviceRefCount == Rhs.DeviceRefCount && + Lhs.IpcRefCount == Rhs.IpcRefCount; } private ulong FindFirstFit( - ulong regionStart, - ulong regionPagesCount, - ulong neededPagesCount, - int alignment, - ulong reservedStart, - ulong reservedPagesCount) + ulong RegionStart, + ulong RegionPagesCount, + ulong NeededPagesCount, + int Alignment, + ulong ReservedStart, + ulong ReservedPagesCount) { - ulong reservedSize = reservedPagesCount * PageSize; + ulong ReservedSize = ReservedPagesCount * PageSize; - ulong totalNeededSize = reservedSize + neededPagesCount * PageSize; + ulong TotalNeededSize = ReservedSize + NeededPagesCount * PageSize; - ulong regionEndAddr = regionStart + regionPagesCount * PageSize; + ulong RegionEndAddr = RegionStart + RegionPagesCount * PageSize; - LinkedListNode<KMemoryBlock> node = FindBlockNode(regionStart); + LinkedListNode<KMemoryBlock> Node = FindBlockNode(RegionStart); - KMemoryInfo info = node.Value.GetInfo(); + KMemoryInfo Info = Node.Value.GetInfo(); - while (regionEndAddr >= info.Address) + while (RegionEndAddr >= Info.Address) { - if (info.State == MemoryState.Unmapped) + if (Info.State == MemoryState.Unmapped) { - ulong currBaseAddr = info.Address + reservedSize; - ulong currEndAddr = info.Address + info.Size - 1; + ulong CurrBaseAddr = Info.Address + ReservedSize; + ulong CurrEndAddr = Info.Address + Info.Size - 1; - ulong address = BitUtils.AlignDown(currBaseAddr, alignment) + reservedStart; + ulong Address = BitUtils.AlignDown(CurrBaseAddr, Alignment) + ReservedStart; - if (currBaseAddr > address) + if (CurrBaseAddr > Address) { - address += (ulong)alignment; + Address += (ulong)Alignment; } - ulong allocationEndAddr = address + totalNeededSize - 1; + ulong AllocationEndAddr = Address + TotalNeededSize - 1; - if (allocationEndAddr <= regionEndAddr && - allocationEndAddr <= currEndAddr && - address < allocationEndAddr) + if (AllocationEndAddr <= RegionEndAddr && + AllocationEndAddr <= CurrEndAddr && + Address < AllocationEndAddr) { - return address; + return Address; } } - node = node.Next; + Node = Node.Next; - if (node == null) + if (Node == null) { break; } - info = node.Value.GetInfo(); + Info = Node.Value.GetInfo(); } return 0; } - private KMemoryBlock FindBlock(ulong address) + private KMemoryBlock FindBlock(ulong Address) { - return FindBlockNode(address)?.Value; + return FindBlockNode(Address)?.Value; } - private LinkedListNode<KMemoryBlock> FindBlockNode(ulong address) + private LinkedListNode<KMemoryBlock> FindBlockNode(ulong Address) { - lock (_blocks) + lock (Blocks) { - LinkedListNode<KMemoryBlock> node = _blocks.First; + LinkedListNode<KMemoryBlock> Node = Blocks.First; - while (node != null) + while (Node != null) { - KMemoryBlock block = node.Value; + KMemoryBlock Block = Node.Value; - ulong currEndAddr = block.PagesCount * PageSize + block.BaseAddress; + ulong CurrEndAddr = Block.PagesCount * PageSize + Block.BaseAddress; - if (block.BaseAddress <= address && currEndAddr - 1 >= address) + if (Block.BaseAddress <= Address && CurrEndAddr - 1 >= Address) { - return node; + return Node; } - node = node.Next; + Node = Node.Next; } } return null; } - private bool ValidateRegionForState(ulong address, ulong size, MemoryState state) + private bool ValidateRegionForState(ulong Address, ulong Size, MemoryState State) { - ulong endAddr = address + size; + ulong EndAddr = Address + Size; - ulong regionBaseAddr = GetBaseAddrForState(state); + ulong RegionBaseAddr = GetBaseAddrForState(State); - ulong regionEndAddr = regionBaseAddr + GetSizeForState(state); + ulong RegionEndAddr = RegionBaseAddr + GetSizeForState(State); bool InsideRegion() { - return regionBaseAddr <= address && - endAddr > address && - endAddr - 1 <= regionEndAddr - 1; + return RegionBaseAddr <= Address && + EndAddr > Address && + EndAddr - 1 <= RegionEndAddr - 1; } bool OutsideHeapRegion() { - return endAddr <= HeapRegionStart || - address >= HeapRegionEnd; + return EndAddr <= HeapRegionStart || + Address >= HeapRegionEnd; } bool OutsideMapRegion() { - return endAddr <= AliasRegionStart || - address >= AliasRegionEnd; + return EndAddr <= AliasRegionStart || + Address >= AliasRegionEnd; } - switch (state) + switch (State) { case MemoryState.Io: case MemoryState.Normal: @@ -2127,12 +2127,12 @@ namespace Ryujinx.HLE.HOS.Kernel return InsideRegion(); } - throw new ArgumentException($"Invalid state value \"{state}\"."); + throw new ArgumentException($"Invalid state value \"{State}\"."); } - private ulong GetBaseAddrForState(MemoryState state) + private ulong GetBaseAddrForState(MemoryState State) { - switch (state) + switch (State) { case MemoryState.Io: case MemoryState.Normal: @@ -2166,12 +2166,12 @@ namespace Ryujinx.HLE.HOS.Kernel return AddrSpaceStart; } - throw new ArgumentException($"Invalid state value \"{state}\"."); + throw new ArgumentException($"Invalid state value \"{State}\"."); } - private ulong GetSizeForState(MemoryState state) + private ulong GetSizeForState(MemoryState State) { - switch (state) + switch (State) { case MemoryState.Io: case MemoryState.Normal: @@ -2205,7 +2205,7 @@ namespace Ryujinx.HLE.HOS.Kernel return AddrSpaceEnd - AddrSpaceStart; } - throw new ArgumentException($"Invalid state value \"{state}\"."); + throw new ArgumentException($"Invalid state value \"{State}\"."); } public ulong GetAddrSpaceBaseAddr() @@ -2244,98 +2244,98 @@ namespace Ryujinx.HLE.HOS.Kernel } } - private KernelResult MapPages(ulong address, KPageList pageList, MemoryPermission permission) + private KernelResult MapPages(ulong Address, KPageList PageList, MemoryPermission Permission) { - ulong currAddr = address; + ulong CurrAddr = Address; - KernelResult result = KernelResult.Success; + KernelResult Result = KernelResult.Success; - foreach (KPageNode pageNode in pageList) + foreach (KPageNode PageNode in PageList) { - result = DoMmuOperation( - currAddr, - pageNode.PagesCount, - pageNode.Address, + Result = DoMmuOperation( + CurrAddr, + PageNode.PagesCount, + PageNode.Address, true, - permission, + Permission, MemoryOperation.MapPa); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - KMemoryInfo info = FindBlock(currAddr).GetInfo(); + KMemoryInfo Info = FindBlock(CurrAddr).GetInfo(); - ulong pagesCount = (address - currAddr) / PageSize; + ulong PagesCount = (Address - CurrAddr) / PageSize; - result = MmuUnmap(address, pagesCount); + Result = MmuUnmap(Address, PagesCount); break; } - currAddr += pageNode.PagesCount * PageSize; + CurrAddr += PageNode.PagesCount * PageSize; } - return result; + return Result; } - private KernelResult MmuUnmap(ulong address, ulong pagesCount) + private KernelResult MmuUnmap(ulong Address, ulong PagesCount) { return DoMmuOperation( - address, - pagesCount, + Address, + PagesCount, 0, false, MemoryPermission.None, MemoryOperation.Unmap); } - private KernelResult MmuChangePermission(ulong address, ulong pagesCount, MemoryPermission permission) + private KernelResult MmuChangePermission(ulong Address, ulong PagesCount, MemoryPermission Permission) { return DoMmuOperation( - address, - pagesCount, + Address, + PagesCount, 0, false, - permission, + Permission, MemoryOperation.ChangePermRw); } private KernelResult DoMmuOperation( - ulong dstVa, - ulong pagesCount, - ulong srcPa, - bool map, - MemoryPermission permission, - MemoryOperation operation) + ulong DstVa, + ulong PagesCount, + ulong SrcPa, + bool Map, + MemoryPermission Permission, + MemoryOperation Operation) { - if (map != (operation == MemoryOperation.MapPa)) + if (Map != (Operation == MemoryOperation.MapPa)) { - throw new ArgumentException(nameof(map) + " value is invalid for this operation."); + throw new ArgumentException(nameof(Map) + " value is invalid for this operation."); } - KernelResult result; + KernelResult Result; - switch (operation) + switch (Operation) { case MemoryOperation.MapPa: { - ulong size = pagesCount * PageSize; + ulong Size = PagesCount * PageSize; - _cpuMemory.Map((long)dstVa, (long)(srcPa - DramMemoryMap.DramBase), (long)size); + CpuMemory.Map((long)DstVa, (long)(SrcPa - DramMemoryMap.DramBase), (long)Size); - result = KernelResult.Success; + Result = KernelResult.Success; break; } case MemoryOperation.Allocate: { - KMemoryRegionManager region = GetMemoryRegionManager(); + KMemoryRegionManager Region = GetMemoryRegionManager(); - result = region.AllocatePages(pagesCount, _aslrDisabled, out KPageList pageList); + Result = Region.AllocatePages(PagesCount, AslrDisabled, out KPageList PageList); - if (result == KernelResult.Success) + if (Result == KernelResult.Success) { - result = MmuMapPages(dstVa, pageList); + Result = MmuMapPages(DstVa, PageList); } break; @@ -2343,68 +2343,68 @@ namespace Ryujinx.HLE.HOS.Kernel case MemoryOperation.Unmap: { - ulong size = pagesCount * PageSize; + ulong Size = PagesCount * PageSize; - _cpuMemory.Unmap((long)dstVa, (long)size); + CpuMemory.Unmap((long)DstVa, (long)Size); - result = KernelResult.Success; + Result = KernelResult.Success; break; } - case MemoryOperation.ChangePermRw: result = KernelResult.Success; break; - case MemoryOperation.ChangePermsAndAttributes: result = KernelResult.Success; break; + case MemoryOperation.ChangePermRw: Result = KernelResult.Success; break; + case MemoryOperation.ChangePermsAndAttributes: Result = KernelResult.Success; break; - default: throw new ArgumentException($"Invalid operation \"{operation}\"."); + default: throw new ArgumentException($"Invalid operation \"{Operation}\"."); } - return result; + return Result; } private KernelResult DoMmuOperation( - ulong address, - ulong pagesCount, - KPageList pageList, - MemoryPermission permission, - MemoryOperation operation) + ulong Address, + ulong PagesCount, + KPageList PageList, + MemoryPermission Permission, + MemoryOperation Operation) { - if (operation != MemoryOperation.MapVa) + if (Operation != MemoryOperation.MapVa) { - throw new ArgumentException($"Invalid memory operation \"{operation}\" specified."); + throw new ArgumentException($"Invalid memory operation \"{Operation}\" specified."); } - return MmuMapPages(address, pageList); + return MmuMapPages(Address, PageList); } private KMemoryRegionManager GetMemoryRegionManager() { - return _system.MemoryRegions[(int)_memRegion]; + return System.MemoryRegions[(int)MemRegion]; } - private KernelResult MmuMapPages(ulong address, KPageList pageList) + private KernelResult MmuMapPages(ulong Address, KPageList PageList) { - foreach (KPageNode pageNode in pageList) + foreach (KPageNode PageNode in PageList) { - ulong size = pageNode.PagesCount * PageSize; + ulong Size = PageNode.PagesCount * PageSize; - _cpuMemory.Map((long)address, (long)(pageNode.Address - DramMemoryMap.DramBase), (long)size); + CpuMemory.Map((long)Address, (long)(PageNode.Address - DramMemoryMap.DramBase), (long)Size); - address += size; + Address += Size; } return KernelResult.Success; } - public KernelResult ConvertVaToPa(ulong va, out ulong pa) + public KernelResult ConvertVaToPa(ulong Va, out ulong Pa) { - pa = DramMemoryMap.DramBase + (ulong)_cpuMemory.GetPhysicalAddress((long)va); + Pa = DramMemoryMap.DramBase + (ulong)CpuMemory.GetPhysicalAddress((long)Va); return KernelResult.Success; } public long GetMmUsedPages() { - lock (_blocks) + lock (Blocks) { return BitUtils.DivRoundUp(GetMmUsedSize(), PageSize); } @@ -2412,47 +2412,47 @@ namespace Ryujinx.HLE.HOS.Kernel private long GetMmUsedSize() { - return _blocks.Count * KMemoryBlockSize; + return Blocks.Count * KMemoryBlockSize; } - public bool IsInvalidRegion(ulong address, ulong size) + public bool IsInvalidRegion(ulong Address, ulong Size) { - return address + size - 1 > GetAddrSpaceBaseAddr() + GetAddrSpaceSize() - 1; + return Address + Size - 1 > GetAddrSpaceBaseAddr() + GetAddrSpaceSize() - 1; } - public bool InsideAddrSpace(ulong address, ulong size) + public bool InsideAddrSpace(ulong Address, ulong Size) { - return AddrSpaceStart <= address && address + size - 1 <= AddrSpaceEnd - 1; + return AddrSpaceStart <= Address && Address + Size - 1 <= AddrSpaceEnd - 1; } - public bool InsideAliasRegion(ulong address, ulong size) + public bool InsideAliasRegion(ulong Address, ulong Size) { - return address + size > AliasRegionStart && AliasRegionEnd > address; + return Address + Size > AliasRegionStart && AliasRegionEnd > Address; } - public bool InsideHeapRegion(ulong address, ulong size) + public bool InsideHeapRegion(ulong Address, ulong Size) { - return address + size > HeapRegionStart && HeapRegionEnd > address; + return Address + Size > HeapRegionStart && HeapRegionEnd > Address; } - public bool InsideStackRegion(ulong address, ulong size) + public bool InsideStackRegion(ulong Address, ulong Size) { - return address + size > StackRegionStart && StackRegionEnd > address; + return Address + Size > StackRegionStart && StackRegionEnd > Address; } - public bool OutsideAliasRegion(ulong address, ulong size) + public bool OutsideAliasRegion(ulong Address, ulong Size) { - return AliasRegionStart > address || address + size - 1 > AliasRegionEnd - 1; + return AliasRegionStart > Address || Address + Size - 1 > AliasRegionEnd - 1; } - public bool OutsideAddrSpace(ulong address, ulong size) + public bool OutsideAddrSpace(ulong Address, ulong Size) { - return AddrSpaceStart > address || address + size - 1 > AddrSpaceEnd - 1; + return AddrSpaceStart > Address || Address + Size - 1 > AddrSpaceEnd - 1; } - public bool OutsideStackRegion(ulong address, ulong size) + public bool OutsideStackRegion(ulong Address, ulong Size) { - return StackRegionStart > address || address + size - 1 > StackRegionEnd - 1; + return StackRegionStart > Address || Address + Size - 1 > StackRegionEnd - 1; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KMemoryRegionBlock.cs b/Ryujinx.HLE/HOS/Kernel/KMemoryRegionBlock.cs index f7e85e9a..1f334e65 100644 --- a/Ryujinx.HLE/HOS/Kernel/KMemoryRegionBlock.cs +++ b/Ryujinx.HLE/HOS/Kernel/KMemoryRegionBlock.cs @@ -12,30 +12,30 @@ namespace Ryujinx.HLE.HOS.Kernel public int Order; public int NextOrder; - public bool TryCoalesce(int index, int size) + public bool TryCoalesce(int Index, int Size) { - long mask = ((1L << size) - 1) << (index & 63); + long Mask = ((1L << Size) - 1) << (Index & 63); - index /= 64; + Index /= 64; - if ((mask & ~Masks[MaxLevel - 1][index]) != 0) + if ((Mask & ~Masks[MaxLevel - 1][Index]) != 0) { return false; } - Masks[MaxLevel - 1][index] &= ~mask; + Masks[MaxLevel - 1][Index] &= ~Mask; - for (int level = MaxLevel - 2; level >= 0; level--, index /= 64) + for (int Level = MaxLevel - 2; Level >= 0; Level--, Index /= 64) { - Masks[level][index / 64] &= ~(1L << (index & 63)); + Masks[Level][Index / 64] &= ~(1L << (Index & 63)); - if (Masks[level][index / 64] != 0) + if (Masks[Level][Index / 64] != 0) { break; } } - FreeCount -= (ulong)size; + FreeCount -= (ulong)Size; return true; } diff --git a/Ryujinx.HLE/HOS/Kernel/KMemoryRegionManager.cs b/Ryujinx.HLE/HOS/Kernel/KMemoryRegionManager.cs index 4c41314d..10db0753 100644 --- a/Ryujinx.HLE/HOS/Kernel/KMemoryRegionManager.cs +++ b/Ryujinx.HLE/HOS/Kernel/KMemoryRegionManager.cs @@ -6,404 +6,404 @@ namespace Ryujinx.HLE.HOS.Kernel { private static readonly int[] BlockOrders = new int[] { 12, 16, 21, 22, 25, 29, 30 }; - public ulong Address { get; } - public ulong EndAddr { get; } - public ulong Size { get; } + public ulong Address { get; private set; } + public ulong EndAddr { get; private set; } + public ulong Size { get; private set; } - private int _blockOrdersCount; + private int BlockOrdersCount; - private KMemoryRegionBlock[] _blocks; + private KMemoryRegionBlock[] Blocks; - public KMemoryRegionManager(ulong address, ulong size, ulong endAddr) + public KMemoryRegionManager(ulong Address, ulong Size, ulong EndAddr) { - _blocks = new KMemoryRegionBlock[BlockOrders.Length]; + Blocks = new KMemoryRegionBlock[BlockOrders.Length]; - Address = address; - Size = size; - EndAddr = endAddr; + this.Address = Address; + this.Size = Size; + this.EndAddr = EndAddr; - _blockOrdersCount = BlockOrders.Length; + BlockOrdersCount = BlockOrders.Length; - for (int blockIndex = 0; blockIndex < _blockOrdersCount; blockIndex++) + for (int BlockIndex = 0; BlockIndex < BlockOrdersCount; BlockIndex++) { - _blocks[blockIndex] = new KMemoryRegionBlock(); + Blocks[BlockIndex] = new KMemoryRegionBlock(); - _blocks[blockIndex].Order = BlockOrders[blockIndex]; + Blocks[BlockIndex].Order = BlockOrders[BlockIndex]; - int nextOrder = blockIndex == _blockOrdersCount - 1 ? 0 : BlockOrders[blockIndex + 1]; + int NextOrder = BlockIndex == BlockOrdersCount - 1 ? 0 : BlockOrders[BlockIndex + 1]; - _blocks[blockIndex].NextOrder = nextOrder; + Blocks[BlockIndex].NextOrder = NextOrder; - int currBlockSize = 1 << BlockOrders[blockIndex]; - int nextBlockSize = currBlockSize; + int CurrBlockSize = 1 << BlockOrders[BlockIndex]; + int NextBlockSize = CurrBlockSize; - if (nextOrder != 0) + if (NextOrder != 0) { - nextBlockSize = 1 << nextOrder; + NextBlockSize = 1 << NextOrder; } - ulong startAligned = BitUtils.AlignDown(address, nextBlockSize); - ulong endAddrAligned = BitUtils.AlignDown(endAddr, currBlockSize); + ulong StartAligned = BitUtils.AlignDown(Address, NextBlockSize); + ulong EndAddrAligned = BitUtils.AlignDown(EndAddr, CurrBlockSize); - ulong sizeInBlocksTruncated = (endAddrAligned - startAligned) >> BlockOrders[blockIndex]; + ulong SizeInBlocksTruncated = (EndAddrAligned - StartAligned) >> BlockOrders[BlockIndex]; - ulong endAddrRounded = BitUtils.AlignUp(address + size, nextBlockSize); + ulong EndAddrRounded = BitUtils.AlignUp(Address + Size, NextBlockSize); - ulong sizeInBlocksRounded = (endAddrRounded - startAligned) >> BlockOrders[blockIndex]; + ulong SizeInBlocksRounded = (EndAddrRounded - StartAligned) >> BlockOrders[BlockIndex]; - _blocks[blockIndex].StartAligned = startAligned; - _blocks[blockIndex].SizeInBlocksTruncated = sizeInBlocksTruncated; - _blocks[blockIndex].SizeInBlocksRounded = sizeInBlocksRounded; + Blocks[BlockIndex].StartAligned = StartAligned; + Blocks[BlockIndex].SizeInBlocksTruncated = SizeInBlocksTruncated; + Blocks[BlockIndex].SizeInBlocksRounded = SizeInBlocksRounded; - ulong currSizeInBlocks = sizeInBlocksRounded; + ulong CurrSizeInBlocks = SizeInBlocksRounded; - int maxLevel = 0; + int MaxLevel = 0; do { - maxLevel++; + MaxLevel++; } - while ((currSizeInBlocks /= 64) != 0); + while ((CurrSizeInBlocks /= 64) != 0); - _blocks[blockIndex].MaxLevel = maxLevel; + Blocks[BlockIndex].MaxLevel = MaxLevel; - _blocks[blockIndex].Masks = new long[maxLevel][]; + Blocks[BlockIndex].Masks = new long[MaxLevel][]; - currSizeInBlocks = sizeInBlocksRounded; + CurrSizeInBlocks = SizeInBlocksRounded; - for (int level = maxLevel - 1; level >= 0; level--) + for (int Level = MaxLevel - 1; Level >= 0; Level--) { - currSizeInBlocks = (currSizeInBlocks + 63) / 64; + CurrSizeInBlocks = (CurrSizeInBlocks + 63) / 64; - _blocks[blockIndex].Masks[level] = new long[currSizeInBlocks]; + Blocks[BlockIndex].Masks[Level] = new long[CurrSizeInBlocks]; } } - if (size != 0) + if (Size != 0) { - FreePages(address, size / KMemoryManager.PageSize); + FreePages(Address, Size / KMemoryManager.PageSize); } } - public KernelResult AllocatePages(ulong pagesCount, bool backwards, out KPageList pageList) + public KernelResult AllocatePages(ulong PagesCount, bool Backwards, out KPageList PageList) { - lock (_blocks) + lock (Blocks) { - return AllocatePagesImpl(pagesCount, backwards, out pageList); + return AllocatePagesImpl(PagesCount, Backwards, out PageList); } } - private KernelResult AllocatePagesImpl(ulong pagesCount, bool backwards, out KPageList pageList) + private KernelResult AllocatePagesImpl(ulong PagesCount, bool Backwards, out KPageList PageList) { - pageList = new KPageList(); + PageList = new KPageList(); - if (_blockOrdersCount > 0) + if (BlockOrdersCount > 0) { - if (GetFreePagesImpl() < pagesCount) + if (GetFreePagesImpl() < PagesCount) { return KernelResult.OutOfMemory; } } - else if (pagesCount != 0) + else if (PagesCount != 0) { return KernelResult.OutOfMemory; } - for (int blockIndex = _blockOrdersCount - 1; blockIndex >= 0; blockIndex--) + for (int BlockIndex = BlockOrdersCount - 1; BlockIndex >= 0; BlockIndex--) { - KMemoryRegionBlock block = _blocks[blockIndex]; + KMemoryRegionBlock Block = Blocks[BlockIndex]; - ulong bestFitBlockSize = 1UL << block.Order; + ulong BestFitBlockSize = 1UL << Block.Order; - ulong blockPagesCount = bestFitBlockSize / KMemoryManager.PageSize; + 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) + while (BlockPagesCount <= PagesCount) { - ulong address = 0; + ulong Address = 0; - for (int currBlockIndex = blockIndex; - currBlockIndex < _blockOrdersCount && address == 0; - currBlockIndex++) + for (int CurrBlockIndex = BlockIndex; + CurrBlockIndex < BlockOrdersCount && Address == 0; + CurrBlockIndex++) { - block = _blocks[currBlockIndex]; + Block = Blocks[CurrBlockIndex]; - int index = 0; + int Index = 0; - bool zeroMask = false; + bool ZeroMask = false; - for (int level = 0; level < block.MaxLevel; level++) + for (int Level = 0; Level < Block.MaxLevel; Level++) { - long mask = block.Masks[level][index]; + long Mask = Block.Masks[Level][Index]; - if (mask == 0) + if (Mask == 0) { - zeroMask = true; + ZeroMask = true; break; } - if (backwards) + if (Backwards) { - index = (index * 64 + 63) - BitUtils.CountLeadingZeros64(mask); + Index = (Index * 64 + 63) - BitUtils.CountLeadingZeros64(Mask); } else { - index = index * 64 + BitUtils.CountLeadingZeros64(BitUtils.ReverseBits64(mask)); + Index = Index * 64 + BitUtils.CountLeadingZeros64(BitUtils.ReverseBits64(Mask)); } } - if (block.SizeInBlocksTruncated <= (ulong)index || zeroMask) + if (Block.SizeInBlocksTruncated <= (ulong)Index || ZeroMask) { continue; } - block.FreeCount--; + Block.FreeCount--; - int tempIdx = index; + int TempIdx = Index; - for (int level = block.MaxLevel - 1; level >= 0; level--, tempIdx /= 64) + for (int Level = Block.MaxLevel - 1; Level >= 0; Level--, TempIdx /= 64) { - block.Masks[level][tempIdx / 64] &= ~(1L << (tempIdx & 63)); + Block.Masks[Level][TempIdx / 64] &= ~(1L << (TempIdx & 63)); - if (block.Masks[level][tempIdx / 64] != 0) + if (Block.Masks[Level][TempIdx / 64] != 0) { break; } } - address = block.StartAligned + ((ulong)index << block.Order); + Address = Block.StartAligned + ((ulong)Index << Block.Order); } - for (int currBlockIndex = blockIndex; - currBlockIndex < _blockOrdersCount && address == 0; - currBlockIndex++) + for (int CurrBlockIndex = BlockIndex; + CurrBlockIndex < BlockOrdersCount && Address == 0; + CurrBlockIndex++) { - block = _blocks[currBlockIndex]; + Block = Blocks[CurrBlockIndex]; - int index = 0; + int Index = 0; - bool zeroMask = false; + bool ZeroMask = false; - for (int level = 0; level < block.MaxLevel; level++) + for (int Level = 0; Level < Block.MaxLevel; Level++) { - long mask = block.Masks[level][index]; + long Mask = Block.Masks[Level][Index]; - if (mask == 0) + if (Mask == 0) { - zeroMask = true; + ZeroMask = true; break; } - if (backwards) + if (Backwards) { - index = index * 64 + BitUtils.CountLeadingZeros64(BitUtils.ReverseBits64(mask)); + Index = Index * 64 + BitUtils.CountLeadingZeros64(BitUtils.ReverseBits64(Mask)); } else { - index = (index * 64 + 63) - BitUtils.CountLeadingZeros64(mask); + Index = (Index * 64 + 63) - BitUtils.CountLeadingZeros64(Mask); } } - if (block.SizeInBlocksTruncated <= (ulong)index || zeroMask) + if (Block.SizeInBlocksTruncated <= (ulong)Index || ZeroMask) { continue; } - block.FreeCount--; + Block.FreeCount--; - int tempIdx = index; + int TempIdx = Index; - for (int level = block.MaxLevel - 1; level >= 0; level--, tempIdx /= 64) + for (int Level = Block.MaxLevel - 1; Level >= 0; Level--, TempIdx /= 64) { - block.Masks[level][tempIdx / 64] &= ~(1L << (tempIdx & 63)); + Block.Masks[Level][TempIdx / 64] &= ~(1L << (TempIdx & 63)); - if (block.Masks[level][tempIdx / 64] != 0) + if (Block.Masks[Level][TempIdx / 64] != 0) { break; } } - address = block.StartAligned + ((ulong)index << block.Order); + 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) + 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; + ulong FirstFreeBlockSize = 1UL << Block.Order; - if (firstFreeBlockSize > bestFitBlockSize) + if (FirstFreeBlockSize > BestFitBlockSize) { - FreePages(address + bestFitBlockSize, (firstFreeBlockSize - bestFitBlockSize) / KMemoryManager.PageSize); + 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); + KernelResult Result = PageList.AddRange(Address, BlockPagesCount); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - FreePages(address, blockPagesCount); + FreePages(Address, BlockPagesCount); - foreach (KPageNode pageNode in pageList) + foreach (KPageNode PageNode in PageList) { - FreePages(pageNode.Address, pageNode.PagesCount); + FreePages(PageNode.Address, PageNode.PagesCount); } - return result; + return Result; } - pagesCount -= blockPagesCount; + PagesCount -= BlockPagesCount; } } //Success case, all requested pages were allocated successfully. - if (pagesCount == 0) + if (PagesCount == 0) { return KernelResult.Success; } //Error case, free allocated pages and return out of memory. - foreach (KPageNode pageNode in pageList) + foreach (KPageNode PageNode in PageList) { - FreePages(pageNode.Address, pageNode.PagesCount); + FreePages(PageNode.Address, PageNode.PagesCount); } - pageList = null; + PageList = null; return KernelResult.OutOfMemory; } - public void FreePages(KPageList pageList) + public void FreePages(KPageList PageList) { - lock (_blocks) + lock (Blocks) { - foreach (KPageNode pageNode in pageList) + foreach (KPageNode PageNode in PageList) { - FreePages(pageNode.Address, pageNode.PagesCount); + FreePages(PageNode.Address, PageNode.PagesCount); } } } - private void FreePages(ulong address, ulong pagesCount) + private void FreePages(ulong Address, ulong PagesCount) { - ulong endAddr = address + pagesCount * KMemoryManager.PageSize; + ulong EndAddr = Address + PagesCount * KMemoryManager.PageSize; - int blockIndex = _blockOrdersCount - 1; + int BlockIndex = BlockOrdersCount - 1; - ulong addressRounded = 0; - ulong endAddrTruncated = 0; + ulong AddressRounded = 0; + ulong EndAddrTruncated = 0; - for (; blockIndex >= 0; blockIndex--) + for (; BlockIndex >= 0; BlockIndex--) { - KMemoryRegionBlock allocInfo = _blocks[blockIndex]; + KMemoryRegionBlock AllocInfo = Blocks[BlockIndex]; - int blockSize = 1 << allocInfo.Order; + int BlockSize = 1 << AllocInfo.Order; - addressRounded = BitUtils.AlignUp (address, blockSize); - endAddrTruncated = BitUtils.AlignDown(endAddr, blockSize); + AddressRounded = BitUtils.AlignUp (Address, BlockSize); + EndAddrTruncated = BitUtils.AlignDown(EndAddr, BlockSize); - if (addressRounded < endAddrTruncated) + if (AddressRounded < EndAddrTruncated) { break; } } - void FreeRegion(ulong currAddress) + void FreeRegion(ulong CurrAddress) { - for (int currBlockIndex = blockIndex; - currBlockIndex < _blockOrdersCount && currAddress != 0; - currBlockIndex++) + for (int CurrBlockIndex = BlockIndex; + CurrBlockIndex < BlockOrdersCount && CurrAddress != 0; + CurrBlockIndex++) { - KMemoryRegionBlock block = _blocks[currBlockIndex]; + KMemoryRegionBlock Block = Blocks[CurrBlockIndex]; - block.FreeCount++; + Block.FreeCount++; - ulong freedBlocks = (currAddress - block.StartAligned) >> block.Order; + ulong FreedBlocks = (CurrAddress - Block.StartAligned) >> Block.Order; - int index = (int)freedBlocks; + int Index = (int)FreedBlocks; - for (int level = block.MaxLevel - 1; level >= 0; level--, index /= 64) + for (int Level = Block.MaxLevel - 1; Level >= 0; Level--, Index /= 64) { - long mask = block.Masks[level][index / 64]; + long Mask = Block.Masks[Level][Index / 64]; - block.Masks[level][index / 64] = mask | (1L << (index & 63)); + Block.Masks[Level][Index / 64] = Mask | (1L << (Index & 63)); - if (mask != 0) + if (Mask != 0) { break; } } - int blockSizeDelta = 1 << (block.NextOrder - block.Order); + int BlockSizeDelta = 1 << (Block.NextOrder - Block.Order); - int freedBlocksTruncated = BitUtils.AlignDown((int)freedBlocks, blockSizeDelta); + int FreedBlocksTruncated = BitUtils.AlignDown((int)FreedBlocks, BlockSizeDelta); - if (!block.TryCoalesce(freedBlocksTruncated, blockSizeDelta)) + if (!Block.TryCoalesce(FreedBlocksTruncated, BlockSizeDelta)) { break; } - currAddress = block.StartAligned + ((ulong)freedBlocksTruncated << block.Order); + CurrAddress = Block.StartAligned + ((ulong)FreedBlocksTruncated << Block.Order); } } //Free inside aligned region. - ulong baseAddress = addressRounded; + ulong BaseAddress = AddressRounded; - while (baseAddress < endAddrTruncated) + while (BaseAddress < EndAddrTruncated) { - ulong blockSize = 1UL << _blocks[blockIndex].Order; + ulong BlockSize = 1UL << Blocks[BlockIndex].Order; - FreeRegion(baseAddress); + FreeRegion(BaseAddress); - baseAddress += blockSize; + BaseAddress += BlockSize; } - int nextBlockIndex = blockIndex - 1; + int NextBlockIndex = BlockIndex - 1; //Free region between Address and aligned region start. - baseAddress = addressRounded; + BaseAddress = AddressRounded; - for (blockIndex = nextBlockIndex; blockIndex >= 0; blockIndex--) + for (BlockIndex = NextBlockIndex; BlockIndex >= 0; BlockIndex--) { - ulong blockSize = 1UL << _blocks[blockIndex].Order; + ulong BlockSize = 1UL << Blocks[BlockIndex].Order; - while (baseAddress - blockSize >= address) + while (BaseAddress - BlockSize >= Address) { - baseAddress -= blockSize; + BaseAddress -= BlockSize; - FreeRegion(baseAddress); + FreeRegion(BaseAddress); } } //Free region between aligned region end and End Address. - baseAddress = endAddrTruncated; + BaseAddress = EndAddrTruncated; - for (blockIndex = nextBlockIndex; blockIndex >= 0; blockIndex--) + for (BlockIndex = NextBlockIndex; BlockIndex >= 0; BlockIndex--) { - ulong blockSize = 1UL << _blocks[blockIndex].Order; + ulong BlockSize = 1UL << Blocks[BlockIndex].Order; - while (baseAddress + blockSize <= endAddr) + while (BaseAddress + BlockSize <= EndAddr) { - FreeRegion(baseAddress); + FreeRegion(BaseAddress); - baseAddress += blockSize; + BaseAddress += BlockSize; } } } public ulong GetFreePages() { - lock (_blocks) + lock (Blocks) { return GetFreePagesImpl(); } @@ -411,18 +411,18 @@ namespace Ryujinx.HLE.HOS.Kernel private ulong GetFreePagesImpl() { - ulong availablePages = 0; + ulong AvailablePages = 0; - for (int blockIndex = 0; blockIndex < _blockOrdersCount; blockIndex++) + for (int BlockIndex = 0; BlockIndex < BlockOrdersCount; BlockIndex++) { - KMemoryRegionBlock block = _blocks[blockIndex]; + KMemoryRegionBlock Block = Blocks[BlockIndex]; - ulong blockPagesCount = (1UL << block.Order) / KMemoryManager.PageSize; + ulong BlockPagesCount = (1UL << Block.Order) / KMemoryManager.PageSize; - availablePages += blockPagesCount * block.FreeCount; + AvailablePages += BlockPagesCount * Block.FreeCount; } - return availablePages; + return AvailablePages; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KPageList.cs b/Ryujinx.HLE/HOS/Kernel/KPageList.cs index 65162646..05162323 100644 --- a/Ryujinx.HLE/HOS/Kernel/KPageList.cs +++ b/Ryujinx.HLE/HOS/Kernel/KPageList.cs @@ -5,31 +5,31 @@ namespace Ryujinx.HLE.HOS.Kernel { class KPageList : IEnumerable<KPageNode> { - public LinkedList<KPageNode> Nodes { get; } + public LinkedList<KPageNode> Nodes { get; private set; } public KPageList() { Nodes = new LinkedList<KPageNode>(); } - public KernelResult AddRange(ulong address, ulong pagesCount) + public KernelResult AddRange(ulong Address, ulong PagesCount) { - if (pagesCount != 0) + if (PagesCount != 0) { if (Nodes.Last != null) { - KPageNode lastNode = Nodes.Last.Value; + KPageNode LastNode = Nodes.Last.Value; - if (lastNode.Address + lastNode.PagesCount * KMemoryManager.PageSize == address) + if (LastNode.Address + LastNode.PagesCount * KMemoryManager.PageSize == Address) { - address = lastNode.Address; - pagesCount += lastNode.PagesCount; + Address = LastNode.Address; + PagesCount += LastNode.PagesCount; Nodes.RemoveLast(); } } - Nodes.AddLast(new KPageNode(address, pagesCount)); + Nodes.AddLast(new KPageNode(Address, PagesCount)); } return KernelResult.Success; @@ -37,34 +37,34 @@ namespace Ryujinx.HLE.HOS.Kernel public ulong GetPagesCount() { - ulong sum = 0; + ulong Sum = 0; - foreach (KPageNode node in Nodes) + foreach (KPageNode Node in Nodes) { - sum += node.PagesCount; + Sum += Node.PagesCount; } - return sum; + return Sum; } - public bool IsEqual(KPageList other) + public bool IsEqual(KPageList Other) { - LinkedListNode<KPageNode> thisNode = Nodes.First; - LinkedListNode<KPageNode> otherNode = other.Nodes.First; + LinkedListNode<KPageNode> ThisNode = Nodes.First; + LinkedListNode<KPageNode> OtherNode = Other.Nodes.First; - while (thisNode != null && otherNode != null) + while (ThisNode != null && OtherNode != null) { - if (thisNode.Value.Address != otherNode.Value.Address || - thisNode.Value.PagesCount != otherNode.Value.PagesCount) + if (ThisNode.Value.Address != OtherNode.Value.Address || + ThisNode.Value.PagesCount != OtherNode.Value.PagesCount) { return false; } - thisNode = thisNode.Next; - otherNode = otherNode.Next; + ThisNode = ThisNode.Next; + OtherNode = OtherNode.Next; } - return thisNode == null && otherNode == null; + return ThisNode == null && OtherNode == null; } public IEnumerator<KPageNode> GetEnumerator() diff --git a/Ryujinx.HLE/HOS/Kernel/KPageNode.cs b/Ryujinx.HLE/HOS/Kernel/KPageNode.cs index 5cdb1c49..6cecab2e 100644 --- a/Ryujinx.HLE/HOS/Kernel/KPageNode.cs +++ b/Ryujinx.HLE/HOS/Kernel/KPageNode.cs @@ -5,10 +5,10 @@ namespace Ryujinx.HLE.HOS.Kernel public ulong Address; public ulong PagesCount; - public KPageNode(ulong address, ulong pagesCount) + public KPageNode(ulong Address, ulong PagesCount) { - Address = address; - PagesCount = pagesCount; + this.Address = Address; + this.PagesCount = PagesCount; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KPort.cs b/Ryujinx.HLE/HOS/Kernel/KPort.cs index 7e5ef394..598f3a32 100644 --- a/Ryujinx.HLE/HOS/Kernel/KPort.cs +++ b/Ryujinx.HLE/HOS/Kernel/KPort.cs @@ -2,25 +2,25 @@ namespace Ryujinx.HLE.HOS.Kernel { class KPort : KAutoObject { - public KServerPort ServerPort { get; } - public KClientPort ClientPort { get; } + public KServerPort ServerPort { get; private set; } + public KClientPort ClientPort { get; private set; } - private long _nameAddress; - private bool _isLight; + private long NameAddress; + private bool IsLight; - public KPort(Horizon system) : base(system) + public KPort(Horizon System) : base(System) { - ServerPort = new KServerPort(system); - ClientPort = new KClientPort(system); + ServerPort = new KServerPort(System); + ClientPort = new KClientPort(System); } - public void Initialize(int maxSessions, bool isLight, long nameAddress) + public void Initialize(int MaxSessions, bool IsLight, long NameAddress) { ServerPort.Initialize(this); - ClientPort.Initialize(this, maxSessions); + ClientPort.Initialize(this, MaxSessions); - _isLight = isLight; - _nameAddress = nameAddress; + this.IsLight = IsLight; + this.NameAddress = NameAddress; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KProcess.cs b/Ryujinx.HLE/HOS/Kernel/KProcess.cs index 53b55f7e..094ef222 100644 --- a/Ryujinx.HLE/HOS/Kernel/KProcess.cs +++ b/Ryujinx.HLE/HOS/Kernel/KProcess.cs @@ -21,10 +21,10 @@ namespace Ryujinx.HLE.HOS.Kernel (KernelVersionMinor << 15) | (KernelVersionRevision << 0); - public KMemoryManager MemoryManager { get; } + public KMemoryManager MemoryManager { get; private set; } - private SortedDictionary<ulong, KTlsPageInfo> _fullTlsPages; - private SortedDictionary<ulong, KTlsPageInfo> _freeTlsPages; + private SortedDictionary<ulong, KTlsPageInfo> FullTlsPages; + private SortedDictionary<ulong, KTlsPageInfo> FreeTlsPages; public int DefaultCpuCore { get; private set; } @@ -34,142 +34,142 @@ namespace Ryujinx.HLE.HOS.Kernel public ulong PersonalMmHeapPagesCount { get; private set; } - private ProcessState _state; + private ProcessState State; - private object _processLock; - private object _threadingLock; + private object ProcessLock; + private object ThreadingLock; - public KAddressArbiter AddressArbiter { get; } + public KAddressArbiter AddressArbiter { get; private set; } - public long[] RandomEntropy { get; } + public long[] RandomEntropy { get; private set; } - private bool _signaled; - private bool _useSystemMemBlocks; + private bool Signaled; + private bool UseSystemMemBlocks; public string Name { get; private set; } - private int _threadCount; + private int ThreadCount; public int MmuFlags { get; private set; } - private MemoryRegion _memRegion; + private MemoryRegion MemRegion; - public KProcessCapabilities Capabilities { get; } + public KProcessCapabilities Capabilities { get; private set; } public long TitleId { get; private set; } public long Pid { get; private set; } - private long _creationTimestamp; - private ulong _entrypoint; - private ulong _imageSize; - private ulong _mainThreadStackSize; - private ulong _memoryUsageCapacity; - private int _category; + private long CreationTimestamp; + private ulong Entrypoint; + private ulong ImageSize; + private ulong MainThreadStackSize; + private ulong MemoryUsageCapacity; + private int Category; public KHandleTable HandleTable { get; private set; } public ulong UserExceptionContextAddress { get; private set; } - private LinkedList<KThread> _threads; + private LinkedList<KThread> Threads; public bool IsPaused { get; private set; } - public Translator Translator { get; } + public Translator Translator { get; private set; } - public MemoryManager CpuMemory { get; } + public MemoryManager CpuMemory { get; private set; } - private SvcHandler _svcHandler; + private SvcHandler SvcHandler; - public HleProcessDebugger Debugger { get; } + public HleProcessDebugger Debugger { get; private set; } - public KProcess(Horizon system) : base(system) + public KProcess(Horizon System) : base(System) { - _processLock = new object(); - _threadingLock = new object(); + ProcessLock = new object(); + ThreadingLock = new object(); - CpuMemory = new MemoryManager(system.Device.Memory.RamPointer); + CpuMemory = new MemoryManager(System.Device.Memory.RamPointer); CpuMemory.InvalidAccess += InvalidAccessHandler; - AddressArbiter = new KAddressArbiter(system); + AddressArbiter = new KAddressArbiter(System); - MemoryManager = new KMemoryManager(system, CpuMemory); + MemoryManager = new KMemoryManager(System, CpuMemory); - _fullTlsPages = new SortedDictionary<ulong, KTlsPageInfo>(); - _freeTlsPages = new SortedDictionary<ulong, KTlsPageInfo>(); + FullTlsPages = new SortedDictionary<ulong, KTlsPageInfo>(); + FreeTlsPages = new SortedDictionary<ulong, KTlsPageInfo>(); Capabilities = new KProcessCapabilities(); RandomEntropy = new long[KScheduler.CpuCoresCount]; - _threads = new LinkedList<KThread>(); + Threads = new LinkedList<KThread>(); Translator = new Translator(); Translator.CpuTrace += CpuTraceHandler; - _svcHandler = new SvcHandler(system.Device, this); + SvcHandler = new SvcHandler(System.Device, this); Debugger = new HleProcessDebugger(this); } public KernelResult InitializeKip( - ProcessCreationInfo creationInfo, - int[] caps, - KPageList pageList, - KResourceLimit resourceLimit, - MemoryRegion memRegion) + ProcessCreationInfo CreationInfo, + int[] Caps, + KPageList PageList, + KResourceLimit ResourceLimit, + MemoryRegion MemRegion) { - ResourceLimit = resourceLimit; - _memRegion = memRegion; + this.ResourceLimit = ResourceLimit; + this.MemRegion = MemRegion; - AddressSpaceType addrSpaceType = (AddressSpaceType)((creationInfo.MmuFlags >> 1) & 7); + AddressSpaceType AddrSpaceType = (AddressSpaceType)((CreationInfo.MmuFlags >> 1) & 7); - bool aslrEnabled = ((creationInfo.MmuFlags >> 5) & 1) != 0; + bool AslrEnabled = ((CreationInfo.MmuFlags >> 5) & 1) != 0; - ulong codeAddress = creationInfo.CodeAddress; + ulong CodeAddress = CreationInfo.CodeAddress; - ulong codeSize = (ulong)creationInfo.CodePagesCount * KMemoryManager.PageSize; + ulong CodeSize = (ulong)CreationInfo.CodePagesCount * KMemoryManager.PageSize; - KMemoryBlockAllocator memoryBlockAllocator = (MmuFlags & 0x40) != 0 + KMemoryBlockAllocator MemoryBlockAllocator = (MmuFlags & 0x40) != 0 ? System.LargeMemoryBlockAllocator : System.SmallMemoryBlockAllocator; - KernelResult result = MemoryManager.InitializeForProcess( - addrSpaceType, - aslrEnabled, - !aslrEnabled, - memRegion, - codeAddress, - codeSize, - memoryBlockAllocator); + KernelResult Result = MemoryManager.InitializeForProcess( + AddrSpaceType, + AslrEnabled, + !AslrEnabled, + MemRegion, + CodeAddress, + CodeSize, + MemoryBlockAllocator); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } - if (!ValidateCodeAddressAndSize(codeAddress, codeSize)) + if (!ValidateCodeAddressAndSize(CodeAddress, CodeSize)) { return KernelResult.InvalidMemRange; } - result = MemoryManager.MapPages( - codeAddress, - pageList, + Result = MemoryManager.MapPages( + CodeAddress, + PageList, MemoryState.CodeStatic, MemoryPermission.None); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } - result = Capabilities.InitializeForKernel(caps, MemoryManager); + Result = Capabilities.InitializeForKernel(Caps, MemoryManager); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } Pid = System.GetKipId(); @@ -179,29 +179,29 @@ namespace Ryujinx.HLE.HOS.Kernel throw new InvalidOperationException($"Invalid KIP Id {Pid}."); } - result = ParseProcessInfo(creationInfo); + Result = ParseProcessInfo(CreationInfo); - return result; + return Result; } public KernelResult Initialize( - ProcessCreationInfo creationInfo, - int[] caps, - KResourceLimit resourceLimit, - MemoryRegion memRegion) + ProcessCreationInfo CreationInfo, + int[] Caps, + KResourceLimit ResourceLimit, + MemoryRegion MemRegion) { - ResourceLimit = resourceLimit; - _memRegion = memRegion; + this.ResourceLimit = ResourceLimit; + this.MemRegion = MemRegion; - ulong personalMmHeapSize = GetPersonalMmHeapSize((ulong)creationInfo.PersonalMmHeapPagesCount, memRegion); + ulong PersonalMmHeapSize = GetPersonalMmHeapSize((ulong)CreationInfo.PersonalMmHeapPagesCount, MemRegion); - ulong codePagesCount = (ulong)creationInfo.CodePagesCount; + ulong CodePagesCount = (ulong)CreationInfo.CodePagesCount; - ulong neededSizeForProcess = personalMmHeapSize + codePagesCount * KMemoryManager.PageSize; + ulong NeededSizeForProcess = PersonalMmHeapSize + CodePagesCount * KMemoryManager.PageSize; - if (neededSizeForProcess != 0 && resourceLimit != null) + if (NeededSizeForProcess != 0 && ResourceLimit != null) { - if (!resourceLimit.Reserve(LimitableResource.Memory, neededSizeForProcess)) + if (!ResourceLimit.Reserve(LimitableResource.Memory, NeededSizeForProcess)) { return KernelResult.ResLimitExceeded; } @@ -209,78 +209,78 @@ namespace Ryujinx.HLE.HOS.Kernel void CleanUpForError() { - if (neededSizeForProcess != 0 && resourceLimit != null) + if (NeededSizeForProcess != 0 && ResourceLimit != null) { - resourceLimit.Release(LimitableResource.Memory, neededSizeForProcess); + ResourceLimit.Release(LimitableResource.Memory, NeededSizeForProcess); } } - PersonalMmHeapPagesCount = (ulong)creationInfo.PersonalMmHeapPagesCount; + PersonalMmHeapPagesCount = (ulong)CreationInfo.PersonalMmHeapPagesCount; - KMemoryBlockAllocator memoryBlockAllocator; + KMemoryBlockAllocator MemoryBlockAllocator; if (PersonalMmHeapPagesCount != 0) { - memoryBlockAllocator = new KMemoryBlockAllocator(PersonalMmHeapPagesCount * KMemoryManager.PageSize); + MemoryBlockAllocator = new KMemoryBlockAllocator(PersonalMmHeapPagesCount * KMemoryManager.PageSize); } else { - memoryBlockAllocator = (MmuFlags & 0x40) != 0 + MemoryBlockAllocator = (MmuFlags & 0x40) != 0 ? System.LargeMemoryBlockAllocator : System.SmallMemoryBlockAllocator; } - AddressSpaceType addrSpaceType = (AddressSpaceType)((creationInfo.MmuFlags >> 1) & 7); + AddressSpaceType AddrSpaceType = (AddressSpaceType)((CreationInfo.MmuFlags >> 1) & 7); - bool aslrEnabled = ((creationInfo.MmuFlags >> 5) & 1) != 0; + bool AslrEnabled = ((CreationInfo.MmuFlags >> 5) & 1) != 0; - ulong codeAddress = creationInfo.CodeAddress; + ulong CodeAddress = CreationInfo.CodeAddress; - ulong codeSize = codePagesCount * KMemoryManager.PageSize; + ulong CodeSize = CodePagesCount * KMemoryManager.PageSize; - KernelResult result = MemoryManager.InitializeForProcess( - addrSpaceType, - aslrEnabled, - !aslrEnabled, - memRegion, - codeAddress, - codeSize, - memoryBlockAllocator); + KernelResult Result = MemoryManager.InitializeForProcess( + AddrSpaceType, + AslrEnabled, + !AslrEnabled, + MemRegion, + CodeAddress, + CodeSize, + MemoryBlockAllocator); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { CleanUpForError(); - return result; + return Result; } - if (!ValidateCodeAddressAndSize(codeAddress, codeSize)) + if (!ValidateCodeAddressAndSize(CodeAddress, CodeSize)) { CleanUpForError(); return KernelResult.InvalidMemRange; } - result = MemoryManager.MapNewProcessCode( - codeAddress, - codePagesCount, + Result = MemoryManager.MapNewProcessCode( + CodeAddress, + CodePagesCount, MemoryState.CodeStatic, MemoryPermission.None); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { CleanUpForError(); - return result; + return Result; } - result = Capabilities.InitializeForUser(caps, MemoryManager); + Result = Capabilities.InitializeForUser(Caps, MemoryManager); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { CleanUpForError(); - return result; + return Result; } Pid = System.GetProcessId(); @@ -290,53 +290,53 @@ namespace Ryujinx.HLE.HOS.Kernel throw new InvalidOperationException($"Invalid Process Id {Pid}."); } - result = ParseProcessInfo(creationInfo); + Result = ParseProcessInfo(CreationInfo); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { CleanUpForError(); } - return result; + return Result; } - private bool ValidateCodeAddressAndSize(ulong address, ulong size) + private bool ValidateCodeAddressAndSize(ulong Address, ulong Size) { - ulong codeRegionStart; - ulong codeRegionSize; + ulong CodeRegionStart; + ulong CodeRegionSize; switch (MemoryManager.AddrSpaceWidth) { case 32: - codeRegionStart = 0x200000; - codeRegionSize = 0x3fe00000; + CodeRegionStart = 0x200000; + CodeRegionSize = 0x3fe00000; break; case 36: - codeRegionStart = 0x8000000; - codeRegionSize = 0x78000000; + CodeRegionStart = 0x8000000; + CodeRegionSize = 0x78000000; break; case 39: - codeRegionStart = 0x8000000; - codeRegionSize = 0x7ff8000000; + CodeRegionStart = 0x8000000; + CodeRegionSize = 0x7ff8000000; break; default: throw new InvalidOperationException("Invalid address space width on memory manager."); } - ulong endAddr = address + size; + ulong EndAddr = Address + Size; - ulong codeRegionEnd = codeRegionStart + codeRegionSize; + ulong CodeRegionEnd = CodeRegionStart + CodeRegionSize; - if (endAddr <= address || - endAddr - 1 > codeRegionEnd - 1) + if (EndAddr <= Address || + EndAddr - 1 > CodeRegionEnd - 1) { return false; } - if (MemoryManager.InsideHeapRegion (address, size) || - MemoryManager.InsideAliasRegion(address, size)) + if (MemoryManager.InsideHeapRegion (Address, Size) || + MemoryManager.InsideAliasRegion(Address, Size)) { return false; } @@ -344,69 +344,69 @@ namespace Ryujinx.HLE.HOS.Kernel return true; } - private KernelResult ParseProcessInfo(ProcessCreationInfo creationInfo) + private KernelResult ParseProcessInfo(ProcessCreationInfo CreationInfo) { //Ensure that the current kernel version is equal or above to the minimum required. - uint requiredKernelVersionMajor = (uint)Capabilities.KernelReleaseVersion >> 19; - uint requiredKernelVersionMinor = ((uint)Capabilities.KernelReleaseVersion >> 15) & 0xf; + uint RequiredKernelVersionMajor = (uint)Capabilities.KernelReleaseVersion >> 19; + uint RequiredKernelVersionMinor = ((uint)Capabilities.KernelReleaseVersion >> 15) & 0xf; if (System.EnableVersionChecks) { - if (requiredKernelVersionMajor > KernelVersionMajor) + if (RequiredKernelVersionMajor > KernelVersionMajor) { return KernelResult.InvalidCombination; } - if (requiredKernelVersionMajor != KernelVersionMajor && requiredKernelVersionMajor < 3) + if (RequiredKernelVersionMajor != KernelVersionMajor && RequiredKernelVersionMajor < 3) { return KernelResult.InvalidCombination; } - if (requiredKernelVersionMinor > KernelVersionMinor) + if (RequiredKernelVersionMinor > KernelVersionMinor) { return KernelResult.InvalidCombination; } } - KernelResult result = AllocateThreadLocalStorage(out ulong userExceptionContextAddress); + KernelResult Result = AllocateThreadLocalStorage(out ulong UserExceptionContextAddress); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } - UserExceptionContextAddress = userExceptionContextAddress; + this.UserExceptionContextAddress = UserExceptionContextAddress; - MemoryHelper.FillWithZeros(CpuMemory, (long)userExceptionContextAddress, KTlsPageInfo.TlsEntrySize); + MemoryHelper.FillWithZeros(CpuMemory, (long)UserExceptionContextAddress, KTlsPageInfo.TlsEntrySize); - Name = creationInfo.Name; + Name = CreationInfo.Name; - _state = ProcessState.Created; + State = ProcessState.Created; - _creationTimestamp = PerformanceCounter.ElapsedMilliseconds; + CreationTimestamp = PerformanceCounter.ElapsedMilliseconds; - MmuFlags = creationInfo.MmuFlags; - _category = creationInfo.Category; - TitleId = creationInfo.TitleId; - _entrypoint = creationInfo.CodeAddress; - _imageSize = (ulong)creationInfo.CodePagesCount * KMemoryManager.PageSize; + MmuFlags = CreationInfo.MmuFlags; + Category = CreationInfo.Category; + TitleId = CreationInfo.TitleId; + Entrypoint = CreationInfo.CodeAddress; + ImageSize = (ulong)CreationInfo.CodePagesCount * KMemoryManager.PageSize; - _useSystemMemBlocks = ((MmuFlags >> 6) & 1) != 0; + UseSystemMemBlocks = ((MmuFlags >> 6) & 1) != 0; switch ((AddressSpaceType)((MmuFlags >> 1) & 7)) { case AddressSpaceType.Addr32Bits: case AddressSpaceType.Addr36Bits: case AddressSpaceType.Addr39Bits: - _memoryUsageCapacity = MemoryManager.HeapRegionEnd - + MemoryUsageCapacity = MemoryManager.HeapRegionEnd - MemoryManager.HeapRegionStart; break; case AddressSpaceType.Addr32BitsNoMap: - _memoryUsageCapacity = MemoryManager.HeapRegionEnd - - MemoryManager.HeapRegionStart + - MemoryManager.AliasRegionEnd - - MemoryManager.AliasRegionStart; + MemoryUsageCapacity = MemoryManager.HeapRegionEnd - + MemoryManager.HeapRegionStart + + MemoryManager.AliasRegionEnd - + MemoryManager.AliasRegionStart; break; default: throw new InvalidOperationException($"Invalid MMU flags value 0x{MmuFlags:x2}."); @@ -417,130 +417,130 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } - public KernelResult AllocateThreadLocalStorage(out ulong address) + public KernelResult AllocateThreadLocalStorage(out ulong Address) { System.CriticalSection.Enter(); - KernelResult result; + KernelResult Result; - if (_freeTlsPages.Count > 0) + if (FreeTlsPages.Count > 0) { //If we have free TLS pages available, just use the first one. - KTlsPageInfo pageInfo = _freeTlsPages.Values.First(); + KTlsPageInfo PageInfo = FreeTlsPages.Values.First(); - if (!pageInfo.TryGetFreePage(out address)) + if (!PageInfo.TryGetFreePage(out Address)) { throw new InvalidOperationException("Unexpected failure getting free TLS page!"); } - if (pageInfo.IsFull()) + if (PageInfo.IsFull()) { - _freeTlsPages.Remove(pageInfo.PageAddr); + FreeTlsPages.Remove(PageInfo.PageAddr); - _fullTlsPages.Add(pageInfo.PageAddr, pageInfo); + FullTlsPages.Add(PageInfo.PageAddr, PageInfo); } - result = KernelResult.Success; + Result = KernelResult.Success; } else { //Otherwise, we need to create a new one. - result = AllocateTlsPage(out KTlsPageInfo pageInfo); + Result = AllocateTlsPage(out KTlsPageInfo PageInfo); - if (result == KernelResult.Success) + if (Result == KernelResult.Success) { - if (!pageInfo.TryGetFreePage(out address)) + if (!PageInfo.TryGetFreePage(out Address)) { throw new InvalidOperationException("Unexpected failure getting free TLS page!"); } - _freeTlsPages.Add(pageInfo.PageAddr, pageInfo); + FreeTlsPages.Add(PageInfo.PageAddr, PageInfo); } else { - address = 0; + Address = 0; } } System.CriticalSection.Leave(); - return result; + return Result; } - private KernelResult AllocateTlsPage(out KTlsPageInfo pageInfo) + private KernelResult AllocateTlsPage(out KTlsPageInfo PageInfo) { - pageInfo = default(KTlsPageInfo); + PageInfo = default(KTlsPageInfo); - if (!System.UserSlabHeapPages.TryGetItem(out ulong tlsPagePa)) + if (!System.UserSlabHeapPages.TryGetItem(out ulong TlsPagePa)) { return KernelResult.OutOfMemory; } - ulong regionStart = MemoryManager.TlsIoRegionStart; - ulong regionSize = MemoryManager.TlsIoRegionEnd - regionStart; + ulong RegionStart = MemoryManager.TlsIoRegionStart; + ulong RegionSize = MemoryManager.TlsIoRegionEnd - RegionStart; - ulong regionPagesCount = regionSize / KMemoryManager.PageSize; + ulong RegionPagesCount = RegionSize / KMemoryManager.PageSize; - KernelResult result = MemoryManager.AllocateOrMapPa( + KernelResult Result = MemoryManager.AllocateOrMapPa( 1, KMemoryManager.PageSize, - tlsPagePa, + TlsPagePa, true, - regionStart, - regionPagesCount, + RegionStart, + RegionPagesCount, MemoryState.ThreadLocal, MemoryPermission.ReadAndWrite, - out ulong tlsPageVa); + out ulong TlsPageVa); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - System.UserSlabHeapPages.Free(tlsPagePa); + System.UserSlabHeapPages.Free(TlsPagePa); } else { - pageInfo = new KTlsPageInfo(tlsPageVa); + PageInfo = new KTlsPageInfo(TlsPageVa); - MemoryHelper.FillWithZeros(CpuMemory, (long)tlsPageVa, KMemoryManager.PageSize); + MemoryHelper.FillWithZeros(CpuMemory, (long)TlsPageVa, KMemoryManager.PageSize); } - return result; + return Result; } - public KernelResult FreeThreadLocalStorage(ulong tlsSlotAddr) + public KernelResult FreeThreadLocalStorage(ulong TlsSlotAddr) { - ulong tlsPageAddr = BitUtils.AlignDown(tlsSlotAddr, KMemoryManager.PageSize); + ulong TlsPageAddr = BitUtils.AlignDown(TlsSlotAddr, KMemoryManager.PageSize); System.CriticalSection.Enter(); - KernelResult result = KernelResult.Success; + KernelResult Result = KernelResult.Success; - KTlsPageInfo pageInfo = null; + KTlsPageInfo PageInfo = null; - if (_fullTlsPages.TryGetValue(tlsPageAddr, out pageInfo)) + if (FullTlsPages.TryGetValue(TlsPageAddr, out PageInfo)) { //TLS page was full, free slot and move to free pages tree. - _fullTlsPages.Remove(tlsPageAddr); + FullTlsPages.Remove(TlsPageAddr); - _freeTlsPages.Add(tlsPageAddr, pageInfo); + FreeTlsPages.Add(TlsPageAddr, PageInfo); } - else if (!_freeTlsPages.TryGetValue(tlsPageAddr, out pageInfo)) + else if (!FreeTlsPages.TryGetValue(TlsPageAddr, out PageInfo)) { - result = KernelResult.InvalidAddress; + Result = KernelResult.InvalidAddress; } - if (pageInfo != null) + if (PageInfo != null) { - pageInfo.FreeTlsSlot(tlsSlotAddr); + PageInfo.FreeTlsSlot(TlsSlotAddr); - if (pageInfo.IsEmpty()) + if (PageInfo.IsEmpty()) { //TLS page is now empty, we should ensure it is removed //from all trees, and free the memory it was using. - _freeTlsPages.Remove(tlsPageAddr); + FreeTlsPages.Remove(TlsPageAddr); System.CriticalSection.Leave(); - FreeTlsPage(pageInfo); + FreeTlsPage(PageInfo); return KernelResult.Success; } @@ -548,26 +548,26 @@ namespace Ryujinx.HLE.HOS.Kernel System.CriticalSection.Leave(); - return result; + return Result; } - private KernelResult FreeTlsPage(KTlsPageInfo pageInfo) + private KernelResult FreeTlsPage(KTlsPageInfo PageInfo) { - KernelResult result = MemoryManager.ConvertVaToPa(pageInfo.PageAddr, out ulong tlsPagePa); + KernelResult Result = MemoryManager.ConvertVaToPa(PageInfo.PageAddr, out ulong TlsPagePa); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { throw new InvalidOperationException("Unexpected failure translating virtual address to physical."); } - result = MemoryManager.UnmapForKernel(pageInfo.PageAddr, 1, MemoryState.ThreadLocal); + Result = MemoryManager.UnmapForKernel(PageInfo.PageAddr, 1, MemoryState.ThreadLocal); - if (result == KernelResult.Success) + if (Result == KernelResult.Success) { - System.UserSlabHeapPages.Free(tlsPagePa); + System.UserSlabHeapPages.Free(TlsPagePa); } - return result; + return Result; } private void GenerateRandomEntropy() @@ -575,11 +575,11 @@ namespace Ryujinx.HLE.HOS.Kernel //TODO. } - public KernelResult Start(int mainThreadPriority, ulong stackSize) + public KernelResult Start(int MainThreadPriority, ulong StackSize) { - lock (_processLock) + lock (ProcessLock) { - if (_state > ProcessState.CreatedAttached) + if (State > ProcessState.CreatedAttached) { return KernelResult.InvalidState; } @@ -589,153 +589,153 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.ResLimitExceeded; } - KResourceLimit threadResourceLimit = ResourceLimit; - KResourceLimit memoryResourceLimit = null; + KResourceLimit ThreadResourceLimit = ResourceLimit; + KResourceLimit MemoryResourceLimit = null; - if (_mainThreadStackSize != 0) + if (MainThreadStackSize != 0) { throw new InvalidOperationException("Trying to start a process with a invalid state!"); } - ulong stackSizeRounded = BitUtils.AlignUp(stackSize, KMemoryManager.PageSize); + ulong StackSizeRounded = BitUtils.AlignUp(StackSize, KMemoryManager.PageSize); - ulong neededSize = stackSizeRounded + _imageSize; + ulong NeededSize = StackSizeRounded + ImageSize; //Check if the needed size for the code and the stack will fit on the //memory usage capacity of this Process. Also check for possible overflow //on the above addition. - if (neededSize > _memoryUsageCapacity || - neededSize < stackSizeRounded) + if (NeededSize > MemoryUsageCapacity || + NeededSize < StackSizeRounded) { - threadResourceLimit?.Release(LimitableResource.Thread, 1); + ThreadResourceLimit?.Release(LimitableResource.Thread, 1); return KernelResult.OutOfMemory; } - if (stackSizeRounded != 0 && ResourceLimit != null) + if (StackSizeRounded != 0 && ResourceLimit != null) { - memoryResourceLimit = ResourceLimit; + MemoryResourceLimit = ResourceLimit; - if (!memoryResourceLimit.Reserve(LimitableResource.Memory, stackSizeRounded)) + if (!MemoryResourceLimit.Reserve(LimitableResource.Memory, StackSizeRounded)) { - threadResourceLimit?.Release(LimitableResource.Thread, 1); + ThreadResourceLimit?.Release(LimitableResource.Thread, 1); return KernelResult.ResLimitExceeded; } } - KernelResult result; + KernelResult Result; - KThread mainThread = null; + KThread MainThread = null; - ulong stackTop = 0; + ulong StackTop = 0; void CleanUpForError() { - mainThread?.Terminate(); + MainThread?.Terminate(); HandleTable.Destroy(); - if (_mainThreadStackSize != 0) + if (MainThreadStackSize != 0) { - ulong stackBottom = stackTop - _mainThreadStackSize; + ulong StackBottom = StackTop - MainThreadStackSize; - ulong stackPagesCount = _mainThreadStackSize / KMemoryManager.PageSize; + ulong StackPagesCount = MainThreadStackSize / KMemoryManager.PageSize; - MemoryManager.UnmapForKernel(stackBottom, stackPagesCount, MemoryState.Stack); + MemoryManager.UnmapForKernel(StackBottom, StackPagesCount, MemoryState.Stack); } - memoryResourceLimit?.Release(LimitableResource.Memory, stackSizeRounded); - threadResourceLimit?.Release(LimitableResource.Thread, 1); + MemoryResourceLimit?.Release(LimitableResource.Memory, StackSizeRounded); + ThreadResourceLimit?.Release(LimitableResource.Thread, 1); } - if (stackSizeRounded != 0) + if (StackSizeRounded != 0) { - ulong stackPagesCount = stackSizeRounded / KMemoryManager.PageSize; + ulong StackPagesCount = StackSizeRounded / KMemoryManager.PageSize; - ulong regionStart = MemoryManager.StackRegionStart; - ulong regionSize = MemoryManager.StackRegionEnd - regionStart; + ulong RegionStart = MemoryManager.StackRegionStart; + ulong RegionSize = MemoryManager.StackRegionEnd - RegionStart; - ulong regionPagesCount = regionSize / KMemoryManager.PageSize; + ulong RegionPagesCount = RegionSize / KMemoryManager.PageSize; - result = MemoryManager.AllocateOrMapPa( - stackPagesCount, + Result = MemoryManager.AllocateOrMapPa( + StackPagesCount, KMemoryManager.PageSize, 0, false, - regionStart, - regionPagesCount, + RegionStart, + RegionPagesCount, MemoryState.Stack, MemoryPermission.ReadAndWrite, - out ulong stackBottom); + out ulong StackBottom); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { CleanUpForError(); - return result; + return Result; } - _mainThreadStackSize += stackSizeRounded; + MainThreadStackSize += StackSizeRounded; - stackTop = stackBottom + stackSizeRounded; + StackTop = StackBottom + StackSizeRounded; } - ulong heapCapacity = _memoryUsageCapacity - _mainThreadStackSize - _imageSize; + ulong HeapCapacity = MemoryUsageCapacity - MainThreadStackSize - ImageSize; - result = MemoryManager.SetHeapCapacity(heapCapacity); + Result = MemoryManager.SetHeapCapacity(HeapCapacity); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { CleanUpForError(); - return result; + return Result; } HandleTable = new KHandleTable(System); - result = HandleTable.Initialize(Capabilities.HandleTableSize); + Result = HandleTable.Initialize(Capabilities.HandleTableSize); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { CleanUpForError(); - return result; + return Result; } - mainThread = new KThread(System); + MainThread = new KThread(System); - result = mainThread.Initialize( - _entrypoint, + Result = MainThread.Initialize( + Entrypoint, 0, - stackTop, - mainThreadPriority, + StackTop, + MainThreadPriority, DefaultCpuCore, this); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { CleanUpForError(); - return result; + return Result; } - result = HandleTable.GenerateHandle(mainThread, out int mainThreadHandle); + Result = HandleTable.GenerateHandle(MainThread, out int MainThreadHandle); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { CleanUpForError(); - return result; + return Result; } - mainThread.SetEntryArguments(0, mainThreadHandle); + MainThread.SetEntryArguments(0, MainThreadHandle); - ProcessState oldState = _state; - ProcessState newState = _state != ProcessState.Created + ProcessState OldState = State; + ProcessState NewState = State != ProcessState.Created ? ProcessState.Attached : ProcessState.Started; - SetState(newState); + SetState(NewState); //TODO: We can't call KThread.Start from a non-guest thread. //We will need to make some changes to allow the creation of @@ -750,41 +750,41 @@ namespace Ryujinx.HLE.HOS.Kernel CleanUpForError(); } */ - mainThread.Reschedule(ThreadSchedState.Running); + MainThread.Reschedule(ThreadSchedState.Running); - return result; + return Result; } } - private void SetState(ProcessState newState) + private void SetState(ProcessState NewState) { - if (_state != newState) + if (State != NewState) { - _state = newState; - _signaled = true; + State = NewState; + Signaled = true; Signal(); } } public KernelResult InitializeThread( - KThread thread, - ulong entrypoint, - ulong argsPtr, - ulong stackTop, - int priority, - int cpuCore) + KThread Thread, + ulong Entrypoint, + ulong ArgsPtr, + ulong StackTop, + int Priority, + int CpuCore) { - lock (_processLock) + lock (ProcessLock) { - return thread.Initialize(entrypoint, argsPtr, stackTop, priority, cpuCore, this); + return Thread.Initialize(Entrypoint, ArgsPtr, StackTop, Priority, CpuCore, this); } } - public void SubscribeThreadEventHandlers(CpuThread context) + public void SubscribeThreadEventHandlers(CpuThread Context) { - context.ThreadState.Interrupt += InterruptHandler; - context.ThreadState.SvcCall += _svcHandler.SvcCall; + Context.ThreadState.Interrupt += InterruptHandler; + Context.ThreadState.SvcCall += SvcHandler.SvcCall; } private void InterruptHandler(object sender, EventArgs e) @@ -794,7 +794,7 @@ namespace Ryujinx.HLE.HOS.Kernel public void IncrementThreadCount() { - Interlocked.Increment(ref _threadCount); + Interlocked.Increment(ref ThreadCount); System.ThreadCounter.AddCount(); } @@ -803,7 +803,7 @@ namespace Ryujinx.HLE.HOS.Kernel { System.ThreadCounter.Signal(); - if (Interlocked.Decrement(ref _threadCount) == 0) + if (Interlocked.Decrement(ref ThreadCount) == 0) { Terminate(); } @@ -811,25 +811,25 @@ namespace Ryujinx.HLE.HOS.Kernel public ulong GetMemoryCapacity() { - ulong totalCapacity = (ulong)ResourceLimit.GetRemainingValue(LimitableResource.Memory); + ulong TotalCapacity = (ulong)ResourceLimit.GetRemainingValue(LimitableResource.Memory); - totalCapacity += MemoryManager.GetTotalHeapSize(); + TotalCapacity += MemoryManager.GetTotalHeapSize(); - totalCapacity += GetPersonalMmHeapSize(); + TotalCapacity += GetPersonalMmHeapSize(); - totalCapacity += _imageSize + _mainThreadStackSize; + TotalCapacity += ImageSize + MainThreadStackSize; - if (totalCapacity <= _memoryUsageCapacity) + if (TotalCapacity <= MemoryUsageCapacity) { - return totalCapacity; + return TotalCapacity; } - return _memoryUsageCapacity; + return MemoryUsageCapacity; } public ulong GetMemoryUsage() { - return _imageSize + _mainThreadStackSize + MemoryManager.GetTotalHeapSize() + GetPersonalMmHeapSize(); + return ImageSize + MainThreadStackSize + MemoryManager.GetTotalHeapSize() + GetPersonalMmHeapSize(); } public ulong GetMemoryCapacityWithoutPersonalMmHeap() @@ -844,83 +844,83 @@ namespace Ryujinx.HLE.HOS.Kernel private ulong GetPersonalMmHeapSize() { - return GetPersonalMmHeapSize(PersonalMmHeapPagesCount, _memRegion); + return GetPersonalMmHeapSize(PersonalMmHeapPagesCount, MemRegion); } - private static ulong GetPersonalMmHeapSize(ulong personalMmHeapPagesCount, MemoryRegion memRegion) + private static ulong GetPersonalMmHeapSize(ulong PersonalMmHeapPagesCount, MemoryRegion MemRegion) { - if (memRegion == MemoryRegion.Applet) + if (MemRegion == MemoryRegion.Applet) { return 0; } - return personalMmHeapPagesCount * KMemoryManager.PageSize; + return PersonalMmHeapPagesCount * KMemoryManager.PageSize; } - public void AddThread(KThread thread) + public void AddThread(KThread Thread) { - lock (_threadingLock) + lock (ThreadingLock) { - thread.ProcessListNode = _threads.AddLast(thread); + Thread.ProcessListNode = Threads.AddLast(Thread); } } - public void RemoveThread(KThread thread) + public void RemoveThread(KThread Thread) { - lock (_threadingLock) + lock (ThreadingLock) { - _threads.Remove(thread.ProcessListNode); + Threads.Remove(Thread.ProcessListNode); } } - public bool IsCpuCoreAllowed(int core) + public bool IsCpuCoreAllowed(int Core) { - return (Capabilities.AllowedCpuCoresMask & (1L << core)) != 0; + return (Capabilities.AllowedCpuCoresMask & (1L << Core)) != 0; } - public bool IsPriorityAllowed(int priority) + public bool IsPriorityAllowed(int Priority) { - return (Capabilities.AllowedThreadPriosMask & (1L << priority)) != 0; + return (Capabilities.AllowedThreadPriosMask & (1L << Priority)) != 0; } public override bool IsSignaled() { - return _signaled; + return Signaled; } public KernelResult Terminate() { - KernelResult result; + KernelResult Result; - bool shallTerminate = false; + bool ShallTerminate = false; System.CriticalSection.Enter(); - lock (_processLock) + lock (ProcessLock) { - if (_state >= ProcessState.Started) + if (State >= ProcessState.Started) { - if (_state == ProcessState.Started || - _state == ProcessState.Crashed || - _state == ProcessState.Attached || - _state == ProcessState.DebugSuspended) + if (State == ProcessState.Started || + State == ProcessState.Crashed || + State == ProcessState.Attached || + State == ProcessState.DebugSuspended) { SetState(ProcessState.Exiting); - shallTerminate = true; + ShallTerminate = true; } - result = KernelResult.Success; + Result = KernelResult.Success; } else { - result = KernelResult.InvalidState; + Result = KernelResult.InvalidState; } } System.CriticalSection.Leave(); - if (shallTerminate) + if (ShallTerminate) { //UnpauseAndTerminateAllThreadsExcept(System.Scheduler.GetCurrentThread()); @@ -930,10 +930,10 @@ namespace Ryujinx.HLE.HOS.Kernel SignalExit(); } - return result; + return Result; } - private void UnpauseAndTerminateAllThreadsExcept(KThread thread) + private void UnpauseAndTerminateAllThreadsExcept(KThread Thread) { //TODO. } @@ -959,38 +959,38 @@ namespace Ryujinx.HLE.HOS.Kernel public KernelResult ClearIfNotExited() { - KernelResult result; + KernelResult Result; System.CriticalSection.Enter(); - lock (_processLock) + lock (ProcessLock) { - if (_state != ProcessState.Exited && _signaled) + if (State != ProcessState.Exited && Signaled) { - _signaled = false; + Signaled = false; - result = KernelResult.Success; + Result = KernelResult.Success; } else { - result = KernelResult.InvalidState; + Result = KernelResult.InvalidState; } } System.CriticalSection.Leave(); - return result; + return Result; } public void StopAllThreads() { - lock (_threadingLock) + lock (ThreadingLock) { - foreach (KThread thread in _threads) + foreach (KThread Thread in Threads) { - thread.Context.StopExecution(); + Thread.Context.StopExecution(); - System.Scheduler.CoreManager.Set(thread.Context.Work); + System.Scheduler.CoreManager.Set(Thread.Context.Work); } } } diff --git a/Ryujinx.HLE/HOS/Kernel/KProcessCapabilities.cs b/Ryujinx.HLE/HOS/Kernel/KProcessCapabilities.cs index c715a41e..dfbe1f36 100644 --- a/Ryujinx.HLE/HOS/Kernel/KProcessCapabilities.cs +++ b/Ryujinx.HLE/HOS/Kernel/KProcessCapabilities.cs @@ -4,8 +4,8 @@ namespace Ryujinx.HLE.HOS.Kernel { class KProcessCapabilities { - public byte[] SvcAccessMask { get; } - public byte[] IrqAccessMask { get; } + public byte[] SvcAccessMask { get; private set; } + public byte[] IrqAccessMask { get; private set; } public long AllowedCpuCoresMask { get; private set; } public long AllowedThreadPriosMask { get; private set; } @@ -21,91 +21,91 @@ namespace Ryujinx.HLE.HOS.Kernel IrqAccessMask = new byte[0x80]; } - public KernelResult InitializeForKernel(int[] caps, KMemoryManager memoryManager) + public KernelResult InitializeForKernel(int[] Caps, KMemoryManager MemoryManager) { AllowedCpuCoresMask = 0xf; AllowedThreadPriosMask = -1; DebuggingFlags &= ~3; KernelReleaseVersion = KProcess.KernelVersionPacked; - return Parse(caps, memoryManager); + return Parse(Caps, MemoryManager); } - public KernelResult InitializeForUser(int[] caps, KMemoryManager memoryManager) + public KernelResult InitializeForUser(int[] Caps, KMemoryManager MemoryManager) { - return Parse(caps, memoryManager); + return Parse(Caps, MemoryManager); } - private KernelResult Parse(int[] caps, KMemoryManager memoryManager) + private KernelResult Parse(int[] Caps, KMemoryManager MemoryManager) { - int mask0 = 0; - int mask1 = 0; + int Mask0 = 0; + int Mask1 = 0; - for (int index = 0; index < caps.Length; index++) + for (int Index = 0; Index < Caps.Length; Index++) { - int cap = caps[index]; + int Cap = Caps[Index]; - if (((cap + 1) & ~cap) != 0x40) + if (((Cap + 1) & ~Cap) != 0x40) { - KernelResult result = ParseCapability(cap, ref mask0, ref mask1, memoryManager); + KernelResult Result = ParseCapability(Cap, ref Mask0, ref Mask1, MemoryManager); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } } else { - if ((uint)index + 1 >= caps.Length) + if ((uint)Index + 1 >= Caps.Length) { return KernelResult.InvalidCombination; } - int prevCap = cap; + int PrevCap = Cap; - cap = caps[++index]; + Cap = Caps[++Index]; - if (((cap + 1) & ~cap) != 0x40) + if (((Cap + 1) & ~Cap) != 0x40) { return KernelResult.InvalidCombination; } - if ((cap & 0x78000000) != 0) + if ((Cap & 0x78000000) != 0) { return KernelResult.MaximumExceeded; } - if ((cap & 0x7ffff80) == 0) + if ((Cap & 0x7ffff80) == 0) { return KernelResult.InvalidSize; } - long address = ((long)(uint)prevCap << 5) & 0xffffff000; - long size = ((long)(uint)cap << 5) & 0xfffff000; + long Address = ((long)(uint)PrevCap << 5) & 0xffffff000; + long Size = ((long)(uint)Cap << 5) & 0xfffff000; - if (((ulong)(address + size - 1) >> 36) != 0) + if (((ulong)(Address + Size - 1) >> 36) != 0) { return KernelResult.InvalidAddress; } - MemoryPermission perm = (prevCap >> 31) != 0 + MemoryPermission Perm = (PrevCap >> 31) != 0 ? MemoryPermission.Read : MemoryPermission.ReadAndWrite; - KernelResult result; + KernelResult Result; - if ((cap >> 31) != 0) + if ((Cap >> 31) != 0) { - result = memoryManager.MapNormalMemory(address, size, perm); + Result = MemoryManager.MapNormalMemory(Address, Size, Perm); } else { - result = memoryManager.MapIoMemory(address, size, perm); + Result = MemoryManager.MapIoMemory(Address, Size, Perm); } - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } } } @@ -113,30 +113,30 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } - private KernelResult ParseCapability(int cap, ref int mask0, ref int mask1, KMemoryManager memoryManager) + private KernelResult ParseCapability(int Cap, ref int Mask0, ref int Mask1, KMemoryManager MemoryManager) { - int code = (cap + 1) & ~cap; + int Code = (Cap + 1) & ~Cap; - if (code == 1) + if (Code == 1) { return KernelResult.InvalidCapability; } - else if (code == 0) + else if (Code == 0) { return KernelResult.Success; } - int codeMask = 1 << (32 - BitUtils.CountLeadingZeros32(code + 1)); + int CodeMask = 1 << (32 - BitUtils.CountLeadingZeros32(Code + 1)); //Check if the property was already set. - if (((mask0 & codeMask) & 0x1e008) != 0) + if (((Mask0 & CodeMask) & 0x1e008) != 0) { return KernelResult.InvalidCombination; } - mask0 |= codeMask; + Mask0 |= CodeMask; - switch (code) + switch (Code) { case 8: { @@ -145,65 +145,65 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.InvalidCapability; } - int lowestCpuCore = (cap >> 16) & 0xff; - int highestCpuCore = (cap >> 24) & 0xff; + int LowestCpuCore = (Cap >> 16) & 0xff; + int HighestCpuCore = (Cap >> 24) & 0xff; - if (lowestCpuCore > highestCpuCore) + if (LowestCpuCore > HighestCpuCore) { return KernelResult.InvalidCombination; } - int highestThreadPrio = (cap >> 4) & 0x3f; - int lowestThreadPrio = (cap >> 10) & 0x3f; + int HighestThreadPrio = (Cap >> 4) & 0x3f; + int LowestThreadPrio = (Cap >> 10) & 0x3f; - if (lowestThreadPrio > highestThreadPrio) + if (LowestThreadPrio > HighestThreadPrio) { return KernelResult.InvalidCombination; } - if (highestCpuCore >= KScheduler.CpuCoresCount) + if (HighestCpuCore >= KScheduler.CpuCoresCount) { return KernelResult.InvalidCpuCore; } - AllowedCpuCoresMask = GetMaskFromMinMax(lowestCpuCore, highestCpuCore); - AllowedThreadPriosMask = GetMaskFromMinMax(lowestThreadPrio, highestThreadPrio); + AllowedCpuCoresMask = GetMaskFromMinMax(LowestCpuCore, HighestCpuCore); + AllowedThreadPriosMask = GetMaskFromMinMax(LowestThreadPrio, HighestThreadPrio); break; } case 0x10: { - int slot = (cap >> 29) & 7; + int Slot = (Cap >> 29) & 7; - int svcSlotMask = 1 << slot; + int SvcSlotMask = 1 << Slot; - if ((mask1 & svcSlotMask) != 0) + if ((Mask1 & SvcSlotMask) != 0) { return KernelResult.InvalidCombination; } - mask1 |= svcSlotMask; + Mask1 |= SvcSlotMask; - int svcMask = (cap >> 5) & 0xffffff; + int SvcMask = (Cap >> 5) & 0xffffff; - int baseSvc = slot * 24; + int BaseSvc = Slot * 24; - for (int index = 0; index < 24; index++) + for (int Index = 0; Index < 24; Index++) { - if (((svcMask >> index) & 1) == 0) + if (((SvcMask >> Index) & 1) == 0) { continue; } - int svcId = baseSvc + index; + int SvcId = BaseSvc + Index; - if (svcId > 0x7f) + if (SvcId > 0x7f) { return KernelResult.MaximumExceeded; } - SvcAccessMask[svcId / 8] |= (byte)(1 << (svcId & 7)); + SvcAccessMask[SvcId / 8] |= (byte)(1 << (SvcId & 7)); } break; @@ -211,9 +211,9 @@ namespace Ryujinx.HLE.HOS.Kernel case 0x80: { - long address = ((long)(uint)cap << 4) & 0xffffff000; + long Address = ((long)(uint)Cap << 4) & 0xffffff000; - memoryManager.MapIoMemory(address, KMemoryManager.PageSize, MemoryPermission.ReadAndWrite); + MemoryManager.MapIoMemory(Address, KMemoryManager.PageSize, MemoryPermission.ReadAndWrite); break; } @@ -221,17 +221,17 @@ namespace Ryujinx.HLE.HOS.Kernel case 0x800: { //TODO: GIC distributor check. - int irq0 = (cap >> 12) & 0x3ff; - int irq1 = (cap >> 22) & 0x3ff; + int Irq0 = (Cap >> 12) & 0x3ff; + int Irq1 = (Cap >> 22) & 0x3ff; - if (irq0 != 0x3ff) + if (Irq0 != 0x3ff) { - IrqAccessMask[irq0 / 8] |= (byte)(1 << (irq0 & 7)); + IrqAccessMask[Irq0 / 8] |= (byte)(1 << (Irq0 & 7)); } - if (irq1 != 0x3ff) + if (Irq1 != 0x3ff) { - IrqAccessMask[irq1 / 8] |= (byte)(1 << (irq1 & 7)); + IrqAccessMask[Irq1 / 8] |= (byte)(1 << (Irq1 & 7)); } break; @@ -239,14 +239,14 @@ namespace Ryujinx.HLE.HOS.Kernel case 0x2000: { - int applicationType = cap >> 14; + int ApplicationType = Cap >> 14; - if ((uint)applicationType > 7) + if ((uint)ApplicationType > 7) { return KernelResult.ReservedValue; } - ApplicationType = applicationType; + this.ApplicationType = ApplicationType; break; } @@ -254,41 +254,41 @@ namespace Ryujinx.HLE.HOS.Kernel case 0x4000: { //Note: This check is bugged on kernel too, we are just replicating the bug here. - if ((KernelReleaseVersion >> 17) != 0 || cap < 0x80000) + if ((KernelReleaseVersion >> 17) != 0 || Cap < 0x80000) { return KernelResult.ReservedValue; } - KernelReleaseVersion = cap; + KernelReleaseVersion = Cap; break; } case 0x8000: { - int handleTableSize = cap >> 26; + int HandleTableSize = Cap >> 26; - if ((uint)handleTableSize > 0x3ff) + if ((uint)HandleTableSize > 0x3ff) { return KernelResult.ReservedValue; } - HandleTableSize = handleTableSize; + this.HandleTableSize = HandleTableSize; break; } case 0x10000: { - int debuggingFlags = cap >> 19; + int DebuggingFlags = Cap >> 19; - if ((uint)debuggingFlags > 3) + if ((uint)DebuggingFlags > 3) { return KernelResult.ReservedValue; } - DebuggingFlags &= ~3; - DebuggingFlags |= debuggingFlags; + this.DebuggingFlags &= ~3; + this.DebuggingFlags |= DebuggingFlags; break; } @@ -299,13 +299,13 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } - private static long GetMaskFromMinMax(int min, int max) + private static long GetMaskFromMinMax(int Min, int Max) { - int range = max - min + 1; + int Range = Max - Min + 1; - long mask = (1L << range) - 1; + long Mask = (1L << Range) - 1; - return mask << min; + return Mask << Min; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KReadableEvent.cs b/Ryujinx.HLE/HOS/Kernel/KReadableEvent.cs index e1a3e63f..bfb8e7e2 100644 --- a/Ryujinx.HLE/HOS/Kernel/KReadableEvent.cs +++ b/Ryujinx.HLE/HOS/Kernel/KReadableEvent.cs @@ -2,22 +2,22 @@ namespace Ryujinx.HLE.HOS.Kernel { class KReadableEvent : KSynchronizationObject { - private KEvent _parent; + private KEvent Parent; - private bool _signaled; + private bool Signaled; - public KReadableEvent(Horizon system, KEvent parent) : base(system) + public KReadableEvent(Horizon System, KEvent Parent) : base(System) { - _parent = parent; + this.Parent = Parent; } public override void Signal() { System.CriticalSection.Enter(); - if (!_signaled) + if (!Signaled) { - _signaled = true; + Signaled = true; base.Signal(); } @@ -27,36 +27,36 @@ namespace Ryujinx.HLE.HOS.Kernel public KernelResult Clear() { - _signaled = false; + Signaled = false; return KernelResult.Success; } public KernelResult ClearIfSignaled() { - KernelResult result; + KernelResult Result; System.CriticalSection.Enter(); - if (_signaled) + if (Signaled) { - _signaled = false; + Signaled = false; - result = KernelResult.Success; + Result = KernelResult.Success; } else { - result = KernelResult.InvalidState; + Result = KernelResult.InvalidState; } System.CriticalSection.Leave(); - return result; + return Result; } public override bool IsSignaled() { - return _signaled; + return Signaled; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KResourceLimit.cs b/Ryujinx.HLE/HOS/Kernel/KResourceLimit.cs index 09c53e5b..6fd70d0c 100644 --- a/Ryujinx.HLE/HOS/Kernel/KResourceLimit.cs +++ b/Ryujinx.HLE/HOS/Kernel/KResourceLimit.cs @@ -7,127 +7,127 @@ namespace Ryujinx.HLE.HOS.Kernel { private const int Time10SecondsMs = 10000; - private long[] _current; - private long[] _limit; - private long[] _available; + private long[] Current; + private long[] Limit; + private long[] Available; - private object _lockObj; + private object LockObj; - private LinkedList<KThread> _waitingThreads; + private LinkedList<KThread> WaitingThreads; - private int _waitingThreadsCount; + private int WaitingThreadsCount; - private Horizon _system; + private Horizon System; - public KResourceLimit(Horizon system) + public KResourceLimit(Horizon System) { - _current = new long[(int)LimitableResource.Count]; - _limit = new long[(int)LimitableResource.Count]; - _available = new long[(int)LimitableResource.Count]; + Current = new long[(int)LimitableResource.Count]; + Limit = new long[(int)LimitableResource.Count]; + Available = new long[(int)LimitableResource.Count]; - _lockObj = new object(); + LockObj = new object(); - _waitingThreads = new LinkedList<KThread>(); + WaitingThreads = new LinkedList<KThread>(); - _system = system; + this.System = System; } - public bool Reserve(LimitableResource resource, ulong amount) + public bool Reserve(LimitableResource Resource, ulong Amount) { - return Reserve(resource, (long)amount); + return Reserve(Resource, (long)Amount); } - public bool Reserve(LimitableResource resource, long amount) + public bool Reserve(LimitableResource Resource, long Amount) { - return Reserve(resource, amount, KTimeManager.ConvertMillisecondsToNanoseconds(Time10SecondsMs)); + return Reserve(Resource, Amount, KTimeManager.ConvertMillisecondsToNanoseconds(Time10SecondsMs)); } - public bool Reserve(LimitableResource resource, long amount, long timeout) + public bool Reserve(LimitableResource Resource, long Amount, long Timeout) { - long endTimePoint = KTimeManager.ConvertNanosecondsToMilliseconds(timeout); + long EndTimePoint = KTimeManager.ConvertNanosecondsToMilliseconds(Timeout); - endTimePoint += PerformanceCounter.ElapsedMilliseconds; + EndTimePoint += PerformanceCounter.ElapsedMilliseconds; - bool success = false; + bool Success = false; - int index = GetIndex(resource); + int Index = GetIndex(Resource); - lock (_lockObj) + lock (LockObj) { - long newCurrent = _current[index] + amount; + long NewCurrent = Current[Index] + Amount; - while (newCurrent > _limit[index] && _available[index] + amount <= _limit[index]) + while (NewCurrent > Limit[Index] && Available[Index] + Amount <= Limit[Index]) { - _waitingThreadsCount++; + WaitingThreadsCount++; - KConditionVariable.Wait(_system, _waitingThreads, _lockObj, timeout); + KConditionVariable.Wait(System, WaitingThreads, LockObj, Timeout); - _waitingThreadsCount--; + WaitingThreadsCount--; - newCurrent = _current[index] + amount; + NewCurrent = Current[Index] + Amount; - if (timeout >= 0 && PerformanceCounter.ElapsedMilliseconds > endTimePoint) + if (Timeout >= 0 && PerformanceCounter.ElapsedMilliseconds > EndTimePoint) { break; } } - if (newCurrent <= _limit[index]) + if (NewCurrent <= Limit[Index]) { - _current[index] = newCurrent; + Current[Index] = NewCurrent; - success = true; + Success = true; } } - return success; + return Success; } - public void Release(LimitableResource resource, ulong amount) + public void Release(LimitableResource Resource, ulong Amount) { - Release(resource, (long)amount); + Release(Resource, (long)Amount); } - public void Release(LimitableResource resource, long amount) + public void Release(LimitableResource Resource, long Amount) { - Release(resource, amount, amount); + Release(Resource, Amount, Amount); } - private void Release(LimitableResource resource, long usedAmount, long availableAmount) + private void Release(LimitableResource Resource, long UsedAmount, long AvailableAmount) { - int index = GetIndex(resource); + int Index = GetIndex(Resource); - lock (_lockObj) + lock (LockObj) { - _current [index] -= usedAmount; - _available[index] -= availableAmount; + Current [Index] -= UsedAmount; + Available[Index] -= AvailableAmount; - if (_waitingThreadsCount > 0) + if (WaitingThreadsCount > 0) { - KConditionVariable.NotifyAll(_system, _waitingThreads); + KConditionVariable.NotifyAll(System, WaitingThreads); } } } - public long GetRemainingValue(LimitableResource resource) + public long GetRemainingValue(LimitableResource Resource) { - int index = GetIndex(resource); + int Index = GetIndex(Resource); - lock (_lockObj) + lock (LockObj) { - return _limit[index] - _current[index]; + return Limit[Index] - Current[Index]; } } - public KernelResult SetLimitValue(LimitableResource resource, long limit) + public KernelResult SetLimitValue(LimitableResource Resource, long Limit) { - int index = GetIndex(resource); + int Index = GetIndex(Resource); - lock (_lockObj) + lock (LockObj) { - if (_current[index] <= limit) + if (Current[Index] <= Limit) { - _limit[index] = limit; + this.Limit[Index] = Limit; return KernelResult.Success; } @@ -138,9 +138,9 @@ namespace Ryujinx.HLE.HOS.Kernel } } - private static int GetIndex(LimitableResource resource) + private static int GetIndex(LimitableResource Resource) { - return (int)resource; + return (int)Resource; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KScheduler.cs b/Ryujinx.HLE/HOS/Kernel/KScheduler.cs index 43f1a994..3342f4a6 100644 --- a/Ryujinx.HLE/HOS/Kernel/KScheduler.cs +++ b/Ryujinx.HLE/HOS/Kernel/KScheduler.cs @@ -12,17 +12,17 @@ namespace Ryujinx.HLE.HOS.Kernel private const int PreemptionPriorityCores012 = 59; private const int PreemptionPriorityCore3 = 63; - private Horizon _system; + private Horizon System; - public KSchedulingData SchedulingData { get; } + public KSchedulingData SchedulingData { get; private set; } - public KCoreContext[] CoreContexts { get; } + public KCoreContext[] CoreContexts { get; private set; } public bool ThreadReselectionRequested { get; set; } - public KScheduler(Horizon system) + public KScheduler(Horizon System) { - _system = system; + this.System = System; SchedulingData = new KSchedulingData(); @@ -30,87 +30,87 @@ namespace Ryujinx.HLE.HOS.Kernel CoreContexts = new KCoreContext[CpuCoresCount]; - for (int core = 0; core < CpuCoresCount; core++) + for (int Core = 0; Core < CpuCoresCount; Core++) { - CoreContexts[core] = new KCoreContext(this, CoreManager); + CoreContexts[Core] = new KCoreContext(this, CoreManager); } } private void PreemptThreads() { - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); PreemptThread(PreemptionPriorityCores012, 0); PreemptThread(PreemptionPriorityCores012, 1); PreemptThread(PreemptionPriorityCores012, 2); PreemptThread(PreemptionPriorityCore3, 3); - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); } - private void PreemptThread(int prio, int core) + private void PreemptThread(int Prio, int Core) { - IEnumerable<KThread> scheduledThreads = SchedulingData.ScheduledThreads(core); + IEnumerable<KThread> ScheduledThreads = SchedulingData.ScheduledThreads(Core); - KThread selectedThread = scheduledThreads.FirstOrDefault(x => x.DynamicPriority == prio); + KThread SelectedThread = ScheduledThreads.FirstOrDefault(x => x.DynamicPriority == Prio); //Yield priority queue. - if (selectedThread != null) + if (SelectedThread != null) { - SchedulingData.Reschedule(prio, core, selectedThread); + SchedulingData.Reschedule(Prio, Core, SelectedThread); } IEnumerable<KThread> SuitableCandidates() { - foreach (KThread thread in SchedulingData.SuggestedThreads(core)) + foreach (KThread Thread in SchedulingData.SuggestedThreads(Core)) { - int srcCore = thread.CurrentCore; + int SrcCore = Thread.CurrentCore; - if (srcCore >= 0) + if (SrcCore >= 0) { - KThread highestPrioSrcCore = SchedulingData.ScheduledThreads(srcCore).FirstOrDefault(); + KThread HighestPrioSrcCore = SchedulingData.ScheduledThreads(SrcCore).FirstOrDefault(); - if (highestPrioSrcCore != null && highestPrioSrcCore.DynamicPriority < 2) + if (HighestPrioSrcCore != null && HighestPrioSrcCore.DynamicPriority < 2) { break; } - if (highestPrioSrcCore == thread) + if (HighestPrioSrcCore == Thread) { continue; } } //If the candidate was scheduled after the current thread, then it's not worth it. - if (selectedThread == null || selectedThread.LastScheduledTime >= thread.LastScheduledTime) + if (SelectedThread == null || SelectedThread.LastScheduledTime >= Thread.LastScheduledTime) { - yield return thread; + yield return Thread; } } } //Select candidate threads that could run on this core. //Only take into account threads that are not yet selected. - KThread dst = SuitableCandidates().FirstOrDefault(x => x.DynamicPriority == prio); + KThread Dst = SuitableCandidates().FirstOrDefault(x => x.DynamicPriority == Prio); - if (dst != null) + if (Dst != null) { - SchedulingData.TransferToCore(prio, core, dst); + SchedulingData.TransferToCore(Prio, Core, Dst); - selectedThread = dst; + SelectedThread = Dst; } //If the priority of the currently selected thread is lower than preemption priority, //then allow threads with lower priorities to be selected aswell. - if (selectedThread != null && selectedThread.DynamicPriority > prio) + if (SelectedThread != null && SelectedThread.DynamicPriority > Prio) { - Func<KThread, bool> predicate = x => x.DynamicPriority >= selectedThread.DynamicPriority; + Func<KThread, bool> Predicate = x => x.DynamicPriority >= SelectedThread.DynamicPriority; - dst = SuitableCandidates().FirstOrDefault(predicate); + Dst = SuitableCandidates().FirstOrDefault(Predicate); - if (dst != null) + if (Dst != null) { - SchedulingData.TransferToCore(dst.DynamicPriority, core, dst); + SchedulingData.TransferToCore(Dst.DynamicPriority, Core, Dst); } } @@ -121,52 +121,52 @@ namespace Ryujinx.HLE.HOS.Kernel { ThreadReselectionRequested = false; - for (int core = 0; core < CpuCoresCount; core++) + for (int Core = 0; Core < CpuCoresCount; Core++) { - KThread thread = SchedulingData.ScheduledThreads(core).FirstOrDefault(); + KThread Thread = SchedulingData.ScheduledThreads(Core).FirstOrDefault(); - CoreContexts[core].SelectThread(thread); + CoreContexts[Core].SelectThread(Thread); } - for (int core = 0; core < CpuCoresCount; core++) + for (int Core = 0; Core < CpuCoresCount; Core++) { //If the core is not idle (there's already a thread running on it), //then we don't need to attempt load balancing. - if (SchedulingData.ScheduledThreads(core).Any()) + if (SchedulingData.ScheduledThreads(Core).Any()) { continue; } - int[] srcCoresHighestPrioThreads = new int[CpuCoresCount]; + int[] SrcCoresHighestPrioThreads = new int[CpuCoresCount]; - int srcCoresHighestPrioThreadsCount = 0; + int SrcCoresHighestPrioThreadsCount = 0; - KThread dst = null; + KThread Dst = null; //Select candidate threads that could run on this core. //Give preference to threads that are not yet selected. - foreach (KThread thread in SchedulingData.SuggestedThreads(core)) + foreach (KThread Thread in SchedulingData.SuggestedThreads(Core)) { - if (thread.CurrentCore < 0 || thread != CoreContexts[thread.CurrentCore].SelectedThread) + if (Thread.CurrentCore < 0 || Thread != CoreContexts[Thread.CurrentCore].SelectedThread) { - dst = thread; + Dst = Thread; break; } - srcCoresHighestPrioThreads[srcCoresHighestPrioThreadsCount++] = thread.CurrentCore; + SrcCoresHighestPrioThreads[SrcCoresHighestPrioThreadsCount++] = Thread.CurrentCore; } //Not yet selected candidate found. - if (dst != null) + if (Dst != null) { //Priorities < 2 are used for the kernel message dispatching //threads, we should skip load balancing entirely. - if (dst.DynamicPriority >= 2) + if (Dst.DynamicPriority >= 2) { - SchedulingData.TransferToCore(dst.DynamicPriority, core, dst); + SchedulingData.TransferToCore(Dst.DynamicPriority, Core, Dst); - CoreContexts[core].SelectThread(dst); + CoreContexts[Core].SelectThread(Dst); } continue; @@ -174,23 +174,23 @@ namespace Ryujinx.HLE.HOS.Kernel //All candiates are already selected, choose the best one //(the first one that doesn't make the source core idle if moved). - for (int index = 0; index < srcCoresHighestPrioThreadsCount; index++) + for (int Index = 0; Index < SrcCoresHighestPrioThreadsCount; Index++) { - int srcCore = srcCoresHighestPrioThreads[index]; + int SrcCore = SrcCoresHighestPrioThreads[Index]; - KThread src = SchedulingData.ScheduledThreads(srcCore).ElementAtOrDefault(1); + KThread Src = SchedulingData.ScheduledThreads(SrcCore).ElementAtOrDefault(1); - if (src != null) + if (Src != null) { //Run the second thread on the queue on the source core, //move the first one to the current core. - KThread origSelectedCoreSrc = CoreContexts[srcCore].SelectedThread; + KThread OrigSelectedCoreSrc = CoreContexts[SrcCore].SelectedThread; - CoreContexts[srcCore].SelectThread(src); + CoreContexts[SrcCore].SelectThread(Src); - SchedulingData.TransferToCore(origSelectedCoreSrc.DynamicPriority, core, origSelectedCoreSrc); + SchedulingData.TransferToCore(OrigSelectedCoreSrc.DynamicPriority, Core, OrigSelectedCoreSrc); - CoreContexts[core].SelectThread(origSelectedCoreSrc); + CoreContexts[Core].SelectThread(OrigSelectedCoreSrc); } } } @@ -200,11 +200,11 @@ namespace Ryujinx.HLE.HOS.Kernel { lock (CoreContexts) { - for (int core = 0; core < CpuCoresCount; core++) + for (int Core = 0; Core < CpuCoresCount; Core++) { - if (CoreContexts[core].CurrentThread?.Context.IsCurrentThread() ?? false) + if (CoreContexts[Core].CurrentThread?.Context.IsCurrentThread() ?? false) { - return CoreContexts[core].CurrentThread; + return CoreContexts[Core].CurrentThread; } } } @@ -222,11 +222,11 @@ namespace Ryujinx.HLE.HOS.Kernel Dispose(true); } - protected virtual void Dispose(bool disposing) + protected virtual void Dispose(bool Disposing) { - if (disposing) + if (Disposing) { - _keepPreempting = false; + KeepPreempting = false; } } } diff --git a/Ryujinx.HLE/HOS/Kernel/KSchedulingData.cs b/Ryujinx.HLE/HOS/Kernel/KSchedulingData.cs index 65116036..ba2730a2 100644 --- a/Ryujinx.HLE/HOS/Kernel/KSchedulingData.cs +++ b/Ryujinx.HLE/HOS/Kernel/KSchedulingData.cs @@ -4,204 +4,204 @@ namespace Ryujinx.HLE.HOS.Kernel { class KSchedulingData { - private LinkedList<KThread>[][] _scheduledThreadsPerPrioPerCore; - private LinkedList<KThread>[][] _suggestedThreadsPerPrioPerCore; + private LinkedList<KThread>[][] ScheduledThreadsPerPrioPerCore; + private LinkedList<KThread>[][] SuggestedThreadsPerPrioPerCore; - private long[] _scheduledPrioritiesPerCore; - private long[] _suggestedPrioritiesPerCore; + private long[] ScheduledPrioritiesPerCore; + private long[] SuggestedPrioritiesPerCore; public KSchedulingData() { - _suggestedThreadsPerPrioPerCore = new LinkedList<KThread>[KScheduler.PrioritiesCount][]; - _scheduledThreadsPerPrioPerCore = new LinkedList<KThread>[KScheduler.PrioritiesCount][]; + SuggestedThreadsPerPrioPerCore = new LinkedList<KThread>[KScheduler.PrioritiesCount][]; + ScheduledThreadsPerPrioPerCore = new LinkedList<KThread>[KScheduler.PrioritiesCount][]; - for (int prio = 0; prio < KScheduler.PrioritiesCount; prio++) + for (int Prio = 0; Prio < KScheduler.PrioritiesCount; Prio++) { - _suggestedThreadsPerPrioPerCore[prio] = new LinkedList<KThread>[KScheduler.CpuCoresCount]; - _scheduledThreadsPerPrioPerCore[prio] = new LinkedList<KThread>[KScheduler.CpuCoresCount]; + SuggestedThreadsPerPrioPerCore[Prio] = new LinkedList<KThread>[KScheduler.CpuCoresCount]; + ScheduledThreadsPerPrioPerCore[Prio] = new LinkedList<KThread>[KScheduler.CpuCoresCount]; - for (int core = 0; core < KScheduler.CpuCoresCount; core++) + for (int Core = 0; Core < KScheduler.CpuCoresCount; Core++) { - _suggestedThreadsPerPrioPerCore[prio][core] = new LinkedList<KThread>(); - _scheduledThreadsPerPrioPerCore[prio][core] = new LinkedList<KThread>(); + SuggestedThreadsPerPrioPerCore[Prio][Core] = new LinkedList<KThread>(); + ScheduledThreadsPerPrioPerCore[Prio][Core] = new LinkedList<KThread>(); } } - _scheduledPrioritiesPerCore = new long[KScheduler.CpuCoresCount]; - _suggestedPrioritiesPerCore = new long[KScheduler.CpuCoresCount]; + ScheduledPrioritiesPerCore = new long[KScheduler.CpuCoresCount]; + SuggestedPrioritiesPerCore = new long[KScheduler.CpuCoresCount]; } - public IEnumerable<KThread> SuggestedThreads(int core) + public IEnumerable<KThread> SuggestedThreads(int Core) { - return Iterate(_suggestedThreadsPerPrioPerCore, _suggestedPrioritiesPerCore, core); + return Iterate(SuggestedThreadsPerPrioPerCore, SuggestedPrioritiesPerCore, Core); } - public IEnumerable<KThread> ScheduledThreads(int core) + public IEnumerable<KThread> ScheduledThreads(int Core) { - return Iterate(_scheduledThreadsPerPrioPerCore, _scheduledPrioritiesPerCore, core); + return Iterate(ScheduledThreadsPerPrioPerCore, ScheduledPrioritiesPerCore, Core); } - private IEnumerable<KThread> Iterate(LinkedList<KThread>[][] listPerPrioPerCore, long[] prios, int core) + private IEnumerable<KThread> Iterate(LinkedList<KThread>[][] ListPerPrioPerCore, long[] Prios, int Core) { - long prioMask = prios[core]; + long PrioMask = Prios[Core]; - int prio = CountTrailingZeros(prioMask); + int Prio = CountTrailingZeros(PrioMask); - prioMask &= ~(1L << prio); + PrioMask &= ~(1L << Prio); - while (prio < KScheduler.PrioritiesCount) + while (Prio < KScheduler.PrioritiesCount) { - LinkedList<KThread> list = listPerPrioPerCore[prio][core]; + LinkedList<KThread> List = ListPerPrioPerCore[Prio][Core]; - LinkedListNode<KThread> node = list.First; + LinkedListNode<KThread> Node = List.First; - while (node != null) + while (Node != null) { - yield return node.Value; + yield return Node.Value; - node = node.Next; + Node = Node.Next; } - prio = CountTrailingZeros(prioMask); + Prio = CountTrailingZeros(PrioMask); - prioMask &= ~(1L << prio); + PrioMask &= ~(1L << Prio); } } - private int CountTrailingZeros(long value) + private int CountTrailingZeros(long Value) { - int count = 0; + int Count = 0; - while (((value >> count) & 0xf) == 0 && count < 64) + while (((Value >> Count) & 0xf) == 0 && Count < 64) { - count += 4; + Count += 4; } - while (((value >> count) & 1) == 0 && count < 64) + while (((Value >> Count) & 1) == 0 && Count < 64) { - count++; + Count++; } - return count; + return Count; } - public void TransferToCore(int prio, int dstCore, KThread thread) + public void TransferToCore(int Prio, int DstCore, KThread Thread) { - bool schedulable = thread.DynamicPriority < KScheduler.PrioritiesCount; + bool Schedulable = Thread.DynamicPriority < KScheduler.PrioritiesCount; - int srcCore = thread.CurrentCore; + int SrcCore = Thread.CurrentCore; - thread.CurrentCore = dstCore; + Thread.CurrentCore = DstCore; - if (srcCore == dstCore || !schedulable) + if (SrcCore == DstCore || !Schedulable) { return; } - if (srcCore >= 0) + if (SrcCore >= 0) { - Unschedule(prio, srcCore, thread); + Unschedule(Prio, SrcCore, Thread); } - if (dstCore >= 0) + if (DstCore >= 0) { - Unsuggest(prio, dstCore, thread); - Schedule(prio, dstCore, thread); + Unsuggest(Prio, DstCore, Thread); + Schedule(Prio, DstCore, Thread); } - if (srcCore >= 0) + if (SrcCore >= 0) { - Suggest(prio, srcCore, thread); + Suggest(Prio, SrcCore, Thread); } } - public void Suggest(int prio, int core, KThread thread) + public void Suggest(int Prio, int Core, KThread Thread) { - if (prio >= KScheduler.PrioritiesCount) + if (Prio >= KScheduler.PrioritiesCount) { return; } - thread.SiblingsPerCore[core] = SuggestedQueue(prio, core).AddFirst(thread); + Thread.SiblingsPerCore[Core] = SuggestedQueue(Prio, Core).AddFirst(Thread); - _suggestedPrioritiesPerCore[core] |= 1L << prio; + SuggestedPrioritiesPerCore[Core] |= 1L << Prio; } - public void Unsuggest(int prio, int core, KThread thread) + public void Unsuggest(int Prio, int Core, KThread Thread) { - if (prio >= KScheduler.PrioritiesCount) + if (Prio >= KScheduler.PrioritiesCount) { return; } - LinkedList<KThread> queue = SuggestedQueue(prio, core); + LinkedList<KThread> Queue = SuggestedQueue(Prio, Core); - queue.Remove(thread.SiblingsPerCore[core]); + Queue.Remove(Thread.SiblingsPerCore[Core]); - if (queue.First == null) + if (Queue.First == null) { - _suggestedPrioritiesPerCore[core] &= ~(1L << prio); + SuggestedPrioritiesPerCore[Core] &= ~(1L << Prio); } } - public void Schedule(int prio, int core, KThread thread) + public void Schedule(int Prio, int Core, KThread Thread) { - if (prio >= KScheduler.PrioritiesCount) + if (Prio >= KScheduler.PrioritiesCount) { return; } - thread.SiblingsPerCore[core] = ScheduledQueue(prio, core).AddLast(thread); + Thread.SiblingsPerCore[Core] = ScheduledQueue(Prio, Core).AddLast(Thread); - _scheduledPrioritiesPerCore[core] |= 1L << prio; + ScheduledPrioritiesPerCore[Core] |= 1L << Prio; } - public void SchedulePrepend(int prio, int core, KThread thread) + public void SchedulePrepend(int Prio, int Core, KThread Thread) { - if (prio >= KScheduler.PrioritiesCount) + if (Prio >= KScheduler.PrioritiesCount) { return; } - thread.SiblingsPerCore[core] = ScheduledQueue(prio, core).AddFirst(thread); + Thread.SiblingsPerCore[Core] = ScheduledQueue(Prio, Core).AddFirst(Thread); - _scheduledPrioritiesPerCore[core] |= 1L << prio; + ScheduledPrioritiesPerCore[Core] |= 1L << Prio; } - public void Reschedule(int prio, int core, KThread thread) + public void Reschedule(int Prio, int Core, KThread Thread) { - LinkedList<KThread> queue = ScheduledQueue(prio, core); + LinkedList<KThread> Queue = ScheduledQueue(Prio, Core); - queue.Remove(thread.SiblingsPerCore[core]); + Queue.Remove(Thread.SiblingsPerCore[Core]); - thread.SiblingsPerCore[core] = queue.AddLast(thread); + Thread.SiblingsPerCore[Core] = Queue.AddLast(Thread); } - public void Unschedule(int prio, int core, KThread thread) + public void Unschedule(int Prio, int Core, KThread Thread) { - if (prio >= KScheduler.PrioritiesCount) + if (Prio >= KScheduler.PrioritiesCount) { return; } - LinkedList<KThread> queue = ScheduledQueue(prio, core); + LinkedList<KThread> Queue = ScheduledQueue(Prio, Core); - queue.Remove(thread.SiblingsPerCore[core]); + Queue.Remove(Thread.SiblingsPerCore[Core]); - if (queue.First == null) + if (Queue.First == null) { - _scheduledPrioritiesPerCore[core] &= ~(1L << prio); + ScheduledPrioritiesPerCore[Core] &= ~(1L << Prio); } } - private LinkedList<KThread> SuggestedQueue(int prio, int core) + private LinkedList<KThread> SuggestedQueue(int Prio, int Core) { - return _suggestedThreadsPerPrioPerCore[prio][core]; + return SuggestedThreadsPerPrioPerCore[Prio][Core]; } - private LinkedList<KThread> ScheduledQueue(int prio, int core) + private LinkedList<KThread> ScheduledQueue(int Prio, int Core) { - return _scheduledThreadsPerPrioPerCore[prio][core]; + return ScheduledThreadsPerPrioPerCore[Prio][Core]; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KServerPort.cs b/Ryujinx.HLE/HOS/Kernel/KServerPort.cs index 0aa74e48..42135cd8 100644 --- a/Ryujinx.HLE/HOS/Kernel/KServerPort.cs +++ b/Ryujinx.HLE/HOS/Kernel/KServerPort.cs @@ -2,13 +2,13 @@ namespace Ryujinx.HLE.HOS.Kernel { class KServerPort : KSynchronizationObject { - private KPort _parent; + private KPort Parent; - public KServerPort(Horizon system) : base(system) { } + public KServerPort(Horizon System) : base(System) { } - public void Initialize(KPort parent) + public void Initialize(KPort Parent) { - _parent = parent; + this.Parent = Parent; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KSession.cs b/Ryujinx.HLE/HOS/Kernel/KSession.cs index a350b323..4b21d3a6 100644 --- a/Ryujinx.HLE/HOS/Kernel/KSession.cs +++ b/Ryujinx.HLE/HOS/Kernel/KSession.cs @@ -5,14 +5,14 @@ namespace Ryujinx.HLE.HOS.Kernel { class KSession : IDisposable { - public IpcService Service { get; } + public IpcService Service { get; private set; } - public string ServiceName { get; } + public string ServiceName { get; private set; } - public KSession(IpcService service, string serviceName) + public KSession(IpcService Service, string ServiceName) { - Service = service; - ServiceName = serviceName; + this.Service = Service; + this.ServiceName = ServiceName; } public void Dispose() @@ -20,11 +20,11 @@ namespace Ryujinx.HLE.HOS.Kernel Dispose(true); } - protected virtual void Dispose(bool disposing) + protected virtual void Dispose(bool Disposing) { - if (disposing && Service is IDisposable disposableService) + if (Disposing && Service is IDisposable DisposableService) { - disposableService.Dispose(); + DisposableService.Dispose(); } } } diff --git a/Ryujinx.HLE/HOS/Kernel/KSharedMemory.cs b/Ryujinx.HLE/HOS/Kernel/KSharedMemory.cs index 0e9f8840..a440438b 100644 --- a/Ryujinx.HLE/HOS/Kernel/KSharedMemory.cs +++ b/Ryujinx.HLE/HOS/Kernel/KSharedMemory.cs @@ -4,65 +4,65 @@ namespace Ryujinx.HLE.HOS.Kernel { class KSharedMemory { - private KPageList _pageList; + private KPageList PageList; - private long _ownerPid; + private long OwnerPid; - private MemoryPermission _ownerPermission; - private MemoryPermission _userPermission; + private MemoryPermission OwnerPermission; + private MemoryPermission UserPermission; public KSharedMemory( - KPageList pageList, - long ownerPid, - MemoryPermission ownerPermission, - MemoryPermission userPermission) + KPageList PageList, + long OwnerPid, + MemoryPermission OwnerPermission, + MemoryPermission UserPermission) { - _pageList = pageList; - _ownerPid = ownerPid; - _ownerPermission = ownerPermission; - _userPermission = userPermission; + 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) + KMemoryManager MemoryManager, + ulong Address, + ulong Size, + KProcess Process, + MemoryPermission Permission) { - ulong pagesCountRounded = BitUtils.DivRoundUp(size, KMemoryManager.PageSize); + ulong PagesCountRounded = BitUtils.DivRoundUp(Size, KMemoryManager.PageSize); - if (_pageList.GetPagesCount() != pagesCountRounded) + if (PageList.GetPagesCount() != PagesCountRounded) { return KernelResult.InvalidSize; } - MemoryPermission expectedPermission = process.Pid == _ownerPid - ? _ownerPermission - : _userPermission; + MemoryPermission ExpectedPermission = Process.Pid == OwnerPid + ? OwnerPermission + : UserPermission; - if (permission != expectedPermission) + if (Permission != ExpectedPermission) { return KernelResult.InvalidPermission; } - return memoryManager.MapPages(address, _pageList, MemoryState.SharedMemory, permission); + return MemoryManager.MapPages(Address, PageList, MemoryState.SharedMemory, Permission); } public KernelResult UnmapFromProcess( - KMemoryManager memoryManager, - ulong address, - ulong size, - KProcess process) + KMemoryManager MemoryManager, + ulong Address, + ulong Size, + KProcess Process) { - ulong pagesCountRounded = BitUtils.DivRoundUp(size, KMemoryManager.PageSize); + ulong PagesCountRounded = BitUtils.DivRoundUp(Size, KMemoryManager.PageSize); - if (_pageList.GetPagesCount() != pagesCountRounded) + if (PageList.GetPagesCount() != PagesCountRounded) { return KernelResult.InvalidSize; } - return memoryManager.UnmapPages(address, _pageList, MemoryState.SharedMemory); + return MemoryManager.UnmapPages(Address, PageList, MemoryState.SharedMemory); } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KSlabHeap.cs b/Ryujinx.HLE/HOS/Kernel/KSlabHeap.cs index 84c4dc01..2d6b3ca0 100644 --- a/Ryujinx.HLE/HOS/Kernel/KSlabHeap.cs +++ b/Ryujinx.HLE/HOS/Kernel/KSlabHeap.cs @@ -4,46 +4,46 @@ namespace Ryujinx.HLE.HOS.Kernel { class KSlabHeap { - private LinkedList<ulong> _items; + private LinkedList<ulong> Items; - public KSlabHeap(ulong pa, ulong itemSize, ulong size) + public KSlabHeap(ulong Pa, ulong ItemSize, ulong Size) { - _items = new LinkedList<ulong>(); + Items = new LinkedList<ulong>(); - int itemsCount = (int)(size / itemSize); + int ItemsCount = (int)(Size / ItemSize); - for (int index = 0; index < itemsCount; index++) + for (int Index = 0; Index < ItemsCount; Index++) { - _items.AddLast(pa); + Items.AddLast(Pa); - pa += itemSize; + Pa += ItemSize; } } - public bool TryGetItem(out ulong pa) + public bool TryGetItem(out ulong Pa) { - lock (_items) + lock (Items) { - if (_items.First != null) + if (Items.First != null) { - pa = _items.First.Value; + Pa = Items.First.Value; - _items.RemoveFirst(); + Items.RemoveFirst(); return true; } } - pa = 0; + Pa = 0; return false; } - public void Free(ulong pa) + public void Free(ulong Pa) { - lock (_items) + lock (Items) { - _items.AddFirst(pa); + Items.AddFirst(Pa); } } } diff --git a/Ryujinx.HLE/HOS/Kernel/KSynchronization.cs b/Ryujinx.HLE/HOS/Kernel/KSynchronization.cs index 51b74a03..19e700f4 100644 --- a/Ryujinx.HLE/HOS/Kernel/KSynchronization.cs +++ b/Ryujinx.HLE/HOS/Kernel/KSynchronization.cs @@ -6,130 +6,130 @@ namespace Ryujinx.HLE.HOS.Kernel { class KSynchronization { - private Horizon _system; + private Horizon System; - public KSynchronization(Horizon system) + public KSynchronization(Horizon System) { - _system = system; + this.System = System; } - public long WaitFor(KSynchronizationObject[] syncObjs, long timeout, ref int hndIndex) + public long WaitFor(KSynchronizationObject[] SyncObjs, long Timeout, ref int HndIndex) { - long result = MakeError(ErrorModule.Kernel, KernelErr.Timeout); + long Result = MakeError(ErrorModule.Kernel, KernelErr.Timeout); - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); //Check if objects are already signaled before waiting. - for (int index = 0; index < syncObjs.Length; index++) + for (int Index = 0; Index < SyncObjs.Length; Index++) { - if (!syncObjs[index].IsSignaled()) + if (!SyncObjs[Index].IsSignaled()) { continue; } - hndIndex = index; + HndIndex = Index; - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); return 0; } - if (timeout == 0) + if (Timeout == 0) { - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - return result; + return Result; } - KThread currentThread = _system.Scheduler.GetCurrentThread(); + KThread CurrentThread = System.Scheduler.GetCurrentThread(); - if (currentThread.ShallBeTerminated || - currentThread.SchedFlags == ThreadSchedState.TerminationPending) + if (CurrentThread.ShallBeTerminated || + CurrentThread.SchedFlags == ThreadSchedState.TerminationPending) { - result = MakeError(ErrorModule.Kernel, KernelErr.ThreadTerminating); + Result = MakeError(ErrorModule.Kernel, KernelErr.ThreadTerminating); } - else if (currentThread.SyncCancelled) + else if (CurrentThread.SyncCancelled) { - currentThread.SyncCancelled = false; + CurrentThread.SyncCancelled = false; - result = MakeError(ErrorModule.Kernel, KernelErr.Cancelled); + Result = MakeError(ErrorModule.Kernel, KernelErr.Cancelled); } else { - LinkedListNode<KThread>[] syncNodes = new LinkedListNode<KThread>[syncObjs.Length]; + LinkedListNode<KThread>[] SyncNodes = new LinkedListNode<KThread>[SyncObjs.Length]; - for (int index = 0; index < syncObjs.Length; index++) + for (int Index = 0; Index < SyncObjs.Length; Index++) { - syncNodes[index] = syncObjs[index].AddWaitingThread(currentThread); + SyncNodes[Index] = SyncObjs[Index].AddWaitingThread(CurrentThread); } - currentThread.WaitingSync = true; - currentThread.SignaledObj = null; - currentThread.ObjSyncResult = (int)result; + CurrentThread.WaitingSync = true; + CurrentThread.SignaledObj = null; + CurrentThread.ObjSyncResult = (int)Result; - currentThread.Reschedule(ThreadSchedState.Paused); + CurrentThread.Reschedule(ThreadSchedState.Paused); - if (timeout > 0) + if (Timeout > 0) { - _system.TimeManager.ScheduleFutureInvocation(currentThread, timeout); + System.TimeManager.ScheduleFutureInvocation(CurrentThread, Timeout); } - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - currentThread.WaitingSync = false; + CurrentThread.WaitingSync = false; - if (timeout > 0) + if (Timeout > 0) { - _system.TimeManager.UnscheduleFutureInvocation(currentThread); + System.TimeManager.UnscheduleFutureInvocation(CurrentThread); } - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - result = (uint)currentThread.ObjSyncResult; + Result = (uint)CurrentThread.ObjSyncResult; - hndIndex = -1; + HndIndex = -1; - for (int index = 0; index < syncObjs.Length; index++) + for (int Index = 0; Index < SyncObjs.Length; Index++) { - syncObjs[index].RemoveWaitingThread(syncNodes[index]); + SyncObjs[Index].RemoveWaitingThread(SyncNodes[Index]); - if (syncObjs[index] == currentThread.SignaledObj) + if (SyncObjs[Index] == CurrentThread.SignaledObj) { - hndIndex = index; + HndIndex = Index; } } } - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - return result; + return Result; } - public void SignalObject(KSynchronizationObject syncObj) + public void SignalObject(KSynchronizationObject SyncObj) { - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - if (syncObj.IsSignaled()) + if (SyncObj.IsSignaled()) { - LinkedListNode<KThread> node = syncObj.WaitingThreads.First; + LinkedListNode<KThread> Node = SyncObj.WaitingThreads.First; - while (node != null) + while (Node != null) { - KThread thread = node.Value; + KThread Thread = Node.Value; - if ((thread.SchedFlags & ThreadSchedState.LowMask) == ThreadSchedState.Paused) + if ((Thread.SchedFlags & ThreadSchedState.LowMask) == ThreadSchedState.Paused) { - thread.SignaledObj = syncObj; - thread.ObjSyncResult = 0; + Thread.SignaledObj = SyncObj; + Thread.ObjSyncResult = 0; - thread.Reschedule(ThreadSchedState.Running); + Thread.Reschedule(ThreadSchedState.Running); } - node = node.Next; + Node = Node.Next; } } - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KSynchronizationObject.cs b/Ryujinx.HLE/HOS/Kernel/KSynchronizationObject.cs index 79f0673f..5ba7784f 100644 --- a/Ryujinx.HLE/HOS/Kernel/KSynchronizationObject.cs +++ b/Ryujinx.HLE/HOS/Kernel/KSynchronizationObject.cs @@ -6,19 +6,19 @@ namespace Ryujinx.HLE.HOS.Kernel { public LinkedList<KThread> WaitingThreads; - public KSynchronizationObject(Horizon system) : base(system) + public KSynchronizationObject(Horizon System) : base(System) { WaitingThreads = new LinkedList<KThread>(); } - public LinkedListNode<KThread> AddWaitingThread(KThread thread) + public LinkedListNode<KThread> AddWaitingThread(KThread Thread) { - return WaitingThreads.AddLast(thread); + return WaitingThreads.AddLast(Thread); } - public void RemoveWaitingThread(LinkedListNode<KThread> node) + public void RemoveWaitingThread(LinkedListNode<KThread> Node) { - WaitingThreads.Remove(node); + WaitingThreads.Remove(Node); } public virtual void Signal() diff --git a/Ryujinx.HLE/HOS/Kernel/KThread.cs b/Ryujinx.HLE/HOS/Kernel/KThread.cs index ae1e860f..88f144c8 100644 --- a/Ryujinx.HLE/HOS/Kernel/KThread.cs +++ b/Ryujinx.HLE/HOS/Kernel/KThread.cs @@ -22,31 +22,31 @@ namespace Ryujinx.HLE.HOS.Kernel public long CondVarAddress { get; set; } - private ulong _entrypoint; + private ulong Entrypoint; public long MutexAddress { get; set; } public KProcess Owner { get; private set; } - private ulong _tlsAddress; + private ulong TlsAddress; public long LastScheduledTime { get; set; } - public LinkedListNode<KThread>[] SiblingsPerCore { get; } + public LinkedListNode<KThread>[] SiblingsPerCore { get; private set; } 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; + private LinkedList<KThread> MutexWaiters; + private LinkedListNode<KThread> MutexWaiterNode; public KThread MutexOwner { get; private set; } public int ThreadHandleForUserMutex { get; set; } - private ThreadSchedState _forcePauseFlags; + private ThreadSchedState ForcePauseFlags; public int ObjSyncResult { get; set; } @@ -55,9 +55,9 @@ namespace Ryujinx.HLE.HOS.Kernel public int BasePriority { get; set; } public int PreferredCore { get; set; } - private long _affinityMaskOverride; - private int _preferredCoreOverride; - private int _affinityOverrideCount; + private long AffinityMaskOverride; + private int PreferredCoreOverride; + private int AffinityOverrideCount; public ThreadSchedState SchedFlags { get; private set; } @@ -66,101 +66,101 @@ namespace Ryujinx.HLE.HOS.Kernel public bool SyncCancelled { get; set; } public bool WaitingSync { get; set; } - private bool _hasExited; + private bool HasExited; public bool WaitingInArbitration { get; set; } - private KScheduler _scheduler; + private KScheduler Scheduler; - private KSchedulingData _schedulingData; + private KSchedulingData SchedulingData; public long LastPc { get; set; } - public KThread(Horizon system) : base(system) + public KThread(Horizon System) : base(System) { - _scheduler = system.Scheduler; - _schedulingData = system.Scheduler.SchedulingData; + Scheduler = System.Scheduler; + SchedulingData = System.Scheduler.SchedulingData; SiblingsPerCore = new LinkedListNode<KThread>[KScheduler.CpuCoresCount]; - _mutexWaiters = new LinkedList<KThread>(); + MutexWaiters = new LinkedList<KThread>(); } public KernelResult Initialize( - ulong entrypoint, - ulong argsPtr, - ulong stackTop, - int priority, - int defaultCpuCore, - KProcess owner, - ThreadType type = ThreadType.User) + ulong Entrypoint, + ulong ArgsPtr, + ulong StackTop, + int Priority, + int DefaultCpuCore, + KProcess Owner, + ThreadType Type = ThreadType.User) { - if ((uint)type > 3) + if ((uint)Type > 3) { - throw new ArgumentException($"Invalid thread type \"{type}\"."); + throw new ArgumentException($"Invalid thread type \"{Type}\"."); } - PreferredCore = defaultCpuCore; + PreferredCore = DefaultCpuCore; - AffinityMask |= 1L << defaultCpuCore; + AffinityMask |= 1L << DefaultCpuCore; - SchedFlags = type == ThreadType.Dummy + SchedFlags = Type == ThreadType.Dummy ? ThreadSchedState.Running : ThreadSchedState.None; CurrentCore = PreferredCore; - DynamicPriority = priority; - BasePriority = priority; + DynamicPriority = Priority; + BasePriority = Priority; ObjSyncResult = 0x7201; - _entrypoint = entrypoint; + this.Entrypoint = Entrypoint; - if (type == ThreadType.User) + if (Type == ThreadType.User) { - if (owner.AllocateThreadLocalStorage(out _tlsAddress) != KernelResult.Success) + if (Owner.AllocateThreadLocalStorage(out TlsAddress) != KernelResult.Success) { return KernelResult.OutOfMemory; } - MemoryHelper.FillWithZeros(owner.CpuMemory, (long)_tlsAddress, KTlsPageInfo.TlsEntrySize); + MemoryHelper.FillWithZeros(Owner.CpuMemory, (long)TlsAddress, KTlsPageInfo.TlsEntrySize); } - bool is64Bits; + bool Is64Bits; - if (owner != null) + if (Owner != null) { - Owner = owner; + this.Owner = Owner; - owner.IncrementThreadCount(); + Owner.IncrementThreadCount(); - is64Bits = (owner.MmuFlags & 1) != 0; + Is64Bits = (Owner.MmuFlags & 1) != 0; } else { - is64Bits = true; + Is64Bits = true; } - Context = new CpuThread(owner.Translator, owner.CpuMemory, (long)entrypoint); + Context = new CpuThread(Owner.Translator, Owner.CpuMemory, (long)Entrypoint); - Context.ThreadState.X0 = argsPtr; - Context.ThreadState.X31 = stackTop; + Context.ThreadState.X0 = ArgsPtr; + Context.ThreadState.X31 = StackTop; Context.ThreadState.CntfrqEl0 = 19200000; - Context.ThreadState.Tpidr = (long)_tlsAddress; + Context.ThreadState.Tpidr = (long)TlsAddress; - owner.SubscribeThreadEventHandlers(Context); + Owner.SubscribeThreadEventHandlers(Context); Context.WorkFinished += ThreadFinishedHandler; ThreadUid = System.GetThreadUid(); - if (owner != null) + if (Owner != null) { - owner.AddThread(this); + Owner.AddThread(this); - if (owner.IsPaused) + if (Owner.IsPaused) { System.CriticalSection.Enter(); @@ -171,7 +171,7 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } - _forcePauseFlags |= ThreadSchedState.ProcessPauseFlag; + ForcePauseFlags |= ThreadSchedState.ProcessPauseFlag; CombineForcePauseFlags(); @@ -190,7 +190,7 @@ namespace Ryujinx.HLE.HOS.Kernel if (!ShallBeTerminated && SchedFlags != ThreadSchedState.TerminationPending) { - _forcePauseFlags |= ThreadSchedState.KernelInitPauseFlag; + ForcePauseFlags |= ThreadSchedState.KernelInitPauseFlag; CombineForcePauseFlags(); } @@ -198,46 +198,46 @@ namespace Ryujinx.HLE.HOS.Kernel System.CriticalSection.Leave(); } - KernelResult result = KernelResult.ThreadTerminating; + KernelResult Result = KernelResult.ThreadTerminating; System.CriticalSection.Enter(); if (!ShallBeTerminated) { - KThread currentThread = System.Scheduler.GetCurrentThread(); + KThread CurrentThread = System.Scheduler.GetCurrentThread(); while (SchedFlags != ThreadSchedState.TerminationPending && - currentThread.SchedFlags != ThreadSchedState.TerminationPending && - !currentThread.ShallBeTerminated) + CurrentThread.SchedFlags != ThreadSchedState.TerminationPending && + !CurrentThread.ShallBeTerminated) { if ((SchedFlags & ThreadSchedState.LowMask) != ThreadSchedState.None) { - result = KernelResult.InvalidState; + Result = KernelResult.InvalidState; break; } - if (currentThread._forcePauseFlags == ThreadSchedState.None) + if (CurrentThread.ForcePauseFlags == ThreadSchedState.None) { - if (Owner != null && _forcePauseFlags != ThreadSchedState.None) + if (Owner != null && ForcePauseFlags != ThreadSchedState.None) { CombineForcePauseFlags(); } SetNewSchedFlags(ThreadSchedState.Running); - result = KernelResult.Success; + Result = KernelResult.Success; break; } else { - currentThread.CombineForcePauseFlags(); + CurrentThread.CombineForcePauseFlags(); System.CriticalSection.Leave(); System.CriticalSection.Enter(); - if (currentThread.ShallBeTerminated) + if (CurrentThread.ShallBeTerminated) { break; } @@ -247,14 +247,14 @@ namespace Ryujinx.HLE.HOS.Kernel System.CriticalSection.Leave(); - return result; + return Result; } public void Exit() { System.CriticalSection.Enter(); - _forcePauseFlags &= ~ThreadSchedState.ForcePauseMask; + ForcePauseFlags &= ~ThreadSchedState.ForcePauseMask; ExitImpl(); @@ -267,14 +267,14 @@ namespace Ryujinx.HLE.HOS.Kernel SetNewSchedFlags(ThreadSchedState.TerminationPending); - _hasExited = true; + HasExited = true; Signal(); System.CriticalSection.Leave(); } - public long Sleep(long timeout) + public long Sleep(long Timeout) { System.CriticalSection.Enter(); @@ -287,14 +287,14 @@ namespace Ryujinx.HLE.HOS.Kernel SetNewSchedFlags(ThreadSchedState.Paused); - if (timeout > 0) + if (Timeout > 0) { - System.TimeManager.ScheduleFutureInvocation(this, timeout); + System.TimeManager.ScheduleFutureInvocation(this, Timeout); } System.CriticalSection.Leave(); - if (timeout > 0) + if (Timeout > 0) { System.TimeManager.UnscheduleFutureInvocation(this); } @@ -318,10 +318,10 @@ namespace Ryujinx.HLE.HOS.Kernel if (DynamicPriority < KScheduler.PrioritiesCount) { //Move current thread to the end of the queue. - _schedulingData.Reschedule(DynamicPriority, CurrentCore, this); + SchedulingData.Reschedule(DynamicPriority, CurrentCore, this); } - _scheduler.ThreadReselectionRequested = true; + Scheduler.ThreadReselectionRequested = true; System.CriticalSection.Leave(); @@ -341,32 +341,32 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - int prio = DynamicPriority; - int core = CurrentCore; + int Prio = DynamicPriority; + int Core = CurrentCore; - KThread nextThreadOnCurrentQueue = null; + KThread NextThreadOnCurrentQueue = null; if (DynamicPriority < KScheduler.PrioritiesCount) { //Move current thread to the end of the queue. - _schedulingData.Reschedule(prio, core, this); + SchedulingData.Reschedule(Prio, Core, this); - Func<KThread, bool> predicate = x => x.DynamicPriority == prio; + Func<KThread, bool> Predicate = x => x.DynamicPriority == Prio; - nextThreadOnCurrentQueue = _schedulingData.ScheduledThreads(core).FirstOrDefault(predicate); + NextThreadOnCurrentQueue = SchedulingData.ScheduledThreads(Core).FirstOrDefault(Predicate); } IEnumerable<KThread> SuitableCandidates() { - foreach (KThread thread in _schedulingData.SuggestedThreads(core)) + foreach (KThread Thread in SchedulingData.SuggestedThreads(Core)) { - int srcCore = thread.CurrentCore; + int SrcCore = Thread.CurrentCore; - if (srcCore >= 0) + if (SrcCore >= 0) { - KThread selectedSrcCore = _scheduler.CoreContexts[srcCore].SelectedThread; + KThread SelectedSrcCore = Scheduler.CoreContexts[SrcCore].SelectedThread; - if (selectedSrcCore == thread || ((selectedSrcCore?.DynamicPriority ?? 2) < 2)) + if (SelectedSrcCore == Thread || ((SelectedSrcCore?.DynamicPriority ?? 2) < 2)) { continue; } @@ -374,26 +374,26 @@ 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.LastScheduledTime >= thread.LastScheduledTime || - nextThreadOnCurrentQueue.DynamicPriority < thread.DynamicPriority) + if (NextThreadOnCurrentQueue.LastScheduledTime >= Thread.LastScheduledTime || + NextThreadOnCurrentQueue.DynamicPriority < Thread.DynamicPriority) { - yield return thread; + yield return Thread; } } } - KThread dst = SuitableCandidates().FirstOrDefault(x => x.DynamicPriority <= prio); + KThread Dst = SuitableCandidates().FirstOrDefault(x => x.DynamicPriority <= Prio); - if (dst != null) + if (Dst != null) { - _schedulingData.TransferToCore(dst.DynamicPriority, core, dst); + SchedulingData.TransferToCore(Dst.DynamicPriority, Core, Dst); - _scheduler.ThreadReselectionRequested = true; + Scheduler.ThreadReselectionRequested = true; } - if (this != nextThreadOnCurrentQueue) + if (this != NextThreadOnCurrentQueue) { - _scheduler.ThreadReselectionRequested = true; + Scheduler.ThreadReselectionRequested = true; } System.CriticalSection.Leave(); @@ -414,42 +414,42 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - int core = CurrentCore; + int Core = CurrentCore; - _schedulingData.TransferToCore(DynamicPriority, -1, this); + SchedulingData.TransferToCore(DynamicPriority, -1, this); - KThread selectedThread = null; + KThread SelectedThread = null; - if (!_schedulingData.ScheduledThreads(core).Any()) + if (!SchedulingData.ScheduledThreads(Core).Any()) { - foreach (KThread thread in _schedulingData.SuggestedThreads(core)) + foreach (KThread Thread in SchedulingData.SuggestedThreads(Core)) { - if (thread.CurrentCore < 0) + if (Thread.CurrentCore < 0) { continue; } - KThread firstCandidate = _schedulingData.ScheduledThreads(thread.CurrentCore).FirstOrDefault(); + KThread FirstCandidate = SchedulingData.ScheduledThreads(Thread.CurrentCore).FirstOrDefault(); - if (firstCandidate == thread) + if (FirstCandidate == Thread) { continue; } - if (firstCandidate == null || firstCandidate.DynamicPriority >= 2) + if (FirstCandidate == null || FirstCandidate.DynamicPriority >= 2) { - _schedulingData.TransferToCore(thread.DynamicPriority, core, thread); + SchedulingData.TransferToCore(Thread.DynamicPriority, Core, Thread); - selectedThread = thread; + SelectedThread = Thread; } break; } } - if (selectedThread != this) + if (SelectedThread != this) { - _scheduler.ThreadReselectionRequested = true; + Scheduler.ThreadReselectionRequested = true; } System.CriticalSection.Leave(); @@ -457,26 +457,26 @@ namespace Ryujinx.HLE.HOS.Kernel System.Scheduler.ContextSwitch(); } - public void SetPriority(int priority) + public void SetPriority(int Priority) { System.CriticalSection.Enter(); - BasePriority = priority; + BasePriority = Priority; UpdatePriorityInheritance(); System.CriticalSection.Leave(); } - public long SetActivity(bool pause) + public long SetActivity(bool Pause) { - long result = 0; + long Result = 0; System.CriticalSection.Enter(); - ThreadSchedState lowNibble = SchedFlags & ThreadSchedState.LowMask; + ThreadSchedState LowNibble = SchedFlags & ThreadSchedState.LowMask; - if (lowNibble != ThreadSchedState.Paused && lowNibble != ThreadSchedState.Running) + if (LowNibble != ThreadSchedState.Paused && LowNibble != ThreadSchedState.Running) { System.CriticalSection.Leave(); @@ -487,41 +487,41 @@ namespace Ryujinx.HLE.HOS.Kernel if (!ShallBeTerminated && SchedFlags != ThreadSchedState.TerminationPending) { - if (pause) + if (Pause) { //Pause, the force pause flag should be clear (thread is NOT paused). - if ((_forcePauseFlags & ThreadSchedState.ThreadPauseFlag) == 0) + if ((ForcePauseFlags & ThreadSchedState.ThreadPauseFlag) == 0) { - _forcePauseFlags |= ThreadSchedState.ThreadPauseFlag; + ForcePauseFlags |= ThreadSchedState.ThreadPauseFlag; CombineForcePauseFlags(); } else { - result = MakeError(ErrorModule.Kernel, KernelErr.InvalidState); + Result = MakeError(ErrorModule.Kernel, KernelErr.InvalidState); } } else { //Unpause, the force pause flag should be set (thread is paused). - if ((_forcePauseFlags & ThreadSchedState.ThreadPauseFlag) != 0) + if ((ForcePauseFlags & ThreadSchedState.ThreadPauseFlag) != 0) { - ThreadSchedState oldForcePauseFlags = _forcePauseFlags; + ThreadSchedState OldForcePauseFlags = ForcePauseFlags; - _forcePauseFlags &= ~ThreadSchedState.ThreadPauseFlag; + ForcePauseFlags &= ~ThreadSchedState.ThreadPauseFlag; - if ((oldForcePauseFlags & ~ThreadSchedState.ThreadPauseFlag) == ThreadSchedState.None) + if ((OldForcePauseFlags & ~ThreadSchedState.ThreadPauseFlag) == ThreadSchedState.None) { - ThreadSchedState oldSchedFlags = SchedFlags; + ThreadSchedState OldSchedFlags = SchedFlags; SchedFlags &= ThreadSchedState.LowMask; - AdjustScheduling(oldSchedFlags); + AdjustScheduling(OldSchedFlags); } } else { - result = MakeError(ErrorModule.Kernel, KernelErr.InvalidState); + Result = MakeError(ErrorModule.Kernel, KernelErr.InvalidState); } } } @@ -529,7 +529,7 @@ namespace Ryujinx.HLE.HOS.Kernel System.CriticalSection.Leave(); System.CriticalSection.Leave(); - return result; + return Result; } public void CancelSynchronization() @@ -563,18 +563,18 @@ namespace Ryujinx.HLE.HOS.Kernel System.CriticalSection.Leave(); } - public KernelResult SetCoreAndAffinityMask(int newCore, long newAffinityMask) + public KernelResult SetCoreAndAffinityMask(int NewCore, long NewAffinityMask) { System.CriticalSection.Enter(); - bool useOverride = _affinityOverrideCount != 0; + bool UseOverride = AffinityOverrideCount != 0; //The value -3 is "do not change the preferred core". - if (newCore == -3) + if (NewCore == -3) { - newCore = useOverride ? _preferredCoreOverride : PreferredCore; + NewCore = UseOverride ? PreferredCoreOverride : PreferredCore; - if ((newAffinityMask & (1 << newCore)) == 0) + if ((NewAffinityMask & (1 << NewCore)) == 0) { System.CriticalSection.Leave(); @@ -582,21 +582,21 @@ namespace Ryujinx.HLE.HOS.Kernel } } - if (useOverride) + if (UseOverride) { - _preferredCoreOverride = newCore; - _affinityMaskOverride = newAffinityMask; + PreferredCoreOverride = NewCore; + AffinityMaskOverride = NewAffinityMask; } else { - long oldAffinityMask = AffinityMask; + long OldAffinityMask = AffinityMask; - PreferredCore = newCore; - AffinityMask = newAffinityMask; + PreferredCore = NewCore; + AffinityMask = NewAffinityMask; - if (oldAffinityMask != newAffinityMask) + if (OldAffinityMask != NewAffinityMask) { - int oldCore = CurrentCore; + int OldCore = CurrentCore; if (CurrentCore >= 0 && ((AffinityMask >> CurrentCore) & 1) == 0) { @@ -610,7 +610,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - AdjustSchedulingForNewAffinity(oldAffinityMask, oldCore); + AdjustSchedulingForNewAffinity(OldAffinityMask, OldCore); } } @@ -619,13 +619,13 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } - private static int HighestSetCore(long mask) + private static int HighestSetCore(long Mask) { - for (int core = KScheduler.CpuCoresCount - 1; core >= 0; core--) + for (int Core = KScheduler.CpuCoresCount - 1; Core >= 0; Core--) { - if (((mask >> core) & 1) != 0) + if (((Mask >> Core) & 1) != 0) { - return core; + return Core; } } @@ -634,25 +634,25 @@ namespace Ryujinx.HLE.HOS.Kernel private void CombineForcePauseFlags() { - ThreadSchedState oldFlags = SchedFlags; - ThreadSchedState lowNibble = SchedFlags & ThreadSchedState.LowMask; + ThreadSchedState OldFlags = SchedFlags; + ThreadSchedState LowNibble = SchedFlags & ThreadSchedState.LowMask; - SchedFlags = lowNibble | _forcePauseFlags; + SchedFlags = LowNibble | ForcePauseFlags; - AdjustScheduling(oldFlags); + AdjustScheduling(OldFlags); } - private void SetNewSchedFlags(ThreadSchedState newFlags) + private void SetNewSchedFlags(ThreadSchedState NewFlags) { System.CriticalSection.Enter(); - ThreadSchedState oldFlags = SchedFlags; + ThreadSchedState OldFlags = SchedFlags; - SchedFlags = (oldFlags & ThreadSchedState.HighMask) | newFlags; + SchedFlags = (OldFlags & ThreadSchedState.HighMask) | NewFlags; - if ((oldFlags & ThreadSchedState.LowMask) != newFlags) + if ((OldFlags & ThreadSchedState.LowMask) != NewFlags) { - AdjustScheduling(oldFlags); + AdjustScheduling(OldFlags); } System.CriticalSection.Leave(); @@ -681,98 +681,98 @@ namespace Ryujinx.HLE.HOS.Kernel System.CriticalSection.Leave(); } - public void Reschedule(ThreadSchedState newFlags) + public void Reschedule(ThreadSchedState NewFlags) { System.CriticalSection.Enter(); - ThreadSchedState oldFlags = SchedFlags; + ThreadSchedState OldFlags = SchedFlags; - SchedFlags = (oldFlags & ThreadSchedState.HighMask) | - (newFlags & ThreadSchedState.LowMask); + SchedFlags = (OldFlags & ThreadSchedState.HighMask) | + (NewFlags & ThreadSchedState.LowMask); - AdjustScheduling(oldFlags); + AdjustScheduling(OldFlags); System.CriticalSection.Leave(); } - public void AddMutexWaiter(KThread requester) + public void AddMutexWaiter(KThread Requester) { - AddToMutexWaitersList(requester); + AddToMutexWaitersList(Requester); - requester.MutexOwner = this; + Requester.MutexOwner = this; UpdatePriorityInheritance(); } - public void RemoveMutexWaiter(KThread thread) + public void RemoveMutexWaiter(KThread Thread) { - if (thread._mutexWaiterNode?.List != null) + if (Thread.MutexWaiterNode?.List != null) { - _mutexWaiters.Remove(thread._mutexWaiterNode); + MutexWaiters.Remove(Thread.MutexWaiterNode); } - thread.MutexOwner = null; + Thread.MutexOwner = null; UpdatePriorityInheritance(); } - public KThread RelinquishMutex(long mutexAddress, out int count) + public KThread RelinquishMutex(long MutexAddress, out int Count) { - count = 0; + Count = 0; - if (_mutexWaiters.First == null) + if (MutexWaiters.First == null) { return null; } - KThread newMutexOwner = null; + KThread NewMutexOwner = null; - LinkedListNode<KThread> currentNode = _mutexWaiters.First; + LinkedListNode<KThread> CurrentNode = MutexWaiters.First; do { //Skip all threads that are not waiting for this mutex. - while (currentNode != null && currentNode.Value.MutexAddress != mutexAddress) + while (CurrentNode != null && CurrentNode.Value.MutexAddress != MutexAddress) { - currentNode = currentNode.Next; + CurrentNode = CurrentNode.Next; } - if (currentNode == null) + if (CurrentNode == null) { break; } - LinkedListNode<KThread> nextNode = currentNode.Next; + LinkedListNode<KThread> NextNode = CurrentNode.Next; - _mutexWaiters.Remove(currentNode); + MutexWaiters.Remove(CurrentNode); - currentNode.Value.MutexOwner = newMutexOwner; + CurrentNode.Value.MutexOwner = NewMutexOwner; - if (newMutexOwner != null) + if (NewMutexOwner != null) { //New owner was already selected, re-insert on new owner list. - newMutexOwner.AddToMutexWaitersList(currentNode.Value); + NewMutexOwner.AddToMutexWaitersList(CurrentNode.Value); } else { //New owner not selected yet, use current thread. - newMutexOwner = currentNode.Value; + NewMutexOwner = CurrentNode.Value; } - count++; + Count++; - currentNode = nextNode; + CurrentNode = NextNode; } - while (currentNode != null); + while (CurrentNode != null); - if (newMutexOwner != null) + if (NewMutexOwner != null) { UpdatePriorityInheritance(); - newMutexOwner.UpdatePriorityInheritance(); + NewMutexOwner.UpdatePriorityInheritance(); } - return newMutexOwner; + return NewMutexOwner; } private void UpdatePriorityInheritance() @@ -780,30 +780,30 @@ namespace Ryujinx.HLE.HOS.Kernel //If any of the threads waiting for the mutex has //higher priority than the current thread, then //the current thread inherits that priority. - int highestPriority = BasePriority; + int HighestPriority = BasePriority; - if (_mutexWaiters.First != null) + if (MutexWaiters.First != null) { - int waitingDynamicPriority = _mutexWaiters.First.Value.DynamicPriority; + int WaitingDynamicPriority = MutexWaiters.First.Value.DynamicPriority; - if (waitingDynamicPriority < highestPriority) + if (WaitingDynamicPriority < HighestPriority) { - highestPriority = waitingDynamicPriority; + HighestPriority = WaitingDynamicPriority; } } - if (highestPriority != DynamicPriority) + if (HighestPriority != DynamicPriority) { - int oldPriority = DynamicPriority; + int OldPriority = DynamicPriority; - DynamicPriority = highestPriority; + DynamicPriority = HighestPriority; - AdjustSchedulingForNewPriority(oldPriority); + AdjustSchedulingForNewPriority(OldPriority); if (MutexOwner != null) { //Remove and re-insert to ensure proper sorting based on new priority. - MutexOwner._mutexWaiters.Remove(_mutexWaiterNode); + MutexOwner.MutexWaiters.Remove(MutexWaiterNode); MutexOwner.AddToMutexWaitersList(this); @@ -812,47 +812,47 @@ namespace Ryujinx.HLE.HOS.Kernel } } - private void AddToMutexWaitersList(KThread thread) + private void AddToMutexWaitersList(KThread Thread) { - LinkedListNode<KThread> nextPrio = _mutexWaiters.First; + LinkedListNode<KThread> NextPrio = MutexWaiters.First; - int currentPriority = thread.DynamicPriority; + int CurrentPriority = Thread.DynamicPriority; - while (nextPrio != null && nextPrio.Value.DynamicPriority <= currentPriority) + while (NextPrio != null && NextPrio.Value.DynamicPriority <= CurrentPriority) { - nextPrio = nextPrio.Next; + NextPrio = NextPrio.Next; } - if (nextPrio != null) + if (NextPrio != null) { - thread._mutexWaiterNode = _mutexWaiters.AddBefore(nextPrio, thread); + Thread.MutexWaiterNode = MutexWaiters.AddBefore(NextPrio, Thread); } else { - thread._mutexWaiterNode = _mutexWaiters.AddLast(thread); + Thread.MutexWaiterNode = MutexWaiters.AddLast(Thread); } } - private void AdjustScheduling(ThreadSchedState oldFlags) + private void AdjustScheduling(ThreadSchedState OldFlags) { - if (oldFlags == SchedFlags) + if (OldFlags == SchedFlags) { return; } - if (oldFlags == ThreadSchedState.Running) + if (OldFlags == ThreadSchedState.Running) { //Was running, now it's stopped. if (CurrentCore >= 0) { - _schedulingData.Unschedule(DynamicPriority, CurrentCore, this); + SchedulingData.Unschedule(DynamicPriority, CurrentCore, this); } - for (int core = 0; core < KScheduler.CpuCoresCount; core++) + for (int Core = 0; Core < KScheduler.CpuCoresCount; Core++) { - if (core != CurrentCore && ((AffinityMask >> core) & 1) != 0) + if (Core != CurrentCore && ((AffinityMask >> Core) & 1) != 0) { - _schedulingData.Unsuggest(DynamicPriority, core, this); + SchedulingData.Unsuggest(DynamicPriority, Core, this); } } } @@ -861,22 +861,22 @@ namespace Ryujinx.HLE.HOS.Kernel //Was stopped, now it's running. if (CurrentCore >= 0) { - _schedulingData.Schedule(DynamicPriority, CurrentCore, this); + SchedulingData.Schedule(DynamicPriority, CurrentCore, this); } - for (int core = 0; core < KScheduler.CpuCoresCount; core++) + for (int Core = 0; Core < KScheduler.CpuCoresCount; Core++) { - if (core != CurrentCore && ((AffinityMask >> core) & 1) != 0) + if (Core != CurrentCore && ((AffinityMask >> Core) & 1) != 0) { - _schedulingData.Suggest(DynamicPriority, core, this); + SchedulingData.Suggest(DynamicPriority, Core, this); } } } - _scheduler.ThreadReselectionRequested = true; + Scheduler.ThreadReselectionRequested = true; } - private void AdjustSchedulingForNewPriority(int oldPriority) + private void AdjustSchedulingForNewPriority(int OldPriority) { if (SchedFlags != ThreadSchedState.Running) { @@ -886,44 +886,44 @@ namespace Ryujinx.HLE.HOS.Kernel //Remove thread from the old priority queues. if (CurrentCore >= 0) { - _schedulingData.Unschedule(oldPriority, CurrentCore, this); + SchedulingData.Unschedule(OldPriority, CurrentCore, this); } - for (int core = 0; core < KScheduler.CpuCoresCount; core++) + for (int Core = 0; Core < KScheduler.CpuCoresCount; Core++) { - if (core != CurrentCore && ((AffinityMask >> core) & 1) != 0) + if (Core != CurrentCore && ((AffinityMask >> Core) & 1) != 0) { - _schedulingData.Unsuggest(oldPriority, core, this); + SchedulingData.Unsuggest(OldPriority, Core, this); } } //Add thread to the new priority queues. - KThread currentThread = _scheduler.GetCurrentThread(); + KThread CurrentThread = Scheduler.GetCurrentThread(); if (CurrentCore >= 0) { - if (currentThread == this) + if (CurrentThread == this) { - _schedulingData.SchedulePrepend(DynamicPriority, CurrentCore, this); + SchedulingData.SchedulePrepend(DynamicPriority, CurrentCore, this); } else { - _schedulingData.Schedule(DynamicPriority, CurrentCore, this); + SchedulingData.Schedule(DynamicPriority, CurrentCore, this); } } - for (int core = 0; core < KScheduler.CpuCoresCount; core++) + for (int Core = 0; Core < KScheduler.CpuCoresCount; Core++) { - if (core != CurrentCore && ((AffinityMask >> core) & 1) != 0) + if (Core != CurrentCore && ((AffinityMask >> Core) & 1) != 0) { - _schedulingData.Suggest(DynamicPriority, core, this); + SchedulingData.Suggest(DynamicPriority, Core, this); } } - _scheduler.ThreadReselectionRequested = true; + Scheduler.ThreadReselectionRequested = true; } - private void AdjustSchedulingForNewAffinity(long oldAffinityMask, int oldCore) + private void AdjustSchedulingForNewAffinity(long OldAffinityMask, int OldCore) { if (SchedFlags != ThreadSchedState.Running || DynamicPriority >= KScheduler.PrioritiesCount) { @@ -931,49 +931,49 @@ namespace Ryujinx.HLE.HOS.Kernel } //Remove from old queues. - for (int core = 0; core < KScheduler.CpuCoresCount; core++) + for (int Core = 0; Core < KScheduler.CpuCoresCount; Core++) { - if (((oldAffinityMask >> core) & 1) != 0) + if (((OldAffinityMask >> Core) & 1) != 0) { - if (core == oldCore) + if (Core == OldCore) { - _schedulingData.Unschedule(DynamicPriority, core, this); + SchedulingData.Unschedule(DynamicPriority, Core, this); } else { - _schedulingData.Unsuggest(DynamicPriority, core, this); + SchedulingData.Unsuggest(DynamicPriority, Core, this); } } } //Insert on new queues. - for (int core = 0; core < KScheduler.CpuCoresCount; core++) + for (int Core = 0; Core < KScheduler.CpuCoresCount; Core++) { - if (((AffinityMask >> core) & 1) != 0) + if (((AffinityMask >> Core) & 1) != 0) { - if (core == CurrentCore) + if (Core == CurrentCore) { - _schedulingData.Schedule(DynamicPriority, core, this); + SchedulingData.Schedule(DynamicPriority, Core, this); } else { - _schedulingData.Suggest(DynamicPriority, core, this); + SchedulingData.Suggest(DynamicPriority, Core, this); } } } - _scheduler.ThreadReselectionRequested = true; + Scheduler.ThreadReselectionRequested = true; } public override bool IsSignaled() { - return _hasExited; + return HasExited; } - public void SetEntryArguments(long argsPtr, int threadHandle) + public void SetEntryArguments(long ArgsPtr, int ThreadHandle) { - Context.ThreadState.X0 = (ulong)argsPtr; - Context.ThreadState.X1 = (ulong)threadHandle; + Context.ThreadState.X0 = (ulong)ArgsPtr; + Context.ThreadState.X1 = (ulong)ThreadHandle; } public void ClearExclusive() @@ -1004,7 +1004,7 @@ namespace Ryujinx.HLE.HOS.Kernel { Owner?.RemoveThread(this); - if (_tlsAddress != 0 && Owner.FreeThreadLocalStorage(_tlsAddress) != KernelResult.Success) + if (TlsAddress != 0 && Owner.FreeThreadLocalStorage(TlsAddress) != KernelResult.Success) { throw new InvalidOperationException("Unexpected failure freeing thread local storage."); } @@ -1013,13 +1013,13 @@ namespace Ryujinx.HLE.HOS.Kernel //Wake up all threads that may be waiting for a mutex being held //by this thread. - foreach (KThread thread in _mutexWaiters) + foreach (KThread Thread in MutexWaiters) { - thread.MutexOwner = null; - thread._preferredCoreOverride = 0; - thread.ObjSyncResult = 0xfa01; + Thread.MutexOwner = null; + Thread.PreferredCoreOverride = 0; + Thread.ObjSyncResult = 0xfa01; - thread.ReleaseAndResume(); + Thread.ReleaseAndResume(); } System.CriticalSection.Leave(); diff --git a/Ryujinx.HLE/HOS/Kernel/KTimeManager.cs b/Ryujinx.HLE/HOS/Kernel/KTimeManager.cs index c662906c..375789f0 100644 --- a/Ryujinx.HLE/HOS/Kernel/KTimeManager.cs +++ b/Ryujinx.HLE/HOS/Kernel/KTimeManager.cs @@ -10,116 +10,116 @@ namespace Ryujinx.HLE.HOS.Kernel { private class WaitingObject { - public IKFutureSchedulerObject Object { get; } + public IKFutureSchedulerObject Object { get; private set; } - public long TimePoint { get; } + public long TimePoint { get; private set; } - public WaitingObject(IKFutureSchedulerObject schedulerObj, long timePoint) + public WaitingObject(IKFutureSchedulerObject Object, long TimePoint) { - Object = schedulerObj; - TimePoint = timePoint; + this.Object = Object; + this.TimePoint = TimePoint; } } - private List<WaitingObject> _waitingObjects; + private List<WaitingObject> WaitingObjects; - private AutoResetEvent _waitEvent; + private AutoResetEvent WaitEvent; - private bool _keepRunning; + private bool KeepRunning; public KTimeManager() { - _waitingObjects = new List<WaitingObject>(); + WaitingObjects = new List<WaitingObject>(); - _keepRunning = true; + KeepRunning = true; - Thread work = new Thread(WaitAndCheckScheduledObjects); + Thread Work = new Thread(WaitAndCheckScheduledObjects); - work.Start(); + Work.Start(); } - public void ScheduleFutureInvocation(IKFutureSchedulerObject schedulerObj, long timeout) + public void ScheduleFutureInvocation(IKFutureSchedulerObject Object, long Timeout) { - long timePoint = PerformanceCounter.ElapsedMilliseconds + ConvertNanosecondsToMilliseconds(timeout); + long TimePoint = PerformanceCounter.ElapsedMilliseconds + ConvertNanosecondsToMilliseconds(Timeout); - lock (_waitingObjects) + lock (WaitingObjects) { - _waitingObjects.Add(new WaitingObject(schedulerObj, timePoint)); + WaitingObjects.Add(new WaitingObject(Object, TimePoint)); } - _waitEvent.Set(); + WaitEvent.Set(); } - public static long ConvertNanosecondsToMilliseconds(long time) + public static long ConvertNanosecondsToMilliseconds(long Time) { - time /= 1000000; + Time /= 1000000; - if ((ulong)time > int.MaxValue) + if ((ulong)Time > int.MaxValue) { return int.MaxValue; } - return time; + return Time; } - public static long ConvertMillisecondsToNanoseconds(long time) + public static long ConvertMillisecondsToNanoseconds(long Time) { - return time * 1000000; + return Time * 1000000; } - public static long ConvertMillisecondsToTicks(long time) + public static long ConvertMillisecondsToTicks(long Time) { - return time * 19200; + return Time * 19200; } public void UnscheduleFutureInvocation(IKFutureSchedulerObject Object) { - lock (_waitingObjects) + lock (WaitingObjects) { - _waitingObjects.RemoveAll(x => x.Object == Object); + WaitingObjects.RemoveAll(x => x.Object == Object); } } private void WaitAndCheckScheduledObjects() { - using (_waitEvent = new AutoResetEvent(false)) + using (WaitEvent = new AutoResetEvent(false)) { - while (_keepRunning) + while (KeepRunning) { - WaitingObject next; + WaitingObject Next; - lock (_waitingObjects) + lock (WaitingObjects) { - next = _waitingObjects.OrderBy(x => x.TimePoint).FirstOrDefault(); + Next = WaitingObjects.OrderBy(x => x.TimePoint).FirstOrDefault(); } - if (next != null) + if (Next != null) { - long timePoint = PerformanceCounter.ElapsedMilliseconds; + long TimePoint = PerformanceCounter.ElapsedMilliseconds; - if (next.TimePoint > timePoint) + if (Next.TimePoint > TimePoint) { - _waitEvent.WaitOne((int)(next.TimePoint - timePoint)); + WaitEvent.WaitOne((int)(Next.TimePoint - TimePoint)); } - bool timeUp = PerformanceCounter.ElapsedMilliseconds >= next.TimePoint; + bool TimeUp = PerformanceCounter.ElapsedMilliseconds >= Next.TimePoint; - if (timeUp) + if (TimeUp) { - lock (_waitingObjects) + lock (WaitingObjects) { - timeUp = _waitingObjects.Remove(next); + TimeUp = WaitingObjects.Remove(Next); } } - if (timeUp) + if (TimeUp) { - next.Object.TimeUp(); + Next.Object.TimeUp(); } } else { - _waitEvent.WaitOne(); + WaitEvent.WaitOne(); } } } @@ -130,13 +130,13 @@ namespace Ryujinx.HLE.HOS.Kernel Dispose(true); } - protected virtual void Dispose(bool disposing) + protected virtual void Dispose(bool Disposing) { - if (disposing) + if (Disposing) { - _keepRunning = false; + KeepRunning = false; - _waitEvent?.Set(); + WaitEvent?.Set(); } } } diff --git a/Ryujinx.HLE/HOS/Kernel/KTlsPageInfo.cs b/Ryujinx.HLE/HOS/Kernel/KTlsPageInfo.cs index aa0614e6..18dc2dec 100644 --- a/Ryujinx.HLE/HOS/Kernel/KTlsPageInfo.cs +++ b/Ryujinx.HLE/HOS/Kernel/KTlsPageInfo.cs @@ -4,70 +4,70 @@ namespace Ryujinx.HLE.HOS.Kernel { public const int TlsEntrySize = 0x200; - public ulong PageAddr { get; } + public ulong PageAddr { get; private set; } - private bool[] _isSlotFree; + private bool[] IsSlotFree; - public KTlsPageInfo(ulong pageAddress) + public KTlsPageInfo(ulong PageAddress) { - PageAddr = pageAddress; + this.PageAddr = PageAddress; - _isSlotFree = new bool[KMemoryManager.PageSize / TlsEntrySize]; + IsSlotFree = new bool[KMemoryManager.PageSize / TlsEntrySize]; - for (int index = 0; index < _isSlotFree.Length; index++) + for (int Index = 0; Index < IsSlotFree.Length; Index++) { - _isSlotFree[index] = true; + IsSlotFree[Index] = true; } } - public bool TryGetFreePage(out ulong address) + public bool TryGetFreePage(out ulong Address) { - address = PageAddr; + Address = PageAddr; - for (int index = 0; index < _isSlotFree.Length; index++) + for (int Index = 0; Index < IsSlotFree.Length; Index++) { - if (_isSlotFree[index]) + if (IsSlotFree[Index]) { - _isSlotFree[index] = false; + IsSlotFree[Index] = false; return true; } - address += TlsEntrySize; + Address += TlsEntrySize; } - address = 0; + Address = 0; return false; } public bool IsFull() { - bool hasFree = false; + bool HasFree = false; - for (int index = 0; index < _isSlotFree.Length; index++) + for (int Index = 0; Index < IsSlotFree.Length; Index++) { - hasFree |= _isSlotFree[index]; + HasFree |= IsSlotFree[Index]; } - return !hasFree; + return !HasFree; } public bool IsEmpty() { - bool allFree = true; + bool AllFree = true; - for (int index = 0; index < _isSlotFree.Length; index++) + for (int Index = 0; Index < IsSlotFree.Length; Index++) { - allFree &= _isSlotFree[index]; + AllFree &= IsSlotFree[Index]; } - return allFree; + return AllFree; } - public void FreeTlsSlot(ulong address) + public void FreeTlsSlot(ulong Address) { - _isSlotFree[(address - PageAddr) / TlsEntrySize] = true; + IsSlotFree[(Address - PageAddr) / TlsEntrySize] = true; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KTlsPageManager.cs b/Ryujinx.HLE/HOS/Kernel/KTlsPageManager.cs index 75f595eb..1fb2ce6a 100644 --- a/Ryujinx.HLE/HOS/Kernel/KTlsPageManager.cs +++ b/Ryujinx.HLE/HOS/Kernel/KTlsPageManager.cs @@ -6,55 +6,55 @@ namespace Ryujinx.HLE.HOS.Kernel { private const int TlsEntrySize = 0x200; - private long _pagePosition; + private long PagePosition; - private int _usedSlots; + private int UsedSlots; - private bool[] _slots; + private bool[] Slots; - public bool IsEmpty => _usedSlots == 0; - public bool IsFull => _usedSlots == _slots.Length; + public bool IsEmpty => UsedSlots == 0; + public bool IsFull => UsedSlots == Slots.Length; - public KTlsPageManager(long pagePosition) + public KTlsPageManager(long PagePosition) { - _pagePosition = pagePosition; + this.PagePosition = PagePosition; - _slots = new bool[KMemoryManager.PageSize / TlsEntrySize]; + Slots = new bool[KMemoryManager.PageSize / TlsEntrySize]; } - public bool TryGetFreeTlsAddr(out long position) + public bool TryGetFreeTlsAddr(out long Position) { - position = _pagePosition; + Position = PagePosition; - for (int index = 0; index < _slots.Length; index++) + for (int Index = 0; Index < Slots.Length; Index++) { - if (!_slots[index]) + if (!Slots[Index]) { - _slots[index] = true; + Slots[Index] = true; - _usedSlots++; + UsedSlots++; return true; } - position += TlsEntrySize; + Position += TlsEntrySize; } - position = 0; + Position = 0; return false; } - public void FreeTlsSlot(int slot) + public void FreeTlsSlot(int Slot) { - if ((uint)slot > _slots.Length) + if ((uint)Slot > Slots.Length) { - throw new ArgumentOutOfRangeException(nameof(slot)); + throw new ArgumentOutOfRangeException(nameof(Slot)); } - _slots[slot] = false; + Slots[Slot] = false; - _usedSlots--; + UsedSlots--; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KTransferMemory.cs b/Ryujinx.HLE/HOS/Kernel/KTransferMemory.cs index 7bdc66e3..5598f78d 100644 --- a/Ryujinx.HLE/HOS/Kernel/KTransferMemory.cs +++ b/Ryujinx.HLE/HOS/Kernel/KTransferMemory.cs @@ -2,13 +2,13 @@ namespace Ryujinx.HLE.HOS.Kernel { class KTransferMemory { - public ulong Address { get; } - public ulong Size { get; } + public ulong Address { get; private set; } + public ulong Size { get; private set; } - public KTransferMemory(ulong address, ulong size) + public KTransferMemory(ulong Address, ulong Size) { - Address = address; - Size = size; + this.Address = Address; + this.Size = Size; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KWritableEvent.cs b/Ryujinx.HLE/HOS/Kernel/KWritableEvent.cs index 4d56a92d..1721ed00 100644 --- a/Ryujinx.HLE/HOS/Kernel/KWritableEvent.cs +++ b/Ryujinx.HLE/HOS/Kernel/KWritableEvent.cs @@ -2,21 +2,21 @@ namespace Ryujinx.HLE.HOS.Kernel { class KWritableEvent { - private KEvent _parent; + private KEvent Parent; - public KWritableEvent(KEvent parent) + public KWritableEvent(KEvent Parent) { - _parent = parent; + this.Parent = Parent; } public void Signal() { - _parent.ReadableEvent.Signal(); + Parent.ReadableEvent.Signal(); } public KernelResult Clear() { - return _parent.ReadableEvent.Clear(); + return Parent.ReadableEvent.Clear(); } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KernelInit.cs b/Ryujinx.HLE/HOS/Kernel/KernelInit.cs index a797951b..efb514c1 100644 --- a/Ryujinx.HLE/HOS/Kernel/KernelInit.cs +++ b/Ryujinx.HLE/HOS/Kernel/KernelInit.cs @@ -4,28 +4,28 @@ namespace Ryujinx.HLE.HOS.Kernel { static class KernelInit { - public static void InitializeResourceLimit(KResourceLimit resourceLimit) + public static void InitializeResourceLimit(KResourceLimit ResourceLimit) { - void EnsureSuccess(KernelResult result) + void EnsureSuccess(KernelResult Result) { - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - throw new InvalidOperationException($"Unexpected result \"{result}\"."); + throw new InvalidOperationException($"Unexpected result \"{Result}\"."); } } - int kernelMemoryCfg = 0; + int KernelMemoryCfg = 0; - long ramSize = GetRamSize(kernelMemoryCfg); + 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)); + 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)) + if (!ResourceLimit.Reserve(LimitableResource.Memory, 0) || + !ResourceLimit.Reserve(LimitableResource.Memory, 0x60000)) { throw new InvalidOperationException("Unexpected failure reserving memory on resource limit."); } @@ -33,99 +33,99 @@ namespace Ryujinx.HLE.HOS.Kernel public static KMemoryRegionManager[] GetMemoryRegions() { - KMemoryArrange arrange = GetMemoryArrange(); + KMemoryArrange Arrange = GetMemoryArrange(); return new KMemoryRegionManager[] { - GetMemoryRegion(arrange.Application), - GetMemoryRegion(arrange.Applet), - GetMemoryRegion(arrange.Service), - GetMemoryRegion(arrange.NvServices) + GetMemoryRegion(Arrange.Application), + GetMemoryRegion(Arrange.Applet), + GetMemoryRegion(Arrange.Service), + GetMemoryRegion(Arrange.NvServices) }; } - private static KMemoryRegionManager GetMemoryRegion(KMemoryArrangeRegion region) + private static KMemoryRegionManager GetMemoryRegion(KMemoryArrangeRegion Region) { - return new KMemoryRegionManager(region.Address, region.Size, region.EndAddr); + return new KMemoryRegionManager(Region.Address, Region.Size, Region.EndAddr); } private static KMemoryArrange GetMemoryArrange() { - int mcEmemCfg = 0x1000; + int McEmemCfg = 0x1000; - ulong ememApertureSize = (ulong)(mcEmemCfg & 0x3fff) << 20; + ulong EmemApertureSize = (ulong)(McEmemCfg & 0x3fff) << 20; - int kernelMemoryCfg = 0; + int KernelMemoryCfg = 0; - ulong ramSize = (ulong)GetRamSize(kernelMemoryCfg); + ulong RamSize = (ulong)GetRamSize(KernelMemoryCfg); - ulong ramPart0; - ulong ramPart1; + ulong RamPart0; + ulong RamPart1; - if (ramSize * 2 > ememApertureSize) + if (RamSize * 2 > EmemApertureSize) { - ramPart0 = ememApertureSize / 2; - ramPart1 = ememApertureSize / 2; + RamPart0 = EmemApertureSize / 2; + RamPart1 = EmemApertureSize / 2; } else { - ramPart0 = ememApertureSize; - ramPart1 = 0; + RamPart0 = EmemApertureSize; + RamPart1 = 0; } - int memoryArrange = 1; + int MemoryArrange = 1; - ulong applicationRgSize; + ulong ApplicationRgSize; - switch (memoryArrange) + switch (MemoryArrange) { - case 2: applicationRgSize = 0x80000000; break; + case 2: ApplicationRgSize = 0x80000000; break; case 0x11: - case 0x21: applicationRgSize = 0x133400000; break; - default: applicationRgSize = 0xcd500000; break; + case 0x21: ApplicationRgSize = 0x133400000; break; + default: ApplicationRgSize = 0xcd500000; break; } - ulong appletRgSize; + ulong AppletRgSize; - switch (memoryArrange) + switch (MemoryArrange) { - case 2: appletRgSize = 0x61200000; break; - case 3: appletRgSize = 0x1c000000; break; - case 0x11: appletRgSize = 0x23200000; break; + 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; + case 0x21: AppletRgSize = 0x89100000; break; + default: AppletRgSize = 0x1fb00000; break; } - KMemoryArrangeRegion serviceRg; - KMemoryArrangeRegion nvServicesRg; - KMemoryArrangeRegion appletRg; - KMemoryArrangeRegion applicationRg; + KMemoryArrangeRegion ServiceRg; + KMemoryArrangeRegion NvServicesRg; + KMemoryArrangeRegion AppletRg; + KMemoryArrangeRegion ApplicationRg; - const ulong nvServicesRgSize = 0x29ba000; + const ulong NvServicesRgSize = 0x29ba000; - ulong applicationRgEnd = DramMemoryMap.DramEnd; //- RamPart0; + ulong ApplicationRgEnd = DramMemoryMap.DramEnd; //- RamPart0; - applicationRg = new KMemoryArrangeRegion(applicationRgEnd - applicationRgSize, applicationRgSize); + ApplicationRg = new KMemoryArrangeRegion(ApplicationRgEnd - ApplicationRgSize, ApplicationRgSize); - ulong nvServicesRgEnd = applicationRg.Address - appletRgSize; + ulong NvServicesRgEnd = ApplicationRg.Address - AppletRgSize; - nvServicesRg = new KMemoryArrangeRegion(nvServicesRgEnd - nvServicesRgSize, nvServicesRgSize); - appletRg = new KMemoryArrangeRegion(nvServicesRgEnd, 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; + ulong ServiceRgSize = NvServicesRg.Address - DramMemoryMap.SlabHeapEnd; - serviceRg = new KMemoryArrangeRegion(DramMemoryMap.SlabHeapEnd, serviceRgSize); + ServiceRg = new KMemoryArrangeRegion(DramMemoryMap.SlabHeapEnd, ServiceRgSize); - return new KMemoryArrange(serviceRg, nvServicesRg, appletRg, applicationRg); + return new KMemoryArrange(ServiceRg, NvServicesRg, AppletRg, ApplicationRg); } - private static long GetRamSize(int kernelMemoryCfg) + private static long GetRamSize(int KernelMemoryCfg) { - switch ((kernelMemoryCfg >> 16) & 3) + switch ((KernelMemoryCfg >> 16) & 3) { case 1: return 0x180000000; case 2: return 0x200000000; diff --git a/Ryujinx.HLE/HOS/Kernel/KernelTransfer.cs b/Ryujinx.HLE/HOS/Kernel/KernelTransfer.cs index c0ce72c0..a3fabeae 100644 --- a/Ryujinx.HLE/HOS/Kernel/KernelTransfer.cs +++ b/Ryujinx.HLE/HOS/Kernel/KernelTransfer.cs @@ -4,48 +4,48 @@ namespace Ryujinx.HLE.HOS.Kernel { static class KernelTransfer { - public static bool UserToKernelInt32(Horizon system, long address, out int value) + public static bool UserToKernelInt32(Horizon System, long Address, out int Value) { - KProcess currentProcess = system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - if (currentProcess.CpuMemory.IsMapped(address) && - currentProcess.CpuMemory.IsMapped(address + 3)) + if (CurrentProcess.CpuMemory.IsMapped(Address) && + CurrentProcess.CpuMemory.IsMapped(Address + 3)) { - value = currentProcess.CpuMemory.ReadInt32(address); + Value = CurrentProcess.CpuMemory.ReadInt32(Address); return true; } - value = 0; + Value = 0; return false; } - public static bool UserToKernelString(Horizon system, long address, int size, out string value) + public static bool UserToKernelString(Horizon System, long Address, int Size, out string Value) { - KProcess currentProcess = system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - if (currentProcess.CpuMemory.IsMapped(address) && - currentProcess.CpuMemory.IsMapped(address + size - 1)) + if (CurrentProcess.CpuMemory.IsMapped(Address) && + CurrentProcess.CpuMemory.IsMapped(Address + Size - 1)) { - value = MemoryHelper.ReadAsciiString(currentProcess.CpuMemory, address, size); + Value = MemoryHelper.ReadAsciiString(CurrentProcess.CpuMemory, Address, Size); return true; } - value = null; + Value = null; return false; } - public static bool KernelToUserInt32(Horizon system, long address, int value) + public static bool KernelToUserInt32(Horizon System, long Address, int Value) { - KProcess currentProcess = system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - if (currentProcess.CpuMemory.IsMapped(address) && - currentProcess.CpuMemory.IsMapped(address + 3)) + if (CurrentProcess.CpuMemory.IsMapped(Address) && + CurrentProcess.CpuMemory.IsMapped(Address + 3)) { - currentProcess.CpuMemory.WriteInt32ToSharedAddr(address, value); + CurrentProcess.CpuMemory.WriteInt32ToSharedAddr(Address, Value); return true; } @@ -53,14 +53,14 @@ namespace Ryujinx.HLE.HOS.Kernel return false; } - public static bool KernelToUserInt64(Horizon system, long address, long value) + public static bool KernelToUserInt64(Horizon System, long Address, long Value) { - KProcess currentProcess = system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - if (currentProcess.CpuMemory.IsMapped(address) && - currentProcess.CpuMemory.IsMapped(address + 7)) + if (CurrentProcess.CpuMemory.IsMapped(Address) && + CurrentProcess.CpuMemory.IsMapped(Address + 7)) { - currentProcess.CpuMemory.WriteInt64(address, value); + CurrentProcess.CpuMemory.WriteInt64(Address, Value); return true; } diff --git a/Ryujinx.HLE/HOS/Kernel/MersenneTwister.cs b/Ryujinx.HLE/HOS/Kernel/MersenneTwister.cs index 5307bdc9..b90d54d2 100644 --- a/Ryujinx.HLE/HOS/Kernel/MersenneTwister.cs +++ b/Ryujinx.HLE/HOS/Kernel/MersenneTwister.cs @@ -4,125 +4,125 @@ namespace Ryujinx.HLE.HOS.Kernel { class MersenneTwister { - private int _index; - private uint[] _mt; + private int Index; + private uint[] Mt; - public MersenneTwister(uint seed) + public MersenneTwister(uint Seed) { - _mt = new uint[624]; + Mt = new uint[624]; - _mt[0] = seed; + Mt[0] = Seed; - for (int mtIdx = 1; mtIdx < _mt.Length; mtIdx++) + for (int MtIdx = 1; MtIdx < Mt.Length; MtIdx++) { - uint prev = _mt[mtIdx - 1]; + uint Prev = Mt[MtIdx - 1]; - _mt[mtIdx] = (uint)(0x6c078965 * (prev ^ (prev >> 30)) + mtIdx); + Mt[MtIdx] = (uint)(0x6c078965 * (Prev ^ (Prev >> 30)) + MtIdx); } - _index = _mt.Length; + Index = Mt.Length; } - public long GenRandomNumber(long min, long max) + public long GenRandomNumber(long Min, long Max) { - long range = max - min; + long Range = Max - Min; - if (min == max) + if (Min == Max) { - return min; + return Min; } - if (range == -1) + if (Range == -1) { //Increment would cause a overflow, special case. return GenRandomNumber(2, 2, 32, 0xffffffffu, 0xffffffffu); } - range++; + Range++; //This is log2(Range) plus one. - int nextRangeLog2 = 64 - BitUtils.CountLeadingZeros64(range); + 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 RangeLog2 = NextRangeLog2 - (BitUtils.IsPowerOfTwo64(Range) ? 1 : 0); - int parts = rangeLog2 > 32 ? 2 : 1; - int bitsPerPart = rangeLog2 / parts; + int Parts = RangeLog2 > 32 ? 2 : 1; + int BitsPerPart = RangeLog2 / Parts; - int fullParts = parts - (rangeLog2 - parts * bitsPerPart); + int FullParts = Parts - (RangeLog2 - Parts * BitsPerPart); - uint mask = 0xffffffffu >> (32 - bitsPerPart); - uint maskPlus1 = 0xffffffffu >> (31 - bitsPerPart); + uint Mask = 0xffffffffu >> (32 - BitsPerPart); + uint MaskPlus1 = 0xffffffffu >> (31 - BitsPerPart); - long randomNumber; + long RandomNumber; do { - randomNumber = GenRandomNumber(parts, fullParts, bitsPerPart, mask, maskPlus1); + RandomNumber = GenRandomNumber(Parts, FullParts, BitsPerPart, Mask, MaskPlus1); } - while ((ulong)randomNumber >= (ulong)range); + while ((ulong)RandomNumber >= (ulong)Range); - return min + randomNumber; + return Min + RandomNumber; } private long GenRandomNumber( - int parts, - int fullParts, - int bitsPerPart, - uint mask, - uint maskPlus1) + int Parts, + int FullParts, + int BitsPerPart, + uint Mask, + uint MaskPlus1) { - long randomNumber = 0; + long RandomNumber = 0; - int part = 0; + int Part = 0; - for (; part < fullParts; part++) + for (; Part < FullParts; Part++) { - randomNumber <<= bitsPerPart; - randomNumber |= GenRandomNumber() & mask; + RandomNumber <<= BitsPerPart; + RandomNumber |= GenRandomNumber() & Mask; } - for (; part < parts; part++) + for (; Part < Parts; Part++) { - randomNumber <<= bitsPerPart + 1; - randomNumber |= GenRandomNumber() & maskPlus1; + RandomNumber <<= BitsPerPart + 1; + RandomNumber |= GenRandomNumber() & MaskPlus1; } - return randomNumber; + return RandomNumber; } private uint GenRandomNumber() { - if (_index >= _mt.Length) + if (Index >= Mt.Length) { Twist(); } - uint value = _mt[_index++]; + uint Value = Mt[Index++]; - value ^= value >> 11; - value ^= (value << 7) & 0x9d2c5680; - value ^= (value << 15) & 0xefc60000; - value ^= value >> 18; + Value ^= Value >> 11; + Value ^= (Value << 7) & 0x9d2c5680; + Value ^= (Value << 15) & 0xefc60000; + Value ^= Value >> 18; - return value; + return Value; } private void Twist() { - for (int mtIdx = 0; mtIdx < _mt.Length; mtIdx++) + for (int MtIdx = 0; MtIdx < Mt.Length; MtIdx++) { - uint value = (_mt[mtIdx] & 0x80000000) + (_mt[(mtIdx + 1) % _mt.Length] & 0x7fffffff); + uint Value = (Mt[MtIdx] & 0x80000000) + (Mt[(MtIdx + 1) % Mt.Length] & 0x7fffffff); - _mt[mtIdx] = _mt[(mtIdx + 397) % _mt.Length] ^ (value >> 1); + Mt[MtIdx] = Mt[(MtIdx + 397) % Mt.Length] ^ (Value >> 1); - if ((value & 1) != 0) + if ((Value & 1) != 0) { - _mt[mtIdx] ^= 0x9908b0df; + Mt[MtIdx] ^= 0x9908b0df; } } - _index = 0; + Index = 0; } } } diff --git a/Ryujinx.HLE/HOS/Kernel/ProcessCreationInfo.cs b/Ryujinx.HLE/HOS/Kernel/ProcessCreationInfo.cs index 37f33f28..dae1345a 100644 --- a/Ryujinx.HLE/HOS/Kernel/ProcessCreationInfo.cs +++ b/Ryujinx.HLE/HOS/Kernel/ProcessCreationInfo.cs @@ -2,36 +2,36 @@ namespace Ryujinx.HLE.HOS.Kernel { struct ProcessCreationInfo { - public string Name { get; } + public string Name { get; private set; } - public int Category { get; } - public long TitleId { get; } + public int Category { get; private set; } + public long TitleId { get; private set; } - public ulong CodeAddress { get; } - public int CodePagesCount { get; } + public ulong CodeAddress { get; private set; } + public int CodePagesCount { get; private set; } - public int MmuFlags { get; } - public int ResourceLimitHandle { get; } - public int PersonalMmHeapPagesCount { get; } + 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) + string Name, + int Category, + long TitleId, + ulong CodeAddress, + int CodePagesCount, + int MmuFlags, + int ResourceLimitHandle, + int PersonalMmHeapPagesCount) { - Name = name; - Category = category; - TitleId = titleId; - CodeAddress = codeAddress; - CodePagesCount = codePagesCount; - MmuFlags = mmuFlags; - ResourceLimitHandle = resourceLimitHandle; - PersonalMmHeapPagesCount = 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; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/SvcHandler.cs b/Ryujinx.HLE/HOS/Kernel/SvcHandler.cs index 61408780..cbc5e31c 100644 --- a/Ryujinx.HLE/HOS/Kernel/SvcHandler.cs +++ b/Ryujinx.HLE/HOS/Kernel/SvcHandler.cs @@ -10,38 +10,38 @@ namespace Ryujinx.HLE.HOS.Kernel { partial class SvcHandler { - private delegate void SvcFunc(CpuThreadState threadState); + private delegate void SvcFunc(CpuThreadState ThreadState); - private Dictionary<int, SvcFunc> _svcFuncs; + private Dictionary<int, SvcFunc> SvcFuncs; - private Switch _device; - private KProcess _process; - private Horizon _system; - private MemoryManager _memory; + private Switch Device; + private KProcess Process; + private Horizon System; + private MemoryManager Memory; private struct HleIpcMessage { - public KThread Thread { get; } - public KSession Session { get; } - public IpcMessage Message { get; } - public long MessagePtr { get; } + public KThread Thread { get; private set; } + public KSession Session { get; private set; } + public IpcMessage Message { get; private set; } + public long MessagePtr { get; private set; } public HleIpcMessage( - KThread thread, - KSession session, - IpcMessage message, - long messagePtr) + KThread Thread, + KSession Session, + IpcMessage Message, + long MessagePtr) { - Thread = thread; - Session = session; - Message = message; - MessagePtr = messagePtr; + this.Thread = Thread; + this.Session = Session; + this.Message = Message; + this.MessagePtr = MessagePtr; } } - public SvcHandler(Switch device, KProcess process) + public SvcHandler(Switch Device, KProcess Process) { - _svcFuncs = new Dictionary<int, SvcFunc> + SvcFuncs = new Dictionary<int, SvcFunc>() { { 0x01, SvcSetHeapSize }, { 0x03, SvcSetMemoryAttribute }, @@ -93,23 +93,23 @@ namespace Ryujinx.HLE.HOS.Kernel { 0x71, ManageNamedPort64 } }; - _device = device; - _process = process; - _system = device.System; - _memory = process.CpuMemory; + this.Device = Device; + this.Process = Process; + this.System = Device.System; + this.Memory = Process.CpuMemory; } public void SvcCall(object sender, InstExceptionEventArgs e) { - CpuThreadState threadState = (CpuThreadState)sender; + CpuThreadState ThreadState = (CpuThreadState)sender; - if (_svcFuncs.TryGetValue(e.Id, out SvcFunc func)) + if (SvcFuncs.TryGetValue(e.Id, out SvcFunc Func)) { - Logger.PrintDebug(LogClass.KernelSvc, $"{func.Method.Name} called."); + Logger.PrintDebug(LogClass.KernelSvc, $"{Func.Method.Name} called."); - func(threadState); + Func(ThreadState); - Logger.PrintDebug(LogClass.KernelSvc, $"{func.Method.Name} ended."); + Logger.PrintDebug(LogClass.KernelSvc, $"{Func.Method.Name} ended."); } else { diff --git a/Ryujinx.HLE/HOS/Kernel/SvcMemory.cs b/Ryujinx.HLE/HOS/Kernel/SvcMemory.cs index c99c1e98..b5845f0b 100644 --- a/Ryujinx.HLE/HOS/Kernel/SvcMemory.cs +++ b/Ryujinx.HLE/HOS/Kernel/SvcMemory.cs @@ -7,575 +7,575 @@ namespace Ryujinx.HLE.HOS.Kernel { partial class SvcHandler { - private void SvcSetHeapSize(CpuThreadState threadState) + private void SvcSetHeapSize(CpuThreadState ThreadState) { - ulong size = threadState.X1; + ulong Size = ThreadState.X1; - if ((size & 0xfffffffe001fffff) != 0) + if ((Size & 0xfffffffe001fffff) != 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Heap size 0x{size:x16} is not aligned!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Heap size 0x{Size:x16} is not aligned!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); return; } - KernelResult result = _process.MemoryManager.SetHeapSize(size, out ulong position); + KernelResult Result = Process.MemoryManager.SetHeapSize(Size, out ulong Position); - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; - if (result == KernelResult.Success) + if (Result == KernelResult.Success) { - threadState.X1 = position; + ThreadState.X1 = Position; } else { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{result}\"."); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{Result}\"."); } } - private void SvcSetMemoryAttribute(CpuThreadState threadState) + private void SvcSetMemoryAttribute(CpuThreadState ThreadState) { - ulong position = threadState.X0; - ulong size = threadState.X1; + ulong Position = ThreadState.X0; + ulong Size = ThreadState.X1; - if (!PageAligned(position)) + if (!PageAligned(Position)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{position:x16} is not page aligned!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Position:x16} is not page aligned!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); return; } - if (!PageAligned(size) || size == 0) + if (!PageAligned(Size) || Size == 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{Size:x16} is not page aligned or is zero!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); return; } - MemoryAttribute attributeMask = (MemoryAttribute)threadState.X2; - MemoryAttribute attributeValue = (MemoryAttribute)threadState.X3; + MemoryAttribute AttributeMask = (MemoryAttribute)ThreadState.X2; + MemoryAttribute AttributeValue = (MemoryAttribute)ThreadState.X3; - MemoryAttribute attributes = attributeMask | attributeValue; + MemoryAttribute Attributes = AttributeMask | AttributeValue; - if (attributes != attributeMask || - (attributes | MemoryAttribute.Uncached) != MemoryAttribute.Uncached) + if (Attributes != AttributeMask || + (Attributes | MemoryAttribute.Uncached) != MemoryAttribute.Uncached) { Logger.PrintWarning(LogClass.KernelSvc, "Invalid memory attributes!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMaskValue); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMaskValue); return; } - KernelResult result = _process.MemoryManager.SetMemoryAttribute( - position, - size, - attributeMask, - attributeValue); + KernelResult Result = Process.MemoryManager.SetMemoryAttribute( + Position, + Size, + AttributeMask, + AttributeValue); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{result}\"."); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{Result}\"."); } else { - _memory.StopObservingRegion((long)position, (long)size); + Memory.StopObservingRegion((long)Position, (long)Size); } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } - private void SvcMapMemory(CpuThreadState threadState) + private void SvcMapMemory(CpuThreadState ThreadState) { - ulong dst = threadState.X0; - ulong src = threadState.X1; - ulong size = threadState.X2; + ulong Dst = ThreadState.X0; + ulong Src = ThreadState.X1; + ulong Size = ThreadState.X2; - if (!PageAligned(src | dst)) + if (!PageAligned(Src | Dst)) { Logger.PrintWarning(LogClass.KernelSvc, "Addresses are not page aligned!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); return; } - if (!PageAligned(size) || size == 0) + if (!PageAligned(Size) || Size == 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{Size:x16} is not page aligned or is zero!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); return; } - if (src + size <= src || dst + size <= dst) + if (Src + Size <= Src || Dst + Size <= Dst) { Logger.PrintWarning(LogClass.KernelSvc, "Addresses outside of range!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - if (!currentProcess.MemoryManager.InsideAddrSpace(src, size)) + if (!CurrentProcess.MemoryManager.InsideAddrSpace(Src, Size)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Src address 0x{src:x16} out of range!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Src address 0x{Src:x16} out of range!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - if (currentProcess.MemoryManager.OutsideStackRegion(dst, size) || - currentProcess.MemoryManager.InsideHeapRegion (dst, size) || - currentProcess.MemoryManager.InsideAliasRegion (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!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Dst address 0x{Dst:x16} out of range!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMemRange); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMemRange); return; } - KernelResult result = _process.MemoryManager.Map(dst, src, size); + KernelResult Result = Process.MemoryManager.Map(Dst, Src, Size); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!"); } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } - private void SvcUnmapMemory(CpuThreadState threadState) + private void SvcUnmapMemory(CpuThreadState ThreadState) { - ulong dst = threadState.X0; - ulong src = threadState.X1; - ulong size = threadState.X2; + ulong Dst = ThreadState.X0; + ulong Src = ThreadState.X1; + ulong Size = ThreadState.X2; - if (!PageAligned(src | dst)) + if (!PageAligned(Src | Dst)) { Logger.PrintWarning(LogClass.KernelSvc, "Addresses are not page aligned!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); return; } - if (!PageAligned(size) || size == 0) + if (!PageAligned(Size) || Size == 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{Size:x16} is not page aligned or is zero!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); return; } - if (src + size <= src || dst + size <= dst) + if (Src + Size <= Src || Dst + Size <= Dst) { Logger.PrintWarning(LogClass.KernelSvc, "Addresses outside of range!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - if (!currentProcess.MemoryManager.InsideAddrSpace(src, size)) + if (!CurrentProcess.MemoryManager.InsideAddrSpace(Src, Size)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Src address 0x{src:x16} out of range!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Src address 0x{Src:x16} out of range!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - if (currentProcess.MemoryManager.OutsideStackRegion(dst, size) || - currentProcess.MemoryManager.InsideHeapRegion (dst, size) || - currentProcess.MemoryManager.InsideAliasRegion (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!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Dst address 0x{Dst:x16} out of range!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMemRange); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidMemRange); return; } - KernelResult result = _process.MemoryManager.Unmap(dst, src, size); + KernelResult Result = Process.MemoryManager.Unmap(Dst, Src, Size); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!"); } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } - private void SvcQueryMemory(CpuThreadState threadState) + private void SvcQueryMemory(CpuThreadState ThreadState) { - long infoPtr = (long)threadState.X0; - ulong position = threadState.X2; - - KMemoryInfo blkInfo = _process.MemoryManager.QueryMemory(position); - - _memory.WriteUInt64(infoPtr + 0x00, blkInfo.Address); - _memory.WriteUInt64(infoPtr + 0x08, blkInfo.Size); - _memory.WriteInt32 (infoPtr + 0x10, (int)blkInfo.State & 0xff); - _memory.WriteInt32 (infoPtr + 0x14, (int)blkInfo.Attribute); - _memory.WriteInt32 (infoPtr + 0x18, (int)blkInfo.Permission); - _memory.WriteInt32 (infoPtr + 0x1c, blkInfo.IpcRefCount); - _memory.WriteInt32 (infoPtr + 0x20, blkInfo.DeviceRefCount); - _memory.WriteInt32 (infoPtr + 0x24, 0); - - threadState.X0 = 0; - threadState.X1 = 0; + long InfoPtr = (long)ThreadState.X0; + ulong Position = ThreadState.X2; + + KMemoryInfo BlkInfo = Process.MemoryManager.QueryMemory(Position); + + Memory.WriteUInt64(InfoPtr + 0x00, BlkInfo.Address); + Memory.WriteUInt64(InfoPtr + 0x08, BlkInfo.Size); + Memory.WriteInt32 (InfoPtr + 0x10, (int)BlkInfo.State & 0xff); + Memory.WriteInt32 (InfoPtr + 0x14, (int)BlkInfo.Attribute); + Memory.WriteInt32 (InfoPtr + 0x18, (int)BlkInfo.Permission); + Memory.WriteInt32 (InfoPtr + 0x1c, BlkInfo.IpcRefCount); + Memory.WriteInt32 (InfoPtr + 0x20, BlkInfo.DeviceRefCount); + Memory.WriteInt32 (InfoPtr + 0x24, 0); + + ThreadState.X0 = 0; + ThreadState.X1 = 0; } - private void SvcMapSharedMemory(CpuThreadState threadState) + private void SvcMapSharedMemory(CpuThreadState ThreadState) { - int handle = (int)threadState.X0; - ulong address = threadState.X1; - ulong size = threadState.X2; + int Handle = (int)ThreadState.X0; + ulong Address = ThreadState.X1; + ulong Size = ThreadState.X2; - if (!PageAligned(address)) + if (!PageAligned(Address)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{address:x16} is not page aligned!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} is not page aligned!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); return; } - if (!PageAligned(size) || size == 0) + if (!PageAligned(Size) || Size == 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{Size:x16} is not page aligned or is zero!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); return; } - if (address + size <= address) + if (Address + Size <= Address) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{address: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); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - MemoryPermission permission = (MemoryPermission)threadState.X3; + MemoryPermission Permission = (MemoryPermission)ThreadState.X3; - if ((permission | MemoryPermission.Write) != MemoryPermission.ReadAndWrite) + if ((Permission | MemoryPermission.Write) != MemoryPermission.ReadAndWrite) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid permission {permission}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid permission {Permission}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidPermission); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidPermission); return; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - KSharedMemory sharedMemory = currentProcess.HandleTable.GetObject<KSharedMemory>(handle); + KSharedMemory SharedMemory = CurrentProcess.HandleTable.GetObject<KSharedMemory>(Handle); - if (sharedMemory == null) + if (SharedMemory == null) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid shared memory handle 0x{handle:x8}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid shared memory handle 0x{Handle:x8}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); return; } - if (currentProcess.MemoryManager.IsInvalidRegion (address, size) || - currentProcess.MemoryManager.InsideHeapRegion (address, size) || - currentProcess.MemoryManager.InsideAliasRegion(address, size)) + if (CurrentProcess.MemoryManager.IsInvalidRegion (Address, Size) || + CurrentProcess.MemoryManager.InsideHeapRegion (Address, Size) || + CurrentProcess.MemoryManager.InsideAliasRegion(Address, Size)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{address:x16} out of range!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} out of range!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - KernelResult result = sharedMemory.MapIntoProcess( - currentProcess.MemoryManager, - address, - size, - currentProcess, - permission); + KernelResult Result = SharedMemory.MapIntoProcess( + CurrentProcess.MemoryManager, + Address, + Size, + CurrentProcess, + Permission); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{result}\"."); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{Result}\"."); } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } - private void SvcUnmapSharedMemory(CpuThreadState threadState) + private void SvcUnmapSharedMemory(CpuThreadState ThreadState) { - int handle = (int)threadState.X0; - ulong address = threadState.X1; - ulong size = threadState.X2; + int Handle = (int)ThreadState.X0; + ulong Address = ThreadState.X1; + ulong Size = ThreadState.X2; - if (!PageAligned(address)) + if (!PageAligned(Address)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{address:x16} is not page aligned!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} is not page aligned!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); return; } - if (!PageAligned(size) || size == 0) + if (!PageAligned(Size) || Size == 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{Size:x16} is not page aligned or is zero!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); return; } - if (address + size <= address) + if (Address + Size <= Address) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{address: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); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - KSharedMemory sharedMemory = currentProcess.HandleTable.GetObject<KSharedMemory>(handle); + KSharedMemory SharedMemory = CurrentProcess.HandleTable.GetObject<KSharedMemory>(Handle); - if (sharedMemory == null) + if (SharedMemory == null) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid shared memory handle 0x{handle:x8}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid shared memory handle 0x{Handle:x8}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); return; } - if (currentProcess.MemoryManager.IsInvalidRegion (address, size) || - currentProcess.MemoryManager.InsideHeapRegion (address, size) || - currentProcess.MemoryManager.InsideAliasRegion(address, size)) + if (CurrentProcess.MemoryManager.IsInvalidRegion (Address, Size) || + CurrentProcess.MemoryManager.InsideHeapRegion (Address, Size) || + CurrentProcess.MemoryManager.InsideAliasRegion(Address, Size)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{address:x16} out of range!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} out of range!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - KernelResult result = sharedMemory.UnmapFromProcess( - currentProcess.MemoryManager, - address, - size, - currentProcess); + KernelResult Result = SharedMemory.UnmapFromProcess( + CurrentProcess.MemoryManager, + Address, + Size, + CurrentProcess); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{result}\"."); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{Result}\"."); } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } - private void SvcCreateTransferMemory(CpuThreadState threadState) + private void SvcCreateTransferMemory(CpuThreadState ThreadState) { - ulong address = threadState.X1; - ulong size = threadState.X2; + ulong Address = ThreadState.X1; + ulong Size = ThreadState.X2; - if (!PageAligned(address)) + if (!PageAligned(Address)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{address:x16} is not page aligned!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} is not page aligned!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); return; } - if (!PageAligned(size) || size == 0) + if (!PageAligned(Size) || Size == 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{Size:x16} is not page aligned or is zero!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); return; } - if (address + size <= address) + if (Address + Size <= Address) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{address: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); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - MemoryPermission permission = (MemoryPermission)threadState.X3; + MemoryPermission Permission = (MemoryPermission)ThreadState.X3; - if (permission > MemoryPermission.ReadAndWrite || permission == MemoryPermission.Write) + if (Permission > MemoryPermission.ReadAndWrite || Permission == MemoryPermission.Write) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid permission {permission}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid permission {Permission}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidPermission); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidPermission); return; } - _process.MemoryManager.ReserveTransferMemory(address, size, permission); + Process.MemoryManager.ReserveTransferMemory(Address, Size, Permission); - KTransferMemory transferMemory = new KTransferMemory(address, size); + KTransferMemory TransferMemory = new KTransferMemory(Address, Size); - KernelResult result = _process.HandleTable.GenerateHandle(transferMemory, out int handle); + KernelResult Result = Process.HandleTable.GenerateHandle(TransferMemory, out int Handle); - threadState.X0 = (uint)result; - threadState.X1 = (ulong)handle; + ThreadState.X0 = (uint)Result; + ThreadState.X1 = (ulong)Handle; } - private void SvcMapPhysicalMemory(CpuThreadState threadState) + private void SvcMapPhysicalMemory(CpuThreadState ThreadState) { - ulong address = threadState.X0; - ulong size = threadState.X1; + ulong Address = ThreadState.X0; + ulong Size = ThreadState.X1; - if (!PageAligned(address)) + if (!PageAligned(Address)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{address:x16} is not page aligned!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} is not page aligned!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); return; } - if (!PageAligned(size) || size == 0) + if (!PageAligned(Size) || Size == 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{Size:x16} is not page aligned or is zero!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); return; } - if (address + size <= address) + if (Address + Size <= Address) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{address: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); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - if ((currentProcess.PersonalMmHeapPagesCount & 0xfffffffffffff) == 0) + if ((CurrentProcess.PersonalMmHeapPagesCount & 0xfffffffffffff) == 0) { Logger.PrintWarning(LogClass.KernelSvc, $"System resource size is zero."); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidState); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidState); return; } - if (!currentProcess.MemoryManager.InsideAddrSpace (address, size) || - currentProcess.MemoryManager.OutsideAliasRegion(address, size)) + if (!CurrentProcess.MemoryManager.InsideAddrSpace (Address, Size) || + CurrentProcess.MemoryManager.OutsideAliasRegion(Address, Size)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address {address:x16}."); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address {Address:x16}."); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - KernelResult result = _process.MemoryManager.MapPhysicalMemory(address, size); + KernelResult Result = Process.MemoryManager.MapPhysicalMemory(Address, Size); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!"); } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } - private void SvcUnmapPhysicalMemory(CpuThreadState threadState) + private void SvcUnmapPhysicalMemory(CpuThreadState ThreadState) { - ulong address = threadState.X0; - ulong size = threadState.X1; + ulong Address = ThreadState.X0; + ulong Size = ThreadState.X1; - if (!PageAligned(address)) + if (!PageAligned(Address)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{address:x16} is not page aligned!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} is not page aligned!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); return; } - if (!PageAligned(size) || size == 0) + if (!PageAligned(Size) || Size == 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{size:x16} is not page aligned or is zero!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Size 0x{Size:x16} is not page aligned or is zero!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidSize); return; } - if (address + size <= address) + if (Address + Size <= Address) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{address: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); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - if ((currentProcess.PersonalMmHeapPagesCount & 0xfffffffffffff) == 0) + if ((CurrentProcess.PersonalMmHeapPagesCount & 0xfffffffffffff) == 0) { Logger.PrintWarning(LogClass.KernelSvc, $"System resource size is zero."); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidState); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidState); return; } - if (!currentProcess.MemoryManager.InsideAddrSpace (address, size) || - currentProcess.MemoryManager.OutsideAliasRegion(address, size)) + if (!CurrentProcess.MemoryManager.InsideAddrSpace (Address, Size) || + CurrentProcess.MemoryManager.OutsideAliasRegion(Address, Size)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address {address:x16}."); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address {Address:x16}."); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - KernelResult result = _process.MemoryManager.UnmapPhysicalMemory(address, size); + KernelResult Result = Process.MemoryManager.UnmapPhysicalMemory(Address, Size); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!"); } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } - private static bool PageAligned(ulong position) + private static bool PageAligned(ulong Position) { - return (position & (KMemoryManager.PageSize - 1)) == 0; + return (Position & (KMemoryManager.PageSize - 1)) == 0; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/SvcSystem.cs b/Ryujinx.HLE/HOS/Kernel/SvcSystem.cs index e42c2b4e..1c1d76f1 100644 --- a/Ryujinx.HLE/HOS/Kernel/SvcSystem.cs +++ b/Ryujinx.HLE/HOS/Kernel/SvcSystem.cs @@ -14,286 +14,286 @@ namespace Ryujinx.HLE.HOS.Kernel { partial class SvcHandler { - private void SvcExitProcess(CpuThreadState threadState) + private void SvcExitProcess(CpuThreadState ThreadState) { - _system.Scheduler.GetCurrentProcess().Terminate(); + System.Scheduler.GetCurrentProcess().Terminate(); } - private void SignalEvent64(CpuThreadState threadState) + private void SignalEvent64(CpuThreadState ThreadState) { - threadState.X0 = (ulong)SignalEvent((int)threadState.X0); + ThreadState.X0 = (ulong)SignalEvent((int)ThreadState.X0); } - private KernelResult SignalEvent(int handle) + private KernelResult SignalEvent(int Handle) { - KWritableEvent writableEvent = _process.HandleTable.GetObject<KWritableEvent>(handle); + KWritableEvent WritableEvent = Process.HandleTable.GetObject<KWritableEvent>(Handle); - KernelResult result; + KernelResult Result; - if (writableEvent != null) + if (WritableEvent != null) { - writableEvent.Signal(); + WritableEvent.Signal(); - result = KernelResult.Success; + Result = KernelResult.Success; } else { - result = KernelResult.InvalidHandle; + Result = KernelResult.InvalidHandle; } - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - Logger.PrintWarning(LogClass.KernelSvc, "Operation failed with error: " + result + "!"); + Logger.PrintWarning(LogClass.KernelSvc, "Operation failed with error: " + Result + "!"); } - return result; + return Result; } - private void ClearEvent64(CpuThreadState threadState) + private void ClearEvent64(CpuThreadState ThreadState) { - threadState.X0 = (ulong)ClearEvent((int)threadState.X0); + ThreadState.X0 = (ulong)ClearEvent((int)ThreadState.X0); } - private KernelResult ClearEvent(int handle) + private KernelResult ClearEvent(int Handle) { - KernelResult result; + KernelResult Result; - KWritableEvent writableEvent = _process.HandleTable.GetObject<KWritableEvent>(handle); + KWritableEvent WritableEvent = Process.HandleTable.GetObject<KWritableEvent>(Handle); - if (writableEvent == null) + if (WritableEvent == null) { - KReadableEvent readableEvent = _process.HandleTable.GetObject<KReadableEvent>(handle); + KReadableEvent ReadableEvent = Process.HandleTable.GetObject<KReadableEvent>(Handle); - result = readableEvent?.Clear() ?? KernelResult.InvalidHandle; + Result = ReadableEvent?.Clear() ?? KernelResult.InvalidHandle; } else { - result = writableEvent.Clear(); + Result = WritableEvent.Clear(); } - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - Logger.PrintWarning(LogClass.KernelSvc, "Operation failed with error: " + result + "!"); + Logger.PrintWarning(LogClass.KernelSvc, "Operation failed with error: " + Result + "!"); } - return result; + return Result; } - private void SvcCloseHandle(CpuThreadState threadState) + private void SvcCloseHandle(CpuThreadState ThreadState) { - int handle = (int)threadState.X0; + int Handle = (int)ThreadState.X0; - object obj = _process.HandleTable.GetObject<object>(handle); + object Obj = Process.HandleTable.GetObject<object>(Handle); - _process.HandleTable.CloseHandle(handle); + Process.HandleTable.CloseHandle(Handle); - if (obj == null) + if (Obj == null) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid handle 0x{handle:x8}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid handle 0x{Handle:x8}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); return; } - if (obj is KSession session) + if (Obj is KSession Session) { - session.Dispose(); + Session.Dispose(); } - else if (obj is KTransferMemory transferMemory) + else if (Obj is KTransferMemory TransferMemory) { - _process.MemoryManager.ResetTransferMemory( - transferMemory.Address, - transferMemory.Size); + Process.MemoryManager.ResetTransferMemory( + TransferMemory.Address, + TransferMemory.Size); } - threadState.X0 = 0; + ThreadState.X0 = 0; } - private void ResetSignal64(CpuThreadState threadState) + private void ResetSignal64(CpuThreadState ThreadState) { - threadState.X0 = (ulong)ResetSignal((int)threadState.X0); + ThreadState.X0 = (ulong)ResetSignal((int)ThreadState.X0); } - private KernelResult ResetSignal(int handle) + private KernelResult ResetSignal(int Handle) { - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - KReadableEvent readableEvent = currentProcess.HandleTable.GetObject<KReadableEvent>(handle); + KReadableEvent ReadableEvent = CurrentProcess.HandleTable.GetObject<KReadableEvent>(Handle); - KernelResult result; + KernelResult Result; - if (readableEvent != null) + if (ReadableEvent != null) { - result = readableEvent.ClearIfSignaled(); + Result = ReadableEvent.ClearIfSignaled(); } else { - KProcess process = currentProcess.HandleTable.GetKProcess(handle); + KProcess Process = CurrentProcess.HandleTable.GetKProcess(Handle); - if (process != null) + if (Process != null) { - result = process.ClearIfNotExited(); + Result = Process.ClearIfNotExited(); } else { - result = KernelResult.InvalidHandle; + Result = KernelResult.InvalidHandle; } } - if (result == KernelResult.InvalidState) + if (Result == KernelResult.InvalidState) { - Logger.PrintDebug(LogClass.KernelSvc, "Operation failed with error: " + result + "!"); + Logger.PrintDebug(LogClass.KernelSvc, "Operation failed with error: " + Result + "!"); } - else if (result != KernelResult.Success) + else if (Result != KernelResult.Success) { - Logger.PrintWarning(LogClass.KernelSvc, "Operation failed with error: " + result + "!"); + Logger.PrintWarning(LogClass.KernelSvc, "Operation failed with error: " + Result + "!"); } - return result; + return Result; } - private void SvcGetSystemTick(CpuThreadState threadState) + private void SvcGetSystemTick(CpuThreadState ThreadState) { - threadState.X0 = threadState.CntpctEl0; + ThreadState.X0 = ThreadState.CntpctEl0; } - private void SvcConnectToNamedPort(CpuThreadState threadState) + private void SvcConnectToNamedPort(CpuThreadState ThreadState) { - long stackPtr = (long)threadState.X0; - long namePtr = (long)threadState.X1; + long StackPtr = (long)ThreadState.X0; + long NamePtr = (long)ThreadState.X1; - string name = MemoryHelper.ReadAsciiString(_memory, namePtr, 8); + string Name = MemoryHelper.ReadAsciiString(Memory, NamePtr, 8); //TODO: Validate that app has perms to access the service, and that the service //actually exists, return error codes otherwise. - KSession session = new KSession(ServiceFactory.MakeService(_system, name), name); + KSession Session = new KSession(ServiceFactory.MakeService(System, Name), Name); - if (_process.HandleTable.GenerateHandle(session, out int handle) != KernelResult.Success) + if (Process.HandleTable.GenerateHandle(Session, out int Handle) != KernelResult.Success) { throw new InvalidOperationException("Out of handles!"); } - threadState.X0 = 0; - threadState.X1 = (uint)handle; + ThreadState.X0 = 0; + ThreadState.X1 = (uint)Handle; } - private void SvcSendSyncRequest(CpuThreadState threadState) + private void SvcSendSyncRequest(CpuThreadState ThreadState) { - SendSyncRequest(threadState, threadState.Tpidr, 0x100, (int)threadState.X0); + SendSyncRequest(ThreadState, ThreadState.Tpidr, 0x100, (int)ThreadState.X0); } - private void SvcSendSyncRequestWithUserBuffer(CpuThreadState threadState) + private void SvcSendSyncRequestWithUserBuffer(CpuThreadState ThreadState) { SendSyncRequest( - threadState, - (long)threadState.X0, - (long)threadState.X1, - (int)threadState.X2); + ThreadState, + (long)ThreadState.X0, + (long)ThreadState.X1, + (int)ThreadState.X2); } - private void SendSyncRequest(CpuThreadState threadState, long messagePtr, long size, int handle) + private void SendSyncRequest(CpuThreadState ThreadState, long MessagePtr, long Size, int Handle) { - byte[] messageData = _memory.ReadBytes(messagePtr, size); + byte[] MessageData = Memory.ReadBytes(MessagePtr, Size); - KSession session = _process.HandleTable.GetObject<KSession>(handle); + KSession Session = Process.HandleTable.GetObject<KSession>(Handle); - if (session != null) + if (Session != null) { - _system.CriticalSection.Enter(); + System.CriticalSection.Enter(); - KThread currentThread = _system.Scheduler.GetCurrentThread(); + KThread CurrentThread = System.Scheduler.GetCurrentThread(); - currentThread.SignaledObj = null; - currentThread.ObjSyncResult = 0; + CurrentThread.SignaledObj = null; + CurrentThread.ObjSyncResult = 0; - currentThread.Reschedule(ThreadSchedState.Paused); + CurrentThread.Reschedule(ThreadSchedState.Paused); - IpcMessage message = new IpcMessage(messageData, messagePtr); + IpcMessage Message = new IpcMessage(MessageData, MessagePtr); ThreadPool.QueueUserWorkItem(ProcessIpcRequest, new HleIpcMessage( - currentThread, - session, - message, - messagePtr)); + CurrentThread, + Session, + Message, + MessagePtr)); - _system.ThreadCounter.AddCount(); + System.ThreadCounter.AddCount(); - _system.CriticalSection.Leave(); + System.CriticalSection.Leave(); - threadState.X0 = (ulong)currentThread.ObjSyncResult; + ThreadState.X0 = (ulong)CurrentThread.ObjSyncResult; } else { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid session handle 0x{handle:x8}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid session handle 0x{Handle:x8}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); } } - private void ProcessIpcRequest(object state) + private void ProcessIpcRequest(object State) { - HleIpcMessage ipcMessage = (HleIpcMessage)state; + HleIpcMessage IpcMessage = (HleIpcMessage)State; - ipcMessage.Thread.ObjSyncResult = (int)IpcHandler.IpcCall( - _device, - _process, - _memory, - ipcMessage.Session, - ipcMessage.Message, - ipcMessage.MessagePtr); + IpcMessage.Thread.ObjSyncResult = (int)IpcHandler.IpcCall( + Device, + Process, + Memory, + IpcMessage.Session, + IpcMessage.Message, + IpcMessage.MessagePtr); - _system.ThreadCounter.Signal(); + System.ThreadCounter.Signal(); - ipcMessage.Thread.Reschedule(ThreadSchedState.Running); + IpcMessage.Thread.Reschedule(ThreadSchedState.Running); } - private void GetProcessId64(CpuThreadState threadState) + private void GetProcessId64(CpuThreadState ThreadState) { - int handle = (int)threadState.X1; + int Handle = (int)ThreadState.X1; - KernelResult result = GetProcessId(handle, out long pid); + KernelResult Result = GetProcessId(Handle, out long Pid); - threadState.X0 = (ulong)result; - threadState.X1 = (ulong)pid; + ThreadState.X0 = (ulong)Result; + ThreadState.X1 = (ulong)Pid; } - private KernelResult GetProcessId(int handle, out long pid) + private KernelResult GetProcessId(int Handle, out long Pid) { - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - KProcess process = currentProcess.HandleTable.GetKProcess(handle); + KProcess Process = CurrentProcess.HandleTable.GetKProcess(Handle); - if (process == null) + if (Process == null) { - KThread thread = currentProcess.HandleTable.GetKThread(handle); + KThread Thread = CurrentProcess.HandleTable.GetKThread(Handle); - if (thread != null) + if (Thread != null) { - process = thread.Owner; + Process = Thread.Owner; } //TODO: KDebugEvent. } - pid = process?.Pid ?? 0; + Pid = Process?.Pid ?? 0; - return process != null + return Process != null ? KernelResult.Success : KernelResult.InvalidHandle; } - private void SvcBreak(CpuThreadState threadState) + private void SvcBreak(CpuThreadState ThreadState) { - long reason = (long)threadState.X0; - long unknown = (long)threadState.X1; - long info = (long)threadState.X2; + long Reason = (long)ThreadState.X0; + long Unknown = (long)ThreadState.X1; + long Info = (long)ThreadState.X2; - KThread currentThread = _system.Scheduler.GetCurrentThread(); + KThread CurrentThread = System.Scheduler.GetCurrentThread(); - if ((reason & (1 << 31)) == 0) + if ((Reason & (1 << 31)) == 0) { - currentThread.PrintGuestStackTrace(); + CurrentThread.PrintGuestStackTrace(); throw new GuestBrokeExecutionException(); } @@ -301,40 +301,40 @@ namespace Ryujinx.HLE.HOS.Kernel { Logger.PrintInfo(LogClass.KernelSvc, "Debugger triggered."); - currentThread.PrintGuestStackTrace(); + CurrentThread.PrintGuestStackTrace(); } } - private void SvcOutputDebugString(CpuThreadState threadState) + private void SvcOutputDebugString(CpuThreadState ThreadState) { - long position = (long)threadState.X0; - long size = (long)threadState.X1; + long Position = (long)ThreadState.X0; + long Size = (long)ThreadState.X1; - string str = MemoryHelper.ReadAsciiString(_memory, position, size); + string Str = MemoryHelper.ReadAsciiString(Memory, Position, Size); - Logger.PrintWarning(LogClass.KernelSvc, str); + Logger.PrintWarning(LogClass.KernelSvc, Str); - threadState.X0 = 0; + ThreadState.X0 = 0; } - private void GetInfo64(CpuThreadState threadState) + private void GetInfo64(CpuThreadState ThreadState) { - long stackPtr = (long)threadState.X0; - uint id = (uint)threadState.X1; - int handle = (int)threadState.X2; - long subId = (long)threadState.X3; + long StackPtr = (long)ThreadState.X0; + uint Id = (uint)ThreadState.X1; + int Handle = (int)ThreadState.X2; + long SubId = (long)ThreadState.X3; - KernelResult result = GetInfo(id, handle, subId, out long value); + KernelResult Result = GetInfo(Id, Handle, SubId, out long Value); - threadState.X0 = (ulong)result; - threadState.X1 = (ulong)value; + ThreadState.X0 = (ulong)Result; + ThreadState.X1 = (ulong)Value; } - private KernelResult GetInfo(uint id, int handle, long subId, out long value) + private KernelResult GetInfo(uint Id, int Handle, long SubId, out long Value) { - value = 0; + Value = 0; - switch (id) + switch (Id) { case 0: case 1: @@ -355,62 +355,62 @@ namespace Ryujinx.HLE.HOS.Kernel case 21: case 22: { - if (subId != 0) + if (SubId != 0) { return KernelResult.InvalidCombination; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - KProcess process = currentProcess.HandleTable.GetKProcess(handle); + KProcess Process = CurrentProcess.HandleTable.GetKProcess(Handle); - if (process == null) + if (Process == null) { return KernelResult.InvalidHandle; } - switch (id) + switch (Id) { - case 0: value = process.Capabilities.AllowedCpuCoresMask; break; - case 1: value = process.Capabilities.AllowedThreadPriosMask; break; + 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 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 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 6: Value = (long)Process.GetMemoryCapacity(); break; - case 7: value = (long)process.GetMemoryUsage(); break; + case 7: Value = (long)Process.GetMemoryUsage(); break; - case 12: value = (long)process.MemoryManager.GetAddrSpaceBaseAddr(); break; + case 12: Value = (long)Process.MemoryManager.GetAddrSpaceBaseAddr(); break; - case 13: value = (long)process.MemoryManager.GetAddrSpaceSize(); 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 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 16: Value = (long)Process.PersonalMmHeapPagesCount * KMemoryManager.PageSize; break; case 17: - if (process.PersonalMmHeapPagesCount != 0) + if (Process.PersonalMmHeapPagesCount != 0) { - value = process.MemoryManager.GetMmUsedPages() * KMemoryManager.PageSize; + Value = Process.MemoryManager.GetMmUsedPages() * KMemoryManager.PageSize; } break; - case 18: value = process.TitleId; break; + case 18: Value = Process.TitleId; break; - case 20: value = (long)process.UserExceptionContextAddress; break; + case 20: Value = (long)Process.UserExceptionContextAddress; break; - case 21: value = (long)process.GetMemoryCapacityWithoutPersonalMmHeap(); break; + case 21: Value = (long)Process.GetMemoryCapacityWithoutPersonalMmHeap(); break; - case 22: value = (long)process.GetMemoryUsageWithoutPersonalMmHeap(); break; + case 22: Value = (long)Process.GetMemoryUsageWithoutPersonalMmHeap(); break; } break; @@ -418,48 +418,48 @@ namespace Ryujinx.HLE.HOS.Kernel case 8: { - if (handle != 0) + if (Handle != 0) { return KernelResult.InvalidHandle; } - if (subId != 0) + if (SubId != 0) { return KernelResult.InvalidCombination; } - value = _system.Scheduler.GetCurrentProcess().Debug ? 1 : 0; + Value = System.Scheduler.GetCurrentProcess().Debug ? 1 : 0; break; } case 9: { - if (handle != 0) + if (Handle != 0) { return KernelResult.InvalidHandle; } - if (subId != 0) + if (SubId != 0) { return KernelResult.InvalidCombination; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - if (currentProcess.ResourceLimit != null) + if (CurrentProcess.ResourceLimit != null) { - KHandleTable handleTable = currentProcess.HandleTable; - KResourceLimit resourceLimit = currentProcess.ResourceLimit; + KHandleTable HandleTable = CurrentProcess.HandleTable; + KResourceLimit ResourceLimit = CurrentProcess.ResourceLimit; - KernelResult result = handleTable.GenerateHandle(resourceLimit, out int resLimHandle); + KernelResult Result = HandleTable.GenerateHandle(ResourceLimit, out int ResLimHandle); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } - value = (uint)resLimHandle; + Value = (uint)ResLimHandle; } break; @@ -467,84 +467,84 @@ namespace Ryujinx.HLE.HOS.Kernel case 10: { - if (handle != 0) + if (Handle != 0) { return KernelResult.InvalidHandle; } - int currentCore = _system.Scheduler.GetCurrentThread().CurrentCore; + int CurrentCore = System.Scheduler.GetCurrentThread().CurrentCore; - if (subId != -1 && subId != currentCore) + if (SubId != -1 && SubId != CurrentCore) { return KernelResult.InvalidCombination; } - value = _system.Scheduler.CoreContexts[currentCore].TotalIdleTimeTicks; + Value = System.Scheduler.CoreContexts[CurrentCore].TotalIdleTimeTicks; break; } case 11: { - if (handle != 0) + if (Handle != 0) { return KernelResult.InvalidHandle; } - if ((ulong)subId > 3) + if ((ulong)SubId > 3) { return KernelResult.InvalidCombination; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - value = currentProcess.RandomEntropy[subId]; + Value = CurrentProcess.RandomEntropy[SubId]; break; } case 0xf0000002u: { - if (subId < -1 || subId > 3) + if (SubId < -1 || SubId > 3) { return KernelResult.InvalidCombination; } - KThread thread = _system.Scheduler.GetCurrentProcess().HandleTable.GetKThread(handle); + KThread Thread = System.Scheduler.GetCurrentProcess().HandleTable.GetKThread(Handle); - if (thread == null) + if (Thread == null) { return KernelResult.InvalidHandle; } - KThread currentThread = _system.Scheduler.GetCurrentThread(); + KThread CurrentThread = System.Scheduler.GetCurrentThread(); - int currentCore = currentThread.CurrentCore; + int CurrentCore = CurrentThread.CurrentCore; - if (subId != -1 && subId != currentCore) + if (SubId != -1 && SubId != CurrentCore) { return KernelResult.Success; } - KCoreContext coreContext = _system.Scheduler.CoreContexts[currentCore]; + KCoreContext CoreContext = System.Scheduler.CoreContexts[CurrentCore]; - long timeDelta = PerformanceCounter.ElapsedMilliseconds - coreContext.LastContextSwitchTime; + long TimeDelta = PerformanceCounter.ElapsedMilliseconds - CoreContext.LastContextSwitchTime; - if (subId != -1) + if (SubId != -1) { - value = KTimeManager.ConvertMillisecondsToTicks(timeDelta); + Value = KTimeManager.ConvertMillisecondsToTicks(TimeDelta); } else { - long totalTimeRunning = thread.TotalTimeRunning; + long TotalTimeRunning = Thread.TotalTimeRunning; - if (thread == currentThread) + if (Thread == CurrentThread) { - totalTimeRunning += timeDelta; + TotalTimeRunning += TimeDelta; } - value = KTimeManager.ConvertMillisecondsToTicks(totalTimeRunning); + Value = KTimeManager.ConvertMillisecondsToTicks(TotalTimeRunning); } break; @@ -556,144 +556,144 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } - private void CreateEvent64(CpuThreadState state) + private void CreateEvent64(CpuThreadState State) { - KernelResult result = CreateEvent(out int wEventHandle, out int rEventHandle); + KernelResult Result = CreateEvent(out int WEventHandle, out int REventHandle); - state.X0 = (ulong)result; - state.X1 = (ulong)wEventHandle; - state.X2 = (ulong)rEventHandle; + State.X0 = (ulong)Result; + State.X1 = (ulong)WEventHandle; + State.X2 = (ulong)REventHandle; } - private KernelResult CreateEvent(out int wEventHandle, out int rEventHandle) + private KernelResult CreateEvent(out int WEventHandle, out int REventHandle) { - KEvent Event = new KEvent(_system); + KEvent Event = new KEvent(System); - KernelResult result = _process.HandleTable.GenerateHandle(Event.WritableEvent, out wEventHandle); + KernelResult Result = Process.HandleTable.GenerateHandle(Event.WritableEvent, out WEventHandle); - if (result == KernelResult.Success) + if (Result == KernelResult.Success) { - result = _process.HandleTable.GenerateHandle(Event.ReadableEvent, out rEventHandle); + Result = Process.HandleTable.GenerateHandle(Event.ReadableEvent, out REventHandle); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - _process.HandleTable.CloseHandle(wEventHandle); + Process.HandleTable.CloseHandle(WEventHandle); } } else { - rEventHandle = 0; + REventHandle = 0; } - return result; + return Result; } - private void GetProcessList64(CpuThreadState state) + private void GetProcessList64(CpuThreadState State) { - ulong address = state.X1; - int maxOut = (int)state.X2; + ulong Address = State.X1; + int MaxOut = (int)State.X2; - KernelResult result = GetProcessList(address, maxOut, out int count); + KernelResult Result = GetProcessList(Address, MaxOut, out int Count); - state.X0 = (ulong)result; - state.X1 = (ulong)count; + State.X0 = (ulong)Result; + State.X1 = (ulong)Count; } - private KernelResult GetProcessList(ulong address, int maxCount, out int count) + private KernelResult GetProcessList(ulong Address, int MaxCount, out int Count) { - count = 0; + Count = 0; - if ((maxCount >> 28) != 0) + if ((MaxCount >> 28) != 0) { return KernelResult.MaximumExceeded; } - if (maxCount != 0) + if (MaxCount != 0) { - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - ulong copySize = (ulong)maxCount * 8; + ulong CopySize = (ulong)MaxCount * 8; - if (address + copySize <= address) + if (Address + CopySize <= Address) { return KernelResult.InvalidMemState; } - if (currentProcess.MemoryManager.OutsideAddrSpace(address, copySize)) + if (CurrentProcess.MemoryManager.OutsideAddrSpace(Address, CopySize)) { return KernelResult.InvalidMemState; } } - int copyCount = 0; + int CopyCount = 0; - lock (_system.Processes) + lock (System.Processes) { - foreach (KProcess process in _system.Processes.Values) + foreach (KProcess Process in System.Processes.Values) { - if (copyCount < maxCount) + if (CopyCount < MaxCount) { - if (!KernelTransfer.KernelToUserInt64(_system, (long)address + copyCount * 8, process.Pid)) + if (!KernelTransfer.KernelToUserInt64(System, (long)Address + CopyCount * 8, Process.Pid)) { return KernelResult.UserCopyFailed; } } - copyCount++; + CopyCount++; } } - count = copyCount; + Count = CopyCount; return KernelResult.Success; } - private void GetSystemInfo64(CpuThreadState state) + private void GetSystemInfo64(CpuThreadState State) { - uint id = (uint)state.X1; - int handle = (int)state.X2; - long subId = (long)state.X3; + uint Id = (uint)State.X1; + int Handle = (int)State.X2; + long SubId = (long)State.X3; - KernelResult result = GetSystemInfo(id, handle, subId, out long value); + KernelResult Result = GetSystemInfo(Id, Handle, SubId, out long Value); - state.X0 = (ulong)result; - state.X1 = (ulong)value; + State.X0 = (ulong)Result; + State.X1 = (ulong)Value; } - private KernelResult GetSystemInfo(uint id, int handle, long subId, out long value) + private KernelResult GetSystemInfo(uint Id, int Handle, long SubId, out long Value) { - value = 0; + Value = 0; - if (id > 2) + if (Id > 2) { return KernelResult.InvalidEnumValue; } - if (handle != 0) + if (Handle != 0) { return KernelResult.InvalidHandle; } - if (id < 2) + if (Id < 2) { - if ((ulong)subId > 3) + if ((ulong)SubId > 3) { return KernelResult.InvalidCombination; } - KMemoryRegionManager region = _system.MemoryRegions[subId]; + KMemoryRegionManager Region = System.MemoryRegions[SubId]; - switch (id) + switch (Id) { //Memory region capacity. - case 0: value = (long)region.Size; break; + case 0: Value = (long)Region.Size; break; //Memory region free space. case 1: { - ulong freePagesCount = region.GetFreePages(); + ulong FreePagesCount = Region.GetFreePages(); - value = (long)(freePagesCount * KMemoryManager.PageSize); + Value = (long)(FreePagesCount * KMemoryManager.PageSize); break; } @@ -701,127 +701,127 @@ namespace Ryujinx.HLE.HOS.Kernel } else /* if (Id == 2) */ { - if ((ulong)subId > 1) + if ((ulong)SubId > 1) { return KernelResult.InvalidCombination; } - switch (subId) + switch (SubId) { - case 0: value = _system.PrivilegedProcessLowestId; break; - case 1: value = _system.PrivilegedProcessHighestId; break; + case 0: Value = System.PrivilegedProcessLowestId; break; + case 1: Value = System.PrivilegedProcessHighestId; break; } } return KernelResult.Success; } - private void CreatePort64(CpuThreadState state) + 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; + 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) + int MaxSessions, + bool IsLight, + long NameAddress, + out int ServerPortHandle, + out int ClientPortHandle) { - serverPortHandle = clientPortHandle = 0; + ServerPortHandle = ClientPortHandle = 0; - if (maxSessions < 1) + if (MaxSessions < 1) { return KernelResult.MaximumExceeded; } - KPort port = new KPort(_system); + KPort Port = new KPort(System); - port.Initialize(maxSessions, isLight, nameAddress); + Port.Initialize(MaxSessions, IsLight, NameAddress); - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - KernelResult result = currentProcess.HandleTable.GenerateHandle(port.ClientPort, out clientPortHandle); + KernelResult Result = CurrentProcess.HandleTable.GenerateHandle(Port.ClientPort, out ClientPortHandle); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } - result = currentProcess.HandleTable.GenerateHandle(port.ServerPort, out serverPortHandle); + Result = CurrentProcess.HandleTable.GenerateHandle(Port.ServerPort, out ServerPortHandle); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - currentProcess.HandleTable.CloseHandle(clientPortHandle); + CurrentProcess.HandleTable.CloseHandle(ClientPortHandle); } - return result; + return Result; } - private void ManageNamedPort64(CpuThreadState state) + private void ManageNamedPort64(CpuThreadState State) { - long nameAddress = (long)state.X1; - int maxSessions = (int)state.X2; + long NameAddress = (long)State.X1; + int MaxSessions = (int)State.X2; - KernelResult result = ManageNamedPort(nameAddress, maxSessions, out int handle); + KernelResult Result = ManageNamedPort(NameAddress, MaxSessions, out int Handle); - state.X0 = (ulong)result; - state.X1 = (ulong)handle; + State.X0 = (ulong)Result; + State.X1 = (ulong)Handle; } - private KernelResult ManageNamedPort(long nameAddress, int maxSessions, out int handle) + private KernelResult ManageNamedPort(long NameAddress, int MaxSessions, out int Handle) { - handle = 0; + Handle = 0; - if (!KernelTransfer.UserToKernelString(_system, nameAddress, 12, out string name)) + if (!KernelTransfer.UserToKernelString(System, NameAddress, 12, out string Name)) { return KernelResult.UserCopyFailed; } - if (maxSessions < 0 || name.Length > 11) + if (MaxSessions < 0 || Name.Length > 11) { return KernelResult.MaximumExceeded; } - if (maxSessions == 0) + if (MaxSessions == 0) { - return KClientPort.RemoveName(_system, name); + return KClientPort.RemoveName(System, Name); } - KPort port = new KPort(_system); + KPort Port = new KPort(System); - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - KernelResult result = currentProcess.HandleTable.GenerateHandle(port.ServerPort, out handle); + KernelResult Result = CurrentProcess.HandleTable.GenerateHandle(Port.ServerPort, out Handle); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - return result; + return Result; } - port.Initialize(maxSessions, false, 0); + Port.Initialize(MaxSessions, false, 0); - result = port.SetName(name); + Result = Port.SetName(Name); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - currentProcess.HandleTable.CloseHandle(handle); + CurrentProcess.HandleTable.CloseHandle(Handle); } - return result; + return Result; } } } diff --git a/Ryujinx.HLE/HOS/Kernel/SvcThread.cs b/Ryujinx.HLE/HOS/Kernel/SvcThread.cs index 0121303d..ded8f8dc 100644 --- a/Ryujinx.HLE/HOS/Kernel/SvcThread.cs +++ b/Ryujinx.HLE/HOS/Kernel/SvcThread.cs @@ -7,458 +7,458 @@ namespace Ryujinx.HLE.HOS.Kernel { partial class SvcHandler { - private void CreateThread64(CpuThreadState threadState) + private void CreateThread64(CpuThreadState ThreadState) { - ulong entrypoint = threadState.X1; - ulong argsPtr = threadState.X2; - ulong stackTop = threadState.X3; - int priority = (int)threadState.X4; - int cpuCore = (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; - KernelResult result = CreateThread(entrypoint, argsPtr, stackTop, priority, cpuCore, out int handle); + KernelResult Result = CreateThread(Entrypoint, ArgsPtr, StackTop, Priority, CpuCore, out int Handle); - threadState.X0 = (ulong)result; - threadState.X1 = (ulong)handle; + ThreadState.X0 = (ulong)Result; + ThreadState.X1 = (ulong)Handle; } private KernelResult CreateThread( - ulong entrypoint, - ulong argsPtr, - ulong stackTop, - int priority, - int cpuCore, - out int handle) + ulong Entrypoint, + ulong ArgsPtr, + ulong StackTop, + int Priority, + int CpuCore, + out int Handle) { - handle = 0; + Handle = 0; - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - if (cpuCore == -2) + if (CpuCore == -2) { - cpuCore = currentProcess.DefaultCpuCore; + CpuCore = CurrentProcess.DefaultCpuCore; } - if ((uint)cpuCore >= KScheduler.CpuCoresCount || !currentProcess.IsCpuCoreAllowed(cpuCore)) + if ((uint)CpuCore >= KScheduler.CpuCoresCount || !CurrentProcess.IsCpuCoreAllowed(CpuCore)) { return KernelResult.InvalidCpuCore; } - if ((uint)priority >= KScheduler.PrioritiesCount || !currentProcess.IsPriorityAllowed(priority)) + if ((uint)Priority >= KScheduler.PrioritiesCount || !CurrentProcess.IsPriorityAllowed(Priority)) { return KernelResult.InvalidPriority; } - long timeout = KTimeManager.ConvertMillisecondsToNanoseconds(100); + long Timeout = KTimeManager.ConvertMillisecondsToNanoseconds(100); - if (currentProcess.ResourceLimit != null && - !currentProcess.ResourceLimit.Reserve(LimitableResource.Thread, 1, timeout)) + if (CurrentProcess.ResourceLimit != null && + !CurrentProcess.ResourceLimit.Reserve(LimitableResource.Thread, 1, Timeout)) { return KernelResult.ResLimitExceeded; } - KThread thread = new KThread(_system); + KThread Thread = new KThread(System); - KernelResult result = currentProcess.InitializeThread( - thread, - entrypoint, - argsPtr, - stackTop, - priority, - cpuCore); + KernelResult Result = CurrentProcess.InitializeThread( + Thread, + Entrypoint, + ArgsPtr, + StackTop, + Priority, + CpuCore); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - currentProcess.ResourceLimit?.Release(LimitableResource.Thread, 1); + CurrentProcess.ResourceLimit?.Release(LimitableResource.Thread, 1); - return result; + return Result; } - result = _process.HandleTable.GenerateHandle(thread, out handle); + Result = Process.HandleTable.GenerateHandle(Thread, out Handle); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - thread.Terminate(); + Thread.Terminate(); - currentProcess.ResourceLimit?.Release(LimitableResource.Thread, 1); + CurrentProcess.ResourceLimit?.Release(LimitableResource.Thread, 1); } - return result; + return Result; } - private void SvcStartThread(CpuThreadState threadState) + private void SvcStartThread(CpuThreadState ThreadState) { - int handle = (int)threadState.X0; + int Handle = (int)ThreadState.X0; - KThread thread = _process.HandleTable.GetObject<KThread>(handle); + KThread Thread = Process.HandleTable.GetObject<KThread>(Handle); - if (thread != null) + if (Thread != null) { - KernelResult result = thread.Start(); + KernelResult Result = Thread.Start(); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{result}\"."); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{Result}\"."); } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } else { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{handle:x8}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); } } - private void SvcExitThread(CpuThreadState threadState) + private void SvcExitThread(CpuThreadState ThreadState) { - KThread currentThread = _system.Scheduler.GetCurrentThread(); + KThread CurrentThread = System.Scheduler.GetCurrentThread(); - _system.Scheduler.ExitThread(currentThread); + System.Scheduler.ExitThread(CurrentThread); - currentThread.Exit(); + CurrentThread.Exit(); } - private void SvcSleepThread(CpuThreadState threadState) + private void SvcSleepThread(CpuThreadState ThreadState) { - long timeout = (long)threadState.X0; + long Timeout = (long)ThreadState.X0; - Logger.PrintDebug(LogClass.KernelSvc, "Timeout = 0x" + timeout.ToString("x16")); + Logger.PrintDebug(LogClass.KernelSvc, "Timeout = 0x" + Timeout.ToString("x16")); - KThread currentThread = _system.Scheduler.GetCurrentThread(); + KThread CurrentThread = System.Scheduler.GetCurrentThread(); - if (timeout < 1) + if (Timeout < 1) { - switch (timeout) + switch (Timeout) { - case 0: currentThread.Yield(); break; - case -1: currentThread.YieldWithLoadBalancing(); break; - case -2: currentThread.YieldAndWaitForLoadBalancing(); break; + case 0: CurrentThread.Yield(); break; + case -1: CurrentThread.YieldWithLoadBalancing(); break; + case -2: CurrentThread.YieldAndWaitForLoadBalancing(); break; } } else { - currentThread.Sleep(timeout); + CurrentThread.Sleep(Timeout); - threadState.X0 = 0; + ThreadState.X0 = 0; } } - private void SvcGetThreadPriority(CpuThreadState threadState) + private void SvcGetThreadPriority(CpuThreadState ThreadState) { - int handle = (int)threadState.X1; + int Handle = (int)ThreadState.X1; - KThread thread = _process.HandleTable.GetKThread(handle); + KThread Thread = Process.HandleTable.GetKThread(Handle); - if (thread != null) + if (Thread != null) { - threadState.X0 = 0; - threadState.X1 = (ulong)thread.DynamicPriority; + ThreadState.X0 = 0; + ThreadState.X1 = (ulong)Thread.DynamicPriority; } else { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{handle:x8}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); } } - private void SvcSetThreadPriority(CpuThreadState threadState) + private void SvcSetThreadPriority(CpuThreadState ThreadState) { - int handle = (int)threadState.X0; - int priority = (int)threadState.X1; + int Handle = (int)ThreadState.X0; + int Priority = (int)ThreadState.X1; Logger.PrintDebug(LogClass.KernelSvc, - "Handle = 0x" + handle .ToString("x8") + ", " + - "Priority = 0x" + priority.ToString("x8")); + "Handle = 0x" + Handle .ToString("x8") + ", " + + "Priority = 0x" + Priority.ToString("x8")); //TODO: NPDM check. - KThread thread = _process.HandleTable.GetKThread(handle); + KThread Thread = Process.HandleTable.GetKThread(Handle); - if (thread == null) + if (Thread == null) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{handle:x8}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); return; } - thread.SetPriority(priority); + Thread.SetPriority(Priority); - threadState.X0 = 0; + ThreadState.X0 = 0; } - private void SvcGetThreadCoreMask(CpuThreadState threadState) + private void SvcGetThreadCoreMask(CpuThreadState ThreadState) { - int handle = (int)threadState.X2; + int Handle = (int)ThreadState.X2; - Logger.PrintDebug(LogClass.KernelSvc, "Handle = 0x" + handle.ToString("x8")); + Logger.PrintDebug(LogClass.KernelSvc, "Handle = 0x" + Handle.ToString("x8")); - KThread thread = _process.HandleTable.GetKThread(handle); + KThread Thread = Process.HandleTable.GetKThread(Handle); - if (thread != null) + if (Thread != null) { - threadState.X0 = 0; - threadState.X1 = (ulong)thread.PreferredCore; - threadState.X2 = (ulong)thread.AffinityMask; + ThreadState.X0 = 0; + ThreadState.X1 = (ulong)Thread.PreferredCore; + ThreadState.X2 = (ulong)Thread.AffinityMask; } else { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{handle:x8}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); } } - private void SetThreadCoreMask64(CpuThreadState threadState) + private void SetThreadCoreMask64(CpuThreadState ThreadState) { - int handle = (int)threadState.X0; - int preferredCore = (int)threadState.X1; - long affinityMask = (long)threadState.X2; + int Handle = (int)ThreadState.X0; + int PreferredCore = (int)ThreadState.X1; + long AffinityMask = (long)ThreadState.X2; Logger.PrintDebug(LogClass.KernelSvc, - "Handle = 0x" + handle .ToString("x8") + ", " + - "PreferredCore = 0x" + preferredCore.ToString("x8") + ", " + - "AffinityMask = 0x" + affinityMask .ToString("x16")); + "Handle = 0x" + Handle .ToString("x8") + ", " + + "PreferredCore = 0x" + PreferredCore.ToString("x8") + ", " + + "AffinityMask = 0x" + AffinityMask .ToString("x16")); - KernelResult result = SetThreadCoreMask(handle, preferredCore, affinityMask); + KernelResult Result = SetThreadCoreMask(Handle, PreferredCore, AffinityMask); - if (result != KernelResult.Success) + if (Result != KernelResult.Success) { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{result}\"."); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error \"{Result}\"."); } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } - private KernelResult SetThreadCoreMask(int handle, int preferredCore, long affinityMask) + private KernelResult SetThreadCoreMask(int Handle, int PreferredCore, long AffinityMask) { - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - if (preferredCore == -2) + if (PreferredCore == -2) { - preferredCore = currentProcess.DefaultCpuCore; + PreferredCore = CurrentProcess.DefaultCpuCore; - affinityMask = 1 << preferredCore; + AffinityMask = 1 << PreferredCore; } else { - if ((currentProcess.Capabilities.AllowedCpuCoresMask | affinityMask) != - currentProcess.Capabilities.AllowedCpuCoresMask) + if ((CurrentProcess.Capabilities.AllowedCpuCoresMask | AffinityMask) != + CurrentProcess.Capabilities.AllowedCpuCoresMask) { return KernelResult.InvalidCpuCore; } - if (affinityMask == 0) + if (AffinityMask == 0) { return KernelResult.InvalidCombination; } - if ((uint)preferredCore > 3) + if ((uint)PreferredCore > 3) { - if ((preferredCore | 2) != -1) + if ((PreferredCore | 2) != -1) { return KernelResult.InvalidCpuCore; } } - else if ((affinityMask & (1 << preferredCore)) == 0) + else if ((AffinityMask & (1 << PreferredCore)) == 0) { return KernelResult.InvalidCombination; } } - KThread thread = _process.HandleTable.GetKThread(handle); + KThread Thread = Process.HandleTable.GetKThread(Handle); - if (thread == null) + if (Thread == null) { return KernelResult.InvalidHandle; } - return thread.SetCoreAndAffinityMask(preferredCore, affinityMask); + return Thread.SetCoreAndAffinityMask(PreferredCore, AffinityMask); } - private void SvcGetCurrentProcessorNumber(CpuThreadState threadState) + private void SvcGetCurrentProcessorNumber(CpuThreadState ThreadState) { - threadState.X0 = (ulong)_system.Scheduler.GetCurrentThread().CurrentCore; + ThreadState.X0 = (ulong)System.Scheduler.GetCurrentThread().CurrentCore; } - private void SvcGetThreadId(CpuThreadState threadState) + private void SvcGetThreadId(CpuThreadState ThreadState) { - int handle = (int)threadState.X1; + int Handle = (int)ThreadState.X1; - KThread thread = _process.HandleTable.GetKThread(handle); + KThread Thread = Process.HandleTable.GetKThread(Handle); - if (thread != null) + if (Thread != null) { - threadState.X0 = 0; - threadState.X1 = (ulong)thread.ThreadUid; + ThreadState.X0 = 0; + ThreadState.X1 = (ulong)Thread.ThreadUid; } else { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{handle:x8}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); } } - private void SvcSetThreadActivity(CpuThreadState threadState) + private void SvcSetThreadActivity(CpuThreadState ThreadState) { - int handle = (int)threadState.X0; - bool pause = (int)threadState.X1 == 1; + int Handle = (int)ThreadState.X0; + bool Pause = (int)ThreadState.X1 == 1; - KThread thread = _process.HandleTable.GetObject<KThread>(handle); + KThread Thread = Process.HandleTable.GetObject<KThread>(Handle); - if (thread == null) + if (Thread == null) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{handle:x8}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); return; } - if (thread.Owner != _system.Scheduler.GetCurrentProcess()) + if (Thread.Owner != System.Scheduler.GetCurrentProcess()) { Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread, it belongs to another process."); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); return; } - if (thread == _system.Scheduler.GetCurrentThread()) + if (Thread == System.Scheduler.GetCurrentThread()) { Logger.PrintWarning(LogClass.KernelSvc, "Invalid thread, current thread is not accepted."); - threadState.X0 = (ulong)KernelResult.InvalidThread; + ThreadState.X0 = (ulong)KernelResult.InvalidThread; return; } - long result = thread.SetActivity(pause); + long Result = Thread.SetActivity(Pause); - if (result != 0) + if (Result != 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!"); } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } - private void SvcGetThreadContext3(CpuThreadState threadState) + private void SvcGetThreadContext3(CpuThreadState ThreadState) { - long position = (long)threadState.X0; - int handle = (int)threadState.X1; + long Position = (long)ThreadState.X0; + int Handle = (int)ThreadState.X1; - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); - KThread currentThread = _system.Scheduler.GetCurrentThread(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); + KThread CurrentThread = System.Scheduler.GetCurrentThread(); - KThread thread = _process.HandleTable.GetObject<KThread>(handle); + KThread Thread = Process.HandleTable.GetObject<KThread>(Handle); - if (thread == null) + if (Thread == null) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{handle:x8}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{Handle:x8}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); return; } - if (thread.Owner != currentProcess) + if (Thread.Owner != CurrentProcess) { Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread, it belongs to another process."); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); return; } - if (currentThread == thread) + if (CurrentThread == Thread) { Logger.PrintWarning(LogClass.KernelSvc, "Invalid thread, current thread is not accepted."); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidThread); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidThread); return; } - _memory.WriteUInt64(position + 0x0, thread.Context.ThreadState.X0); - _memory.WriteUInt64(position + 0x8, thread.Context.ThreadState.X1); - _memory.WriteUInt64(position + 0x10, thread.Context.ThreadState.X2); - _memory.WriteUInt64(position + 0x18, thread.Context.ThreadState.X3); - _memory.WriteUInt64(position + 0x20, thread.Context.ThreadState.X4); - _memory.WriteUInt64(position + 0x28, thread.Context.ThreadState.X5); - _memory.WriteUInt64(position + 0x30, thread.Context.ThreadState.X6); - _memory.WriteUInt64(position + 0x38, thread.Context.ThreadState.X7); - _memory.WriteUInt64(position + 0x40, thread.Context.ThreadState.X8); - _memory.WriteUInt64(position + 0x48, thread.Context.ThreadState.X9); - _memory.WriteUInt64(position + 0x50, thread.Context.ThreadState.X10); - _memory.WriteUInt64(position + 0x58, thread.Context.ThreadState.X11); - _memory.WriteUInt64(position + 0x60, thread.Context.ThreadState.X12); - _memory.WriteUInt64(position + 0x68, thread.Context.ThreadState.X13); - _memory.WriteUInt64(position + 0x70, thread.Context.ThreadState.X14); - _memory.WriteUInt64(position + 0x78, thread.Context.ThreadState.X15); - _memory.WriteUInt64(position + 0x80, thread.Context.ThreadState.X16); - _memory.WriteUInt64(position + 0x88, thread.Context.ThreadState.X17); - _memory.WriteUInt64(position + 0x90, thread.Context.ThreadState.X18); - _memory.WriteUInt64(position + 0x98, thread.Context.ThreadState.X19); - _memory.WriteUInt64(position + 0xa0, thread.Context.ThreadState.X20); - _memory.WriteUInt64(position + 0xa8, thread.Context.ThreadState.X21); - _memory.WriteUInt64(position + 0xb0, thread.Context.ThreadState.X22); - _memory.WriteUInt64(position + 0xb8, thread.Context.ThreadState.X23); - _memory.WriteUInt64(position + 0xc0, thread.Context.ThreadState.X24); - _memory.WriteUInt64(position + 0xc8, thread.Context.ThreadState.X25); - _memory.WriteUInt64(position + 0xd0, thread.Context.ThreadState.X26); - _memory.WriteUInt64(position + 0xd8, thread.Context.ThreadState.X27); - _memory.WriteUInt64(position + 0xe0, thread.Context.ThreadState.X28); - _memory.WriteUInt64(position + 0xe8, thread.Context.ThreadState.X29); - _memory.WriteUInt64(position + 0xf0, thread.Context.ThreadState.X30); - _memory.WriteUInt64(position + 0xf8, thread.Context.ThreadState.X31); - - _memory.WriteInt64(position + 0x100, thread.LastPc); - - _memory.WriteUInt64(position + 0x108, (ulong)thread.Context.ThreadState.Psr); - - _memory.WriteVector128(position + 0x110, thread.Context.ThreadState.V0); - _memory.WriteVector128(position + 0x120, thread.Context.ThreadState.V1); - _memory.WriteVector128(position + 0x130, thread.Context.ThreadState.V2); - _memory.WriteVector128(position + 0x140, thread.Context.ThreadState.V3); - _memory.WriteVector128(position + 0x150, thread.Context.ThreadState.V4); - _memory.WriteVector128(position + 0x160, thread.Context.ThreadState.V5); - _memory.WriteVector128(position + 0x170, thread.Context.ThreadState.V6); - _memory.WriteVector128(position + 0x180, thread.Context.ThreadState.V7); - _memory.WriteVector128(position + 0x190, thread.Context.ThreadState.V8); - _memory.WriteVector128(position + 0x1a0, thread.Context.ThreadState.V9); - _memory.WriteVector128(position + 0x1b0, thread.Context.ThreadState.V10); - _memory.WriteVector128(position + 0x1c0, thread.Context.ThreadState.V11); - _memory.WriteVector128(position + 0x1d0, thread.Context.ThreadState.V12); - _memory.WriteVector128(position + 0x1e0, thread.Context.ThreadState.V13); - _memory.WriteVector128(position + 0x1f0, thread.Context.ThreadState.V14); - _memory.WriteVector128(position + 0x200, thread.Context.ThreadState.V15); - _memory.WriteVector128(position + 0x210, thread.Context.ThreadState.V16); - _memory.WriteVector128(position + 0x220, thread.Context.ThreadState.V17); - _memory.WriteVector128(position + 0x230, thread.Context.ThreadState.V18); - _memory.WriteVector128(position + 0x240, thread.Context.ThreadState.V19); - _memory.WriteVector128(position + 0x250, thread.Context.ThreadState.V20); - _memory.WriteVector128(position + 0x260, thread.Context.ThreadState.V21); - _memory.WriteVector128(position + 0x270, thread.Context.ThreadState.V22); - _memory.WriteVector128(position + 0x280, thread.Context.ThreadState.V23); - _memory.WriteVector128(position + 0x290, thread.Context.ThreadState.V24); - _memory.WriteVector128(position + 0x2a0, thread.Context.ThreadState.V25); - _memory.WriteVector128(position + 0x2b0, thread.Context.ThreadState.V26); - _memory.WriteVector128(position + 0x2c0, thread.Context.ThreadState.V27); - _memory.WriteVector128(position + 0x2d0, thread.Context.ThreadState.V28); - _memory.WriteVector128(position + 0x2e0, thread.Context.ThreadState.V29); - _memory.WriteVector128(position + 0x2f0, thread.Context.ThreadState.V30); - _memory.WriteVector128(position + 0x300, thread.Context.ThreadState.V31); - - _memory.WriteInt32(position + 0x310, thread.Context.ThreadState.Fpcr); - _memory.WriteInt32(position + 0x314, thread.Context.ThreadState.Fpsr); - _memory.WriteInt64(position + 0x318, thread.Context.ThreadState.Tpidr); - - threadState.X0 = 0; + Memory.WriteUInt64(Position + 0x0, Thread.Context.ThreadState.X0); + Memory.WriteUInt64(Position + 0x8, Thread.Context.ThreadState.X1); + Memory.WriteUInt64(Position + 0x10, Thread.Context.ThreadState.X2); + Memory.WriteUInt64(Position + 0x18, Thread.Context.ThreadState.X3); + Memory.WriteUInt64(Position + 0x20, Thread.Context.ThreadState.X4); + Memory.WriteUInt64(Position + 0x28, Thread.Context.ThreadState.X5); + Memory.WriteUInt64(Position + 0x30, Thread.Context.ThreadState.X6); + Memory.WriteUInt64(Position + 0x38, Thread.Context.ThreadState.X7); + Memory.WriteUInt64(Position + 0x40, Thread.Context.ThreadState.X8); + Memory.WriteUInt64(Position + 0x48, Thread.Context.ThreadState.X9); + Memory.WriteUInt64(Position + 0x50, Thread.Context.ThreadState.X10); + Memory.WriteUInt64(Position + 0x58, Thread.Context.ThreadState.X11); + Memory.WriteUInt64(Position + 0x60, Thread.Context.ThreadState.X12); + Memory.WriteUInt64(Position + 0x68, Thread.Context.ThreadState.X13); + Memory.WriteUInt64(Position + 0x70, Thread.Context.ThreadState.X14); + Memory.WriteUInt64(Position + 0x78, Thread.Context.ThreadState.X15); + Memory.WriteUInt64(Position + 0x80, Thread.Context.ThreadState.X16); + Memory.WriteUInt64(Position + 0x88, Thread.Context.ThreadState.X17); + Memory.WriteUInt64(Position + 0x90, Thread.Context.ThreadState.X18); + Memory.WriteUInt64(Position + 0x98, Thread.Context.ThreadState.X19); + Memory.WriteUInt64(Position + 0xa0, Thread.Context.ThreadState.X20); + Memory.WriteUInt64(Position + 0xa8, Thread.Context.ThreadState.X21); + Memory.WriteUInt64(Position + 0xb0, Thread.Context.ThreadState.X22); + Memory.WriteUInt64(Position + 0xb8, Thread.Context.ThreadState.X23); + Memory.WriteUInt64(Position + 0xc0, Thread.Context.ThreadState.X24); + Memory.WriteUInt64(Position + 0xc8, Thread.Context.ThreadState.X25); + Memory.WriteUInt64(Position + 0xd0, Thread.Context.ThreadState.X26); + Memory.WriteUInt64(Position + 0xd8, Thread.Context.ThreadState.X27); + Memory.WriteUInt64(Position + 0xe0, Thread.Context.ThreadState.X28); + Memory.WriteUInt64(Position + 0xe8, Thread.Context.ThreadState.X29); + Memory.WriteUInt64(Position + 0xf0, Thread.Context.ThreadState.X30); + Memory.WriteUInt64(Position + 0xf8, Thread.Context.ThreadState.X31); + + Memory.WriteInt64(Position + 0x100, Thread.LastPc); + + Memory.WriteUInt64(Position + 0x108, (ulong)Thread.Context.ThreadState.Psr); + + Memory.WriteVector128(Position + 0x110, Thread.Context.ThreadState.V0); + Memory.WriteVector128(Position + 0x120, Thread.Context.ThreadState.V1); + Memory.WriteVector128(Position + 0x130, Thread.Context.ThreadState.V2); + Memory.WriteVector128(Position + 0x140, Thread.Context.ThreadState.V3); + Memory.WriteVector128(Position + 0x150, Thread.Context.ThreadState.V4); + Memory.WriteVector128(Position + 0x160, Thread.Context.ThreadState.V5); + Memory.WriteVector128(Position + 0x170, Thread.Context.ThreadState.V6); + Memory.WriteVector128(Position + 0x180, Thread.Context.ThreadState.V7); + Memory.WriteVector128(Position + 0x190, Thread.Context.ThreadState.V8); + Memory.WriteVector128(Position + 0x1a0, Thread.Context.ThreadState.V9); + Memory.WriteVector128(Position + 0x1b0, Thread.Context.ThreadState.V10); + Memory.WriteVector128(Position + 0x1c0, Thread.Context.ThreadState.V11); + Memory.WriteVector128(Position + 0x1d0, Thread.Context.ThreadState.V12); + Memory.WriteVector128(Position + 0x1e0, Thread.Context.ThreadState.V13); + Memory.WriteVector128(Position + 0x1f0, Thread.Context.ThreadState.V14); + Memory.WriteVector128(Position + 0x200, Thread.Context.ThreadState.V15); + Memory.WriteVector128(Position + 0x210, Thread.Context.ThreadState.V16); + Memory.WriteVector128(Position + 0x220, Thread.Context.ThreadState.V17); + Memory.WriteVector128(Position + 0x230, Thread.Context.ThreadState.V18); + Memory.WriteVector128(Position + 0x240, Thread.Context.ThreadState.V19); + Memory.WriteVector128(Position + 0x250, Thread.Context.ThreadState.V20); + Memory.WriteVector128(Position + 0x260, Thread.Context.ThreadState.V21); + Memory.WriteVector128(Position + 0x270, Thread.Context.ThreadState.V22); + Memory.WriteVector128(Position + 0x280, Thread.Context.ThreadState.V23); + Memory.WriteVector128(Position + 0x290, Thread.Context.ThreadState.V24); + Memory.WriteVector128(Position + 0x2a0, Thread.Context.ThreadState.V25); + Memory.WriteVector128(Position + 0x2b0, Thread.Context.ThreadState.V26); + Memory.WriteVector128(Position + 0x2c0, Thread.Context.ThreadState.V27); + Memory.WriteVector128(Position + 0x2d0, Thread.Context.ThreadState.V28); + Memory.WriteVector128(Position + 0x2e0, Thread.Context.ThreadState.V29); + Memory.WriteVector128(Position + 0x2f0, Thread.Context.ThreadState.V30); + Memory.WriteVector128(Position + 0x300, Thread.Context.ThreadState.V31); + + Memory.WriteInt32(Position + 0x310, Thread.Context.ThreadState.Fpcr); + Memory.WriteInt32(Position + 0x314, Thread.Context.ThreadState.Fpsr); + Memory.WriteInt64(Position + 0x318, Thread.Context.ThreadState.Tpidr); + + ThreadState.X0 = 0; } } }
\ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/SvcThreadSync.cs b/Ryujinx.HLE/HOS/Kernel/SvcThreadSync.cs index 11cfffe9..3935df5d 100644 --- a/Ryujinx.HLE/HOS/Kernel/SvcThreadSync.cs +++ b/Ryujinx.HLE/HOS/Kernel/SvcThreadSync.cs @@ -8,366 +8,366 @@ namespace Ryujinx.HLE.HOS.Kernel { partial class SvcHandler { - private void SvcWaitSynchronization(CpuThreadState threadState) + private void SvcWaitSynchronization(CpuThreadState ThreadState) { - long handlesPtr = (long)threadState.X1; - int handlesCount = (int)threadState.X2; - long timeout = (long)threadState.X3; + long HandlesPtr = (long)ThreadState.X1; + int HandlesCount = (int)ThreadState.X2; + long Timeout = (long)ThreadState.X3; Logger.PrintDebug(LogClass.KernelSvc, - "HandlesPtr = 0x" + handlesPtr .ToString("x16") + ", " + - "HandlesCount = 0x" + handlesCount.ToString("x8") + ", " + - "Timeout = 0x" + timeout .ToString("x16")); + "HandlesPtr = 0x" + HandlesPtr .ToString("x16") + ", " + + "HandlesCount = 0x" + HandlesCount.ToString("x8") + ", " + + "Timeout = 0x" + Timeout .ToString("x16")); - if ((uint)handlesCount > 0x40) + if ((uint)HandlesCount > 0x40) { - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.CountOutOfRange); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.CountOutOfRange); return; } - List<KSynchronizationObject> syncObjs = new List<KSynchronizationObject>(); + List<KSynchronizationObject> SyncObjs = new List<KSynchronizationObject>(); - for (int index = 0; index < handlesCount; index++) + for (int Index = 0; Index < HandlesCount; Index++) { - int handle = _memory.ReadInt32(handlesPtr + index * 4); + int Handle = Memory.ReadInt32(HandlesPtr + Index * 4); - Logger.PrintDebug(LogClass.KernelSvc, $"Sync handle 0x{handle:x8}"); + Logger.PrintDebug(LogClass.KernelSvc, $"Sync handle 0x{Handle:x8}"); - KSynchronizationObject syncObj = _process.HandleTable.GetObject<KSynchronizationObject>(handle); + KSynchronizationObject SyncObj = Process.HandleTable.GetObject<KSynchronizationObject>(Handle); - if (syncObj == null) + if (SyncObj == null) { break; } - syncObjs.Add(syncObj); + SyncObjs.Add(SyncObj); } - int hndIndex = (int)threadState.X1; + int HndIndex = (int)ThreadState.X1; - ulong high = threadState.X1 & (0xffffffffUL << 32); + ulong High = ThreadState.X1 & (0xffffffffUL << 32); - long result = _system.Synchronization.WaitFor(syncObjs.ToArray(), timeout, ref hndIndex); + long Result = System.Synchronization.WaitFor(SyncObjs.ToArray(), Timeout, ref HndIndex); - if (result != 0) + if (Result != 0) { - if (result == MakeError(ErrorModule.Kernel, KernelErr.Timeout) || - result == MakeError(ErrorModule.Kernel, KernelErr.Cancelled)) + if (Result == MakeError(ErrorModule.Kernel, KernelErr.Timeout) || + Result == MakeError(ErrorModule.Kernel, KernelErr.Cancelled)) { - Logger.PrintDebug(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!"); + Logger.PrintDebug(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!"); } else { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!"); } } - threadState.X0 = (ulong)result; - threadState.X1 = (uint)hndIndex | high; + ThreadState.X0 = (ulong)Result; + ThreadState.X1 = (uint)HndIndex | High; } - private void SvcCancelSynchronization(CpuThreadState threadState) + private void SvcCancelSynchronization(CpuThreadState ThreadState) { - int threadHandle = (int)threadState.X0; + int ThreadHandle = (int)ThreadState.X0; - Logger.PrintDebug(LogClass.KernelSvc, "ThreadHandle = 0x" + threadHandle.ToString("x8")); + Logger.PrintDebug(LogClass.KernelSvc, "ThreadHandle = 0x" + ThreadHandle.ToString("x8")); - KThread thread = _process.HandleTable.GetKThread(threadHandle); + KThread Thread = Process.HandleTable.GetKThread(ThreadHandle); - if (thread == null) + if (Thread == null) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{threadHandle:x8}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid thread handle 0x{ThreadHandle:x8}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); return; } - thread.CancelSynchronization(); + Thread.CancelSynchronization(); - threadState.X0 = 0; + ThreadState.X0 = 0; } - private void SvcArbitrateLock(CpuThreadState threadState) + private void SvcArbitrateLock(CpuThreadState ThreadState) { - int ownerHandle = (int)threadState.X0; - long mutexAddress = (long)threadState.X1; - int requesterHandle = (int)threadState.X2; + int OwnerHandle = (int)ThreadState.X0; + long MutexAddress = (long)ThreadState.X1; + int RequesterHandle = (int)ThreadState.X2; Logger.PrintDebug(LogClass.KernelSvc, - "OwnerHandle = 0x" + ownerHandle .ToString("x8") + ", " + - "MutexAddress = 0x" + mutexAddress .ToString("x16") + ", " + - "RequesterHandle = 0x" + requesterHandle.ToString("x8")); + "OwnerHandle = 0x" + OwnerHandle .ToString("x8") + ", " + + "MutexAddress = 0x" + MutexAddress .ToString("x16") + ", " + + "RequesterHandle = 0x" + RequesterHandle.ToString("x8")); - if (IsPointingInsideKernel(mutexAddress)) + if (IsPointingInsideKernel(MutexAddress)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid mutex address 0x{mutexAddress:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid mutex address 0x{MutexAddress:x16}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - if (IsAddressNotWordAligned(mutexAddress)) + if (IsAddressNotWordAligned(MutexAddress)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Unaligned mutex address 0x{mutexAddress:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Unaligned mutex address 0x{MutexAddress:x16}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); return; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - long result = currentProcess.AddressArbiter.ArbitrateLock(ownerHandle, mutexAddress, requesterHandle); + long Result = CurrentProcess.AddressArbiter.ArbitrateLock(OwnerHandle, MutexAddress, RequesterHandle); - if (result != 0) + if (Result != 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!"); } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } - private void SvcArbitrateUnlock(CpuThreadState threadState) + private void SvcArbitrateUnlock(CpuThreadState ThreadState) { - long mutexAddress = (long)threadState.X0; + long MutexAddress = (long)ThreadState.X0; - Logger.PrintDebug(LogClass.KernelSvc, "MutexAddress = 0x" + mutexAddress.ToString("x16")); + Logger.PrintDebug(LogClass.KernelSvc, "MutexAddress = 0x" + MutexAddress.ToString("x16")); - if (IsPointingInsideKernel(mutexAddress)) + if (IsPointingInsideKernel(MutexAddress)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid mutex address 0x{mutexAddress:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid mutex address 0x{MutexAddress:x16}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - if (IsAddressNotWordAligned(mutexAddress)) + if (IsAddressNotWordAligned(MutexAddress)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Unaligned mutex address 0x{mutexAddress:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Unaligned mutex address 0x{MutexAddress:x16}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); return; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - long result = currentProcess.AddressArbiter.ArbitrateUnlock(mutexAddress); + long Result = CurrentProcess.AddressArbiter.ArbitrateUnlock(MutexAddress); - if (result != 0) + if (Result != 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!"); } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } - private void SvcWaitProcessWideKeyAtomic(CpuThreadState threadState) + private void SvcWaitProcessWideKeyAtomic(CpuThreadState ThreadState) { - long mutexAddress = (long)threadState.X0; - long condVarAddress = (long)threadState.X1; - int threadHandle = (int)threadState.X2; - long timeout = (long)threadState.X3; + long MutexAddress = (long)ThreadState.X0; + long CondVarAddress = (long)ThreadState.X1; + int ThreadHandle = (int)ThreadState.X2; + long Timeout = (long)ThreadState.X3; Logger.PrintDebug(LogClass.KernelSvc, - "MutexAddress = 0x" + mutexAddress .ToString("x16") + ", " + - "CondVarAddress = 0x" + condVarAddress.ToString("x16") + ", " + - "ThreadHandle = 0x" + threadHandle .ToString("x8") + ", " + - "Timeout = 0x" + timeout .ToString("x16")); + "MutexAddress = 0x" + MutexAddress .ToString("x16") + ", " + + "CondVarAddress = 0x" + CondVarAddress.ToString("x16") + ", " + + "ThreadHandle = 0x" + ThreadHandle .ToString("x8") + ", " + + "Timeout = 0x" + Timeout .ToString("x16")); - if (IsPointingInsideKernel(mutexAddress)) + if (IsPointingInsideKernel(MutexAddress)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid mutex address 0x{mutexAddress:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid mutex address 0x{MutexAddress:x16}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - if (IsAddressNotWordAligned(mutexAddress)) + if (IsAddressNotWordAligned(MutexAddress)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Unaligned mutex address 0x{mutexAddress:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Unaligned mutex address 0x{MutexAddress:x16}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); return; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - long result = currentProcess.AddressArbiter.WaitProcessWideKeyAtomic( - mutexAddress, - condVarAddress, - threadHandle, - timeout); + long Result = CurrentProcess.AddressArbiter.WaitProcessWideKeyAtomic( + MutexAddress, + CondVarAddress, + ThreadHandle, + Timeout); - if (result != 0) + if (Result != 0) { - if (result == MakeError(ErrorModule.Kernel, KernelErr.Timeout)) + if (Result == MakeError(ErrorModule.Kernel, KernelErr.Timeout)) { - Logger.PrintDebug(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!"); + Logger.PrintDebug(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!"); } else { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!"); } } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } - private void SvcSignalProcessWideKey(CpuThreadState threadState) + private void SvcSignalProcessWideKey(CpuThreadState ThreadState) { - long address = (long)threadState.X0; - int count = (int)threadState.X1; + long Address = (long)ThreadState.X0; + int Count = (int)ThreadState.X1; Logger.PrintDebug(LogClass.KernelSvc, - "Address = 0x" + address.ToString("x16") + ", " + - "Count = 0x" + count .ToString("x8")); + "Address = 0x" + Address.ToString("x16") + ", " + + "Count = 0x" + Count .ToString("x8")); - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - currentProcess.AddressArbiter.SignalProcessWideKey(address, count); + CurrentProcess.AddressArbiter.SignalProcessWideKey(Address, Count); - threadState.X0 = 0; + ThreadState.X0 = 0; } - private void SvcWaitForAddress(CpuThreadState threadState) + private void SvcWaitForAddress(CpuThreadState ThreadState) { - long address = (long)threadState.X0; - ArbitrationType type = (ArbitrationType)threadState.X1; - int value = (int)threadState.X2; - long timeout = (long)threadState.X3; + long Address = (long)ThreadState.X0; + ArbitrationType Type = (ArbitrationType)ThreadState.X1; + int Value = (int)ThreadState.X2; + long Timeout = (long)ThreadState.X3; Logger.PrintDebug(LogClass.KernelSvc, - "Address = 0x" + address.ToString("x16") + ", " + - "Type = " + type .ToString() + ", " + - "Value = 0x" + value .ToString("x8") + ", " + - "Timeout = 0x" + timeout.ToString("x16")); + "Address = 0x" + Address.ToString("x16") + ", " + + "Type = " + Type .ToString() + ", " + + "Value = 0x" + Value .ToString("x8") + ", " + + "Timeout = 0x" + Timeout.ToString("x16")); - if (IsPointingInsideKernel(address)) + if (IsPointingInsideKernel(Address)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address 0x{address:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address 0x{Address:x16}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - if (IsAddressNotWordAligned(address)) + if (IsAddressNotWordAligned(Address)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Unaligned address 0x{address:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Unaligned address 0x{Address:x16}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); return; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - long result; + long Result; - switch (type) + switch (Type) { case ArbitrationType.WaitIfLessThan: - result = currentProcess.AddressArbiter.WaitForAddressIfLessThan(address, value, false, timeout); + Result = CurrentProcess.AddressArbiter.WaitForAddressIfLessThan(Address, Value, false, Timeout); break; case ArbitrationType.DecrementAndWaitIfLessThan: - result = currentProcess.AddressArbiter.WaitForAddressIfLessThan(address, value, true, timeout); + Result = CurrentProcess.AddressArbiter.WaitForAddressIfLessThan(Address, Value, true, Timeout); break; case ArbitrationType.WaitIfEqual: - result = currentProcess.AddressArbiter.WaitForAddressIfEqual(address, value, timeout); + Result = CurrentProcess.AddressArbiter.WaitForAddressIfEqual(Address, Value, Timeout); break; default: - result = MakeError(ErrorModule.Kernel, KernelErr.InvalidEnumValue); + Result = MakeError(ErrorModule.Kernel, KernelErr.InvalidEnumValue); break; } - if (result != 0) + if (Result != 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!"); } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } - private void SvcSignalToAddress(CpuThreadState threadState) + private void SvcSignalToAddress(CpuThreadState ThreadState) { - long address = (long)threadState.X0; - SignalType type = (SignalType)threadState.X1; - int value = (int)threadState.X2; - int count = (int)threadState.X3; + long Address = (long)ThreadState.X0; + SignalType Type = (SignalType)ThreadState.X1; + int Value = (int)ThreadState.X2; + int Count = (int)ThreadState.X3; Logger.PrintDebug(LogClass.KernelSvc, - "Address = 0x" + address.ToString("x16") + ", " + - "Type = " + type .ToString() + ", " + - "Value = 0x" + value .ToString("x8") + ", " + - "Count = 0x" + count .ToString("x8")); + "Address = 0x" + Address.ToString("x16") + ", " + + "Type = " + Type .ToString() + ", " + + "Value = 0x" + Value .ToString("x8") + ", " + + "Count = 0x" + Count .ToString("x8")); - if (IsPointingInsideKernel(address)) + if (IsPointingInsideKernel(Address)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address 0x{address:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address 0x{Address:x16}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - if (IsAddressNotWordAligned(address)) + if (IsAddressNotWordAligned(Address)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Unaligned address 0x{address:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Unaligned address 0x{Address:x16}!"); - threadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); return; } - KProcess currentProcess = _system.Scheduler.GetCurrentProcess(); + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); - long result; + long Result; - switch (type) + switch (Type) { case SignalType.Signal: - result = currentProcess.AddressArbiter.Signal(address, count); + Result = CurrentProcess.AddressArbiter.Signal(Address, Count); break; case SignalType.SignalAndIncrementIfEqual: - result = currentProcess.AddressArbiter.SignalAndIncrementIfEqual(address, value, count); + Result = CurrentProcess.AddressArbiter.SignalAndIncrementIfEqual(Address, Value, Count); break; case SignalType.SignalAndModifyIfEqual: - result = currentProcess.AddressArbiter.SignalAndModifyIfEqual(address, value, count); + Result = CurrentProcess.AddressArbiter.SignalAndModifyIfEqual(Address, Value, Count); break; default: - result = MakeError(ErrorModule.Kernel, KernelErr.InvalidEnumValue); + Result = MakeError(ErrorModule.Kernel, KernelErr.InvalidEnumValue); break; } - if (result != 0) + if (Result != 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{result:x}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Operation failed with error 0x{Result:x}!"); } - threadState.X0 = (ulong)result; + ThreadState.X0 = (ulong)Result; } - private bool IsPointingInsideKernel(long address) + private bool IsPointingInsideKernel(long Address) { - return ((ulong)address + 0x1000000000) < 0xffffff000; + return ((ulong)Address + 0x1000000000) < 0xffffff000; } - private bool IsAddressNotWordAligned(long address) + private bool IsAddressNotWordAligned(long Address) { - return (address & 3) != 0; + return (Address & 3) != 0; } } }
\ No newline at end of file |