critical.c File Reference

#include <rtl.h>
#include <debug.h>
#include <reactos/verifier.h>

Include dependency graph for critical.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	MAX_STATIC_CS_DEBUG_OBJECTS   64
#define	CRITSECT_HAS_DEBUG_INFO(CriticalSection)

Functions
	_At_ (CriticalSection->LockSemaphore, _Post_notnull_) VOID NTAPI RtlpCreateCriticalSectionSem(PRTL_CRITICAL_SECTION CriticalSection)
NTSTATUS NTAPI	RtlpWaitForCriticalSection (PRTL_CRITICAL_SECTION CriticalSection)
VOID NTAPI	RtlpUnWaitCriticalSection (PRTL_CRITICAL_SECTION CriticalSection)
VOID NTAPI	RtlpInitDeferredCriticalSection (VOID)
PRTL_CRITICAL_SECTION_DEBUG NTAPI	RtlpAllocateDebugInfo (VOID)
VOID NTAPI	RtlpFreeDebugInfo (PRTL_CRITICAL_SECTION_DEBUG DebugInfo)
NTSTATUS NTAPI	RtlDeleteCriticalSection (PRTL_CRITICAL_SECTION CriticalSection)
ULONG NTAPI	RtlSetCriticalSectionSpinCount (PRTL_CRITICAL_SECTION CriticalSection, ULONG SpinCount)
NTSTATUS NTAPI	RtlEnterCriticalSection (PRTL_CRITICAL_SECTION CriticalSection)
NTSTATUS NTAPI	RtlInitializeCriticalSection (PRTL_CRITICAL_SECTION CriticalSection)
NTSTATUS NTAPI	RtlInitializeCriticalSectionEx (_Out_ PRTL_CRITICAL_SECTION CriticalSection, _In_ ULONG SpinCount, _In_ ULONG Flags)
NTSTATUS NTAPI	RtlInitializeCriticalSectionAndSpinCount (_Out_ PRTL_CRITICAL_SECTION CriticalSection, _In_ ULONG SpinCount)
LONG NTAPI	RtlGetCriticalSectionRecursionCount (PRTL_CRITICAL_SECTION CriticalSection)
NTSTATUS NTAPI	RtlLeaveCriticalSection (PRTL_CRITICAL_SECTION CriticalSection)
LOGICAL NTAPI	RtlTryEnterCriticalSection (PRTL_CRITICAL_SECTION CriticalSection)
VOID NTAPI	RtlCheckForOrphanedCriticalSections (_In_ HANDLE ThreadHandle)
	RtlCheckForOrphanedCriticalSections.
LOGICAL NTAPI	RtlIsCriticalSectionLocked (PRTL_CRITICAL_SECTION CriticalSection)
LOGICAL NTAPI	RtlIsCriticalSectionLockedByThread (PRTL_CRITICAL_SECTION CriticalSection)
VOID NTAPI	RtlpNotOwnerCriticalSection (PRTL_CRITICAL_SECTION CriticalSection)

Variables
static RTL_CRITICAL_SECTION	RtlCriticalSectionLock
static LIST_ENTRY	RtlCriticalSectionList = {&RtlCriticalSectionList, &RtlCriticalSectionList}
static BOOLEAN	RtlpCritSectInitialized = FALSE
static RTL_CRITICAL_SECTION_DEBUG	RtlpStaticDebugInfo [MAX_STATIC_CS_DEBUG_OBJECTS]
static BOOLEAN	RtlpDebugInfoFreeList [MAX_STATIC_CS_DEBUG_OBJECTS]
LARGE_INTEGER	RtlpTimeout
BOOLEAN	RtlpTimeoutDisable
BOOLEAN	RtlpCriticalSectionVerifier = FALSE
BOOLEAN	LdrpShutdownInProgress
HANDLE	LdrpShutdownThreadId

Macro Definition Documentation

CRITSECT_HAS_DEBUG_INFO

#define CRITSECT_HAS_DEBUG_INFO

(

CriticalSection

)

Value:

    (((CriticalSection)->DebugInfo != NULL) && \
     ((CriticalSection)->DebugInfo != LongToPtr(-1)))

