condvar.c File Reference

#include <rtl_vista.h>
#include <debug.h>

Include dependency graph for condvar.c:

Go to the source code of this file.

Classes
struct	_COND_VAR_WAIT_ENTRY

Macros
#define	NDEBUG
#define	COND_VAR_UNUSED_FLAG   ((ULONG_PTR)1)
#define	COND_VAR_LOCKED_FLAG   ((ULONG_PTR)2)
#define	COND_VAR_FLAGS_MASK   ((ULONG_PTR)3)
#define	COND_VAR_ADDRESS_MASK   (~COND_VAR_FLAGS_MASK)
#define	CONTAINING_COND_VAR_WAIT_ENTRY(address, field)    CONTAINING_RECORD(address, COND_VAR_WAIT_ENTRY, field)

Typedefs
typedef struct _COND_VAR_WAIT_ENTRY	COND_VAR_WAIT_ENTRY
typedef struct _COND_VAR_WAIT_ENTRY *	PCOND_VAR_WAIT_ENTRY

Functions
FORCEINLINE ULONG_PTR	InternalCmpXChgCondVarAcq (IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, IN ULONG_PTR Exchange, IN ULONG_PTR Comperand)
FORCEINLINE ULONG_PTR	InternalCmpXChgCondVarRel (IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, IN ULONG_PTR Exchange, IN ULONG_PTR Comperand)
FORCEINLINE BOOLEAN *	InternalGetListRemovalHandledFlag (IN PCOND_VAR_WAIT_ENTRY Entry)
static PCOND_VAR_WAIT_ENTRY	InternalLockCondVar (IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, IN PCOND_VAR_WAIT_ENTRY InsertEntry OPTIONAL, IN BOOLEAN *AbortIfLocked OPTIONAL)
static VOID	InternalUnlockCondVar (IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, IN PCOND_VAR_WAIT_ENTRY RemoveEntry OPTIONAL)
static VOID	InternalWake (IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, IN BOOLEAN ReleaseAll)
VOID NTAPI	RtlAcquireSRWLockExclusive (IN OUT PRTL_SRWLOCK SRWLock)
VOID NTAPI	RtlAcquireSRWLockShared (IN OUT PRTL_SRWLOCK SRWLock)
VOID NTAPI	RtlReleaseSRWLockExclusive (IN OUT PRTL_SRWLOCK SRWLock)
VOID NTAPI	RtlReleaseSRWLockShared (IN OUT PRTL_SRWLOCK SRWLock)
static NTSTATUS	InternalSleep (IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, IN OUT PRTL_CRITICAL_SECTION CriticalSection OPTIONAL, IN OUT PRTL_SRWLOCK SRWLock OPTIONAL, IN ULONG SRWFlags, IN const LARGE_INTEGER *TimeOut OPTIONAL)
VOID NTAPI	RtlpInitializeKeyedEvent (VOID)
VOID NTAPI	RtlpCloseKeyedEvent (VOID)
VOID NTAPI	RtlInitializeConditionVariable (OUT PRTL_CONDITION_VARIABLE ConditionVariable)
VOID NTAPI	RtlWakeConditionVariable (IN OUT PRTL_CONDITION_VARIABLE ConditionVariable)
VOID NTAPI	RtlWakeAllConditionVariable (IN OUT PRTL_CONDITION_VARIABLE ConditionVariable)
NTSTATUS NTAPI	RtlSleepConditionVariableCS (IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, IN OUT PRTL_CRITICAL_SECTION CriticalSection, IN PLARGE_INTEGER TimeOut OPTIONAL)
NTSTATUS NTAPI	RtlSleepConditionVariableSRW (IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, IN OUT PRTL_SRWLOCK SRWLock, IN PLARGE_INTEGER TimeOut OPTIONAL, IN ULONG Flags)

Variables
static HANDLE	CondVarKeyedEventHandle = NULL

Macro Definition Documentation

COND_VAR_ADDRESS_MASK

#define COND_VAR_ADDRESS_MASK   (~COND_VAR_FLAGS_MASK)

Definition at line 26 of file condvar.c.

COND_VAR_FLAGS_MASK

#define COND_VAR_FLAGS_MASK   ((ULONG_PTR)3)

Definition at line 25 of file condvar.c.

COND_VAR_LOCKED_FLAG

#define COND_VAR_LOCKED_FLAG   ((ULONG_PTR)2)

Definition at line 24 of file condvar.c.

COND_VAR_UNUSED_FLAG

#define COND_VAR_UNUSED_FLAG   ((ULONG_PTR)1)

Definition at line 23 of file condvar.c.

CONTAINING_COND_VAR_WAIT_ENTRY

#define CONTAINING_COND_VAR_WAIT_ENTRY	(		address,
			field
	)		CONTAINING_RECORD(address, COND_VAR_WAIT_ENTRY, field)

Definition at line 37 of file condvar.c.

NDEBUG

#define NDEBUG

Definition at line 18 of file condvar.c.

Typedef Documentation

