srw.c File Reference

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

Include dependency graph for srw.c:

Go to the source code of this file.

Classes
struct	_RTLP_SRWLOCK_SHARED_WAKE
struct	_RTLP_SRWLOCK_WAITBLOCK

Macros
#define	NDEBUG
#define	InterlockedBitTestAndSetPointer(ptr, val)   InterlockedBitTestAndSet((PLONG)ptr,(LONG)val)
#define	InterlockedAddPointer(ptr, val)   InterlockedAdd((PLONG)ptr,(LONG)val)
#define	InterlockedAndPointer(ptr, val)   InterlockedAnd((PLONG)ptr,(LONG)val)
#define	InterlockedOrPointer(ptr, val)   InterlockedOr((PLONG)ptr,(LONG)val)
#define	_ONE   1L
#define	RTL_SRWLOCK_OWNED_BIT   0
#define	RTL_SRWLOCK_CONTENDED_BIT   1
#define	RTL_SRWLOCK_SHARED_BIT   2
#define	RTL_SRWLOCK_CONTENTION_LOCK_BIT   3
#define	RTL_SRWLOCK_OWNED   (_ONE << RTL_SRWLOCK_OWNED_BIT)
#define	RTL_SRWLOCK_CONTENDED   (_ONE << RTL_SRWLOCK_CONTENDED_BIT)
#define	RTL_SRWLOCK_SHARED   (_ONE << RTL_SRWLOCK_SHARED_BIT)
#define	RTL_SRWLOCK_CONTENTION_LOCK   (_ONE << RTL_SRWLOCK_CONTENTION_LOCK_BIT)
#define	RTL_SRWLOCK_MASK
#define	RTL_SRWLOCK_BITS   4

Typedefs
typedef struct _RTLP_SRWLOCK_SHARED_WAKE	RTLP_SRWLOCK_SHARED_WAKE
typedef struct _RTLP_SRWLOCK_SHARED_WAKE *	PRTLP_SRWLOCK_SHARED_WAKE
typedef struct _RTLP_SRWLOCK_WAITBLOCK	RTLP_SRWLOCK_WAITBLOCK
typedef struct _RTLP_SRWLOCK_WAITBLOCK *	PRTLP_SRWLOCK_WAITBLOCK

Functions
static VOID NTAPI	RtlpReleaseWaitBlockLockExclusive (IN OUT PRTL_SRWLOCK SRWLock, IN PRTLP_SRWLOCK_WAITBLOCK FirstWaitBlock)
static VOID NTAPI	RtlpReleaseWaitBlockLockLastShared (IN OUT PRTL_SRWLOCK SRWLock, IN PRTLP_SRWLOCK_WAITBLOCK FirstWaitBlock)
static VOID NTAPI	RtlpReleaseWaitBlockLock (IN OUT PRTL_SRWLOCK SRWLock)
static PRTLP_SRWLOCK_WAITBLOCK NTAPI	RtlpAcquireWaitBlockLock (IN OUT PRTL_SRWLOCK SRWLock)
static VOID NTAPI	RtlpAcquireSRWLockExclusiveWait (IN OUT PRTL_SRWLOCK SRWLock, IN PRTLP_SRWLOCK_WAITBLOCK WaitBlock)
static VOID NTAPI	RtlpAcquireSRWLockSharedWait (IN OUT PRTL_SRWLOCK SRWLock, IN OUT PRTLP_SRWLOCK_WAITBLOCK FirstWait OPTIONAL, IN OUT PRTLP_SRWLOCK_SHARED_WAKE WakeChain)
VOID NTAPI	RtlInitializeSRWLock (OUT PRTL_SRWLOCK SRWLock)
VOID NTAPI	RtlAcquireSRWLockShared (IN OUT PRTL_SRWLOCK SRWLock)
VOID NTAPI	RtlReleaseSRWLockShared (IN OUT PRTL_SRWLOCK SRWLock)
VOID NTAPI	RtlAcquireSRWLockExclusive (IN OUT PRTL_SRWLOCK SRWLock)
VOID NTAPI	RtlReleaseSRWLockExclusive (IN OUT PRTL_SRWLOCK SRWLock)
BOOLEAN NTAPI	RtlTryAcquireSRWLockShared (PRTL_SRWLOCK SRWLock)
BOOLEAN NTAPI	RtlTryAcquireSRWLockExclusive (PRTL_SRWLOCK SRWLock)

Macro Definition Documentation

_ONE

#define _ONE   1L

Definition at line 34 of file srw.c.

InterlockedAddPointer

#define InterlockedAddPointer	(		ptr,
			val
	)		InterlockedAdd((PLONG)ptr,(LONG)val)

Definition at line 31 of file srw.c.

InterlockedAndPointer

