resource.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for resource.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	IsExclusiveWaiting(r)   (r->NumberOfExclusiveWaiters > 0)
#define	IsSharedWaiting(r)   (r->NumberOfSharedWaiters > 0)
#define	IsOwnedExclusive(r)   (r->Flag & ResourceOwnedExclusive)
#define	IsBoostAllowed(r)   (!(r->Flag & ResourceHasDisabledPriorityBoost))
#define	ExpVerifyResource(r)
#define	ExpCheckForApcsDisabled(b, r, t)

Functions
FORCEINLINE VOID	ExAcquireResourceLock (IN PERESOURCE Resource, IN PKLOCK_QUEUE_HANDLE LockHandle)
FORCEINLINE VOID	ExReleaseResourceLock (IN PERESOURCE Resource, IN PKLOCK_QUEUE_HANDLE LockHandle)
VOID NTAPI	ExpResourceInitialization (VOID)
VOID NTAPI	ExpAllocateExclusiveWaiterEvent (IN PERESOURCE Resource, IN PKLOCK_QUEUE_HANDLE LockHandle)
VOID NTAPI	ExpAllocateSharedWaiterSemaphore (IN PERESOURCE Resource, IN PKLOCK_QUEUE_HANDLE LockHandle)
VOID NTAPI	ExpExpandResourceOwnerTable (IN PERESOURCE Resource, IN PKLOCK_QUEUE_HANDLE LockHandle)
POWNER_ENTRY FASTCALL	ExpFindFreeEntry (IN PERESOURCE Resource, IN PKLOCK_QUEUE_HANDLE LockHandle)
POWNER_ENTRY FASTCALL	ExpFindEntryForThread (IN PERESOURCE Resource, IN ERESOURCE_THREAD Thread, IN PKLOCK_QUEUE_HANDLE LockHandle, IN BOOLEAN FirstEntryInelligible)
VOID FASTCALL	ExpBoostOwnerThread (IN PKTHREAD Thread, IN PKTHREAD OwnerThread)
VOID FASTCALL	ExpWaitForResource (IN PERESOURCE Resource, IN PVOID Object)
BOOLEAN NTAPI	ExAcquireResourceExclusiveLite (IN PERESOURCE Resource, IN BOOLEAN Wait)
BOOLEAN NTAPI	ExAcquireResourceSharedLite (IN PERESOURCE Resource, IN BOOLEAN Wait)
BOOLEAN NTAPI	ExAcquireSharedStarveExclusive (IN PERESOURCE Resource, IN BOOLEAN Wait)
BOOLEAN NTAPI	ExAcquireSharedWaitForExclusive (IN PERESOURCE Resource, IN BOOLEAN Wait)
VOID NTAPI	ExConvertExclusiveToSharedLite (IN PERESOURCE Resource)
NTSTATUS NTAPI	ExDeleteResourceLite (IN PERESOURCE Resource)
VOID NTAPI	ExDisableResourceBoostLite (IN PERESOURCE Resource)
ULONG NTAPI	ExGetExclusiveWaiterCount (IN PERESOURCE Resource)
ULONG NTAPI	ExGetSharedWaiterCount (IN PERESOURCE Resource)
NTSTATUS NTAPI	ExInitializeResourceLite (IN PERESOURCE Resource)
BOOLEAN NTAPI	ExIsResourceAcquiredExclusiveLite (IN PERESOURCE Resource)
ULONG NTAPI	ExIsResourceAcquiredSharedLite (IN PERESOURCE Resource)
NTSTATUS NTAPI	ExReinitializeResourceLite (IN PERESOURCE Resource)
VOID FASTCALL	ExReleaseResourceLite (IN PERESOURCE Resource)
VOID NTAPI	ExReleaseResourceForThreadLite (IN PERESOURCE Resource, IN ERESOURCE_THREAD Thread)
VOID NTAPI	ExSetResourceOwnerPointer (IN PERESOURCE Resource, IN PVOID OwnerPointer)
BOOLEAN NTAPI	ExTryToAcquireResourceExclusiveLite (IN PERESOURCE Resource)
PVOID NTAPI	ExEnterCriticalRegionAndAcquireResourceExclusive (IN PERESOURCE Resource)
PVOID NTAPI	ExEnterCriticalRegionAndAcquireResourceShared (IN PERESOURCE Resource)
PVOID NTAPI	ExEnterCriticalRegionAndAcquireSharedWaitForExclusive (IN PERESOURCE Resource)
VOID FASTCALL	ExReleaseResourceAndLeaveCriticalRegion (IN PERESOURCE Resource)

Variables
LARGE_INTEGER	ExShortTime = {{-100000, -1}}
LARGE_INTEGER	ExpTimeout
ULONG	ExpResourceTimeoutCount = 90 * 3600 / 2
KSPIN_LOCK	ExpResourceSpinLock
LIST_ENTRY	ExpSystemResourcesList
BOOLEAN	ExResourceStrict = TRUE

Macro Definition Documentation

ExpCheckForApcsDisabled

#define ExpCheckForApcsDisabled	(		b,
			r,
			t
	)

Definition at line 155 of file resource.c.

ExpVerifyResource

#define ExpVerifyResource

(

r

)

Definition at line 154 of file resource.c.

IsBoostAllowed

#define IsBoostAllowed

(

r

)

(!(r->Flag & ResourceHasDisabledPriorityBoost))

Definition at line 19 of file resource.c.

IsExclusiveWaiting

#define IsExclusiveWaiting

(

r

)

(r->NumberOfExclusiveWaiters > 0)

Definition at line 16 of file resource.c.

IsOwnedExclusive

#define IsOwnedExclusive

(

r

)

(r->Flag & ResourceOwnedExclusive)

Definition at line 18 of file resource.c.

IsSharedWaiting

#define IsSharedWaiting

(

r

)

(r->NumberOfSharedWaiters > 0)

Definition at line 17 of file resource.c.

NDEBUG

#define NDEBUG

Definition at line 12 of file resource.c.

Function Documentation

ExAcquireResourceExclusiveLite()

BOOLEAN NTAPI ExAcquireResourceExclusiveLite	(	IN PERESOURCE	Resource,
		IN BOOLEAN	Wait
	)

Definition at line 775 of file resource.c.

{
    KLOCK_QUEUE_HANDLE LockHandle;
    ERESOURCE_THREAD Thread;
    BOOLEAN Success;
 
    /* Sanity check */
    ASSERT((Resource->Flag & ResourceNeverExclusive) == 0);
 
    /* Get the thread */
    Thread = ExGetCurrentResourceThread();
 
    /* Sanity check and validation */
    ASSERT(KeIsExecutingDpc() == FALSE);
    ExpVerifyResource(Resource);
 
    /* Acquire the lock */
    ExAcquireResourceLock(Resource, &LockHandle);
    ExpCheckForApcsDisabled(LockHandle.OldIrql, Resource, (PKTHREAD)Thread);
 
    /* Check if there is a shared owner or exclusive owner */
TryAcquire:
    if (Resource->ActiveEntries)
    {
        /* Check if it's exclusively owned, and we own it */
        if ((IsOwnedExclusive(Resource)) &&
            (Resource->OwnerEntry.OwnerThread == Thread))
        {
            /* Increase the owning count */
            Resource->OwnerEntry.OwnerCount++;
            Success = TRUE;
        }
        else
        {
            /*
             * If the caller doesn't want us to wait, we can't acquire the
             * resource because someone else then us owns it. If we can wait,
             * then we'll wait.
             */
            if (!Wait)
            {
                Success = FALSE;
            }
            else
            {
                /* Check if it has exclusive waiters */
                if (!Resource->ExclusiveWaiters)
                {
                    /* It doesn't, allocate the event and try acquiring again */
                    ExpAllocateExclusiveWaiterEvent(Resource, &LockHandle);
                    goto TryAcquire;
                }
 
                /* Has exclusive waiters, wait on it */
                Resource->NumberOfExclusiveWaiters++;
                ExReleaseResourceLock(Resource, &LockHandle);
                ExpWaitForResource(Resource, Resource->ExclusiveWaiters);
 
                /* Set owner and return success */
                Resource->OwnerEntry.OwnerThread = ExGetCurrentResourceThread();
                return TRUE;
            }
        }
    }
    else
    {
        /* Nobody owns it, so let's! */
        ASSERT(Resource->ActiveEntries == 0);
        ASSERT(Resource->ActiveCount == 0);
        Resource->Flag |= ResourceOwnedExclusive;
        Resource->ActiveEntries = 1;
        Resource->ActiveCount = 1;
        Resource->OwnerEntry.OwnerThread = Thread;
        Resource->OwnerEntry.OwnerCount = 1;
        Success = TRUE;
    }
 
    /* Release the lock and return */
    ExReleaseResourceLock(Resource, &LockHandle);
    return Success;
}

ExAcquireResourceLock()

FORCEINLINE VOID ExAcquireResourceLock	(	IN PERESOURCE	Resource,
		IN PKLOCK_QUEUE_HANDLE	LockHandle
	)

Definition at line 25 of file resource.c.

{
    UNREFERENCED_PARAMETER(Resource);
    UNREFERENCED_PARAMETER(LockHandle);
 
    /* Simply disable interrupts */
    _disable();
}