Definition at line 35 of file critical.c.

MAX_STATIC_CS_DEBUG_OBJECTS

#define MAX_STATIC_CS_DEBUG_OBJECTS   64

Definition at line 18 of file critical.c.

NDEBUG

#define NDEBUG

Definition at line 14 of file critical.c.

Function Documentation

_At_()

_At_	(	CriticalSection->	LockSemaphore,
		_Post_notnull_
	)

Definition at line 54 of file critical.c.

{
    HANDLE hEvent = CriticalSection->LockSemaphore;
    HANDLE hNewEvent;
    NTSTATUS Status;
 
    /* Check if we have an event */
    if (!hEvent)
    {
        /* No, so create it */
        Status = NtCreateEvent(&hNewEvent,
                               EVENT_ALL_ACCESS,
                               NULL,
                               SynchronizationEvent,
                               FALSE);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Failed to Create Event!\n");
 
            /*
             * Use INVALID_HANDLE_VALUE (-1) to signal that
             * the global keyed event must be used.
             */
            hNewEvent = INVALID_HANDLE_VALUE;
        }
 
        DPRINT("Created Event: %p\n", hNewEvent);
 
        /* Exchange the LockSemaphore field with the new handle, if it is still 0 */
        if (InterlockedCompareExchangePointer((PVOID*)&CriticalSection->LockSemaphore,
                                              (PVOID)hNewEvent,
                                               NULL) != NULL)
        {
            /* Someone else just created an event */
            if (hNewEvent != INVALID_HANDLE_VALUE)
            {
                DPRINT("Closing already created event: %p\n", hNewEvent);
                NtClose(hNewEvent);
            }
        }
    }
 
    return;
}

RtlCheckForOrphanedCriticalSections()

VOID NTAPI RtlCheckForOrphanedCriticalSections

(

_In_ HANDLE

ThreadHandle

)

RtlCheckForOrphanedCriticalSections.

Checks if the given thread owns any critical sections at the time of its exit, and emits a debug message for each orphaned section found.

Parameters

[in]

ThreadHandle

Handle to the thread to check.

Returns

Nothing

Remarks

This function is typically called by the loader during thread exit.

Definition at line 879 of file critical.c.

{
    THREAD_BASIC_INFORMATION ThreadInfo;
    NTSTATUS Status;
    PLIST_ENTRY ListEntry;
 
    /* Early exit if verifier is not active */
    if (!RtlpCriticalSectionVerifier)
        return;
 
    /* Get current thread ID first */
    if (ThreadHandle == NtCurrentThread())
    {
        /* Using current thread */
        ThreadInfo.ClientId.UniqueThread = NtCurrentTeb()->ClientId.UniqueThread;
    }
    else
    {
        /* Query thread info from the handle */
        Status = NtQueryInformationThread(
            ThreadHandle,
            ThreadBasicInformation,
            &ThreadInfo,
            sizeof(ThreadInfo),
            NULL);
 
        if (!NT_SUCCESS(Status))
            return;
    }
 
    /* Lock the critical section list */
    RtlEnterCriticalSection(&RtlCriticalSectionLock);
 
    /* Walk the global critical section list */
    ListEntry = RtlCriticalSectionList.Flink;
    while (ListEntry != &RtlCriticalSectionList)
    {
        PRTL_CRITICAL_SECTION_DEBUG DebugInfo;
        PRTL_CRITICAL_SECTION CriticalSection;
 
        /* Get the debug info from the list entry */
        DebugInfo = CONTAINING_RECORD(
            ListEntry,
            RTL_CRITICAL_SECTION_DEBUG,
            ProcessLocksList);
        CriticalSection = DebugInfo->CriticalSection;
 
        /* Skip our own lock since we own it right now */
        if (CriticalSection == &RtlCriticalSectionLock)
        {
            ListEntry = ListEntry->Flink;
            continue;
        }
 
        /* Check if this critical section is owned by the target thread */
        if (CriticalSection &&
            CriticalSection->OwningThread == ThreadInfo.ClientId.UniqueThread)
        {
            /* Thread is exiting while owning a critical section! */
            VERIFIER_STOP(
                APPLICATION_VERIFIER_EXIT_THREAD_OWNS_LOCK,
                "Thread is exiting while owning a critical section",
                CriticalSection,
                "Critical section object",
                ThreadInfo.ClientId.UniqueThread,
                "Thread ID",
                DebugInfo,
                "Critical section debug info",
                NULL,
                NULL);
            /* TODO: Add stack trace information here (CORE-16870) */
        }
 
        ListEntry = ListEntry->Flink;
    }
 
    RtlLeaveCriticalSection(&RtlCriticalSectionLock);
}

