public static ulong WaitForAddressIfLessThan(Process Process, AThreadState ThreadState, AMemory Memory, long Address, int Value, ulong Timeout, bool ShouldDecrement) { Memory.SetExclusive(ThreadState, Address); int CurrentValue = Memory.ReadInt32(Address); while (true) { if (Memory.TestExclusive(ThreadState, Address)) { if (CurrentValue < Value) { if (ShouldDecrement) { Memory.WriteInt32(Address, CurrentValue - 1); } Memory.ClearExclusiveForStore(ThreadState); } else { Memory.ClearExclusiveForStore(ThreadState); return(MakeError(ErrorModule.Kernel, KernelErr.InvalidState)); } break; } Memory.SetExclusive(ThreadState, Address); CurrentValue = Memory.ReadInt32(Address); } if (Timeout == 0) { return(MakeError(ErrorModule.Kernel, KernelErr.Timeout)); } return(WaitForAddress(Process, ThreadState, Address, Timeout)); }
public long SignalAndIncrementIfEqual(AMemory Memory, long Address, int Value, int Count) { System.CriticalSectionLock.Lock(); Memory.SetExclusive(0, Address); if (!UserToKernelInt32(Memory, Address, out int CurrentValue)) { System.CriticalSectionLock.Unlock(); return(MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm)); } while (CurrentValue == Value) { if (Memory.TestExclusive(0, Address)) { Memory.WriteInt32(Address, CurrentValue + 1); Memory.ClearExclusiveForStore(0); break; } Memory.SetExclusive(0, Address); CurrentValue = Memory.ReadInt32(Address); } Memory.ClearExclusive(0); if (CurrentValue != Value) { System.CriticalSectionLock.Unlock(); return(MakeError(ErrorModule.Kernel, KernelErr.InvalidState)); } WakeArbiterThreads(Address, Count); System.CriticalSectionLock.Unlock(); return(0); }
private KThread TryAcquireMutex(Process Process, AMemory Memory, KThread Requester) { int Core = Requester.CurrentCore; long Address = Requester.MutexAddress; Memory.SetExclusive(Core, Address); int MutexValue = Memory.ReadInt32(Address); while (MutexValue != 0) { if (Memory.TestExclusive(Core, Address)) { if (MutexValue != 0) { //Update value to indicate there is a mutex waiter now. Memory.WriteInt32(Address, MutexValue | HasListenersMask); } else { //No thread owning the mutex, assign to requesting thread. Memory.WriteInt32(Address, Requester.ThreadHandleForUserMutex); } Memory.ClearExclusiveForStore(Core); break; } Memory.SetExclusive(Core, Address); MutexValue = Memory.ReadInt32(Address); } if (MutexValue == 0) { //We now own the mutex. Requester.SignaledObj = null; Requester.ObjSyncResult = 0; Requester.ReleaseAndResume(); return(null); } MutexValue &= ~HasListenersMask; KThread MutexOwner = Process.HandleTable.GetData <KThread>(MutexValue); if (MutexOwner != null) { //Mutex already belongs to another thread, wait for it. MutexOwner.AddMutexWaiter(Requester); } else { //Invalid mutex owner. Requester.SignaledObj = null; Requester.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.InvalidHandle); Requester.ReleaseAndResume(); } return(MutexOwner); }
public long SignalAndModifyIfEqual(AMemory Memory, long Address, int Value, int Count) { System.CriticalSectionLock.Lock(); 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; foreach (KThread Thread in ArbiterThreads.Where(x => x.MutexAddress == Address)) { if (++WaitingCount > Count) { break; } } if (WaitingCount > 0) { Offset = WaitingCount <= Count || Count <= 0 ? -1 : 0; } else { Offset = 1; } Memory.SetExclusive(0, Address); if (!UserToKernelInt32(Memory, Address, out int CurrentValue)) { System.CriticalSectionLock.Unlock(); return(MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm)); } while (CurrentValue == Value) { if (Memory.TestExclusive(0, Address)) { Memory.WriteInt32(Address, CurrentValue + Offset); Memory.ClearExclusiveForStore(0); break; } Memory.SetExclusive(0, Address); CurrentValue = Memory.ReadInt32(Address); } Memory.ClearExclusive(0); if (CurrentValue != Value) { System.CriticalSectionLock.Unlock(); return(MakeError(ErrorModule.Kernel, KernelErr.InvalidState)); } WakeArbiterThreads(Address, Count); System.CriticalSectionLock.Unlock(); return(0); }
public long WaitForAddressIfLessThan( AMemory Memory, long Address, int Value, bool ShouldDecrement, long Timeout) { KThread CurrentThread = System.Scheduler.GetCurrentThread(); System.CriticalSectionLock.Lock(); if (CurrentThread.ShallBeTerminated || CurrentThread.SchedFlags == ThreadSchedState.TerminationPending) { System.CriticalSectionLock.Unlock(); return(MakeError(ErrorModule.Kernel, KernelErr.ThreadTerminating)); } CurrentThread.SignaledObj = null; CurrentThread.ObjSyncResult = (int)MakeError(ErrorModule.Kernel, KernelErr.Timeout); //If ShouldDecrement is true, do atomic decrement of the value at Address. Memory.SetExclusive(0, Address); if (!UserToKernelInt32(Memory, Address, out int CurrentValue)) { System.CriticalSectionLock.Unlock(); return(MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm)); } if (ShouldDecrement) { while (CurrentValue < Value) { if (Memory.TestExclusive(0, Address)) { Memory.WriteInt32(Address, CurrentValue - 1); Memory.ClearExclusiveForStore(0); break; } Memory.SetExclusive(0, Address); CurrentValue = Memory.ReadInt32(Address); } } Memory.ClearExclusive(0); if (CurrentValue < Value) { if (Timeout == 0) { System.CriticalSectionLock.Unlock(); return(MakeError(ErrorModule.Kernel, KernelErr.Timeout)); } CurrentThread.MutexAddress = Address; CurrentThread.WaitingInArbitration = true; InsertSortedByPriority(ArbiterThreads, CurrentThread); CurrentThread.Reschedule(ThreadSchedState.Paused); if (Timeout > 0) { System.TimeManager.ScheduleFutureInvocation(CurrentThread, Timeout); } System.CriticalSectionLock.Unlock(); if (Timeout > 0) { System.TimeManager.UnscheduleFutureInvocation(CurrentThread); } System.CriticalSectionLock.Lock(); if (CurrentThread.WaitingInArbitration) { ArbiterThreads.Remove(CurrentThread); CurrentThread.WaitingInArbitration = false; } System.CriticalSectionLock.Unlock(); return(CurrentThread.ObjSyncResult); } System.CriticalSectionLock.Unlock(); return(MakeError(ErrorModule.Kernel, KernelErr.InvalidState)); }