Referenced by ExAcquireResourceExclusiveLite(), ExAcquireResourceSharedLite(), ExAcquireSharedStarveExclusive(), ExAcquireSharedWaitForExclusive(), ExConvertExclusiveToSharedLite(), ExDisableResourceBoostLite(), ExIsResourceAcquiredSharedLite(), ExpAllocateExclusiveWaiterEvent(), ExpAllocateSharedWaiterSemaphore(), ExpExpandResourceOwnerTable(), ExpWaitForResource(), ExReleaseResourceForThreadLite(), ExSetResourceOwnerPointer(), and ExTryToAcquireResourceExclusiveLite().

ExAcquireResourceSharedLite()

BOOLEAN NTAPI ExAcquireResourceSharedLite	(	IN PERESOURCE	Resource,
		IN BOOLEAN	Wait
	)

Definition at line 890 of file resource.c.

{
    KLOCK_QUEUE_HANDLE LockHandle;
    ERESOURCE_THREAD Thread;
    POWNER_ENTRY Owner = NULL;
    BOOLEAN FirstEntryBusy;
 
    /* Get the thread */
    Thread = ExGetCurrentResourceThread();
 
    /* Sanity check and validation */
    ASSERT(KeIsExecutingDpc() == FALSE);
    ExpVerifyResource(Resource);
 
    /* Acquire the lock */
    ExAcquireResourceLock(Resource, &LockHandle);
    ExpCheckForApcsDisabled(LockHandle.OldIrql, Resource, (PKTHREAD)Thread);
 
    /* Check how many active entries we've got */
    while (Resource->ActiveEntries != 0)
    {
        /* Check if it's exclusively owned */
        if (IsOwnedExclusive(Resource))
        {
            /* Check if we own it */
            if (Resource->OwnerEntry.OwnerThread == Thread)
            {
                /* Increase the owning count */
                Resource->OwnerEntry.OwnerCount++;
 
                /* Release the lock and return */
                ExReleaseResourceLock(Resource, &LockHandle);
                return TRUE;
            }
 
            /* Find a free entry */
            Owner = ExpFindFreeEntry(Resource, &LockHandle);
            if (!Owner) continue;
        }
        else
        {
            /* Resource is shared, find who owns it */
            FirstEntryBusy = IsExclusiveWaiting(Resource);
            Owner = ExpFindEntryForThread(Resource,
                                          Thread,
                                          &LockHandle,
                                          FirstEntryBusy);
            if (!Owner) continue;
 
            /* Is it us? */
            if (Owner->OwnerThread == Thread)
            {
                /* Increase acquire count and return */
                Owner->OwnerCount++;
                ASSERT(Owner->OwnerCount != 0);
 
                /* Release the lock and return */
                ExReleaseResourceLock(Resource, &LockHandle);
                return TRUE;
            }
 
            /* Try to find if there are exclusive waiters */
            if (!FirstEntryBusy)
            {
                /* There are none, so acquire it */
                Owner->OwnerThread = Thread;
                Owner->OwnerCount = 1;
 
                /* Check how many active entries we had */
                if (Resource->ActiveEntries == 0)
                {
                    /* Set initial counts */
                    ASSERT(Resource->ActiveCount == 0);
                    Resource->ActiveEntries = 1;
                    Resource->ActiveCount = 1;
                }
                else
                {
                    /* Increase active entries */
                    ASSERT(Resource->ActiveCount == 1);
                    Resource->ActiveEntries++;
                }
 
                /* Release the lock and return */
                ExReleaseResourceLock(Resource, &LockHandle);
                return TRUE;
            }
        }
 
        /* If we got here, then we need to wait. Are we allowed? */
        if (!Wait)
        {
            /* Release the lock and return */
            ExReleaseResourceLock(Resource, &LockHandle);
            return FALSE;
        }
 
        /* Check if we have a shared waiters semaphore */
        if (!Resource->SharedWaiters)
        {
            /* Allocate it and try another acquire */
            ExpAllocateSharedWaiterSemaphore(Resource, &LockHandle);
        }
        else
        {
            /* We have shared waiters, wait for it */
            break;
        }
    }
 
    /* Did we get here because we don't have active entries? */
    if (Resource->ActiveEntries == 0)
    {
        /* Acquire it */
        ASSERT(Resource->ActiveEntries == 0);
        ASSERT(Resource->ActiveCount == 0);
        Resource->ActiveEntries = 1;
        Resource->ActiveCount = 1;
        Resource->OwnerEntry.OwnerThread = Thread;
        Resource->OwnerEntry.OwnerCount = 1;
 
        /* Release the lock and return */
        ExReleaseResourceLock(Resource, &LockHandle);
        return TRUE;
    }
 
    /* Now wait for the resource */
    Owner->OwnerThread = Thread;
    Owner->OwnerCount = 1;
    Resource->NumberOfSharedWaiters++;
 
    /* Release the lock and return */
    ExReleaseResourceLock(Resource, &LockHandle);
    ExpWaitForResource(Resource, Resource->SharedWaiters);
    return TRUE;
}

ExAcquireSharedStarveExclusive()

BOOLEAN NTAPI ExAcquireSharedStarveExclusive	(	IN PERESOURCE	Resource,
		IN BOOLEAN	Wait
	)

Definition at line 1068 of file resource.c.

{
    KLOCK_QUEUE_HANDLE LockHandle;
    ERESOURCE_THREAD Thread;
    POWNER_ENTRY Owner;
 
    /* Get the thread */
    Thread = ExGetCurrentResourceThread();
 
    /* Sanity check and validation */
    ASSERT(KeIsExecutingDpc() == FALSE);
    ExpVerifyResource(Resource);
 
    /* Acquire the lock */
    ExAcquireResourceLock(Resource, &LockHandle);
 
    /* See if anyone owns it */
TryAcquire:
    if (Resource->ActiveEntries == 0)
    {
        /* Nobody owns it, so let's take control */
        ASSERT(Resource->ActiveEntries == 0);
        ASSERT(Resource->ActiveCount == 0);
        Resource->ActiveCount = 1;
        Resource->ActiveEntries = 1;
        Resource->OwnerEntry.OwnerThread = Thread;
        Resource->OwnerEntry.OwnerCount = 1;
 
        /* Release the lock and return */
        ExReleaseResourceLock(Resource, &LockHandle);
        return TRUE;
    }
 
    /* Check if it's exclusively owned */
    if (IsOwnedExclusive(Resource))
    {
        /* Check if we own it */
        if (Resource->OwnerEntry.OwnerThread == Thread)
        {
            /* Increase the owning count */
            Resource->OwnerEntry.OwnerCount++;
 
            /* Release the lock and return */
            ExReleaseResourceLock(Resource, &LockHandle);
            return TRUE;
        }
 
        /* Find a free entry */
        Owner = ExpFindFreeEntry(Resource, &LockHandle);
        if (!Owner) goto TryAcquire;
    }
    else
    {
        /* Resource is shared, find who owns it */
        Owner = ExpFindEntryForThread(Resource, Thread, &LockHandle, FALSE);
        if (!Owner) goto TryAcquire;
 
        /* Is it us? */
        if (Owner->OwnerThread == Thread)
        {
            /* Increase acquire count and return */
            Owner->OwnerCount++;
            ASSERT(Owner->OwnerCount != 0);
 
            /* Release the lock and return */
            ExReleaseResourceLock(Resource, &LockHandle);
            return TRUE;
        }
 
        /* Acquire it */
        Owner->OwnerThread = Thread;
        Owner->OwnerCount = 1;
 
        /* Check how many active entries we had */
        if (Resource->ActiveEntries == 0)
        {
            /* Set initial counts */
            ASSERT(Resource->ActiveCount == 0);
            Resource->ActiveEntries = 1;
            Resource->ActiveCount = 1;
        }
        else
        {
            /* Increase active entries */
            ASSERT(Resource->ActiveCount == 1);
            Resource->ActiveEntries++;
        }
 
        /* Release the lock and return */
        ExReleaseResourceLock(Resource, &LockHandle);
        return TRUE;
    }
 
    /* If we got here, then we need to wait. Are we allowed? */
    if (!Wait)
    {
        /* Release the lock and return */
        ExReleaseResourceLock(Resource, &LockHandle);
        return FALSE;
    }
 
    /* Check if we have a shared waiters semaphore */
    if (!Resource->SharedWaiters)
    {
        /* Allocate it and try another acquire */
        ExpAllocateSharedWaiterSemaphore(Resource, &LockHandle);
        goto TryAcquire;
    }
 
    /* Now wait for the resource */
    Owner->OwnerThread = Thread;
    Owner->OwnerCount = 1;
    Resource->NumberOfSharedWaiters++;
 
    /* Release the lock and return */
    ExReleaseResourceLock(Resource, &LockHandle);
    ExpWaitForResource(Resource, Resource->SharedWaiters);
    return TRUE;
}

Referenced by __RxAcquireFcb(), _Requires_lock_held_(), CcpGetAppropriateBcb(), CcpPinData(), CmpLockRegistry(), Ext2FloppyFlush(), Ext2FlushVolume(), Ext2PurgeFile(), Ext2PurgeVolume(), Ext2WriteFile(), Ext2WriteVolume(), get_block_bh_mdl(), get_block_bh_pin(), TestResourceExclusiveAccess(), TestResourceSharedAccess(), and TestResourceWithThreads().