RtlDeleteCriticalSection()

NTSTATUS NTAPI RtlDeleteCriticalSection

(

PRTL_CRITICAL_SECTION

CriticalSection

)

Definition at line 399 of file critical.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    DPRINT("Deleting Critical Section: %p\n", CriticalSection);
 
    /* Close the Event Object Handle if it exists */
    if (CriticalSection->LockSemaphore)
    {
        /* In case NtClose fails, return the status */
        Status = NtClose(CriticalSection->LockSemaphore);
    }
 
    /* Protect List */
    RtlEnterCriticalSection(&RtlCriticalSectionLock);
 
    if (CRITSECT_HAS_DEBUG_INFO(CriticalSection))
    {
        /* Remove it from the list */
        RemoveEntryList(&CriticalSection->DebugInfo->ProcessLocksList);
#if 0
        /* HACK for Wine: We need to preserve Flags for RtlpFreeDebugInfo */
        RtlZeroMemory(CriticalSection->DebugInfo, sizeof(RTL_CRITICAL_SECTION_DEBUG));
#endif
    }
 
    /* Unprotect */
    RtlLeaveCriticalSection(&RtlCriticalSectionLock);
 
    if (CRITSECT_HAS_DEBUG_INFO(CriticalSection))
    {
        /* Free it */
        RtlpFreeDebugInfo(CriticalSection->DebugInfo);
    }
 
    /* Wipe it out */
    RtlZeroMemory(CriticalSection, sizeof(RTL_CRITICAL_SECTION));
 
    /* Return */
    return Status;
}

RtlEnterCriticalSection()

NTSTATUS NTAPI RtlEnterCriticalSection

(

PRTL_CRITICAL_SECTION

CriticalSection

)

Definition at line 489 of file critical.c.

{
    HANDLE Thread = (HANDLE)NtCurrentTeb()->ClientId.UniqueThread;
 
    /* Try to lock it */
    if (InterlockedIncrement(&CriticalSection->LockCount) != 0)
    {
        /* We've failed to lock it! Does this thread actually own it? */
        if (Thread == CriticalSection->OwningThread)
        {
            /*
             * You own it, so you'll get it when you're done with it! No need to
             * use the interlocked functions as only the thread who already owns
             * the lock can modify this data.
             */
            CriticalSection->RecursionCount++;
            return STATUS_SUCCESS;
        }
 
        /* NOTE - CriticalSection->OwningThread can be NULL here because changing
                  this information is not serialized. This happens when thread a
                  acquires the lock (LockCount == 0) and thread b tries to
                  acquire it as well (LockCount == 1) but thread a hasn't had a
                  chance to set the OwningThread! So it's not an error when
                  OwningThread is NULL here! */
 
        /* We don't own it, so we must wait for it */
        RtlpWaitForCriticalSection(CriticalSection);
    }
 
    /*
     * Lock successful. Changing this information has not to be serialized
     * because only one thread at a time can actually change it (the one who
     * acquired the lock)!
     */
    CriticalSection->OwningThread = Thread;
    CriticalSection->RecursionCount = 1;
    NtCurrentTeb()->CountOfOwnedCriticalSections++;
    return STATUS_SUCCESS;
}

Referenced by RtlCheckForOrphanedCriticalSections(), RtlDeleteCriticalSection(), and RtlInitializeCriticalSectionEx().

RtlGetCriticalSectionRecursionCount()

LONG NTAPI RtlGetCriticalSectionRecursionCount

(

PRTL_CRITICAL_SECTION

CriticalSection

)

Definition at line 730 of file critical.c.