COND_VAR_WAIT_ENTRY

typedef struct _COND_VAR_WAIT_ENTRY COND_VAR_WAIT_ENTRY

PCOND_VAR_WAIT_ENTRY

typedef struct _COND_VAR_WAIT_ENTRY * PCOND_VAR_WAIT_ENTRY

Function Documentation

InternalCmpXChgCondVarAcq()

FORCEINLINE ULONG_PTR InternalCmpXChgCondVarAcq	(	IN OUT PRTL_CONDITION_VARIABLE	ConditionVariable,
		IN ULONG_PTR	Exchange,
		IN ULONG_PTR	Comperand
	)

Definition at line 48 of file condvar.c.

{
    return (ULONG_PTR)InterlockedCompareExchangePointerAcquire(&ConditionVariable->Ptr,
                                                               (PVOID)Exchange,
                                                               (PVOID)Comperand);
}

Referenced by InternalLockCondVar().

InternalCmpXChgCondVarRel()

FORCEINLINE ULONG_PTR InternalCmpXChgCondVarRel	(	IN OUT PRTL_CONDITION_VARIABLE	ConditionVariable,
		IN ULONG_PTR	Exchange,
		IN ULONG_PTR	Comperand
	)

Definition at line 59 of file condvar.c.

{
    return (ULONG_PTR)InterlockedCompareExchangePointerRelease(&ConditionVariable->Ptr,
                                                               (PVOID)Exchange,
                                                               (PVOID)Comperand);
}

Referenced by InternalUnlockCondVar().

InternalGetListRemovalHandledFlag()

FORCEINLINE BOOLEAN * InternalGetListRemovalHandledFlag

(

IN PCOND_VAR_WAIT_ENTRY

Entry

)

Definition at line 70 of file condvar.c.

{
    return (BOOLEAN *)&Entry->ListRemovalHandled;
}

Referenced by InternalSleep(), and InternalWake().

InternalLockCondVar()

static PCOND_VAR_WAIT_ENTRY InternalLockCondVar ( IN OUT PRTL_CONDITION_VARIABLE  ConditionVariable, IN PCOND_VAR_WAIT_ENTRY InsertEntry  OPTIONAL, IN BOOLEAN *AbortIfLocked  OPTIONAL  )

static

Definition at line 77 of file condvar.c.

{
    /* InsertEntry and AbortIfLocked may be NULL on entry. This routine
       will return NULL if the lock was not acquired. Otherwise it has
       successfully acquired the lock and the return value is a valid
       reference to the list head associated with ConditionVariable.
       The caller must in this case call InternalUnlockCondVar later
       in order to unlock the condition variable.
 
       If InsertEntry is NULL and there are no entries on the list, this
       routine will not acquire the lock and return NULL. If InsertEntry
       is not NULL this routine ensures that InsertEntry will be on the
       list when it returns successfully.
 
       If the lock is owned by another thread and AbortIfLocked is NULL,
       this routine will block until it acquires the lock. If AbortIfLocked
       is not NULL and the lock is owned by another thread, this routine
       will periodically check if *AbortIfLocked is nonzero and if so, will
       return NULL instead of continuing the wait. */
 
    ULONG_PTR OldVal = (ULONG_PTR)ConditionVariable->Ptr;
 
    for (;;)
    {
        ULONG_PTR NewVal, LockRes;
        PLIST_ENTRY OldListHead;
 
        if (OldVal & COND_VAR_LOCKED_FLAG)
        {
            /* The locked flag is set, indicating someone else currently
               holds the lock. We'll spin until this flag becomes
               clear or we're asked to abort. */
            YieldProcessor();
 
            if ((AbortIfLocked != NULL) && *AbortIfLocked)
            {
                /* The caller wants us to abort in this case. */
                return NULL;
            }
 
            /* Refresh OldVal and try again. */
            OldVal = *(ULONG_PTR *)&ConditionVariable->Ptr;
            continue;
        }
 
        /* Retrieve the list head currently associated with the
           condition variable. */
        OldListHead = (PLIST_ENTRY)(OldVal & COND_VAR_ADDRESS_MASK);
        if (InsertEntry == NULL)
        {
            /* The caller doesn't want to put any entry on the list. */
            if (OldListHead == NULL)
            {
                /* The list is empty, so there is nothing to lock. */
                return NULL;
            }
 
            /* The list isn't empty. In this case we need to preserve
               all of OldVal. */
            NewVal = OldVal;
        }
        else
        {
            /* Let InsertEntry be the new list head. Preserve only the
               bits inside the COND_VAR_FLAGS_MASK range. */
            NewVal = ((OldVal & COND_VAR_FLAGS_MASK) |
                      (ULONG_PTR)&InsertEntry->ListEntry);
        }
 
        /* Set the flag that indicates someone is holding the lock and
           try to update the condition variable thread-safe. */
        NewVal |= COND_VAR_LOCKED_FLAG;
        LockRes = InternalCmpXChgCondVarAcq(ConditionVariable, NewVal, OldVal);
        if (LockRes == OldVal)
        {
            /* We successfully updated ConditionVariable the way we
               wanted and now hold the lock. */
            if (InsertEntry == NULL)
            {
                /* We know that OldVal contains a valid address in
                   this case. */
                ASSERT(OldListHead != NULL);
                return CONTAINING_COND_VAR_WAIT_ENTRY(OldListHead, ListEntry);
            }
 
            /* InsertEntry is not on the list yet, so add it. In any
               case InsertEntry will be the new list head. */
            if (OldListHead == NULL)
            {
                /* List was empty before. */
                InitializeListHead(&InsertEntry->ListEntry);
            }
            else
            {
                /* Make InsertEntry the last entry of the old list.
                   As InsertEntry will take the role as new list head,
                   OldListHead will become the second entry (InsertEntry->Flink)
                   on the new list. */
                InsertTailList(OldListHead, &InsertEntry->ListEntry);
            }
 
            return InsertEntry;
        }
 
        /* We didn't manage to update ConditionVariable, so try again. */
        OldVal = LockRes;
    }
}