#define InterlockedAndPointer	(		ptr,
			val
	)		InterlockedAnd((PLONG)ptr,(LONG)val)

Definition at line 32 of file srw.c.

InterlockedBitTestAndSetPointer

#define InterlockedBitTestAndSetPointer	(		ptr,
			val
	)		InterlockedBitTestAndSet((PLONG)ptr,(LONG)val)

Definition at line 30 of file srw.c.

InterlockedOrPointer

#define InterlockedOrPointer	(		ptr,
			val
	)		InterlockedOr((PLONG)ptr,(LONG)val)

Definition at line 33 of file srw.c.

NDEBUG

#define NDEBUG

Definition at line 18 of file srw.c.

RTL_SRWLOCK_BITS

#define RTL_SRWLOCK_BITS   4

Definition at line 47 of file srw.c.

RTL_SRWLOCK_CONTENDED

#define RTL_SRWLOCK_CONTENDED   (_ONE << RTL_SRWLOCK_CONTENDED_BIT)

Definition at line 42 of file srw.c.

RTL_SRWLOCK_CONTENDED_BIT

#define RTL_SRWLOCK_CONTENDED_BIT   1

Definition at line 38 of file srw.c.

RTL_SRWLOCK_CONTENTION_LOCK

#define RTL_SRWLOCK_CONTENTION_LOCK   (_ONE << RTL_SRWLOCK_CONTENTION_LOCK_BIT)

Definition at line 44 of file srw.c.

RTL_SRWLOCK_CONTENTION_LOCK_BIT

#define RTL_SRWLOCK_CONTENTION_LOCK_BIT   3

Definition at line 40 of file srw.c.

RTL_SRWLOCK_MASK

#define RTL_SRWLOCK_MASK

Value:

(RTL_SRWLOCK_OWNED | RTL_SRWLOCK_CONTENDED | \
                             RTL_SRWLOCK_SHARED | RTL_SRWLOCK_CONTENTION_LOCK)

Definition at line 45 of file srw.c.

RTL_SRWLOCK_OWNED

#define RTL_SRWLOCK_OWNED   (_ONE << RTL_SRWLOCK_OWNED_BIT)

Definition at line 41 of file srw.c.

RTL_SRWLOCK_OWNED_BIT

#define RTL_SRWLOCK_OWNED_BIT   0

Definition at line 37 of file srw.c.

RTL_SRWLOCK_SHARED

#define RTL_SRWLOCK_SHARED   (_ONE << RTL_SRWLOCK_SHARED_BIT)

Definition at line 43 of file srw.c.

RTL_SRWLOCK_SHARED_BIT

#define RTL_SRWLOCK_SHARED_BIT   2

Definition at line 39 of file srw.c.

Typedef Documentation

PRTLP_SRWLOCK_SHARED_WAKE

typedef struct _RTLP_SRWLOCK_SHARED_WAKE * PRTLP_SRWLOCK_SHARED_WAKE

PRTLP_SRWLOCK_WAITBLOCK

typedef struct _RTLP_SRWLOCK_WAITBLOCK * PRTLP_SRWLOCK_WAITBLOCK

RTLP_SRWLOCK_SHARED_WAKE

typedef struct _RTLP_SRWLOCK_SHARED_WAKE RTLP_SRWLOCK_SHARED_WAKE

RTLP_SRWLOCK_WAITBLOCK

typedef struct _RTLP_SRWLOCK_WAITBLOCK RTLP_SRWLOCK_WAITBLOCK

Function Documentation

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 AcquireSRWLockExclusive(), and 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 AcquireSRWLockShared(), and InternalSleep().

RtlInitializeSRWLock()

VOID NTAPI RtlInitializeSRWLock

(

OUT PRTL_SRWLOCK

SRWLock

)

Definition at line 317 of file srw.c.

{
    SRWLock->Ptr = NULL;
}

Referenced by InitializeSRWLock().

RtlpAcquireSRWLockExclusiveWait()

static VOID NTAPI RtlpAcquireSRWLockExclusiveWait ( IN OUT PRTL_SRWLOCK  SRWLock, IN PRTLP_SRWLOCK_WAITBLOCK  WaitBlock  )

static

Definition at line 232 of file srw.c.

{
    LONG_PTR CurrentValue;

    while (1)
    {
        CurrentValue = *(volatile LONG_PTR *)&SRWLock->Ptr;
        if (!(CurrentValue & RTL_SRWLOCK_SHARED))
        {
            if (CurrentValue & RTL_SRWLOCK_CONTENDED)
            {
                if (WaitBlock->Wake != 0)
                {
                    /* Our wait block became the first one
                       in the chain, we own the lock now! */
                    break;
                }
            }
            else
            {
                /* The last wait block was removed and/or we're
                   finally a simple exclusive lock. This means we
                   don't need to wait anymore, we acquired the lock! */
                break;
            }
        }

        YieldProcessor();
    }
}