{
    if (CriticalSection->OwningThread == NtCurrentTeb()->ClientId.UniqueThread)
    {
        /*
         * The critical section is owned by the current thread,
         * therefore retrieve its actual recursion count.
         */
        return CriticalSection->RecursionCount;
    }
    else
    {
        /*
         * It is not owned by the current thread, so
         * for this thread there is no recursion.
         */
        return 0;
    }
}

RtlInitializeCriticalSection()

NTSTATUS NTAPI RtlInitializeCriticalSection

(

PRTL_CRITICAL_SECTION

CriticalSection

)

Definition at line 548 of file critical.c.

{
    /* Call the Main Function */
    return RtlInitializeCriticalSectionAndSpinCount(CriticalSection, 0);
}

Referenced by RtlpInitDeferredCriticalSection().

RtlInitializeCriticalSectionAndSpinCount()

NTSTATUS NTAPI RtlInitializeCriticalSectionAndSpinCount	(	_Out_ PRTL_CRITICAL_SECTION	CriticalSection,
		_In_ ULONG	SpinCount
	)

Definition at line 703 of file critical.c.

{
    SpinCount &= ~RTL_CRITICAL_SECTION_ALL_FLAG_BITS;
    return RtlInitializeCriticalSectionEx(CriticalSection, SpinCount, 0);
}

Referenced by RtlInitializeCriticalSection().

RtlInitializeCriticalSectionEx()

NTSTATUS NTAPI RtlInitializeCriticalSectionEx	(	_Out_ PRTL_CRITICAL_SECTION	CriticalSection,
		_In_ ULONG	SpinCount,
		_In_ ULONG	Flags
	)

Definition at line 576 of file critical.c.