ExAcquireSharedWaitForExclusive()

BOOLEAN NTAPI ExAcquireSharedWaitForExclusive	(	IN PERESOURCE	Resource,
		IN BOOLEAN	Wait
	)

Definition at line 1222 of file resource.c.

{
    KLOCK_QUEUE_HANDLE LockHandle;
    ERESOURCE_THREAD Thread;
    POWNER_ENTRY Owner;
 
    /* Get the thread */
    Thread = ExGetCurrentResourceThread();
 
    /* Sanity check and validation */
    ASSERT(KeIsExecutingDpc() == FALSE);
    ExpVerifyResource(Resource);
 
    /* Acquire the lock */
    ExAcquireResourceLock(Resource, &LockHandle);
 
    /* See if nobody owns us */
TryAcquire:
    if (!Resource->ActiveEntries)
    {
        /* Nobody owns it, so let's take control */
        ASSERT(Resource->ActiveEntries == 0);
        ASSERT(Resource->ActiveCount == 0);
        Resource->ActiveCount = 1;
        Resource->ActiveEntries = 1;
        Resource->OwnerEntry.OwnerThread = Thread;
        Resource->OwnerEntry.OwnerCount = 1;
 
        /* Release the lock and return */
        ExReleaseResourceLock(Resource, &LockHandle);
        return TRUE;
    }
 
    /* Check if it's exclusively owned */
    if (IsOwnedExclusive(Resource))
    {
        /* Check if we own it */
        if (Resource->OwnerEntry.OwnerThread == Thread)
        {
            /* Increase the owning count */
            Resource->OwnerEntry.OwnerCount++;
 
            /* Release the lock and return */
            ExReleaseResourceLock(Resource, &LockHandle);
            return TRUE;
        }
 
        /* Find a free entry */
        Owner = ExpFindFreeEntry(Resource, &LockHandle);
        if (!Owner) goto TryAcquire;
    }
    else
    {
        /* Try to find if there are exclusive waiters */
        if (IsExclusiveWaiting(Resource))
        {
            /* We have to wait for the exclusive waiter to be done */
            if (!Wait)
            {
                /* So bail out if we're not allowed */
                ExReleaseResourceLock(Resource, &LockHandle);
                return FALSE;
            }
 
            /* Check if we have a shared waiters semaphore */
            if (!Resource->SharedWaiters)
            {
                /* Allocate one and try again */
                ExpAllocateSharedWaiterSemaphore(Resource, &LockHandle);
                goto TryAcquire;
            }
 
            /* Now wait for the resource */
            Resource->NumberOfSharedWaiters++;
            ExReleaseResourceLock(Resource, &LockHandle);
            ExpWaitForResource(Resource, Resource->SharedWaiters);
 
            /* Get the lock back */
            ExAcquireResourceLock(Resource, &LockHandle);
 
            /* Find who owns it now */
            while (!(Owner = ExpFindEntryForThread(Resource, Thread, &LockHandle, TRUE)));
 
            /* Sanity checks */
            ASSERT(IsOwnedExclusive(Resource) == FALSE);
            ASSERT(Resource->ActiveEntries > 0);
            ASSERT(Owner->OwnerThread != Thread);
 
            /* Take control */
            Owner->OwnerThread = Thread;
            Owner->OwnerCount = 1;
 
            /* Release the lock and return */
            ExReleaseResourceLock(Resource, &LockHandle);
            return TRUE;
        }
        else
        {
            /* Resource is shared, find who owns it */
            Owner = ExpFindEntryForThread(Resource, Thread, &LockHandle, FALSE);
            if (!Owner) goto TryAcquire;
 
            /* Is it us? */
            if (Owner->OwnerThread == Thread)
            {
                /* Increase acquire count and return */
                Owner->OwnerCount++;
                ASSERT(Owner->OwnerCount != 0);
 
                /* Release the lock and return */
                ExReleaseResourceLock(Resource, &LockHandle);
                return TRUE;
            }
 
            /* No exclusive waiters, so acquire it */
            Owner->OwnerThread = Thread;
            Owner->OwnerCount = 1;
 
            /* Check how many active entries we had */
            if (Resource->ActiveEntries == 0)
            {
                /* Set initial counts */
                ASSERT(Resource->ActiveCount == 0);
                Resource->ActiveEntries = 1;
                Resource->ActiveCount = 1;
            }
            else
            {
                /* Increase active entries */
                ASSERT(Resource->ActiveCount == 1);
                Resource->ActiveEntries++;
            }
 
            /* Release the lock and return */
            ExReleaseResourceLock(Resource, &LockHandle);
            return TRUE;
        }
    }
 
    /* We have to wait for the exclusive waiter to be done */
    if (!Wait)
    {
        /* So bail out if we're not allowed */
        ExReleaseResourceLock(Resource, &LockHandle);
        return FALSE;
    }
 
    /* Check if we have a shared waiters semaphore */
    if (!Resource->SharedWaiters)
    {
        /* Allocate one and try again */
        ExpAllocateSharedWaiterSemaphore(Resource,&LockHandle);
        goto TryAcquire;
    }
 
    /* Take control */
    Owner->OwnerThread = Thread;
    Owner->OwnerCount = 1;
    Resource->NumberOfSharedWaiters++;
 
    /* Release the lock and return */
    ExReleaseResourceLock(Resource, &LockHandle);
    ExpWaitForResource(Resource, Resource->SharedWaiters);
    return TRUE;
}

Referenced by __RxAcquireFcb(), ExEnterCriticalRegionAndAcquireSharedWaitForExclusive(), FsRtlAcquireFileForModWriteEx(), TestResourceExclusiveAccess(), TestResourceSharedAccess(), and TestResourceWithThreads().

ExConvertExclusiveToSharedLite()

VOID NTAPI ExConvertExclusiveToSharedLite

(

IN PERESOURCE

Resource

)

Definition at line 1407 of file resource.c.

{
    ULONG OldWaiters;
    KLOCK_QUEUE_HANDLE LockHandle;
 
    /* Sanity checks */
    ASSERT(KeIsExecutingDpc() == FALSE);
    ExpVerifyResource(Resource);
    ASSERT(IsOwnedExclusive(Resource));
    ASSERT(Resource->OwnerEntry.OwnerThread == (ERESOURCE_THREAD)PsGetCurrentThread());
 
    /* Lock the resource */
    ExAcquireResourceLock(Resource, &LockHandle);
 
    /* Erase the exclusive flag */
    Resource->Flag &= ~ResourceOwnedExclusive;
 
    /* Check if we have shared waiters */
    if (IsSharedWaiting(Resource))
    {
        /* Make the waiters active owners */
        OldWaiters = Resource->NumberOfSharedWaiters;
        Resource->ActiveEntries += OldWaiters;
        Resource->NumberOfSharedWaiters = 0;
 
        /* Release lock and wake the waiters */
        ExReleaseResourceLock(Resource, &LockHandle);
        KeReleaseSemaphore(Resource->SharedWaiters, 0, OldWaiters, FALSE);
    }
    else
    {
        /* Release lock */
        ExReleaseResourceLock(Resource, &LockHandle);
    }
}

ExDeleteResourceLite()

NTSTATUS NTAPI ExDeleteResourceLite

(

IN PERESOURCE

Resource

)

Definition at line 1461 of file resource.c.

{
    KLOCK_QUEUE_HANDLE LockHandle;
 
    /* Sanity checks */
    ASSERT(IsSharedWaiting(Resource) == FALSE);
    ASSERT(IsExclusiveWaiting(Resource) == FALSE);
    ASSERT(KeIsExecutingDpc() == FALSE);
    ExpVerifyResource(Resource);
 
    /* Lock the resource */
    KeAcquireInStackQueuedSpinLock(&ExpResourceSpinLock, &LockHandle);
 
    /* Remove the resource */
    RemoveEntryList(&Resource->SystemResourcesList);
 
    /* Release the lock */
    KeReleaseInStackQueuedSpinLock(&LockHandle);
 
    /* Free every  structure */
    if (Resource->OwnerTable) ExFreePoolWithTag(Resource->OwnerTable, TAG_RESOURCE_TABLE);
    if (Resource->SharedWaiters) ExFreePoolWithTag(Resource->SharedWaiters, TAG_RESOURCE_SEMAPHORE);
    if (Resource->ExclusiveWaiters) ExFreePoolWithTag(Resource->ExclusiveWaiters, TAG_RESOURCE_EVENT);
 
    /* Return success */
    return STATUS_SUCCESS;
}

ExDisableResourceBoostLite()

VOID NTAPI ExDisableResourceBoostLite

(

IN PERESOURCE

Resource

)

Definition at line 1506 of file resource.c.

{
    KLOCK_QUEUE_HANDLE LockHandle;
 
    /* Sanity check */
    ExpVerifyResource(Resource);
 
    /* Lock the resource */
    ExAcquireResourceLock(Resource, &LockHandle);
 
    /* Remove the flag */
    Resource->Flag |= ResourceHasDisabledPriorityBoost;
 
    /* Release the lock */
    ExReleaseResourceLock(Resource, &LockHandle);
}

ExEnterCriticalRegionAndAcquireResourceExclusive()

PVOID NTAPI ExEnterCriticalRegionAndAcquireResourceExclusive

(

IN PERESOURCE

Resource

)

Definition at line 2194 of file resource.c.