Referenced by InternalSleep(), and InternalWake().

InternalSleep()

static NTSTATUS InternalSleep ( IN OUT PRTL_CONDITION_VARIABLE  ConditionVariable, IN OUT PRTL_CRITICAL_SECTION CriticalSection  OPTIONAL, IN OUT PRTL_SRWLOCK SRWLock  OPTIONAL, IN ULONG  SRWFlags, IN const LARGE_INTEGER *TimeOut  OPTIONAL  )

static

Definition at line 367 of file condvar.c.

{
    /* Either CriticalSection or SRWLock must be NULL, but not both.
       These caller provided lock must be held on entry and will be
       held again on return. */
 
    COND_VAR_WAIT_ENTRY OwnEntry;
    NTSTATUS Status;
 
    ASSERT(CondVarKeyedEventHandle != NULL);
    ASSERT((CriticalSection == NULL) != (SRWLock == NULL));
 
    RtlZeroMemory(&OwnEntry, sizeof(OwnEntry));
 
    /* Put OwnEntry on the list. */
    InternalLockCondVar(ConditionVariable, &OwnEntry, NULL);
    InternalUnlockCondVar(ConditionVariable, NULL);
 
    /* We can now drop the caller provided lock as a preparation for
       going to sleep. */
    if (CriticalSection == NULL)
    {
        if (0 == (RTL_CONDITION_VARIABLE_LOCKMODE_SHARED & SRWFlags))
        {
            RtlReleaseSRWLockExclusive(SRWLock);
        }
        else
        {
            RtlReleaseSRWLockShared(SRWLock);
        }
    }
    else
    {
        RtlLeaveCriticalSection(CriticalSection);
    }
 
    /* Now sleep using the caller provided timeout. */
    Status = NtWaitForKeyedEvent(CondVarKeyedEventHandle,
                                 &OwnEntry.WaitKey,
                                 FALSE,
                                 (PLARGE_INTEGER)TimeOut);
 
    ASSERT(STATUS_INVALID_HANDLE != Status);
 
    if (!*InternalGetListRemovalHandledFlag(&OwnEntry))
    {
        /* Remove OwnEntry from the list again, since it still seems to
           be on the list. We will know for sure once we've acquired
           the lock. */
        if (InternalLockCondVar(ConditionVariable,
                                NULL,
                                InternalGetListRemovalHandledFlag(&OwnEntry)))
        {
            /* Unlock and potentially remove OwnEntry. Self-removal is
               usually only necessary when a timeout occurred. */
            InternalUnlockCondVar(ConditionVariable,
                                  !OwnEntry.ListRemovalHandled ?
                                  &OwnEntry : NULL);
        }
    }
 
#ifdef _DEBUG
    /* Clear OwnEntry to aid in detecting bugs. */
    RtlZeroMemory(&OwnEntry, sizeof(OwnEntry));
#endif
 
    /* Reacquire the caller provided lock, as we are about to return. */
    if (CriticalSection == NULL)
    {
        if (0 == (RTL_CONDITION_VARIABLE_LOCKMODE_SHARED & SRWFlags))
        {
            RtlAcquireSRWLockExclusive(SRWLock);
        }
        else
        {
            RtlAcquireSRWLockShared(SRWLock);
        }
    }
    else
    {
        RtlEnterCriticalSection(CriticalSection);
    }
 
    /* Return whatever NtWaitForKeyedEvent returned. */
    return Status;
}

Referenced by RtlSleepConditionVariableCS(), and RtlSleepConditionVariableSRW().

InternalUnlockCondVar()

static VOID InternalUnlockCondVar ( IN OUT PRTL_CONDITION_VARIABLE  ConditionVariable, IN PCOND_VAR_WAIT_ENTRY RemoveEntry  OPTIONAL  )

static

Definition at line 190 of file condvar.c.