Referenced by RtlAcquireSRWLockExclusive().

RtlpAcquireSRWLockSharedWait()

static VOID NTAPI RtlpAcquireSRWLockSharedWait ( IN OUT PRTL_SRWLOCK  SRWLock, IN OUT PRTLP_SRWLOCK_WAITBLOCK FirstWait  OPTIONAL, IN OUT PRTLP_SRWLOCK_SHARED_WAKE  WakeChain  )

static

Definition at line 267 of file srw.c.

{
    if (FirstWait != NULL)
    {
        while (WakeChain->Wake == 0)
        {
            YieldProcessor();
        }
    }
    else
    {
        LONG_PTR CurrentValue;

        while (1)
        {
            CurrentValue = *(volatile LONG_PTR *)&SRWLock->Ptr;
            if (CurrentValue & RTL_SRWLOCK_SHARED)
            {
                /* The RTL_SRWLOCK_OWNED bit always needs to be set when
                   RTL_SRWLOCK_SHARED is set! */
                ASSERT(CurrentValue & RTL_SRWLOCK_OWNED);

                if (CurrentValue & RTL_SRWLOCK_CONTENDED)
                {
                    if (WakeChain->Wake != 0)
                    {
                        /* Our wait block became the first one
                           in the chain, we own the lock now! */
                        break;
                    }
                }
                else
                {
                    /* The last wait block was removed and/or we're
                       finally a simple shared lock. This means we
                       don't need to wait anymore, we acquired the lock! */
                    break;
                }
            }

            YieldProcessor();
        }
    }
}

Referenced by RtlAcquireSRWLockShared().

RtlpAcquireWaitBlockLock()

static PRTLP_SRWLOCK_WAITBLOCK NTAPI RtlpAcquireWaitBlockLock ( IN OUT PRTL_SRWLOCK  SRWLock )

static

Definition at line 199 of file srw.c.

{
    LONG_PTR PrevValue;
    PRTLP_SRWLOCK_WAITBLOCK WaitBlock;

    while (1)
    {
        PrevValue = InterlockedOrPointer(&SRWLock->Ptr,
                                         RTL_SRWLOCK_CONTENTION_LOCK);

        if (!(PrevValue & RTL_SRWLOCK_CONTENTION_LOCK))
            break;

        YieldProcessor();
    }

    if (!(PrevValue & RTL_SRWLOCK_CONTENDED) ||
        (PrevValue & ~RTL_SRWLOCK_MASK) == 0)
    {
        /* Too bad, looks like the wait block was removed in the
           meanwhile, unlock again */
        RtlpReleaseWaitBlockLock(SRWLock);
        return NULL;
    }

    WaitBlock = (PRTLP_SRWLOCK_WAITBLOCK)(PrevValue & ~RTL_SRWLOCK_MASK);

    return WaitBlock;
}

Referenced by RtlAcquireSRWLockExclusive(), RtlAcquireSRWLockShared(), RtlReleaseSRWLockExclusive(), and RtlReleaseSRWLockShared().

RtlpReleaseWaitBlockLock()

static VOID NTAPI RtlpReleaseWaitBlockLock ( IN OUT PRTL_SRWLOCK  SRWLock )

static

Definition at line 190 of file srw.c.

{
    InterlockedAndPointer(&SRWLock->Ptr,
                          ~RTL_SRWLOCK_CONTENTION_LOCK);
}

Referenced by RtlAcquireSRWLockExclusive(), RtlAcquireSRWLockShared(), RtlpAcquireWaitBlockLock(), and RtlReleaseSRWLockShared().

RtlpReleaseWaitBlockLockExclusive()

static VOID NTAPI RtlpReleaseWaitBlockLockExclusive ( IN OUT PRTL_SRWLOCK  SRWLock, IN PRTLP_SRWLOCK_WAITBLOCK  FirstWaitBlock  )

static

Definition at line 85 of file srw.c.