{
    PRTL_CRITICAL_SECTION_DEBUG CritcalSectionDebugData;
    ULONG AllowedFlags;
    ULONG OsVersion;
 
    /* Remove lower bits from flags */
    Flags &= RTL_CRITICAL_SECTION_ALL_FLAG_BITS;
 
    /* These flags generally allowed */
    AllowedFlags = RTL_CRITICAL_SECTION_FLAG_NO_DEBUG_INFO |
                   RTL_CRITICAL_SECTION_FLAG_DYNAMIC_SPIN |
                   RTL_CRITICAL_SECTION_FLAG_STATIC_INIT;
 
    /* Flags for Windows 7+ (CHECKME) */
    OsVersion = NtCurrentPeb()->OSMajorVersion << 8 |
                NtCurrentPeb()->OSMinorVersion;
    if (OsVersion >= _WIN32_WINNT_WIN7)
    {
        AllowedFlags |= RTL_CRITICAL_SECTION_FLAG_RESOURCE_TYPE |
                        RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO;
    }
 
    if (Flags & ~AllowedFlags)
    {
        return STATUS_INVALID_PARAMETER_3;
    }
 
    if (SpinCount & RTL_CRITICAL_SECTION_ALL_FLAG_BITS)
    {
        return STATUS_INVALID_PARAMETER_2;
    }
 
    /* First things first, set up the Object */
    DPRINT("Initializing Critical Section: %p\n", CriticalSection);
    CriticalSection->LockCount = -1;
    CriticalSection->RecursionCount = 0;
    CriticalSection->OwningThread = 0;
    CriticalSection->SpinCount = (NtCurrentPeb()->NumberOfProcessors > 1) ? SpinCount : 0;
    CriticalSection->LockSemaphore = 0;
 
    if (Flags & RTL_CRITICAL_SECTION_FLAG_NO_DEBUG_INFO)
    {
        CriticalSection->DebugInfo = LongToPtr(-1);
    }
    else
    {
        /* Allocate the Debug Data */
        CritcalSectionDebugData = RtlpAllocateDebugInfo();
        DPRINT("Allocated Debug Data: %p inside Process: %p\n",
               CritcalSectionDebugData,
               NtCurrentTeb()->ClientId.UniqueProcess);
 
        if (!CritcalSectionDebugData)
        {
            /* This is bad! */
            DPRINT1("Couldn't allocate Debug Data for: %p\n", CriticalSection);
            return STATUS_NO_MEMORY;
        }
 
        /* Set it up */
        CritcalSectionDebugData->Type = RTL_CRITSECT_TYPE;
        CritcalSectionDebugData->ContentionCount = 0;
        CritcalSectionDebugData->EntryCount = 0;
        CritcalSectionDebugData->CriticalSection = CriticalSection;
        CritcalSectionDebugData->Flags = 0;
        CriticalSection->DebugInfo = CritcalSectionDebugData;
 
        /*
         * Add it to the List of Critical Sections owned by the process.
         * If we've initialized the Lock, then use it. If not, then probably
         * this is the lock initialization itself, so insert it directly.
         */
        if ((CriticalSection != &RtlCriticalSectionLock) && (RtlpCritSectInitialized))
        {
            DPRINT("Securely Inserting into ProcessLocks: %p, %p, %p\n",
                   &CritcalSectionDebugData->ProcessLocksList,
                   CriticalSection,
                   &RtlCriticalSectionList);
 
            /* Protect List */
            RtlEnterCriticalSection(&RtlCriticalSectionLock);
 
            /* Add this one */
            InsertTailList(&RtlCriticalSectionList, &CritcalSectionDebugData->ProcessLocksList);
 
            /* Unprotect */
            RtlLeaveCriticalSection(&RtlCriticalSectionLock);
        }
        else
        {
            DPRINT("Inserting into ProcessLocks: %p, %p, %p\n",
                   &CritcalSectionDebugData->ProcessLocksList,
                   CriticalSection,
                   &RtlCriticalSectionList);
 
            /* Add it directly */
            InsertTailList(&RtlCriticalSectionList, &CritcalSectionDebugData->ProcessLocksList);
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by RtlInitializeCriticalSectionAndSpinCount().

RtlIsCriticalSectionLocked()

LOGICAL NTAPI RtlIsCriticalSectionLocked

(

PRTL_CRITICAL_SECTION

CriticalSection

)

Definition at line 961 of file critical.c.

{
    return CriticalSection->RecursionCount != 0;
}

RtlIsCriticalSectionLockedByThread()

LOGICAL NTAPI RtlIsCriticalSectionLockedByThread

(

PRTL_CRITICAL_SECTION

CriticalSection

)

Definition at line 968 of file critical.c.

{
    return CriticalSection->OwningThread == NtCurrentTeb()->ClientId.UniqueThread &&
           CriticalSection->RecursionCount != 0;
}

RtlLeaveCriticalSection()

NTSTATUS NTAPI RtlLeaveCriticalSection

(

PRTL_CRITICAL_SECTION

CriticalSection

)

Definition at line 768 of file critical.c.

{
#if DBG
    HANDLE Thread = (HANDLE)NtCurrentTeb()->ClientId.UniqueThread;
 
    /*
     * In win this case isn't checked. However it's a valid check so it should
     * only be performed in debug builds!
     */
    if (Thread != CriticalSection->OwningThread)
    {
       DPRINT1("Releasing critical section not owned!\n");
       return STATUS_INVALID_PARAMETER;
    }
#endif
 
    /*
     * Decrease the Recursion Count. No need to do this atomically because only
     * the thread who holds the lock can call this function (unless the program
     * is totally screwed...
     */
    if (--CriticalSection->RecursionCount)
    {
        if (CriticalSection->RecursionCount < 0)
        {
            DPRINT1("CRITICAL SECTION MESS: Section %p is not acquired!\n", CriticalSection);
            return STATUS_UNSUCCESSFUL;
        }
        /* Someone still owns us, but we are free. This needs to be done atomically. */
        InterlockedDecrement(&CriticalSection->LockCount);
    }
    else
    {
        /*
         * Nobody owns us anymore. No need to do this atomically.
         * See comment above.
         */
        CriticalSection->OwningThread = 0;
        NtCurrentTeb()->CountOfOwnedCriticalSections--;
 
        /* Was someone wanting us? This needs to be done atomically. */
        if (-1 != InterlockedDecrement(&CriticalSection->LockCount))
        {
            /* Let him have us */
            RtlpUnWaitCriticalSection(CriticalSection);
        }
    }
 
    /* Sucessful! */
    return STATUS_SUCCESS;
}

Referenced by RtlCheckForOrphanedCriticalSections(), RtlDeleteCriticalSection(), and RtlInitializeCriticalSectionEx().

RtlpAllocateDebugInfo()

PRTL_CRITICAL_SECTION_DEBUG NTAPI RtlpAllocateDebugInfo

(

VOID

)

Definition at line 301 of file critical.c.

{
    ULONG i;
 
    /* Try to allocate from our buffer first */
    for (i = 0; i < MAX_STATIC_CS_DEBUG_OBJECTS; i++)
    {
        /* Check if Entry is free */
        if (!RtlpDebugInfoFreeList[i])
        {
            /* Mark entry in use */
            DPRINT("Using entry: %lu. Buffer: %p\n", i, &RtlpStaticDebugInfo[i]);
            RtlpDebugInfoFreeList[i] = TRUE;
 
            /* Use free entry found */
            return &RtlpStaticDebugInfo[i];
        }
    }
 
    /* We are out of static buffer, allocate dynamic */
    return RtlAllocateHeap(RtlGetProcessHeap(),
                           0,
                           sizeof(RTL_CRITICAL_SECTION_DEBUG));
}

Referenced by RtlInitializeCriticalSectionEx().

RtlpFreeDebugInfo()

VOID NTAPI RtlpFreeDebugInfo

(

PRTL_CRITICAL_SECTION_DEBUG

DebugInfo

)

Definition at line 344 of file critical.c.

{
    SIZE_T EntryId;
 
    /* Is it part of our cached entries? */
    if ((DebugInfo >= RtlpStaticDebugInfo) &&
        (DebugInfo <= &RtlpStaticDebugInfo[MAX_STATIC_CS_DEBUG_OBJECTS-1]))
    {
        /* Yes. zero it out */
        RtlZeroMemory(DebugInfo, sizeof(RTL_CRITICAL_SECTION_DEBUG));
 
        /* Mark as free */
        EntryId = (DebugInfo - RtlpStaticDebugInfo);
        DPRINT("Freeing from Buffer: %p. Entry: %Iu inside Process: %p\n",
               DebugInfo,
               EntryId,
               NtCurrentTeb()->ClientId.UniqueProcess);
        RtlpDebugInfoFreeList[EntryId] = FALSE;
 
    }
    else if (!DebugInfo->Flags)
    {
        /* It's a dynamic one, so free from the heap */
        DPRINT("Freeing from Heap: %p inside Process: %p\n",
               DebugInfo,
               NtCurrentTeb()->ClientId.UniqueProcess);
        RtlFreeHeap(NtCurrentPeb()->ProcessHeap, 0, DebugInfo);
    }
    else
    {
        /* HACK for Wine: stores a section name pointer in the Flags member */
        DPRINT("Assuming static: %p inside Process: %p\n",
               DebugInfo,
               NtCurrentTeb()->ClientId.UniqueProcess);
    }
}

Referenced by RtlDeleteCriticalSection().

RtlpInitDeferredCriticalSection()

VOID NTAPI RtlpInitDeferredCriticalSection

(

VOID

)

Definition at line 274 of file critical.c.

{
    /* Initialize the CS Protecting the List */
    RtlInitializeCriticalSection(&RtlCriticalSectionLock);
 
    /* It's now safe to enter it */
    RtlpCritSectInitialized = TRUE;
}

Referenced by LdrpInitializeProcess().

RtlpNotOwnerCriticalSection()

VOID NTAPI RtlpNotOwnerCriticalSection

(

PRTL_CRITICAL_SECTION

CriticalSection

)

Definition at line 976 of file critical.c.

{
    RtlRaiseStatus(STATUS_RESOURCE_NOT_OWNED);
}

RtlpUnWaitCriticalSection()

VOID NTAPI RtlpUnWaitCriticalSection

(

PRTL_CRITICAL_SECTION

CriticalSection

)

Definition at line 219 of file critical.c.

{
    NTSTATUS Status;
 
    /* Do we have an Event yet? */
    if (!CriticalSection->LockSemaphore)
    {
        RtlpCreateCriticalSectionSem(CriticalSection);
    }
 
    /* Signal the Event */
    DPRINT("Signaling Critical Section Event: %p, %p\n",
            CriticalSection,
            CriticalSection->LockSemaphore);
 
    /* Check if this critical section needs to use the keyed event */
    if (CriticalSection->LockSemaphore == INVALID_HANDLE_VALUE)
    {
        /* Release keyed event */
        Status = NtReleaseKeyedEvent(NULL, CriticalSection, FALSE, &RtlpTimeout);
    }
    else
    {
        /* Set the event */
        Status = NtSetEvent(CriticalSection->LockSemaphore, NULL);
    }
 
    if (!NT_SUCCESS(Status))
    {
        /* We've failed */
        DPRINT1("Signaling Failed for: %p, %p, 0x%08lx\n",
                CriticalSection,
                CriticalSection->LockSemaphore,
                Status);
        RtlRaiseStatus(Status);
    }
}

Referenced by RtlLeaveCriticalSection().

RtlpWaitForCriticalSection()

NTSTATUS NTAPI RtlpWaitForCriticalSection

(

PRTL_CRITICAL_SECTION

CriticalSection

)

Definition at line 119 of file critical.c.

{
    NTSTATUS Status;
    EXCEPTION_RECORD ExceptionRecord;
    BOOLEAN LastChance = FALSE;
 
    /* Increase the Debug Entry count */
    DPRINT("Waiting on Critical Section Event: %p %p\n",
            CriticalSection,
            CriticalSection->LockSemaphore);
 
    if (CRITSECT_HAS_DEBUG_INFO(CriticalSection))
        CriticalSection->DebugInfo->EntryCount++;
 
    /*
     * If we're shutting down the process, we're allowed to acquire any
     * critical sections by force (the loader lock in particular)
     */
    if (LdrpShutdownInProgress &&
        LdrpShutdownThreadId == NtCurrentTeb()->RealClientId.UniqueThread)
    {
        DPRINT("Forcing ownership of critical section %p\n", CriticalSection);
        return STATUS_SUCCESS;
    }
 
    /* Do we have an Event yet? */
    if (!CriticalSection->LockSemaphore)
    {
        RtlpCreateCriticalSectionSem(CriticalSection);
    }
 
    for (;;)
    {
        /* Increase the number of times we've had contention */
        if (CRITSECT_HAS_DEBUG_INFO(CriticalSection))
            CriticalSection->DebugInfo->ContentionCount++;
 
        /* Check if allocating the event failed */
        if (CriticalSection->LockSemaphore == INVALID_HANDLE_VALUE)
        {
            /* Use the global keyed event (NULL as keyed event handle) */
            Status = NtWaitForKeyedEvent(NULL,
                                         CriticalSection,
                                         FALSE,
                                         (RtlpTimeoutDisable ? NULL : &RtlpTimeout));
        }
        else
        {
            /* Wait on the Event */
            Status = NtWaitForSingleObject(CriticalSection->LockSemaphore,
                                           FALSE,
                                           (RtlpTimeoutDisable ? NULL : &RtlpTimeout));
        }
 
        /* We have Timed out */
        if (Status == STATUS_TIMEOUT)
        {
            /* Is this the 2nd time we've timed out? */
            if (LastChance)
            {
                ERROR_DBGBREAK("Deadlock: 0x%p\n", CriticalSection);
 
                /* Yes it is, we are raising an exception */
                ExceptionRecord.ExceptionCode    = STATUS_POSSIBLE_DEADLOCK;
                ExceptionRecord.ExceptionFlags   = 0;
                ExceptionRecord.ExceptionRecord  = NULL;
                ExceptionRecord.ExceptionAddress = RtlRaiseException;
                ExceptionRecord.NumberParameters = 1;
                ExceptionRecord.ExceptionInformation[0] = (ULONG_PTR)CriticalSection;
                RtlRaiseException(&ExceptionRecord);
            }
 
            /* One more try */
            LastChance = TRUE;
        }
        else
        {
            /* If we are here, everything went fine */
            return STATUS_SUCCESS;
        }
    }
}

Referenced by RtlEnterCriticalSection().

RtlSetCriticalSectionSpinCount()

ULONG NTAPI RtlSetCriticalSectionSpinCount	(	PRTL_CRITICAL_SECTION	CriticalSection,
		ULONG	SpinCount
	)

Definition at line 461 of file critical.c.

{
    ULONG OldCount = (ULONG)CriticalSection->SpinCount;
 
    /* Set to parameter if MP, or to 0 if this is Uniprocessor */
    CriticalSection->SpinCount = (NtCurrentPeb()->NumberOfProcessors > 1) ? SpinCount : 0;
    return OldCount;
}

RtlTryEnterCriticalSection()

LOGICAL NTAPI RtlTryEnterCriticalSection

(

PRTL_CRITICAL_SECTION

CriticalSection

)

Definition at line 838 of file critical.c.

{
    /* Try to take control */
    if (InterlockedCompareExchange(&CriticalSection->LockCount, 0, -1) == -1)
    {
        /* It's ours */
        CriticalSection->OwningThread = NtCurrentTeb()->ClientId.UniqueThread;
        CriticalSection->RecursionCount = 1;
        NtCurrentTeb()->CountOfOwnedCriticalSections++;
        return TRUE;
    }
    else if (CriticalSection->OwningThread == NtCurrentTeb()->ClientId.UniqueThread)
    {
        /* It's already ours */
        InterlockedIncrement(&CriticalSection->LockCount);
        CriticalSection->RecursionCount++;
        return TRUE;
    }
 
    /* It's not ours */
    return FALSE;
}

Variable Documentation

LdrpShutdownInProgress

BOOLEAN LdrpShutdownInProgress

extern

Definition at line 34 of file ldrinit.c.

Referenced by LdrpInitializeThread(), LdrShutdownProcess(), LdrShutdownThread(), and RtlpWaitForCriticalSection().

LdrpShutdownThreadId

HANDLE LdrpShutdownThreadId

extern

Definition at line 35 of file ldrinit.c.

Referenced by LdrShutdownProcess(), and RtlpWaitForCriticalSection().

RtlCriticalSectionList

LIST_ENTRY RtlCriticalSectionList = {&RtlCriticalSectionList, &RtlCriticalSectionList}

static

Definition at line 21 of file critical.c.

Referenced by RtlCheckForOrphanedCriticalSections(), and RtlInitializeCriticalSectionEx().

RtlCriticalSectionLock

RTL_CRITICAL_SECTION RtlCriticalSectionLock

static

Definition at line 20 of file critical.c.

Referenced by RtlCheckForOrphanedCriticalSections(), RtlDeleteCriticalSection(), RtlInitializeCriticalSectionEx(), and RtlpInitDeferredCriticalSection().

RtlpCriticalSectionVerifier

BOOLEAN RtlpCriticalSectionVerifier = FALSE

Definition at line 28 of file critical.c.

Referenced by RtlCheckForOrphanedCriticalSections().

RtlpCritSectInitialized

BOOLEAN RtlpCritSectInitialized = FALSE

static

Definition at line 22 of file critical.c.

Referenced by RtlInitializeCriticalSectionEx(), and RtlpInitDeferredCriticalSection().

RtlpDebugInfoFreeList

BOOLEAN RtlpDebugInfoFreeList[MAX_STATIC_CS_DEBUG_OBJECTS]

static

Definition at line 24 of file critical.c.

Referenced by RtlpAllocateDebugInfo(), and RtlpFreeDebugInfo().

RtlpStaticDebugInfo

RTL_CRITICAL_SECTION_DEBUG RtlpStaticDebugInfo[MAX_STATIC_CS_DEBUG_OBJECTS]

static

Definition at line 23 of file critical.c.

Referenced by RtlpAllocateDebugInfo(), and RtlpFreeDebugInfo().

RtlpTimeout

LARGE_INTEGER RtlpTimeout

Definition at line 26 of file critical.c.

Referenced by LdrpInitializeProcess(), RtlpUnWaitCriticalSection(), and RtlpWaitForCriticalSection().

RtlpTimeoutDisable

BOOLEAN RtlpTimeoutDisable

Definition at line 27 of file critical.c.

Referenced by LdrpInitializeProcess(), and RtlpWaitForCriticalSection().