{
    /* This routine assumes that the lock is being held on entry.
       RemoveEntry may be NULL. If it is not NULL, this routine
       assumes that RemoveEntry is on the list and will remove it
       before releasing the lock. */
    ULONG_PTR OldVal = (ULONG_PTR)ConditionVariable->Ptr;
    PLIST_ENTRY NewHeadEntry;
 
    ASSERT((OldVal & COND_VAR_LOCKED_FLAG) &&
           (OldVal & COND_VAR_ADDRESS_MASK));
 
    NewHeadEntry = (PLIST_ENTRY)(OldVal & COND_VAR_ADDRESS_MASK);
    if (RemoveEntry != NULL)
    {
        /* We have to drop RemoveEntry from the list. */
        if (&RemoveEntry->ListEntry == NewHeadEntry)
        {
            /* RemoveEntry is the list head. */
            if (!IsListEmpty(NewHeadEntry))
            {
                /* The second entry in the list will become the new
                   list head. It's from the thread that arrived
                   right before the owner of RemoveEntry. */
                NewHeadEntry = NewHeadEntry->Flink;
                RemoveEntryList(&RemoveEntry->ListEntry);
            }
            else
            {
                /* The list will be empty, so discard the list. */
                NewHeadEntry = NULL;
            }
        }
        else
        {
            /* RemoveEntry is not the list head. The current list head
               will remain. */
            RemoveEntryList(&RemoveEntry->ListEntry);
        }
 
        /* Indicate to the owner of RemoveEntry that the entry
           was removed from the list. RemoveEntry may not be touched
           from here on. We don't use volatile semantics here since
           the cache will anyway be flushed soon when we update
           ConditionVariable. */
        RemoveEntry->ListRemovalHandled = TRUE;
    }
 
    /* Now unlock thread-safe, while preserving any flags within the
       COND_VAR_FLAGS_MASK range except for COND_VAR_LOCKED_FLAG. */
    for (;;)
    {
        ULONG_PTR NewVal = ((OldVal & (COND_VAR_FLAGS_MASK ^ COND_VAR_LOCKED_FLAG)) |
                            (ULONG_PTR)NewHeadEntry);
        ULONG_PTR LockRes = InternalCmpXChgCondVarRel(ConditionVariable, NewVal, OldVal);
        if (LockRes == OldVal)
        {
            /* We unlocked. */
            break;
        }
 
        /* Try again. */
        OldVal = LockRes;
    }
}

Referenced by InternalSleep(), and InternalWake().

InternalWake()

static VOID InternalWake ( IN OUT PRTL_CONDITION_VARIABLE  ConditionVariable, IN BOOLEAN  ReleaseAll  )

static

Definition at line 259 of file condvar.c.

{
    /* If ReleaseAll is zero on entry, one thread at most will be woken.
       Otherwise all waiting threads are woken. Wakeups happen in FIFO
       order. */
    PCOND_VAR_WAIT_ENTRY CONST HeadEntry = InternalLockCondVar(ConditionVariable, NULL, NULL);
    PCOND_VAR_WAIT_ENTRY Entry;
    PCOND_VAR_WAIT_ENTRY NextEntry;
    LARGE_INTEGER Timeout;
    PCOND_VAR_WAIT_ENTRY RemoveOnUnlockEntry;
 
    ASSERT(CondVarKeyedEventHandle != NULL);
 
    if (HeadEntry == NULL)
    {
        /* There is noone there to wake up. In this case do nothing
           and return immediately. We don't stockpile releases. */
        return;
    }
 
    Timeout.QuadPart = 0;
    RemoveOnUnlockEntry = NULL;
 
    /* Release sleeping threads. We will iterate from the last entry on
       the list to the first. Note that the loop condition is always
       true for the initial test. */
    for (Entry = CONTAINING_COND_VAR_WAIT_ENTRY(HeadEntry->ListEntry.Blink, ListEntry);
         Entry != NULL;
         Entry = NextEntry)
    {
        NTSTATUS Status;
 
        if (HeadEntry == Entry)
        {
            /* After the current entry we've iterated through the
               entire list in backward direction. Then exit.*/
            NextEntry = NULL;
        }
        else
        {
            /* Store away the next reference right now, since we may
               not touch Entry anymore at the end of the block. */
            NextEntry = CONTAINING_COND_VAR_WAIT_ENTRY(Entry->ListEntry.Blink, ListEntry);
        }
 
        /* Wake the thread associated with this event. We will
           immediately return if we failed (zero timeout). */
        Status = NtReleaseKeyedEvent(CondVarKeyedEventHandle,
                                     &Entry->WaitKey,
                                     FALSE,
                                     &Timeout);
 
        if (!NT_SUCCESS(Status))
        {
            /* We failed to wake a thread. We'll keep trying. */
            ASSERT(STATUS_INVALID_HANDLE != Status);
            continue;
        }
 
        /* We've woken a thread and will make sure this thread
           is removed from the list. */
        if (HeadEntry == Entry)
        {
            /* This is the list head. We can't remove it as easily as
               other entries and will pass it to the unlock routine
               later (we will exit the loop after this round anyway). */
            RemoveOnUnlockEntry = HeadEntry;
        }
        else
        {
            /* We can remove the entry right away. */
            RemoveEntryList(&Entry->ListEntry);
 
            /* Now tell the woken thread that removal from the list was
               already taken care of here so that this thread can resume
               its normal operation more quickly. We may not touch
               Entry after signaling this, since it may lie in invalid
               memory from there on. */
            *InternalGetListRemovalHandledFlag(Entry) = TRUE;
        }
 
        if (!ReleaseAll)
        {
            /* We've successfully woken one thread as the caller
               demanded. */
            break;
        }
    }
 
    InternalUnlockCondVar(ConditionVariable, RemoveOnUnlockEntry);
}