{
    /* Enter critical region */
    KeEnterCriticalRegion();
 
    /* Acquire the resource */
    NT_VERIFY(ExAcquireResourceExclusiveLite(Resource, TRUE));
 
    /* Return the Win32 Thread */
    return KeGetCurrentThread()->Win32Thread;
}

Referenced by _Acquires_lock_().

ExEnterCriticalRegionAndAcquireResourceShared()

PVOID NTAPI ExEnterCriticalRegionAndAcquireResourceShared

(

IN PERESOURCE

Resource

)

Definition at line 2223 of file resource.c.

{
    /* Enter critical region */
    KeEnterCriticalRegion();
 
    /* Acquire the resource */
    NT_VERIFY(ExAcquireResourceSharedLite(Resource, TRUE));
 
    /* Return the Win32 Thread */
    return KeGetCurrentThread()->Win32Thread;
}

ExEnterCriticalRegionAndAcquireSharedWaitForExclusive()

PVOID NTAPI ExEnterCriticalRegionAndAcquireSharedWaitForExclusive

(

IN PERESOURCE

Resource

)

Definition at line 2254 of file resource.c.

{
    /* Enter critical region */
    KeEnterCriticalRegion();
 
    /* Acquire the resource */
    NT_VERIFY(ExAcquireSharedWaitForExclusive(Resource, TRUE));
 
    /* Return the Win32 Thread */
    return KeGetCurrentThread()->Win32Thread;
}

ExGetExclusiveWaiterCount()

ULONG NTAPI ExGetExclusiveWaiterCount

(

IN PERESOURCE

Resource

)

Definition at line 1540 of file resource.c.

{
    /* Return the count */
    return Resource->NumberOfExclusiveWaiters;
}

ExGetSharedWaiterCount()

ULONG NTAPI ExGetSharedWaiterCount

(

IN PERESOURCE

Resource

)

Definition at line 1563 of file resource.c.

{
    /* Return the count */
    return Resource->NumberOfSharedWaiters;
}

ExInitializeResourceLite()

NTSTATUS NTAPI ExInitializeResourceLite

(

IN PERESOURCE

Resource

)

Definition at line 1587 of file resource.c.

{
    KLOCK_QUEUE_HANDLE LockHandle;
 
    /* Clear the structure */
    RtlZeroMemory(Resource, sizeof(ERESOURCE));
 
    /* Initialize the lock */
    KeInitializeSpinLock(&Resource->SpinLock);
 
    /* Add it into the system list */
    KeAcquireInStackQueuedSpinLock(&ExpResourceSpinLock, &LockHandle);
    InsertTailList(&ExpSystemResourcesList, &Resource->SystemResourcesList);
    KeReleaseInStackQueuedSpinLock(&LockHandle);
 
    /* Return success */
    return STATUS_SUCCESS;
}

ExIsResourceAcquiredExclusiveLite()

BOOLEAN NTAPI ExIsResourceAcquiredExclusiveLite

(

IN PERESOURCE

Resource

)

Definition at line 1624 of file resource.c.

{
    BOOLEAN IsAcquired = FALSE;
 
    /* Sanity check */
    ExpVerifyResource(Resource);
 
    /* Check if it's exclusively acquired */
    if ((IsOwnedExclusive(Resource)) &&
        (Resource->OwnerEntry.OwnerThread == ExGetCurrentResourceThread()))
    {
        /* It is acquired */
        IsAcquired = TRUE;
    }
 
    /* Return if it's acquired */
    return IsAcquired;
}

Referenced by __attribute__(), _Dispatch_type_(), _Requires_lock_held_(), CcSetBcbOwnerPointer(), CmpLockHiveFlusherExclusive(), CmpLockHiveFlusherShared(), CmpTestHiveFlusherLockExclusive(), CmpTestRegistryLockExclusive(), EngIsSemaphoreOwnedByCurrentThread(), Ext2AllocateFcb(), Ext2FlushVcb(), Ext2InsertFcb(), flush_fcb(), oplock_complete(), UDFAcquireResourceExclusiveWithCheck(), UDFAcquireResourceSharedWithCheck(), UDFCommonFlush(), UDFFastIoAcqCreateSec(), UDFIsResourceAcquired(), UserIsEntered(), and UserIsEnteredExclusive().

ExIsResourceAcquiredSharedLite()

ULONG NTAPI ExIsResourceAcquiredSharedLite

(

IN PERESOURCE

Resource

)

Definition at line 1663 of file resource.c.

{
    ERESOURCE_THREAD Thread;
    ULONG i, Size;
    ULONG Count = 0;
    KLOCK_QUEUE_HANDLE LockHandle;
    POWNER_ENTRY Owner;
 
    /* Sanity check */
    ExpVerifyResource(Resource);
 
    /* Check if nobody owns us */
    if (!Resource->ActiveEntries) return 0;
 
    /* Get the thread */
    Thread = ExGetCurrentResourceThread();
 
    /* Check if we are in the thread list */
    if (Resource->OwnerEntry.OwnerThread == Thread)
    {
        /* Found it, return count */
        Count = Resource->OwnerEntry.OwnerCount;
    }
    else
    {
        /* We can't own an exclusive resource at this point */
        if (IsOwnedExclusive(Resource)) return 0;
 
        /* Lock the resource */
        ExAcquireResourceLock(Resource, &LockHandle);
 
        /* Not in the list, do a full table look up */
        Owner = Resource->OwnerTable;
        if (Owner)
        {
            /* Get the resource index */
            i = ((PKTHREAD)Thread)->ResourceIndex;
            Size = Owner->TableSize;
 
            /* Check if the index is valid and check if we don't match */
            if ((i >= Size) || (Owner[i].OwnerThread != Thread))
            {
                /* Sh*t! We need to do a full search */
                for (i = 1; i < Size; i++)
                {
                    /* Move to next owner */
                    Owner++;
 
                    /* Try to find a match */
                    if (Owner->OwnerThread == Thread)
                    {
                        /* Finally! */
                        Count = Owner->OwnerCount;
                        break;
                    }
                }
            }
            else
            {
                /* We found the match directlry */
                Count = Owner[i].OwnerCount;
            }
        }
 
        /* Release the lock */
        ExReleaseResourceLock(Resource, &LockHandle);
    }
 
    /* Return count */
    return Count;
}

Referenced by _Dispatch_type_(), _Function_class_(), CcSetBcbOwnerPointer(), CmpTestHiveFlusherLockShared(), CmpTestRegistryLock(), do_read_job(), find_file_in_dir(), FsRtlAcquireFileForCcFlushEx(), open_fileref_child(), UDFAcquireResourceExclusiveWithCheck(), UDFAcquireResourceSharedWithCheck(), UDFCommonFlush(), UDFIsResourceAcquired(), and UserIsEntered().

ExpAllocateExclusiveWaiterEvent()

VOID NTAPI ExpAllocateExclusiveWaiterEvent	(	IN PERESOURCE	Resource,
		IN PKLOCK_QUEUE_HANDLE	LockHandle
	)

Definition at line 200 of file resource.c.

{
    PKEVENT Event;
 
    /* Release the lock */
    ExReleaseResourceLock(Resource, LockHandle);
 
    /* Loop as long as we keep running out of memory */
    do
    {
        /* Allocate the event */
        Event = ExAllocatePoolWithTag(NonPagedPool,
                                      sizeof(KEVENT),
                                      TAG_RESOURCE_EVENT);
        if (Event)
        {
            /* Initialize it */
            KeInitializeEvent(Event, SynchronizationEvent, FALSE);
 
            /* Set it */
            if (InterlockedCompareExchangePointer((PVOID*)&Resource->ExclusiveWaiters,
                                                  Event,
                                                  NULL))
            {
                /* Someone already set it, free our event */
                DPRINT1("WARNING: Handling race condition\n");
                ExFreePoolWithTag(Event, TAG_RESOURCE_EVENT);
            }
 
            break;
        }
 
        /* Wait a bit before trying again */
        KeDelayExecutionThread(KernelMode, FALSE, &ExShortTime);
    } while (TRUE);
 
    /* Re-acquire the lock */
    ExAcquireResourceLock(Resource, LockHandle);
}

Referenced by ExAcquireResourceExclusiveLite().

ExpAllocateSharedWaiterSemaphore()

VOID NTAPI ExpAllocateSharedWaiterSemaphore	(	IN PERESOURCE	Resource,
		IN PKLOCK_QUEUE_HANDLE	LockHandle
	)

Definition at line 260 of file resource.c.

{
    PKSEMAPHORE Semaphore;
 
    /* Release the lock */
    ExReleaseResourceLock(Resource, LockHandle);
 
    /* Loop as long as we keep running out of memory */
    do
    {
        /* Allocate the semaphore */
        Semaphore = ExAllocatePoolWithTag(NonPagedPool,
                                          sizeof(KSEMAPHORE),
                                          TAG_RESOURCE_SEMAPHORE);
        if (Semaphore)
        {
            /* Initialize it */
            KeInitializeSemaphore(Semaphore, 0, MAXLONG);
 
            /* Set it */
            if (InterlockedCompareExchangePointer((PVOID*)&Resource->SharedWaiters,
                                                  Semaphore,
                                                  NULL))
            {
                /* Someone already set it, free our semaphore */
                DPRINT1("WARNING: Handling race condition\n");
                ExFreePoolWithTag(Semaphore, TAG_RESOURCE_SEMAPHORE);
            }
 
            break;
        }
 
        /* Wait a bit before trying again */
        KeDelayExecutionThread(KernelMode, FALSE, &ExShortTime);
    } while (TRUE);
 
    /* Re-acquire the lock */
    ExAcquireResourceLock(Resource, LockHandle);
}

