sync.c File Reference

#include "k32_vista.h"
#include <debug.h>

Include dependency graph for sync.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
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)
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)
VOID WINAPI	AcquireSRWLockExclusive (PSRWLOCK Lock)
VOID WINAPI	AcquireSRWLockShared (PSRWLOCK Lock)
VOID WINAPI	InitializeConditionVariable (PCONDITION_VARIABLE ConditionVariable)
VOID WINAPI	InitializeSRWLock (PSRWLOCK Lock)
VOID WINAPI	ReleaseSRWLockExclusive (PSRWLOCK Lock)
VOID WINAPI	ReleaseSRWLockShared (PSRWLOCK Lock)
FORCEINLINE PLARGE_INTEGER	GetNtTimeout (PLARGE_INTEGER Time, DWORD Timeout)
BOOL WINAPI	SleepConditionVariableCS (PCONDITION_VARIABLE ConditionVariable, PCRITICAL_SECTION CriticalSection, DWORD Timeout)
BOOL WINAPI	SleepConditionVariableSRW (PCONDITION_VARIABLE ConditionVariable, PSRWLOCK Lock, DWORD Timeout, ULONG Flags)
VOID WINAPI	WakeAllConditionVariable (PCONDITION_VARIABLE ConditionVariable)
VOID WINAPI	WakeConditionVariable (PCONDITION_VARIABLE ConditionVariable)
BOOL WINAPI	InitializeCriticalSectionEx (OUT LPCRITICAL_SECTION lpCriticalSection, IN DWORD dwSpinCount, IN DWORD flags)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 3 of file sync.c.

Function Documentation

AcquireSRWLockExclusive()

VOID WINAPI AcquireSRWLockExclusive

(

PSRWLOCK

Lock

)

Definition at line 54 of file sync.c.

{
    RtlAcquireSRWLockExclusive((PRTL_SRWLOCK)Lock);
}

Referenced by cache_insert(), compound_encode_send_decode(), create_new_rpc_auth(), deleg_lock_update(), delegation_flush_locks(), delegation_recovery_status(), delegation_remove(), delete_stale_component(), device_fetch(), do_open(), file_layout_fetch(), file_layout_recall(), file_layout_return(), get_volume_size_info(), handle_nfs41_set_size(), layout_commit(), nfs41_attr_cache_update(), nfs41_client_delegation_return_lru(), nfs41_client_renew(), nfs41_delegate_open(), nfs41_delegation_recall(), nfs41_delegation_remove_srvopen(), nfs41_delegation_return(), nfs41_delegation_to_open(), nfs41_name_cache_delegreturn(), nfs41_name_cache_insert(), nfs41_name_cache_remove(), nfs41_name_cache_rename(), nfs41_send_compound(), nfs41_session_create(), nfs41_session_free(), nfs41_session_renew(), nfs41_superblock_for_fh(), nfs41_superblock_space_changed(), open_lock_add(), open_lock_delegate(), open_state_rename(), open_unlock_delegate(), open_unlock_remove(), pnfs_data_server_client(), pnfs_layout_io_finished(), pnfs_layout_recall_fenced(), pnfs_layout_state_close(), pnfs_layout_state_open(), pnfs_read(), pnfs_write(), recover_delegation_open(), recover_delegation_want(), recover_locks(), recover_open(), referral_resolve(), rpc_reconnect(), rpc_renew_in_progress(), rpc_should_retry(), and server_addrs_add().

AcquireSRWLockShared()

VOID WINAPI AcquireSRWLockShared

(

PSRWLOCK

Lock

)

Definition at line 61 of file sync.c.

{
    RtlAcquireSRWLockShared((PRTL_SRWLOCK)Lock);
}

Referenced by cache_lookup(), cl_addr_compare(), cl_exid_compare(), client_server(), client_supports_pnfs(), compound_encode_send_decode(), deleg_lock_find(), delegation_flush_locks(), delegation_return(), file_layout_return(), get_path_fhs(), get_volume_size_info(), layout_commit(), lock_stateid_arg(), nfs41_attr_cache_lookup(), nfs41_create(), nfs41_create_session(), nfs41_delegation_getattr(), nfs41_delegation_to_open(), nfs41_delegreturn(), nfs41_link(), nfs41_lookup(), nfs41_name_cache_lookup(), nfs41_name_cache_remove_stale(), nfs41_open_stateid_arg(), nfs41_remove(), nfs41_rename(), nfs41_rpc_netaddr(), nfs41_send_compound(), nfs41_server_addrs(), nfs41_session_bump_seq(), nfs41_session_create(), nfs41_session_free_slot(), nfs41_session_get_slot(), nfs41_session_recall_slot(), nfs41_superblock_for_fh(), open_deleg_cmp(), open_lock_delegate(), open_update_cache(), pnfs_data_server_client(), pnfs_layout_state_close(), pnfs_layout_state_open(), recover_delegation_open(), recover_delegation_want(), recover_open(), recover_stateid_delegation(), recover_stateid_lock(), recover_stateid_open(), session_get_lease(), stateid_array(), and thread_next_unit().