Referenced by RtlWakeAllConditionVariable(), and RtlWakeConditionVariable().

RtlAcquireSRWLockExclusive()

VOID NTAPI RtlAcquireSRWLockExclusive

(

IN OUT PRTL_SRWLOCK

SRWLock

)

Definition at line 591 of file srw.c.

{
    __ALIGNED(16) RTLP_SRWLOCK_WAITBLOCK StackWaitBlock;
    PRTLP_SRWLOCK_WAITBLOCK First, Last;
 
    if (InterlockedBitTestAndSetPointer(&SRWLock->Ptr,
                                        RTL_SRWLOCK_OWNED_BIT))
    {
        LONG_PTR CurrentValue, NewValue;
 
        while (1)
        {
            CurrentValue = *(volatile LONG_PTR *)&SRWLock->Ptr;
 
            if (CurrentValue & RTL_SRWLOCK_SHARED)
            {
                /* A shared lock is being held right now. We need to add a wait block! */
 
                if (CurrentValue & RTL_SRWLOCK_CONTENDED)
                {
                    goto AddWaitBlock;
                }
                else
                {
                    /* There are no wait blocks so far, we need to add ourselves as the first
                       wait block. We need to keep the shared count! */
                    StackWaitBlock.Exclusive = TRUE;
                    StackWaitBlock.SharedCount = (LONG)(CurrentValue >> RTL_SRWLOCK_BITS);
                    StackWaitBlock.Next = NULL;
                    StackWaitBlock.Last = &StackWaitBlock;
                    StackWaitBlock.Wake = 0;
 
                    NewValue = (ULONG_PTR)&StackWaitBlock | RTL_SRWLOCK_SHARED | RTL_SRWLOCK_CONTENDED | RTL_SRWLOCK_OWNED;
 
                    if ((LONG_PTR)InterlockedCompareExchangePointer(&SRWLock->Ptr,
                                                                    (PVOID)NewValue,
                                                                    (PVOID)CurrentValue) == CurrentValue)
                    {
                        RtlpAcquireSRWLockExclusiveWait(SRWLock,
                                                        &StackWaitBlock);
 
                        /* Successfully acquired the exclusive lock */
                        break;
                    }
                }
            }
            else
            {
                if (CurrentValue & RTL_SRWLOCK_OWNED)
                {
                    /* An exclusive lock is being held right now. We need to add a wait block! */
 
                    if (CurrentValue & RTL_SRWLOCK_CONTENDED)
                    {
AddWaitBlock:
                        StackWaitBlock.Exclusive = TRUE;
                        StackWaitBlock.SharedCount = 0;
                        StackWaitBlock.Next = NULL;
                        StackWaitBlock.Last = &StackWaitBlock;
                        StackWaitBlock.Wake = 0;
 
                        First = RtlpAcquireWaitBlockLock(SRWLock);
                        if (First != NULL)
                        {
                            Last = First->Last;
                            Last->Next = &StackWaitBlock;
                            First->Last = &StackWaitBlock;
 
                            RtlpReleaseWaitBlockLock(SRWLock);
 
                            RtlpAcquireSRWLockExclusiveWait(SRWLock,
                                                            &StackWaitBlock);
 
                            /* Successfully acquired the exclusive lock */
                            break;
                        }
                    }
                    else
                    {
                        /* There are no wait blocks so far, we need to add ourselves as the first
                           wait block. We need to keep the shared count! */
                        StackWaitBlock.Exclusive = TRUE;
                        StackWaitBlock.SharedCount = 0;
                        StackWaitBlock.Next = NULL;
                        StackWaitBlock.Last = &StackWaitBlock;
                        StackWaitBlock.Wake = 0;
 
                        NewValue = (ULONG_PTR)&StackWaitBlock | RTL_SRWLOCK_OWNED | RTL_SRWLOCK_CONTENDED;
                        if ((LONG_PTR)InterlockedCompareExchangePointer(&SRWLock->Ptr,
                                                                        (PVOID)NewValue,
                                                                        (PVOID)CurrentValue) == CurrentValue)
                        {
                            RtlpAcquireSRWLockExclusiveWait(SRWLock,
                                                            &StackWaitBlock);
 
                            /* Successfully acquired the exclusive lock */
                            break;
                        }
                    }
                }
                else
                {
                    if (!InterlockedBitTestAndSetPointer(&SRWLock->Ptr,
                                                         RTL_SRWLOCK_OWNED_BIT))
                    {
                        /* We managed to get hold of a simple exclusive lock! */
                        break;
                    }
                }
            }
 
            YieldProcessor();
        }
    }
}