Referenced by ExAcquireResourceSharedLite(), ExAcquireSharedStarveExclusive(), and ExAcquireSharedWaitForExclusive().

ExpBoostOwnerThread()

VOID FASTCALL ExpBoostOwnerThread	(	IN PKTHREAD	Thread,
		IN PKTHREAD	OwnerThread
	)

Definition at line 576 of file resource.c.

{
    /* Make sure the owner thread is a pointer, not an ID */
    if (!((ULONG_PTR)OwnerThread & 0x3))
    {
        /* Check if we can actually boost it */
        if ((OwnerThread->Priority < Thread->Priority) &&
            (OwnerThread->Priority < 14))
        {
            /* Acquire the thread lock */
            KiAcquireThreadLock(Thread);
 
            /* Set the new priority */
            OwnerThread->PriorityDecrement += 14 - OwnerThread->Priority;
 
            /* Update quantum */
            OwnerThread->Quantum = OwnerThread->QuantumReset;
 
            /* Update the kernel state */
            KiSetPriorityThread(OwnerThread, 14);
 
            /* Release the thread lock */
            KiReleaseThreadLock(Thread);
        }
    }
}

Referenced by ExpWaitForResource().

ExpExpandResourceOwnerTable()

VOID NTAPI ExpExpandResourceOwnerTable	(	IN PERESOURCE	Resource,
		IN PKLOCK_QUEUE_HANDLE	LockHandle
	)

Definition at line 320 of file resource.c.

{
    POWNER_ENTRY Owner, Table;
    KIRQL OldIrql;
    ULONG NewSize, OldSize;
 
    /* Get the owner table */
    Owner = Resource->OwnerTable;
    if (!Owner)
    {
        /* Start with the default size of 3 */
        OldSize = 0;
        NewSize = 3;
    }
    else
    {
        /* Add 4 more entries */
        OldSize = Owner->TableSize;
        NewSize = OldSize + 4;
    }
 
    /* Release the lock */
    ExReleaseResourceLock(Resource, LockHandle);
 
    /* Allocate memory for the table */
    Table = ExAllocatePoolWithTag(NonPagedPool,
                                  NewSize * sizeof(OWNER_ENTRY),
                                  TAG_RESOURCE_TABLE);
 
    /* Zero the table */
    RtlZeroMemory(Table + OldSize,
                  (NewSize - OldSize) * sizeof(OWNER_ENTRY));
 
    /* Lock the resource */
    ExAcquireResourceLock(Resource, LockHandle);
 
    /* Make sure nothing has changed */
    if ((Owner != Resource->OwnerTable) ||
        ((Owner) && (OldSize != Owner->TableSize)))
    {
        /* Resource changed while we weren't holding the lock; bail out */
        ExReleaseResourceLock(Resource, LockHandle);
        ExFreePoolWithTag(Table, TAG_RESOURCE_TABLE);
    }
    else
    {
        /* Copy the table */
        if (Owner) RtlCopyMemory(Table, Owner, OldSize * sizeof(OWNER_ENTRY));
 
        /* Acquire dispatcher lock to prevent thread boosting */
        OldIrql = KiAcquireDispatcherLock();
 
        /* Set the new table data */
        Table->TableSize = NewSize;
        Resource->OwnerTable = Table;
 
        /* Release dispatcher lock */
        KiReleaseDispatcherLock(OldIrql);
 
        /* Sanity check */
        ExpVerifyResource(Resource);
 
        /* Release lock */
        ExReleaseResourceLock(Resource, LockHandle);
 
        /* Free the old table */
        if (Owner) ExFreePoolWithTag(Owner, TAG_RESOURCE_TABLE);
 
        /* Set the resource index */
        if (!OldSize) OldSize = 1;
    }
 
    /* Set the resource index */
    KeGetCurrentThread()->ResourceIndex = (UCHAR)OldSize;
 
    /* Lock the resource again */
    ExAcquireResourceLock(Resource, LockHandle);
}

Referenced by ExpFindEntryForThread(), and ExpFindFreeEntry().

ExpFindEntryForThread()

POWNER_ENTRY FASTCALL ExpFindEntryForThread	(	IN PERESOURCE	Resource,
		IN ERESOURCE_THREAD	Thread,
		IN PKLOCK_QUEUE_HANDLE	LockHandle,
		IN BOOLEAN	FirstEntryInelligible
	)

Definition at line 483 of file resource.c.

{
    POWNER_ENTRY FreeEntry, Owner, Limit;
 
    /* Start by looking in the static array */
    Owner = &Resource->OwnerEntry;
    if (Owner->OwnerThread == Thread) return Owner;
 
    /* Check if this is a free entry */
    if ((FirstEntryInelligible) || (Owner->OwnerThread))
    {
        /* No free entry */
        FreeEntry = NULL;
    }
    else
    {
        /* Use the first entry as our free entry */
        FreeEntry = Owner;
    }
 
    /* Get the current table pointer */
    Owner = Resource->OwnerTable;
    if (Owner)
    {
        /* Set the limit, move to the next owner and loop owner entries */
        Limit = &Owner[Owner->TableSize];
        Owner++;
        while (Owner->OwnerThread != Thread)
        {
            /* Check if we don't have a free entry */
            if (!FreeEntry)
            {
                /* Check if this entry is free */
                if (!Owner->OwnerThread)
                {
                    /* Save it as our free entry */
                    FreeEntry = Owner;
                }
            }
 
            /* Move to the next one */
            Owner++;
 
            /* Check if the entry is free */
            if (Owner == Limit) goto Expand;
        }
 
        /* Update the resource entry */
        KeGetCurrentThread()->ResourceIndex = (UCHAR)(Owner - Resource->OwnerTable);
        return Owner;
    }
    else
    {
Expand:
        /* Check if it's OK to do an expansion */
        if (!LockHandle) return NULL;
 
        /* If we found a free entry by now, return it */
        if (FreeEntry)
        {
            /* Set the resource index */
            KeGetCurrentThread()->ResourceIndex = (UCHAR)(FreeEntry - Resource->OwnerTable);
            return FreeEntry;
        }
 
        /* No free entry, expand the table */
        ExpExpandResourceOwnerTable(Resource, LockHandle);
        return NULL;
    }
}

Referenced by ExAcquireResourceSharedLite(), ExAcquireSharedStarveExclusive(), ExAcquireSharedWaitForExclusive(), and ExSetResourceOwnerPointer().

ExpFindFreeEntry()

POWNER_ENTRY FASTCALL ExpFindFreeEntry	(	IN PERESOURCE	Resource,
		IN PKLOCK_QUEUE_HANDLE	LockHandle
	)

Definition at line 420 of file resource.c.

{
    POWNER_ENTRY Owner, Limit;
 
    /* Sanity check */
    ASSERT(LockHandle != 0);
    ASSERT(Resource->OwnerEntry.OwnerThread != 0);
 
    /* Get the current table pointer */
    Owner = Resource->OwnerTable;
    if (Owner)
    {
        /* Set the limit, move to the next owner and loop owner entries */
        Limit = &Owner[Owner->TableSize];
        Owner++;
        while (Owner->OwnerThread)
        {
            /* Move to the next one */
            Owner++;
 
            /* Check if the entry is free */
            if (Owner == Limit) goto Expand;
        }
 
        /* Update the resource entry */
        KeGetCurrentThread()->ResourceIndex = (UCHAR)(Owner - Resource->OwnerTable);
    }
    else
    {
Expand:
        /* No free entry, expand the table */
        ExpExpandResourceOwnerTable(Resource, LockHandle);
        Owner = NULL;
    }
 
    /* Return the entry found */
    return Owner;
}

Referenced by ExAcquireResourceSharedLite(), ExAcquireSharedStarveExclusive(), and ExAcquireSharedWaitForExclusive().

ExpResourceInitialization()

VOID NTAPI ExpResourceInitialization

(

VOID

)

Definition at line 173 of file resource.c.

{
    /* Setup the timeout */
    ExpTimeout.QuadPart = Int32x32To64(4, -10000000);
    InitializeListHead(&ExpSystemResourcesList);
    KeInitializeSpinLock(&ExpResourceSpinLock);
}

Referenced by ExpInitSystemPhase0().

ExpWaitForResource()

VOID FASTCALL ExpWaitForResource	(	IN PERESOURCE	Resource,
		IN PVOID	Object
	)

Definition at line 622 of file resource.c.