GetNtTimeout()

FORCEINLINE PLARGE_INTEGER GetNtTimeout	(	PLARGE_INTEGER	Time,
		DWORD	Timeout
	)

Definition at line 96 of file sync.c.

{
    if (Timeout == INFINITE) return NULL;
    Time->QuadPart = (ULONGLONG)Timeout * -10000;
    return Time;
}

Referenced by SleepConditionVariableCS(), and SleepConditionVariableSRW().

InitializeConditionVariable()

VOID WINAPI InitializeConditionVariable

(

PCONDITION_VARIABLE

ConditionVariable

)

Definition at line 68 of file sync.c.

{
    RtlInitializeConditionVariable((PRTL_CONDITION_VARIABLE)ConditionVariable);
}

Referenced by delegation_create(), layout_state_create(), nfs41_client_create(), and session_alloc().

InitializeCriticalSectionEx()

BOOL WINAPI InitializeCriticalSectionEx	(	OUT LPCRITICAL_SECTION	lpCriticalSection,
		IN DWORD	dwSpinCount,
		IN DWORD	flags
	)

Definition at line 153 of file sync.c.

{
    NTSTATUS Status;
 
    /* FIXME: Flags ignored */
 
    /* Initialize the critical section */
    Status = RtlInitializeCriticalSectionAndSpinCount(
        (PRTL_CRITICAL_SECTION)lpCriticalSection,
        dwSpinCount);
    if (!NT_SUCCESS(Status))
    {
        /* Set failure code */
        SetLastError(RtlNtStatusToDosError(Status));
        return FALSE;
    }
 
    /* Success */
    return TRUE;
}

InitializeSRWLock()

VOID WINAPI InitializeSRWLock

(

PSRWLOCK

Lock

)

Definition at line 75 of file sync.c.

{
    RtlInitializeSRWLock((PRTL_SRWLOCK)Lock);
}

Referenced by cache_init(), create_open_state(), delegation_create(), format_abs_path(), handle_mount(), layout_state_create(), nfs41_client_create(), nfs41_lookup(), nfs41_name_cache_create(), nfs41_rpc_clnt_create(), nfs41_superblock_list_init(), nfs41_symlink_follow(), server_create(), session_alloc(), superblock_create(), and xdr_data_server_list().

ReleaseSRWLockExclusive()

VOID WINAPI ReleaseSRWLockExclusive

(

PSRWLOCK

Lock

)

Definition at line 82 of file sync.c.

{
    RtlReleaseSRWLockExclusive((PRTL_SRWLOCK)Lock);
}

Referenced by cache_insert(), compound_encode_send_decode(), create_new_rpc_auth(), deleg_lock_update(), delegation_flush_locks(), delegation_recovery_status(), delegation_remove(), delete_stale_component(), device_fetch(), do_open(), file_layout_fetch(), file_layout_recall(), file_layout_return(), get_volume_size_info(), handle_nfs41_set_size(), layout_commit(), nfs41_attr_cache_update(), nfs41_client_delegation_return_lru(), nfs41_client_renew(), nfs41_delegate_open(), nfs41_delegation_recall(), nfs41_delegation_remove_srvopen(), nfs41_delegation_return(), nfs41_delegation_to_open(), nfs41_name_cache_delegreturn(), nfs41_name_cache_insert(), nfs41_name_cache_remove(), nfs41_name_cache_rename(), nfs41_send_compound(), nfs41_session_create(), nfs41_session_free(), nfs41_session_renew(), nfs41_superblock_for_fh(), nfs41_superblock_space_changed(), open_lock_add(), open_lock_delegate(), open_state_rename(), open_unlock_delegate(), open_unlock_remove(), pnfs_data_server_client(), pnfs_layout_io_finished(), pnfs_layout_recall_fenced(), pnfs_layout_state_close(), pnfs_layout_state_open(), pnfs_read(), pnfs_write(), recover_delegation_open(), recover_delegation_want(), recover_locks(), recover_open(), referral_resolve(), rpc_reconnect(), rpc_renew_in_progress(), rpc_should_retry(), and server_addrs_add().

ReleaseSRWLockShared()

VOID WINAPI ReleaseSRWLockShared

(

PSRWLOCK

Lock

)

Definition at line 89 of file sync.c.

{
    RtlReleaseSRWLockShared((PRTL_SRWLOCK)Lock);
}