{
    PRTLP_SRWLOCK_WAITBLOCK Next;
    LONG_PTR NewValue;

    /* NOTE: We're currently in an exclusive lock in contended mode. */

    Next = FirstWaitBlock->Next;
    if (Next != NULL)
    {
        /* There's more blocks chained, we need to update the pointers
           in the next wait block and update the wait block pointer. */
        NewValue = (LONG_PTR)Next | RTL_SRWLOCK_OWNED | RTL_SRWLOCK_CONTENDED;
        if (!FirstWaitBlock->Exclusive)
        {
            /* The next wait block has to be an exclusive lock! */
            ASSERT(Next->Exclusive);

            /* Save the shared count */
            Next->SharedCount = FirstWaitBlock->SharedCount;

            NewValue |= RTL_SRWLOCK_SHARED;
        }

        Next->Last = FirstWaitBlock->Last;
    }
    else
    {
        /* Convert the lock to a simple lock. */
        if (FirstWaitBlock->Exclusive)
            NewValue = RTL_SRWLOCK_OWNED;
        else
        {
            ASSERT(FirstWaitBlock->SharedCount > 0);

            NewValue = ((LONG_PTR)FirstWaitBlock->SharedCount << RTL_SRWLOCK_BITS) |
                       RTL_SRWLOCK_SHARED | RTL_SRWLOCK_OWNED;
        }
    }

    (void)InterlockedExchangePointer(&SRWLock->Ptr, (PVOID)NewValue);

    if (FirstWaitBlock->Exclusive)
    {
        (void)InterlockedOr(&FirstWaitBlock->Wake,
                            TRUE);
    }
    else
    {
        PRTLP_SRWLOCK_SHARED_WAKE WakeChain, NextWake;

        /* If we were the first one to acquire the shared
           lock, we now need to wake all others... */
        WakeChain = FirstWaitBlock->SharedWakeChain;
        do
        {
            NextWake = WakeChain->Next;

            (void)InterlockedOr((PLONG)&WakeChain->Wake,
                                TRUE);

            WakeChain = NextWake;
        } while (WakeChain != NULL);
    }
}

Referenced by RtlReleaseSRWLockExclusive().

RtlpReleaseWaitBlockLockLastShared()

static VOID NTAPI RtlpReleaseWaitBlockLockLastShared ( IN OUT PRTL_SRWLOCK  SRWLock, IN PRTLP_SRWLOCK_WAITBLOCK  FirstWaitBlock  )

static

Definition at line 155 of file srw.c.

{
    PRTLP_SRWLOCK_WAITBLOCK Next;
    LONG_PTR NewValue;

    /* NOTE: We're currently in a shared lock in contended mode. */

    /* The next acquirer to be unwaited *must* be an exclusive lock! */
    ASSERT(FirstWaitBlock->Exclusive);

    Next = FirstWaitBlock->Next;
    if (Next != NULL)
    {
        /* There's more blocks chained, we need to update the pointers
           in the next wait block and update the wait block pointer. */
        NewValue = (LONG_PTR)Next | RTL_SRWLOCK_OWNED | RTL_SRWLOCK_CONTENDED;

        Next->Last = FirstWaitBlock->Last;
    }
    else
    {
        /* Convert the lock to a simple exclusive lock. */
        NewValue = RTL_SRWLOCK_OWNED;
    }

    (void)InterlockedExchangePointer(&SRWLock->Ptr, (PVOID)NewValue);

    (void)InterlockedOr(&FirstWaitBlock->Wake,
                        TRUE);
}

Referenced by RtlReleaseSRWLockShared().

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(), and ReleaseSRWLockExclusive().

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(), and ReleaseSRWLockShared().

RtlTryAcquireSRWLockExclusive()

BOOLEAN NTAPI RtlTryAcquireSRWLockExclusive

(

PRTL_SRWLOCK

SRWLock

)

Definition at line 792 of file srw.c.

{
    return InterlockedCompareExchangePointer(&SRWLock->Ptr, (ULONG_PTR*)RTL_SRWLOCK_OWNED, 0) == 0;
}

RtlTryAcquireSRWLockShared()

BOOLEAN NTAPI RtlTryAcquireSRWLockShared

(

PRTL_SRWLOCK

SRWLock

)

Definition at line 771 of file srw.c.

{

    LONG_PTR CompareValue, NewValue, GotValue;

    do
    {
        CompareValue = *(volatile LONG_PTR *)&SRWLock->Ptr;
        NewValue = ((CompareValue >> RTL_SRWLOCK_BITS) + 1) | RTL_SRWLOCK_SHARED | RTL_SRWLOCK_OWNED;

        /* Only increment shared count if there is no waiter */
        CompareValue &= ~RTL_SRWLOCK_MASK | RTL_SRWLOCK_SHARED | RTL_SRWLOCK_OWNED;
    } while (
        ((GotValue = (LONG_PTR)InterlockedCompareExchangePointer(&SRWLock->Ptr, (LONG_PTR*)NewValue, (LONG_PTR*)CompareValue)) != CompareValue)
        && (((GotValue & RTL_SRWLOCK_MASK) == (RTL_SRWLOCK_SHARED | RTL_SRWLOCK_OWNED)) || (GotValue == 0)));

    return ((GotValue & RTL_SRWLOCK_MASK) == (RTL_SRWLOCK_SHARED | RTL_SRWLOCK_OWNED)) || (GotValue == 0);
}