Referenced by InternalSleep().

RtlAcquireSRWLockShared()

VOID NTAPI RtlAcquireSRWLockShared

(

IN OUT PRTL_SRWLOCK

SRWLock

)

Definition at line 325 of file srw.c.

{
    __ALIGNED(16) RTLP_SRWLOCK_WAITBLOCK StackWaitBlock;
    RTLP_SRWLOCK_SHARED_WAKE SharedWake;
    LONG_PTR CurrentValue, NewValue;
    PRTLP_SRWLOCK_WAITBLOCK First, Shared, FirstWait;
 
    while (1)
    {
        CurrentValue = *(volatile LONG_PTR *)&SRWLock->Ptr;
 
        if (CurrentValue & RTL_SRWLOCK_SHARED)
        {
            /* NOTE: It is possible that the RTL_SRWLOCK_OWNED bit is set! */
 
            if (CurrentValue & RTL_SRWLOCK_CONTENDED)
            {
                /* There's other waiters already, lock the wait blocks and
                   increment the shared count */
                First = RtlpAcquireWaitBlockLock(SRWLock);
                if (First != NULL)
                {
                    FirstWait = NULL;
 
                    if (First->Exclusive)
                    {
                        /* We need to setup a new wait block! Although
                           we're currently in a shared lock and we're acquiring
                           a shared lock, there are exclusive locks queued. We need
                           to wait until those are released. */
                        Shared = First->Last;
 
                        if (Shared->Exclusive)
                        {
                            StackWaitBlock.Exclusive = FALSE;
                            StackWaitBlock.SharedCount = 1;
                            StackWaitBlock.Next = NULL;
                            StackWaitBlock.Last = &StackWaitBlock;
                            StackWaitBlock.SharedWakeChain = &SharedWake;
 
                            Shared->Next = &StackWaitBlock;
                            First->Last = &StackWaitBlock;
 
                            Shared = &StackWaitBlock;
                            FirstWait = &StackWaitBlock;
                        }
                        else
                        {
                            Shared->LastSharedWake->Next = &SharedWake;
                            Shared->SharedCount++;
                        }
                    }
                    else
                    {
                        Shared = First;
                        Shared->LastSharedWake->Next = &SharedWake;
                        Shared->SharedCount++;
                    }
 
                    SharedWake.Next = NULL;
                    SharedWake.Wake = 0;
 
                    Shared->LastSharedWake = &SharedWake;
 
                    RtlpReleaseWaitBlockLock(SRWLock);
 
                    RtlpAcquireSRWLockSharedWait(SRWLock,
                                                 FirstWait,
                                                 &SharedWake);
 
                    /* Successfully incremented the shared count, we acquired the lock */
                    break;
                }
            }
            else
            {
                /* This is a fastest path, just increment the number of
                   current shared locks */
 
                /* Since the RTL_SRWLOCK_SHARED bit is set, the RTL_SRWLOCK_OWNED bit also has
                   to be set! */
 
                ASSERT(CurrentValue & RTL_SRWLOCK_OWNED);
 
                NewValue = (CurrentValue >> RTL_SRWLOCK_BITS) + 1;
                NewValue = (NewValue << RTL_SRWLOCK_BITS) | (CurrentValue & RTL_SRWLOCK_MASK);
 
                if ((LONG_PTR)InterlockedCompareExchangePointer(&SRWLock->Ptr,
                                                                (PVOID)NewValue,
                                                                (PVOID)CurrentValue) == CurrentValue)
                {
                    /* Successfully incremented the shared count, we acquired the lock */
                    break;
                }
            }
        }
        else
        {
            if (CurrentValue & RTL_SRWLOCK_OWNED)
            {
                /* The resource is currently acquired exclusively */
                if (CurrentValue & RTL_SRWLOCK_CONTENDED)
                {
                    SharedWake.Next = NULL;
                    SharedWake.Wake = 0;
 
                    /* There's other waiters already, lock the wait blocks and
                       increment the shared count. If the last block in the chain
                       is an exclusive lock, add another block. */
 
                    StackWaitBlock.Exclusive = FALSE;
                    StackWaitBlock.SharedCount = 0;
                    StackWaitBlock.Next = NULL;
                    StackWaitBlock.Last = &StackWaitBlock;
                    StackWaitBlock.SharedWakeChain = &SharedWake;
 
                    First = RtlpAcquireWaitBlockLock(SRWLock);
                    if (First != NULL)
                    {
                        Shared = First->Last;
                        if (Shared->Exclusive)
                        {
                            Shared->Next = &StackWaitBlock;
                            First->Last = &StackWaitBlock;
 
                            Shared = &StackWaitBlock;
                            FirstWait = &StackWaitBlock;
                        }
                        else
                        {
                            FirstWait = NULL;
                            Shared->LastSharedWake->Next = &SharedWake;
                        }
 
                        Shared->SharedCount++;
                        Shared->LastSharedWake = &SharedWake;
 
                        RtlpReleaseWaitBlockLock(SRWLock);
 
                        RtlpAcquireSRWLockSharedWait(SRWLock,
                                                     FirstWait,
                                                     &SharedWake);
 
                        /* Successfully incremented the shared count, we acquired the lock */
                        break;
                    }
                }
                else
                {
                    SharedWake.Next = NULL;
                    SharedWake.Wake = 0;
 
                    /* We need to setup the first wait block. Currently an exclusive lock is
                       held, change the lock to contended mode. */
                    StackWaitBlock.Exclusive = FALSE;
                    StackWaitBlock.SharedCount = 1;
                    StackWaitBlock.Next = NULL;
                    StackWaitBlock.Last = &StackWaitBlock;
                    StackWaitBlock.SharedWakeChain = &SharedWake;
                    StackWaitBlock.LastSharedWake = &SharedWake;
 
                    NewValue = (ULONG_PTR)&StackWaitBlock | RTL_SRWLOCK_OWNED | RTL_SRWLOCK_CONTENDED;
                    if ((LONG_PTR)InterlockedCompareExchangePointer(&SRWLock->Ptr,
                                                                    (PVOID)NewValue,
                                                                    (PVOID)CurrentValue) == CurrentValue)
                    {
                        RtlpAcquireSRWLockSharedWait(SRWLock,
                                                     &StackWaitBlock,
                                                     &SharedWake);
 
                        /* Successfully set the shared count, we acquired the lock */
                        break;
                    }
                }
            }
            else
            {
                /* This is a fast path, we can simply try to set the shared count to 1 */
                NewValue = (1 << RTL_SRWLOCK_BITS) | RTL_SRWLOCK_SHARED | RTL_SRWLOCK_OWNED;
 
                /* The RTL_SRWLOCK_CONTENDED bit should never be set if neither the
                   RTL_SRWLOCK_SHARED nor the RTL_SRWLOCK_OWNED bit is set */
                ASSERT(!(CurrentValue & RTL_SRWLOCK_CONTENDED));
 
                if ((LONG_PTR)InterlockedCompareExchangePointer(&SRWLock->Ptr,
                                                                (PVOID)NewValue,
                                                                (PVOID)CurrentValue) == CurrentValue)
                {
                    /* Successfully set the shared count, we acquired the lock */
                    break;
                }
            }
        }
 
        YieldProcessor();
    }
}