{
    ULONG i;
    ULONG Size;
    POWNER_ENTRY Owner;
    ULONG WaitCount = 0;
    NTSTATUS Status;
    LARGE_INTEGER Timeout;
    PKTHREAD Thread, OwnerThread;
#if DBG
    KLOCK_QUEUE_HANDLE LockHandle;
#endif
 
    /* Increase contention count and use a 5 second timeout */
    Resource->ContentionCount++;
    Timeout.QuadPart = 500 * -10000LL;
    for (;;)
    {
        /* Wait for ownership */
        Status = KeWaitForSingleObject(Object,
                                       WrResource,
                                       KernelMode,
                                       FALSE,
                                       &Timeout);
        if (Status != STATUS_TIMEOUT)
            break;
 
        /* Increase wait count */
        WaitCount++;
        Timeout = ExpTimeout;
 
        /* Check if we've exceeded the limit */
        if (WaitCount > ExpResourceTimeoutCount)
        {
            /* Reset wait count */
            WaitCount = 0;
#if DBG
            /* Lock the resource */
            ExAcquireResourceLock(Resource, &LockHandle);
 
            /* Dump debug information */
            DPRINT1("Resource @ %p\n", Resource);
            DPRINT1(" ActiveEntries = %04lx  Flags = %s%s%s\n",
                    Resource->ActiveEntries,
                    IsOwnedExclusive(Resource) ? "IsOwnedExclusive " : "",
                    IsSharedWaiting(Resource) ? "SharedWaiter "     : "",
                    IsExclusiveWaiting(Resource) ? "ExclusiveWaiter "  : "");
            DPRINT1(" NumberOfExclusiveWaiters = %04lx\n",
                    Resource->NumberOfExclusiveWaiters);
            DPRINT1("   Thread = %08lx, Count = %02x\n",
                    Resource->OwnerEntry.OwnerThread,
                    Resource->OwnerEntry.OwnerCount);
 
            /* Dump out the table too */
            Owner = Resource->OwnerTable;
            if (Owner)
            {
                /* Loop every entry */
                Size = Owner->TableSize;
                for (i = 1; i < Size; i++)
                {
                    /* Print the data */
                    Owner++;
                    DPRINT1("   Thread = %08lx, Count = %02x\n",
                            Owner->OwnerThread,
                            Owner->OwnerCount);
                }
            }
 
            /* Break */
            DbgBreakPoint();
            DPRINT1("EX - Rewaiting\n");
            ExReleaseResourceLock(Resource, &LockHandle);
#endif
        }
 
        /* Check if we can boost */
        if (IsBoostAllowed(Resource))
        {
            /* Get the current kernel thread and lock the dispatcher */
            Thread = KeGetCurrentThread();
            Thread->WaitIrql = KiAcquireDispatcherLock();
            Thread->WaitNext = TRUE;
 
            /* Get the owner thread and boost it */
            OwnerThread = (PKTHREAD)Resource->OwnerEntry.OwnerThread;
            if (OwnerThread) ExpBoostOwnerThread(Thread, OwnerThread);
 
            /* If it's a shared resource */
            if (!IsOwnedExclusive(Resource))
            {
                /* Get the table */
                Owner = Resource->OwnerTable;
                if (Owner)
                {
                    /* Loop every entry */
                    Size = Owner->TableSize;
                    for (i = 1; i < Size; i++)
                    {
                        /* Move to next entry */
                        Owner++;
 
                        /* Get the thread */
                        OwnerThread = (PKTHREAD)Owner->OwnerThread;
 
                        /* Boost it */
                        if (OwnerThread) ExpBoostOwnerThread(Thread, OwnerThread);
                    }
                }
            }
        }
    }
}

Referenced by ExAcquireResourceExclusiveLite(), ExAcquireResourceSharedLite(), ExAcquireSharedStarveExclusive(), and ExAcquireSharedWaitForExclusive().

ExReinitializeResourceLite()

NTSTATUS NTAPI ExReinitializeResourceLite

(

IN PERESOURCE

Resource

)

Definition at line 1761 of file resource.c.

{
    PKEVENT Event;
    PKSEMAPHORE Semaphore;
    ULONG i, Size;
    POWNER_ENTRY Owner;
 
    /* Get the owner table */
    Owner = Resource->OwnerTable;
    if (Owner)
    {
        /* Get the size and loop it */
        Size = Owner->TableSize;
        for (i = 0; i < Size; i++)
        {
            /* Zero the table */
            Owner[i].OwnerThread = 0;
            Owner[i].OwnerCount = 0;
        }
    }
 
    /* Zero the flags and count */
    Resource->Flag = 0;
    Resource->ActiveCount = 0;
    Resource->ActiveEntries = 0;
 
    /* Reset the semaphore */
    Semaphore = Resource->SharedWaiters;
    if (Semaphore) KeInitializeSemaphore(Semaphore, 0, MAXLONG);
 
    /* Reset the event */
    Event = Resource->ExclusiveWaiters;
    if (Event) KeInitializeEvent(Event, SynchronizationEvent, FALSE);
 
    /* Clear the resource data */
    Resource->OwnerEntry.OwnerThread = 0;
    Resource->OwnerEntry.OwnerCount = 0;
    Resource->ContentionCount = 0;
    Resource->NumberOfSharedWaiters = 0;
    Resource->NumberOfExclusiveWaiters = 0;
    return STATUS_SUCCESS;
}

Referenced by START_TEST().

ExReleaseResourceAndLeaveCriticalRegion()

VOID FASTCALL ExReleaseResourceAndLeaveCriticalRegion

(

IN PERESOURCE

Resource

)

Definition at line 2283 of file resource.c.

{
    /* Release the resource */
    ExReleaseResourceLite(Resource);
 
    /* Leave critical region */
    KeLeaveCriticalRegion();
}

Referenced by _Releases_lock_().

ExReleaseResourceForThreadLite()

VOID NTAPI ExReleaseResourceForThreadLite	(	IN PERESOURCE	Resource,
		IN ERESOURCE_THREAD	Thread
	)

Definition at line 1849 of file resource.c.

{
    ULONG i;
    ULONG Count;
    KLOCK_QUEUE_HANDLE LockHandle;
    POWNER_ENTRY Owner, Limit;
    ASSERT(Thread != 0);
 
    /* Get the thread and lock the resource */
    ExAcquireResourceLock(Resource, &LockHandle);
 
    /* Sanity checks */
    ExpVerifyResource(Resource);
    ExpCheckForApcsDisabled(LockHandle.OldIrql, Resource, KeGetCurrentThread());
 
    /* Check if it's exclusively owned */
    if (IsOwnedExclusive(Resource))
    {
        /* Decrement owner count and check if we're done */
        ASSERT(Resource->OwnerEntry.OwnerThread == Thread);
        if (--Resource->OwnerEntry.OwnerCount)
        {
            /* Done, release lock! */
            ExReleaseResourceLock(Resource, &LockHandle);
            return;
        }
 
        /* Clear the owner */
        Resource->OwnerEntry.OwnerThread = 0;
 
        /* Decrement the number of active entries */
        ASSERT(Resource->ActiveEntries == 1);
        Resource->ActiveEntries--;
 
        /* Check if there are shared waiters */
        if (IsSharedWaiting(Resource))
        {
            /* Remove the exclusive flag */
            Resource->Flag &= ~ResourceOwnedExclusive;
 
            /* Give ownage to another thread */
            Count = Resource->NumberOfSharedWaiters;
            Resource->ActiveEntries = Count;
            Resource->NumberOfSharedWaiters = 0;
 
            /* Release lock and let someone else have it */
            ASSERT(Resource->ActiveCount == 1);
            ExReleaseResourceLock(Resource, &LockHandle);
            KeReleaseSemaphore(Resource->SharedWaiters, 0, Count, FALSE);
            return;
        }
        else if (IsExclusiveWaiting(Resource))
        {
            /* Give exclusive access */
            Resource->OwnerEntry.OwnerThread = 1;
            Resource->OwnerEntry.OwnerCount = 1;
            Resource->ActiveEntries = 1;
            Resource->NumberOfExclusiveWaiters--;
 
            /* Release the lock and give it away */
            ASSERT(Resource->ActiveCount == 1);
            ExReleaseResourceLock(Resource, &LockHandle);
            KeSetEventBoostPriority(Resource->ExclusiveWaiters,
                                    (PKTHREAD*)&Resource->OwnerEntry.OwnerThread);
            return;
        }
 
        /* Remove the exclusive flag */
        Resource->Flag &= ~ResourceOwnedExclusive;
        Resource->ActiveCount = 0;
    }
    else
    {
        /* Check if we are in the thread list */
        if (Resource->OwnerEntry.OwnerThread == Thread)
        {
            /* Found it, get owner */
            Owner = &Resource->OwnerEntry;
        }
        else
        {
            /* Assume no valid index */
            i = 1;
 
            /* If we got a valid pointer, try to get the resource index */
            if (!((ULONG)Thread & 3)) i = ((PKTHREAD)Thread)->ResourceIndex;
 
            /* Do a table lookup */
            Owner = Resource->OwnerTable;
            ASSERT(Owner != NULL);
 
            /* Check if we're out of the size and don't match */
            if ((i >= Owner->TableSize) || (Owner[i].OwnerThread != Thread))
            {
                /* Get the last entry */
                Limit = &Owner[Owner->TableSize];
                for (;;)
                {
                    /* Move to the next entry */
                    Owner++;
 
                    /* Make sure we're not out of bounds */
                    if (Owner >= Limit)
                    {
                        /* Bugcheck, nobody owns us */
                        KeBugCheckEx(RESOURCE_NOT_OWNED,
                                     (ULONG_PTR)Resource,
                                     (ULONG_PTR)Thread,
                                     (ULONG_PTR)Resource->OwnerTable,
                                     (ULONG_PTR)3);
                    }
 
                    /* Check for a match */
                    if (Owner->OwnerThread == Thread) break;
                }
            }
            else
            {
                /* Get the entry directly */
                Owner = &Owner[i];
            }
        }
 
        /* Sanity checks */
        ASSERT(Owner->OwnerThread == Thread);
        ASSERT(Owner->OwnerCount > 0);
 
        /* Check if we are the last owner */
        if (--Owner->OwnerCount)
        {
            /* There are other owners, release lock */
            ExReleaseResourceLock(Resource, &LockHandle);
            return;
        }
 
        /* Clear owner */
        Owner->OwnerThread = 0;
 
        /* See if the resource isn't being owned anymore */
        ASSERT(Resource->ActiveEntries > 0);
        if (!(--Resource->ActiveEntries))
        {
            /* Check if there's an exclusive waiter */
            if (IsExclusiveWaiting(Resource))
            {
                /* Give exclusive access */
                Resource->Flag |= ResourceOwnedExclusive;
                Resource->OwnerEntry.OwnerThread = 1;
                Resource->OwnerEntry.OwnerCount = 1;
                Resource->ActiveEntries = 1;
                Resource->NumberOfExclusiveWaiters--;
 
                /* Release the lock and give it away */
                ASSERT(Resource->ActiveCount == 1);
                ExReleaseResourceLock(Resource, &LockHandle);
                KeSetEventBoostPriority(Resource->ExclusiveWaiters,
                                        (PKTHREAD*)&Resource->OwnerEntry.OwnerThread);
                return;
            }
 
            /* Clear the active count */
            Resource->ActiveCount = 0;
        }
    }
 
    /* Release lock */
    ExReleaseResourceLock(Resource, &LockHandle);
}