Referenced by cache_lookup(), cl_addr_compare(), cl_exid_compare(), client_server(), client_supports_pnfs(), deleg_lock_find(), delegation_flush_locks(), delegation_return(), file_layout_return(), get_path_fhs(), get_volume_size_info(), layout_commit(), lock_stateid_arg(), nfs41_attr_cache_lookup(), nfs41_create(), nfs41_create_session(), nfs41_delegation_getattr(), nfs41_delegation_to_open(), nfs41_delegreturn(), nfs41_link(), nfs41_lookup(), nfs41_name_cache_lookup(), nfs41_name_cache_remove_stale(), nfs41_open_stateid_arg(), nfs41_remove(), nfs41_rename(), nfs41_rpc_netaddr(), nfs41_send_compound(), nfs41_server_addrs(), nfs41_session_bump_seq(), nfs41_session_create(), nfs41_session_free_slot(), nfs41_session_get_slot(), nfs41_session_recall_slot(), nfs41_superblock_for_fh(), open_deleg_cmp(), open_lock_delegate(), open_update_cache(), pnfs_data_server_client(), pnfs_layout_state_close(), pnfs_layout_state_open(), recover_delegation_open(), recover_delegation_want(), recover_open(), recover_stateid_delegation(), recover_stateid_lock(), recover_stateid_open(), session_get_lease(), stateid_array(), and thread_next_unit().

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

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

RtlInitializeConditionVariable()

VOID NTAPI RtlInitializeConditionVariable

(

OUT PRTL_CONDITION_VARIABLE

ConditionVariable

)

Definition at line 477 of file condvar.c.

{
    ConditionVariable->Ptr = NULL;
}

Referenced by InitializeConditionVariable().

RtlInitializeSRWLock()

VOID NTAPI RtlInitializeSRWLock

(

OUT PRTL_SRWLOCK

SRWLock

)

Definition at line 317 of file srw.c.

{
    SRWLock->Ptr = NULL;
}

Referenced by InitializeSRWLock().

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

RtlSleepConditionVariableCS()

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

Referenced by SleepConditionVariableCS().

RtlSleepConditionVariableSRW()

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

Referenced by SleepConditionVariableSRW().

RtlWakeAllConditionVariable()

VOID NTAPI RtlWakeAllConditionVariable

(

IN OUT PRTL_CONDITION_VARIABLE

ConditionVariable

)

Definition at line 491 of file condvar.c.

{
    InternalWake(ConditionVariable, TRUE);
}

Referenced by WakeAllConditionVariable().

RtlWakeConditionVariable()

VOID NTAPI RtlWakeConditionVariable

(

IN OUT PRTL_CONDITION_VARIABLE

ConditionVariable

)

Definition at line 484 of file condvar.c.

{
    InternalWake(ConditionVariable, FALSE);
}

Referenced by WakeConditionVariable().

SleepConditionVariableCS()

BOOL WINAPI SleepConditionVariableCS	(	PCONDITION_VARIABLE	ConditionVariable,
		PCRITICAL_SECTION	CriticalSection,
		DWORD	Timeout
	)

Definition at line 105 of file sync.c.

{
    NTSTATUS Status;
    LARGE_INTEGER Time;
 
    Status = RtlSleepConditionVariableCS(ConditionVariable, (PRTL_CRITICAL_SECTION)CriticalSection, GetNtTimeout(&Time, Timeout));
    if (!NT_SUCCESS(Status) || Status == STATUS_TIMEOUT)
    {
        SetLastError(RtlNtStatusToDosError(Status));
        return FALSE;
    }
    return TRUE;
}

Referenced by nfs41_recover_stateid(), nfs41_recovery_start_or_wait(), and nfs41_session_get_slot().

SleepConditionVariableSRW()

BOOL WINAPI SleepConditionVariableSRW	(	PCONDITION_VARIABLE	ConditionVariable,
		PSRWLOCK	Lock,
		DWORD	Timeout,
		ULONG	Flags
	)

Definition at line 121 of file sync.c.

{
    NTSTATUS Status;
    LARGE_INTEGER Time;
 
    Status = RtlSleepConditionVariableSRW(ConditionVariable, Lock, GetNtTimeout(&Time, Timeout), Flags);
    if (!NT_SUCCESS(Status) || Status == STATUS_TIMEOUT)
    {
        SetLastError(RtlNtStatusToDosError(Status));
        return FALSE;
    }
    return TRUE;
}

Referenced by file_layout_return(), layout_fetch(), nfs41_delegate_open(), nfs41_delegation_return(), nfs41_delegation_to_open(), and nfs41_open_stateid_arg().

WakeAllConditionVariable()

VOID WINAPI WakeAllConditionVariable

(

PCONDITION_VARIABLE

ConditionVariable

)

Definition at line 137 of file sync.c.

{
    RtlWakeAllConditionVariable((PRTL_CONDITION_VARIABLE)ConditionVariable);
}

Referenced by delegation_remove(), init_slot_table(), nfs41_delegation_to_open(), nfs41_recovery_finish(), nfs41_session_free_slot(), and resize_slot_table().

WakeConditionVariable()

VOID WINAPI WakeConditionVariable

(

PCONDITION_VARIABLE

ConditionVariable

)

Definition at line 144 of file sync.c.

{
    RtlWakeConditionVariable((PRTL_CONDITION_VARIABLE)ConditionVariable);
}

Referenced by file_layout_return(), and layout_fetch().