Referenced by InternalSleep().

RtlInitializeConditionVariable()

VOID NTAPI RtlInitializeConditionVariable

(

OUT PRTL_CONDITION_VARIABLE

ConditionVariable

)

Definition at line 479 of file condvar.c.

{
    ConditionVariable->Ptr = NULL;
}

RtlpCloseKeyedEvent()

VOID NTAPI RtlpCloseKeyedEvent

(

VOID

)

Definition at line 468 of file condvar.c.

{
    ASSERT(CondVarKeyedEventHandle != NULL);
    NtClose(CondVarKeyedEventHandle);
    CondVarKeyedEventHandle = NULL;
}

Referenced by DllMain().

RtlpInitializeKeyedEvent()

VOID NTAPI RtlpInitializeKeyedEvent

(

VOID

)

Definition at line 460 of file condvar.c.

{
    ASSERT(CondVarKeyedEventHandle == NULL);
    NtCreateKeyedEvent(&CondVarKeyedEventHandle, EVENT_ALL_ACCESS, NULL, 0);
}

Referenced by DllMain(), and LdrpInitializeProcess().

RtlReleaseSRWLockExclusive()

VOID NTAPI RtlReleaseSRWLockExclusive

(

IN OUT PRTL_SRWLOCK

SRWLock

)

Definition at line 710 of file srw.c.

{
    LONG_PTR CurrentValue, NewValue;
    PRTLP_SRWLOCK_WAITBLOCK WaitBlock;
 
    while (1)
    {
        CurrentValue = *(volatile LONG_PTR *)&SRWLock->Ptr;
 
        if (!(CurrentValue & RTL_SRWLOCK_OWNED))
        {
            RtlRaiseStatus(STATUS_RESOURCE_NOT_OWNED);
        }
 
        if (!(CurrentValue & RTL_SRWLOCK_SHARED))
        {
            if (CurrentValue & RTL_SRWLOCK_CONTENDED)
            {
                /* There's a wait block, we need to wake the next pending
                   acquirer (exclusive or shared) */
                WaitBlock = RtlpAcquireWaitBlockLock(SRWLock);
                if (WaitBlock != NULL)
                {
                    RtlpReleaseWaitBlockLockExclusive(SRWLock,
                                                      WaitBlock);
 
                    /* We released the lock */
                    break;
                }
            }
            else
            {
                /* This is a fast path, we can simply clear the RTL_SRWLOCK_OWNED
                   bit. All other bits should be 0 now because this is a simple
                   exclusive lock and no one is waiting. */
 
                ASSERT(!(CurrentValue & ~RTL_SRWLOCK_OWNED));
 
                NewValue = 0;
                if ((LONG_PTR)InterlockedCompareExchangePointer(&SRWLock->Ptr,
                                                                (PVOID)NewValue,
                                                                (PVOID)CurrentValue) == CurrentValue)
                {
                    /* We released the lock */
                    break;
                }
            }
        }
        else
        {
            /* The RTL_SRWLOCK_SHARED bit must not be present now,
               not even in the contended case! */
            RtlRaiseStatus(STATUS_RESOURCE_NOT_OWNED);
        }
 
        YieldProcessor();
    }
}