ExReleaseResourceLite()

VOID FASTCALL ExReleaseResourceLite

(

IN PERESOURCE

Resource

)

Definition at line 1822 of file resource.c.

{
    /* Just call the For-Thread function */
    ExReleaseResourceForThreadLite(Resource, ExGetCurrentResourceThread());
}

Referenced by __attribute__(), __brelse(), __RxAcquireFcb(), __RxReleaseFcb(), _Dispatch_type_(), _Function_class_(), _Requires_lock_held_(), acquire_for_lazy_write(), add_balance_item(), add_children_to_move_list(), add_device(), add_dir_child(), add_metadata_reloc_extent_item(), add_volume_device(), AddUnregisteredProvider(), allocate_cache(), ApphelpCacheReleaseLock(), balance_data_chunk(), balance_metadata_chunk(), BroadcastOpen(), BuildAndSubmitIrp(), bus_query_device_relations(), CcUnpinRepinnedBcb(), check_system_root(), chunk_lock_range(), chunk_unlock_range(), clean_space_cache(), clear_free_space_cache(), close_file(), CmpUnlockHiveFlusher(), CmpUnlockRegistry(), CountAvailableClusters(), create_snapshot(), create_stream(), create_subvol(), CreateRedirectedFile(), delete_fileref(), delete_reparse_point(), disk_arrival(), dismount_volume(), do_create_snapshot(), do_flush(), do_read_job(), do_tree_writes(), do_write2(), DoQuery(), drive_letter_callback2(), duplicate_extents(), DxEngUnlockHdev(), Ex2ProcessUserPerfStat(), ExReleaseResourceAndLeaveCriticalRegion(), ExReleaseTimeRefreshLock(), Ext2AddEntry(), Ext2bhReaperThread(), Ext2CheckDismount(), Ext2Cleanup(), Ext2CleanupAllMcbs(), Ext2Close(), Ext2Create(), Ext2CreateFile(), Ext2DeleteFile(), Ext2DeleteReparsePoint(), Ext2DismountVolume(), Ext2DropBH(), Ext2ExceptionHandler(), Ext2FastIoQueryBasicInfo(), Ext2FastIoQueryNetworkOpenInfo(), Ext2FastIoQueryStandardInfo(), Ext2FastIoWrite(), Ext2FcbReaperThread(), Ext2FirstUnusedMcb(), Ext2FloppyFlush(), Ext2Flush(), Ext2FlushFiles(), Ext2FlushVcb(), Ext2FlushVolume(), Ext2FreeBlock(), Ext2FreeInode(), Ext2GetRetrievalPointerBase(), Ext2GetRetrievalPointers(), Ext2InsertMcb(), Ext2InvalidateVolumes(), Ext2LinkHeadMcb(), Ext2LinkTailMcb(), Ext2LoadGroup(), Ext2LoadGroupBH(), Ext2LockControl(), Ext2LockVolume(), Ext2LookupFile(), Ext2McbReaperThread(), Ext2MediaEjectControl(), Ext2MountVolume(), Ext2NewBlock(), Ext2NewInode(), Ext2NotifyChangeDirectory(), Ext2OplockRequest(), Ext2ProcessGlobalProperty(), Ext2ProcessVolumeProperty(), Ext2PurgeFile(), Ext2PurgeVolume(), Ext2QueryDirectory(), Ext2QueryEa(), Ext2QueryFileInformation(), Ext2QueryRetrievalPointers(), Ext2QueryUnusedBH(), Ext2QueryUnusedFcb(), Ext2QueryVolumeInformation(), Ext2ReadFile(), Ext2ReadVolume(), Ext2RecoverJournal(), Ext2ReleaseFcb(), Ext2ReleaseFileForCcFlush(), Ext2ReleaseFileForModWrite(), Ext2ReleaseForCreateSection(), Ext2ReleaseFromLazyWrite(), Ext2ReleaseFromReadAhead(), Ext2RemoveEntry(), Ext2RemoveMcb(), Ext2SearchMcb(), Ext2SetEa(), Ext2SetFileInformation(), Ext2SetFileType(), Ext2SetLinkInfo(), Ext2SetParentEntry(), Ext2SetRenameInfo(), Ext2SetReparsePoint(), Ext2SetVolumeInformation(), Ext2ShutDown(), Ext2UnlinkFcb(), Ext2UnlinkMcb(), Ext2UnlockVolume(), Ext2UpdateGroupDirStat(), Ext2VerifyVolume(), Ext2WriteFile(), Ext2WriteVolume(), fast_io_release_for_create_section(), FatDeferredFlush(), file_create(), file_create2(), fill_in_file_stream_information(), fill_in_hard_link_full_id_information(), fill_in_hard_link_information(), find_device_from_uuid(), find_file_in_dir(), find_gid(), find_subvol(), finish_removing_device(), FltEnumerateVolumes(), FltUnregisterFilter(), flush_fcb(), fsctl_get_xattrs(), fsctl_oplock(), fsctl_set_xattr(), FsRtlAcquireFileForModWriteEx(), FsRtlCopyRead(), FsRtlCopyRead2(), FsRtlCopyWrite(), FsRtlCopyWrite2(), FsRtlMdlReadDev(), FsRtlPrepareMdlWriteDev(), FsRtlReleaseFile(), FsRtlReleaseFileForCcFlush(), FsRtlReleaseFileForModWrite(), get_block_bh_mdl(), get_block_bh_pin(), get_csum_info(), get_devices(), get_inode_info(), get_object_id(), get_reparse_point(), get_reparse_tag(), get_retrieval_pointers(), get_subvol_path(), get_tree_new_address(), get_usage(), GetDirtyStatus(), GetNextCluster(), GetNextClusterExtend(), IncreaseMftSize(), insert_extent_chunk(), invalidate_volumes(), IoEnumerateRegisteredFiltersList(), IopBootLog(), IopGetSetSecurityObject(), IopLoadDriver(), IopMountVolume(), IopParseDevice(), IopSaveBootLogToFile(), IopSetDeviceSecurityDescriptor(), IoRegisterFileSystem(), IoRegisterFsRegistrationChange(), IoUnregisterFileSystem(), IoUnregisterFsRegistrationChange(), is_device_part_of_mounted_btrfs_raid(), is_volume_mounted(), KspSynchronizedEventRoutine(), KsReleaseDeviceSecurityLock(), load_chunk_root(), lock_volume(), log_error(), log_file_checksum_error(), log_tree_checksum_error(), mark_fcb_dirty(), mark_fileref_dirty(), mark_subvol_dirty(), MiFindInitializationCode(), MiProcessLoaderEntry(), mknod(), MmGetSystemRoutineAddress(), MmInitSystem(), mount_vol(), mountmgr_process_drive(), move_across_subvols(), MupCheckForUnregisteredProvider(), MupCleanup(), MupCleanupFcb(), MupCleanupVcb(), MupCloseFcb(), MupCloseUncProvider(), MupCloseVcb(), MupDecodeFileObject(), MupDereferenceCcb(), MupDereferenceMasterQueryContext(), MupForwardIoRequest(), MupInvalidatePrefixTable(), notify_change_directory(), NpCommonFlushBuffers(), NpCommonRead(), NpCommonWrite(), NpDisconnect(), NpListen(), NpQueryClientProcess(), NpReleaseVcb(), NpSetClientProcess(), NpTransceive(), NtfsCleanup(), NtfsCleanupFile(), NtfsClose(), NtfsCreate(), NtfsCreateFile(), NtfsQueryDirectory(), NtfsQueryInformation(), NtfsQueryVolumeInformation(), NtfsSetInformation(), NtfsWrite(), NtQueryInformationJobObject(), ObpLeaveObjectTypeMutex(), ObpReleaseObjectLock(), open_file(), open_fileref_by_inode(), open_fileref_child(), OpenMupFileSystem(), oplock_complete(), pdo_device_usage_notification(), pnp_query_remove_device(), pnp_remove_device(), pnp_surprise_removal(), QSI_DEF(), query_directory(), query_filesystems(), query_info(), query_ranges(), query_scrub(), QueryPathCompletionRoutine(), read_data_raid5(), read_data_raid6(), read_registry(), read_send_buffer(), ReadVolumeLabel(), recvd_subvol(), RegisterUncProvider(), release_from_lazy_write(), release_from_read_ahead(), remove_balance_item(), remove_device(), remove_volume_child(), reset_stats(), resize_device(), RtlLeaveHeapLock(), RxAcquireFcbForLazyWrite(), RxAcquireFcbForReadAhead(), RxFindOrCreateFcb(), RxpReleasePrefixTableLock(), RxReleaseFcbFromLazyWrite(), RxReleaseFcbFromReadAhead(), RxStartMinirdr(), scrub_chunk(), send_notification_fcb(), send_subvol(), set_basic_information(), set_case_sensitive_information(), set_disposition_information(), set_end_of_file_information(), set_file_security(), set_inode_info(), set_label(), set_link_information(), set_rename_information(), set_reparse_point(), set_sparse(), set_valid_data_length_information(), set_zero_data(), SetDirtyStatus(), sid_to_uid(), TestResourceExclusiveAccess(), TestResourceSharedAccess(), try_consolidation(), uid_to_sid(), uninit(), update_changed_extent_ref(), update_chunk_caches(), update_chunk_caches_tree(), update_chunk_usage(), update_chunks(), update_root_root(), update_volumes(), UserLeave(), verify_device(), verify_vcb(), verify_volume(), VfatCheckForDismount(), VfatCleanup(), VfatCleanupFile(), VfatClose(), VfatCloseWorker(), VfatCreate(), VfatCreateFile(), VfatDismountVolume(), VfatFastIoQueryBasicInfo(), VfatFastIoQueryStandardInfo(), vfatFCBInitializeCacheFromVolume(), VfatFlush(), VfatFlushFile(), VfatFlushVolume(), VfatGetRetrievalPointers(), VfatMount(), VfatQueryInformation(), VfatQueryVolumeInformation(), VfatRead(), VfatReleaseForCcFlush(), VfatReleaseFromLazyWrite(), VfatSetInformation(), VfatSetVolumeInformation(), VfatShutdown(), VfatWrite(), vol_check_verify(), vol_close(), vol_get_device_number(), vol_get_disk_extents(), vol_get_drive_geometry(), vol_get_length(), vol_ioctl_passthrough(), vol_is_writable(), vol_read(), vol_write(), volume_arrival(), volume_removal(), wait_for_flush(), write_compressed(), write_metadata_items(), and WriteCluster().