Referenced by InternalSleep().

RtlReleaseSRWLockShared()

VOID NTAPI RtlReleaseSRWLockShared

(

IN OUT PRTL_SRWLOCK

SRWLock

)

Definition at line 526 of file srw.c.

{
    LONG_PTR CurrentValue, NewValue;
    PRTLP_SRWLOCK_WAITBLOCK WaitBlock;
    BOOLEAN LastShared;
 
    while (1)
    {
        CurrentValue = *(volatile LONG_PTR *)&SRWLock->Ptr;
 
        if (CurrentValue & RTL_SRWLOCK_SHARED)
        {
            if (CurrentValue & RTL_SRWLOCK_CONTENDED)
            {
                /* There's a wait block, we need to wake a pending
                   exclusive acquirer if this is the last shared release */
                WaitBlock = RtlpAcquireWaitBlockLock(SRWLock);
                if (WaitBlock != NULL)
                {
                    LastShared = (--WaitBlock->SharedCount == 0);
 
                    if (LastShared)
                        RtlpReleaseWaitBlockLockLastShared(SRWLock,
                                                           WaitBlock);
                    else
                        RtlpReleaseWaitBlockLock(SRWLock);
 
                    /* We released the lock */
                    break;
                }
            }
            else
            {
                /* This is a fast path, we can simply decrement the shared
                   count and store the pointer */
                NewValue = CurrentValue >> RTL_SRWLOCK_BITS;
 
                if (--NewValue != 0)
                {
                    NewValue = (NewValue << RTL_SRWLOCK_BITS) | RTL_SRWLOCK_SHARED | RTL_SRWLOCK_OWNED;
                }
 
                if ((LONG_PTR)InterlockedCompareExchangePointer(&SRWLock->Ptr,
                                                                (PVOID)NewValue,
                                                                (PVOID)CurrentValue) == CurrentValue)
                {
                    /* Successfully released the lock */
                    break;
                }
            }
        }
        else
        {
            /* The RTL_SRWLOCK_SHARED bit has to be present now,
               even in the contended case! */
            RtlRaiseStatus(STATUS_RESOURCE_NOT_OWNED);
        }
 
        YieldProcessor();
    }
}

Referenced by InternalSleep().

RtlSleepConditionVariableCS()

NTSTATUS NTAPI RtlSleepConditionVariableCS	(	IN OUT PRTL_CONDITION_VARIABLE	ConditionVariable,
		IN OUT PRTL_CRITICAL_SECTION	CriticalSection,
		IN PLARGE_INTEGER TimeOut	OPTIONAL
	)

Definition at line 500 of file condvar.c.

{
    return InternalSleep(ConditionVariable,
                         CriticalSection,
                         (PRTL_SRWLOCK)NULL,
                         0,
                         TimeOut);
}

RtlSleepConditionVariableSRW()

NTSTATUS NTAPI RtlSleepConditionVariableSRW	(	IN OUT PRTL_CONDITION_VARIABLE	ConditionVariable,
		IN OUT PRTL_SRWLOCK	SRWLock,
		IN PLARGE_INTEGER TimeOut	OPTIONAL,
		IN ULONG	Flags
	)

Definition at line 513 of file condvar.c.

{
    return InternalSleep(ConditionVariable,
                         (PRTL_CRITICAL_SECTION)NULL,
                         SRWLock,
                         Flags,
                         TimeOut);
}

RtlWakeAllConditionVariable()

VOID NTAPI RtlWakeAllConditionVariable

(

IN OUT PRTL_CONDITION_VARIABLE

ConditionVariable

)

Definition at line 493 of file condvar.c.

{
    InternalWake(ConditionVariable, TRUE);
}

RtlWakeConditionVariable()

VOID NTAPI RtlWakeConditionVariable

(

IN OUT PRTL_CONDITION_VARIABLE

ConditionVariable

)

Definition at line 486 of file condvar.c.

{
    InternalWake(ConditionVariable, FALSE);
}

Variable Documentation

CondVarKeyedEventHandle

HANDLE CondVarKeyedEventHandle = NULL

static

Definition at line 42 of file condvar.c.

Referenced by InternalSleep(), InternalWake(), RtlpCloseKeyedEvent(), and RtlpInitializeKeyedEvent().