ExReleaseResourceLock()

FORCEINLINE VOID ExReleaseResourceLock	(	IN PERESOURCE	Resource,
		IN PKLOCK_QUEUE_HANDLE	LockHandle
	)

Definition at line 37 of file resource.c.

{
    UNREFERENCED_PARAMETER(Resource);
    UNREFERENCED_PARAMETER(LockHandle);
 
    /* Simply enable interrupts */
    _enable();
}

Referenced by ExAcquireResourceExclusiveLite(), ExAcquireResourceSharedLite(), ExAcquireSharedStarveExclusive(), ExAcquireSharedWaitForExclusive(), ExConvertExclusiveToSharedLite(), ExDisableResourceBoostLite(), ExIsResourceAcquiredSharedLite(), ExpAllocateExclusiveWaiterEvent(), ExpAllocateSharedWaiterSemaphore(), ExpExpandResourceOwnerTable(), ExpWaitForResource(), ExReleaseResourceForThreadLite(), ExSetResourceOwnerPointer(), and ExTryToAcquireResourceExclusiveLite().

ExSetResourceOwnerPointer()

VOID NTAPI ExSetResourceOwnerPointer	(	IN PERESOURCE	Resource,
		IN PVOID	OwnerPointer
	)

Definition at line 2050 of file resource.c.

{
    ERESOURCE_THREAD Thread;
    KLOCK_QUEUE_HANDLE LockHandle;
    POWNER_ENTRY Owner, ThisOwner;
 
    /* Sanity check */
    ASSERT((OwnerPointer != 0) && (((ULONG_PTR)OwnerPointer & 3) == 3));
 
    /* Get the thread */
    Thread = ExGetCurrentResourceThread();
 
    /* Sanity check */
    ExpVerifyResource(Resource);
 
    /* Lock the resource */
    ExAcquireResourceLock(Resource, &LockHandle);
 
    /* Check if it's exclusive */
    if (IsOwnedExclusive(Resource))
    {
        /* If it's exclusive, set the first entry no matter what */
        ASSERT(Resource->OwnerEntry.OwnerThread == Thread);
        ASSERT(Resource->OwnerEntry.OwnerCount > 0);
        Resource->OwnerEntry.OwnerThread = (ULONG_PTR)OwnerPointer;
    }
    else
    {
        /* Set the thread in both entries */
        ThisOwner = ExpFindEntryForThread(Resource,
                                          (ERESOURCE_THREAD)OwnerPointer,
                                          0,
                                          FALSE);
        Owner = ExpFindEntryForThread(Resource, Thread, 0, FALSE);
        if (!Owner)
        {
            /* Nobody owns it, crash */
            KeBugCheckEx(RESOURCE_NOT_OWNED,
                         (ULONG_PTR)Resource,
                         Thread,
                         (ULONG_PTR)Resource->OwnerTable,
                         3);
        }
 
        /* Set if we are the owner */
        if (ThisOwner)
        {
            /* Update data */
            ThisOwner->OwnerCount += Owner->OwnerCount;
            Owner->OwnerCount = 0;
            Owner->OwnerThread = 0;
            ASSERT(Resource->ActiveEntries >= 2);
            Resource->ActiveEntries--;
        }
        else
        {
            /* Update the owner entry instead */
            Owner->OwnerThread = (ERESOURCE_THREAD)OwnerPointer;
        }
    }
 
    /* Release the resource */
    ExReleaseResourceLock(Resource, &LockHandle);
}

Referenced by CcSetBcbOwnerPointer(), FatMultipleAsync(), FatSingleAsync(), RxCommonRead(), RxCommonWrite(), and TestResourceWithOwner().

ExTryToAcquireResourceExclusiveLite()

BOOLEAN NTAPI ExTryToAcquireResourceExclusiveLite

(

IN PERESOURCE

Resource

)

Definition at line 2134 of file resource.c.

{
    ERESOURCE_THREAD Thread;
    KLOCK_QUEUE_HANDLE LockHandle;
    BOOLEAN Acquired = FALSE;
 
    /* Sanity check */
    ASSERT((Resource->Flag & ResourceNeverExclusive) == 0);
 
    /* Get the thread */
    Thread = ExGetCurrentResourceThread();
 
    /* Sanity check and validation */
    ASSERT(KeIsExecutingDpc() == FALSE);
    ExpVerifyResource(Resource);
 
    /* Acquire the lock */
    ExAcquireResourceLock(Resource, &LockHandle);
 
    /* Check if there is an owner */
    if (!Resource->ActiveCount)
    {
        /* No owner, give exclusive access */
        Resource->Flag |= ResourceOwnedExclusive;
        Resource->OwnerEntry.OwnerThread = Thread;
        Resource->OwnerEntry.OwnerCount = 1;
        Resource->ActiveCount = 1;
        Resource->ActiveEntries = 1;
        Acquired = TRUE;
    }
    else if ((IsOwnedExclusive(Resource)) &&
             (Resource->OwnerEntry.OwnerThread == Thread))
    {
        /* Do a recursive acquire */
        Resource->OwnerEntry.OwnerCount++;
        Acquired = TRUE;
    }
 
    /* Release the resource */
    ExReleaseResourceLock(Resource, &LockHandle);
    return Acquired;
}

Referenced by ApphelpCacheTryAcquireLock().

Variable Documentation

ExpResourceSpinLock

KSPIN_LOCK ExpResourceSpinLock

Definition at line 79 of file resource.c.

Referenced by ExDeleteResourceLite(), ExInitializeResourceLite(), and ExpResourceInitialization().

ExpResourceTimeoutCount

ULONG ExpResourceTimeoutCount = 90 * 3600 / 2

Definition at line 77 of file resource.c.

Referenced by ExpWaitForResource().

ExpSystemResourcesList

LIST_ENTRY ExpSystemResourcesList

Definition at line 80 of file resource.c.

Referenced by ExInitializeResourceLite(), and ExpResourceInitialization().

ExpTimeout

LARGE_INTEGER ExpTimeout

Definition at line 74 of file resource.c.

Referenced by ExpResourceInitialization(), and ExpWaitForResource().

ExResourceStrict

BOOLEAN ExResourceStrict = TRUE

Definition at line 81 of file resource.c.

ExShortTime

LARGE_INTEGER ExShortTime = {{-100000, -1}}

Definition at line 73 of file resource.c.

Referenced by ExpAllocateExclusiveWaiterEvent(), and ExpAllocateSharedWaiterSemaphore().