You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
934 lines
23 KiB
934 lines
23 KiB
/*++
|
|
|
|
Copyright (c) 1989-1993 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Resource.cpp
|
|
|
|
Abstract:
|
|
|
|
This module implements the executive functions to acquire and release
|
|
a shared resource.
|
|
|
|
Author:
|
|
|
|
Mark Lucovsky (markl) 04-Aug-1989
|
|
|
|
Environment:
|
|
|
|
These routines are statically linked in the caller's executable and
|
|
are callable in only from user mode. They make use of Nt system
|
|
services.
|
|
|
|
Revision History:
|
|
|
|
02-Feb-97 vlads Adapted to Win9x environment to support portable syncronization
|
|
( RTL calls do not exist)
|
|
|
|
|
|
--*/
|
|
|
|
#include "cplusinc.h"
|
|
#include "sticomm.h"
|
|
|
|
#include <lock.h>
|
|
|
|
//
|
|
// The semaphore wait time before retrying the wait
|
|
//
|
|
|
|
#define _RES_TIMEOUT (2 * 60 * 1000)
|
|
|
|
|
|
|
|
BOOL
|
|
InitializeResource(
|
|
IN PRTL_RESOURCE Resource
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine initializes the input resource variable
|
|
|
|
Arguments:
|
|
|
|
Resource - Supplies the resource variable being initialized
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
//
|
|
// Initialize the lock fields, the count indicates how many are waiting
|
|
// to enter or are in the critical section, LockSemaphore is the object
|
|
// to wait on when entering the critical section. SpinLock is used
|
|
// for the add interlock instruction.
|
|
//
|
|
|
|
__try {
|
|
#ifdef UNICODE
|
|
if(!InitializeCriticalSectionAndSpinCount( &Resource->CriticalSection, MINLONG ))
|
|
return FALSE;
|
|
#else
|
|
InitializeCriticalSection( &Resource->CriticalSection);
|
|
#endif
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER) {
|
|
return FALSE;
|
|
}
|
|
|
|
Resource->DebugInfo = NULL;
|
|
|
|
//
|
|
// Initialize flags so there is a default value.
|
|
// (Some apps may set RTL_RESOURCE_FLAGS_LONG_TERM to affect timeouts.)
|
|
//
|
|
|
|
Resource->Flags = 0;
|
|
|
|
|
|
//
|
|
// Initialize the shared and exclusive waiting counters and semaphore.
|
|
// The counters indicate how many are waiting for access to the resource
|
|
// and the semaphores are used to wait on the resource. Note that
|
|
// the semaphores can also indicate the number waiting for a resource
|
|
// however there is a race condition in the alogrithm on the acquire
|
|
// side if count if not updated before the critical section is exited.
|
|
//
|
|
|
|
Resource->SharedSemaphore = CreateSemaphore( NULL,
|
|
0,
|
|
MAXLONG,
|
|
NULL );
|
|
|
|
if ( !Resource->SharedSemaphore ) {
|
|
return FALSE;
|
|
}
|
|
|
|
Resource->NumberOfWaitingShared = 0;
|
|
|
|
Resource->ExclusiveSemaphore = CreateSemaphore( NULL,
|
|
0,
|
|
MAXLONG,
|
|
NULL );
|
|
if ( !Resource->ExclusiveSemaphore ){
|
|
CloseHandle( Resource->SharedSemaphore );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
Resource->NumberOfWaitingExclusive = 0;
|
|
|
|
//
|
|
// Initialize the current state of the resource
|
|
//
|
|
|
|
Resource->NumberOfActive = 0;
|
|
|
|
Resource->ExclusiveOwnerThread = NULL;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
AcquireResourceShared(
|
|
IN PRTL_RESOURCE Resource,
|
|
IN BOOL Wait
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The routine acquires the resource for shared access. Upon return from
|
|
the procedure the resource is acquired for shared access.
|
|
|
|
Arguments:
|
|
|
|
Resource - Supplies the resource to acquire
|
|
|
|
Wait - Indicates if the call is allowed to wait for the resource
|
|
to become available for must return immediately
|
|
|
|
Return Value:
|
|
|
|
BOOL - TRUE if the resource is acquired and FALSE otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD ret;
|
|
ULONG TimeoutCount = 0;
|
|
DWORD TimeoutTime = _RES_TIMEOUT;
|
|
//
|
|
// Enter the critical section
|
|
//
|
|
|
|
EnterCriticalSection(&Resource->CriticalSection);
|
|
|
|
//
|
|
// If it is not currently acquired for exclusive use then we can acquire
|
|
// the resource for shared access. Note that this can potentially
|
|
// starve an exclusive waiter however, this is necessary given the
|
|
// ability to recursively acquire the resource shared. Otherwise we
|
|
// might/will reach a deadlock situation where a thread tries to acquire
|
|
// the resource recusively shared but is blocked by an exclusive waiter.
|
|
//
|
|
// The test to reanable not starving an exclusive waiter is:
|
|
//
|
|
// if ((Resource->NumberOfWaitingExclusive == 0) &&
|
|
// (Resource->NumberOfActive >= 0)) {
|
|
//
|
|
|
|
if (Resource->NumberOfActive >= 0) {
|
|
|
|
//
|
|
// The resource is ours, so indicate that we have it and
|
|
// exit the critical section
|
|
//
|
|
|
|
Resource->NumberOfActive += 1;
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
|
|
//
|
|
// Otherwise check to see if this thread is the one currently holding
|
|
// exclusive access to the resource. And if it is then we change
|
|
// this shared request to an exclusive recusive request and grant
|
|
// access to the resource.
|
|
//
|
|
|
|
} else if (Resource->ExclusiveOwnerThread == (HANDLE)ULongToPtr(GetCurrentThreadId())) {
|
|
|
|
//
|
|
// The resource is ours (recusively) so indicate that we have it
|
|
// and exit the critial section
|
|
//
|
|
|
|
Resource->NumberOfActive -= 1;
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
|
|
//
|
|
// Otherwise we'll have to wait for access.
|
|
//
|
|
|
|
} else {
|
|
|
|
//
|
|
// Check if we are allowed to wait or must return immedately, and
|
|
// indicate that we didn't acquire the resource
|
|
//
|
|
|
|
if (!Wait) {
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
//
|
|
// Otherwise we need to wait to acquire the resource.
|
|
// To wait we will increment the number of waiting shared,
|
|
// release the lock, and wait on the shared semaphore
|
|
//
|
|
|
|
Resource->NumberOfWaitingShared += 1;
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
|
|
rewait:
|
|
if ( Resource->Flags & RTL_RESOURCE_FLAG_LONG_TERM ) {
|
|
TimeoutTime = INFINITE;
|
|
}
|
|
ret = WaitForSingleObject(
|
|
Resource->SharedSemaphore,
|
|
TimeoutTime
|
|
);
|
|
|
|
if ( ret == WAIT_TIMEOUT ) {
|
|
#if DBG
|
|
OutputDebugString( TEXT("[AcquireResourceShared] Sem timeout\n") );
|
|
#endif
|
|
|
|
TimeoutCount++;
|
|
if ( TimeoutCount > 2 ) {
|
|
#if DBG
|
|
DebugBreak();
|
|
#endif
|
|
}
|
|
#if DBG
|
|
OutputDebugString(TEXT("[AcquireResourceShared]: Re-Waiting\n"));
|
|
#endif
|
|
goto rewait;
|
|
} else if ( ret != WAIT_OBJECT_0 ) {
|
|
#if DBG
|
|
OutputDebugString(TEXT("[AcquireResourceShared]: WaitForSingleObjectFailed\n"));
|
|
#endif
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now the resource is ours, for shared access
|
|
//
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
BOOL
|
|
AcquireResourceExclusive(
|
|
IN PRTL_RESOURCE Resource,
|
|
IN BOOL Wait
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The routine acquires the resource for exclusive access. Upon return from
|
|
the procedure the resource is acquired for exclusive access.
|
|
|
|
Arguments:
|
|
|
|
Resource - Supplies the resource to acquire
|
|
|
|
Wait - Indicates if the call is allowed to wait for the resource
|
|
to become available for must return immediately
|
|
|
|
Return Value:
|
|
|
|
BOOL - TRUE if the resource is acquired and FALSE otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG TimeoutCount = 0;
|
|
DWORD TimeoutTime = _RES_TIMEOUT;
|
|
DWORD ret;
|
|
|
|
//
|
|
// Loop until the resource is ours or exit if we cannot wait.
|
|
//
|
|
|
|
while (TRUE) {
|
|
|
|
//
|
|
// Enter the critical section
|
|
//
|
|
|
|
EnterCriticalSection(&Resource->CriticalSection);
|
|
|
|
//
|
|
// If there are no shared users and it is not currently acquired for
|
|
// exclusive use then we can acquire the resource for exclusive
|
|
// access. We also can acquire it if the resource indicates exclusive
|
|
// access but there isn't currently an owner.
|
|
//
|
|
|
|
if ((Resource->NumberOfActive == 0)
|
|
|
|
||
|
|
|
|
((Resource->NumberOfActive == -1) &&
|
|
(Resource->ExclusiveOwnerThread == NULL))) {
|
|
|
|
//
|
|
// The resource is ours, so indicate that we have it and
|
|
// exit the critical section
|
|
//
|
|
|
|
Resource->NumberOfActive = -1;
|
|
|
|
Resource->ExclusiveOwnerThread = (HANDLE) ULongToPtr(GetCurrentThreadId());
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
//
|
|
// Otherwise check to see if we already have exclusive access to the
|
|
// resource and can simply recusively acquire it again.
|
|
//
|
|
|
|
if (Resource->ExclusiveOwnerThread == (HANDLE) ULongToPtr(GetCurrentThreadId())) {
|
|
|
|
//
|
|
// The resource is ours (recusively) so indicate that we have it
|
|
// and exit the critial section
|
|
//
|
|
|
|
Resource->NumberOfActive -= 1;
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
//
|
|
// Check if we are allowed to wait or must return immedately, and
|
|
// indicate that we didn't acquire the resource
|
|
//
|
|
|
|
if (!Wait) {
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
//
|
|
// Otherwise we need to wait to acquire the resource.
|
|
// To wait we will increment the number of waiting exclusive,
|
|
// release the lock, and wait on the exclusive semaphore
|
|
//
|
|
|
|
Resource->NumberOfWaitingExclusive += 1;
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
|
|
rewait:
|
|
if ( Resource->Flags & RTL_RESOURCE_FLAG_LONG_TERM ) {
|
|
TimeoutTime = INFINITE;
|
|
}
|
|
ret = WaitForSingleObject(
|
|
Resource->ExclusiveSemaphore,
|
|
TimeoutTime
|
|
);
|
|
|
|
if ( ret == WAIT_TIMEOUT ) {
|
|
#if DBG
|
|
OutputDebugString( TEXT("[AcquireResourceExclusive] Sem timeout\n") );
|
|
#endif
|
|
|
|
TimeoutCount++;
|
|
if ( TimeoutCount > 2 ) {
|
|
#if DBG
|
|
DebugBreak();
|
|
#endif
|
|
}
|
|
#if DBG
|
|
OutputDebugString(TEXT("[AcquireResourceExclusive]: Re-Waiting\n"));
|
|
#endif
|
|
goto rewait;
|
|
} else if ( ret != WAIT_OBJECT_0 ) {
|
|
#if DBG
|
|
OutputDebugString(TEXT("[AcquireResourceExclusive]: WaitForSingleObject Failed\n"));
|
|
#endif
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
ReleaseResource(
|
|
IN PRTL_RESOURCE Resource
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine release the input resource. The resource can have been
|
|
acquired for either shared or exclusive access.
|
|
|
|
Arguments:
|
|
|
|
Resource - Supplies the resource to release
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
LONG PreviousCount;
|
|
|
|
//
|
|
// Enter the critical section
|
|
//
|
|
|
|
EnterCriticalSection(&Resource->CriticalSection);
|
|
|
|
//
|
|
// Test if the resource is acquired for shared or exclusive access
|
|
//
|
|
|
|
if (Resource->NumberOfActive > 0) {
|
|
|
|
//
|
|
// Releasing shared access to the resource, so decrement
|
|
// the number of shared users
|
|
//
|
|
|
|
Resource->NumberOfActive -= 1;
|
|
|
|
//
|
|
// If the resource is now available and there is a waiting
|
|
// exclusive user then give the resource to the waiting thread
|
|
//
|
|
|
|
if ((Resource->NumberOfActive == 0) &&
|
|
(Resource->NumberOfWaitingExclusive > 0)) {
|
|
|
|
//
|
|
// Set the resource state to exclusive (but not owned),
|
|
// decrement the number of waiting exclusive, and release
|
|
// one exclusive waiter
|
|
//
|
|
|
|
Resource->NumberOfActive = -1;
|
|
Resource->ExclusiveOwnerThread = NULL;
|
|
|
|
Resource->NumberOfWaitingExclusive -= 1;
|
|
|
|
if ( !ReleaseSemaphore(
|
|
Resource->ExclusiveSemaphore,
|
|
1,
|
|
&PreviousCount
|
|
)) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
} else if (Resource->NumberOfActive < 0) {
|
|
|
|
//
|
|
// Releasing exclusive access to the resource, so increment the
|
|
// number of active by one. And continue testing only
|
|
// if the resource is now available.
|
|
//
|
|
|
|
Resource->NumberOfActive += 1;
|
|
|
|
if (Resource->NumberOfActive == 0) {
|
|
|
|
//
|
|
// The resource is now available. Remove ourselves as the
|
|
// owner thread
|
|
//
|
|
|
|
Resource->ExclusiveOwnerThread = NULL;
|
|
|
|
//
|
|
// If there is another waiting exclusive then give the resource
|
|
// to it.
|
|
//
|
|
|
|
if (Resource->NumberOfWaitingExclusive > 0) {
|
|
|
|
//
|
|
// Set the resource to exclusive, and its owner undefined.
|
|
// Decrement the number of waiting exclusive and release one
|
|
// exclusive waiter
|
|
//
|
|
|
|
Resource->NumberOfActive = -1;
|
|
Resource->NumberOfWaitingExclusive -= 1;
|
|
|
|
if ( !ReleaseSemaphore(
|
|
Resource->ExclusiveSemaphore,
|
|
1,
|
|
&PreviousCount
|
|
)) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Check to see if there are waiting shared, who should now get
|
|
// the resource
|
|
//
|
|
|
|
} else if (Resource->NumberOfWaitingShared > 0) {
|
|
|
|
//
|
|
// Set the new state to indicate that all of the shared
|
|
// requesters have access and there are no more waiting
|
|
// shared requesters, and then release all of the shared
|
|
// requsters
|
|
//
|
|
|
|
Resource->NumberOfActive = Resource->NumberOfWaitingShared;
|
|
|
|
Resource->NumberOfWaitingShared = 0;
|
|
|
|
if ( !ReleaseSemaphore(
|
|
Resource->SharedSemaphore,
|
|
Resource->NumberOfActive,
|
|
&PreviousCount
|
|
)) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if DBG
|
|
} else {
|
|
|
|
//
|
|
// The resource isn't current acquired, there is nothing to release
|
|
// so tell the user the mistake
|
|
//
|
|
|
|
|
|
OutputDebugString(TEXT("[ReleaseResource] - Resource released too many times!\n"));
|
|
DebugBreak();
|
|
#endif
|
|
}
|
|
|
|
//
|
|
// Exit the critical section, and return to the caller
|
|
//
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
ConvertSharedToExclusive(
|
|
IN PRTL_RESOURCE Resource
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine converts a resource acquired for shared access into
|
|
one acquired for exclusive access. Upon return from the procedure
|
|
the resource is acquired for exclusive access
|
|
|
|
Arguments:
|
|
|
|
Resource - Supplies the resource to acquire for shared access, it
|
|
must already be acquired for shared access
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD ret;
|
|
DWORD TimeoutTime = _RES_TIMEOUT;
|
|
ULONG TimeoutCount = 0;
|
|
|
|
//
|
|
// Enter the critical section
|
|
//
|
|
|
|
EnterCriticalSection(&Resource->CriticalSection);
|
|
|
|
//
|
|
// If there is only one shared user (it's us) and we can acquire the
|
|
// resource for exclusive access.
|
|
//
|
|
|
|
if (Resource->NumberOfActive == 1) {
|
|
|
|
//
|
|
// The resource is ours, so indicate that we have it and
|
|
// exit the critical section, and return
|
|
//
|
|
|
|
Resource->NumberOfActive = -1;
|
|
|
|
Resource->ExclusiveOwnerThread = (HANDLE) ULongToPtr(GetCurrentThreadId());
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// If the resource is currently acquired exclusive and it's us then
|
|
// we already have exclusive access
|
|
//
|
|
|
|
if ((Resource->NumberOfActive < 0) &&
|
|
(Resource->ExclusiveOwnerThread == (HANDLE) ULongToPtr(GetCurrentThreadId()))) {
|
|
|
|
//
|
|
// We already have exclusive access to the resource so we'll just
|
|
// exit the critical section and return
|
|
//
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// If the resource is acquired by more than one shared then we need
|
|
// to wait to get exclusive access to the resource
|
|
//
|
|
|
|
if (Resource->NumberOfActive > 1) {
|
|
|
|
//
|
|
// To wait we will decrement the fact that we have the resource for
|
|
// shared, and then loop waiting on the exclusive lock, and then
|
|
// testing to see if we can get exclusive access to the resource
|
|
//
|
|
|
|
Resource->NumberOfActive -= 1;
|
|
|
|
while (TRUE) {
|
|
|
|
//
|
|
// Increment the number of waiting exclusive, exit and critical
|
|
// section and wait on the exclusive semaphore
|
|
//
|
|
|
|
Resource->NumberOfWaitingExclusive += 1;
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
rewait:
|
|
if ( Resource->Flags & RTL_RESOURCE_FLAG_LONG_TERM ) {
|
|
TimeoutTime = INFINITE;
|
|
}
|
|
ret = WaitForSingleObject(
|
|
Resource->ExclusiveSemaphore,
|
|
TimeoutTime
|
|
);
|
|
|
|
if ( ret == WAIT_TIMEOUT ) {
|
|
#if DBG
|
|
OutputDebugString( TEXT("[ConverSharedToExclusive] Sem timeout\n") );
|
|
#endif
|
|
|
|
TimeoutCount++;
|
|
if ( TimeoutCount > 2 ) {
|
|
#if DBG
|
|
DebugBreak();
|
|
#endif
|
|
}
|
|
#if DBG
|
|
OutputDebugString(TEXT("[ConvertSharedToExclusive]: Re-Waiting\n"));
|
|
#endif
|
|
goto rewait;
|
|
} else if ( ret != WAIT_OBJECT_0 ) {
|
|
#if DBG
|
|
OutputDebugString(TEXT("[ConvertSharedToExclusive]: WaitForSingleObject Failed\n"));
|
|
#endif
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Enter the critical section
|
|
//
|
|
|
|
EnterCriticalSection(&Resource->CriticalSection);
|
|
|
|
//
|
|
// If there are no shared users and it is not currently acquired
|
|
// for exclusive use then we can acquire the resource for
|
|
// exclusive access. We can also acquire it if the resource
|
|
// indicates exclusive access but there isn't currently an owner
|
|
//
|
|
|
|
if ((Resource->NumberOfActive == 0)
|
|
|
|
||
|
|
|
|
((Resource->NumberOfActive == -1) &&
|
|
(Resource->ExclusiveOwnerThread == NULL))) {
|
|
|
|
//
|
|
// The resource is ours, so indicate that we have it and
|
|
// exit the critical section and return.
|
|
//
|
|
|
|
Resource->NumberOfActive = -1;
|
|
|
|
Resource->ExclusiveOwnerThread = (HANDLE) ULongToPtr(GetCurrentThreadId());
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Otherwise check to see if we already have exclusive access to
|
|
// the resource and can simply recusively acquire it again.
|
|
//
|
|
|
|
if (Resource->ExclusiveOwnerThread == (HANDLE) ULongToPtr(GetCurrentThreadId())) {
|
|
|
|
//
|
|
// The resource is ours (recusively) so indicate that we have
|
|
// it and exit the critical section and return.
|
|
//
|
|
|
|
Resource->NumberOfActive -= 1;
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// The resource is not currently acquired for shared so this is a
|
|
// spurious call
|
|
//
|
|
|
|
#if DBG
|
|
OutputDebugString(TEXT("[ConvertSharedToExclusive]: Failed error - SHARED_RESOURCE_CONV_ERROR\n"));
|
|
DebugBreak();
|
|
#endif
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
ConvertExclusiveToShared(
|
|
IN PRTL_RESOURCE Resource
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine converts a resource acquired for exclusive access into
|
|
one acquired for shared access. Upon return from the procedure
|
|
the resource is acquired for shared access
|
|
|
|
Arguments:
|
|
|
|
Resource - Supplies the resource to acquire for shared access, it
|
|
must already be acquired for exclusive access
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
LONG PreviousCount;
|
|
|
|
//
|
|
// Enter the critical section
|
|
//
|
|
|
|
EnterCriticalSection(&Resource->CriticalSection);
|
|
|
|
//
|
|
// If there is only one shared user (it's us) and we can acquire the
|
|
// resource for exclusive access.
|
|
//
|
|
|
|
if (Resource->NumberOfActive == -1) {
|
|
|
|
Resource->ExclusiveOwnerThread = NULL;
|
|
|
|
//
|
|
// Check to see if there are waiting shared, who should now get the
|
|
// resource along with us
|
|
//
|
|
|
|
if (Resource->NumberOfWaitingShared > 0) {
|
|
|
|
//
|
|
// Set the new state to indicate that all of the shared requesters
|
|
// have access including us, and there are no more waiting shared
|
|
// requesters, and then release all of the shared requsters
|
|
//
|
|
|
|
Resource->NumberOfActive = Resource->NumberOfWaitingShared + 1;
|
|
|
|
Resource->NumberOfWaitingShared = 0;
|
|
|
|
if ( !ReleaseSemaphore(
|
|
Resource->SharedSemaphore,
|
|
Resource->NumberOfActive - 1,
|
|
&PreviousCount
|
|
)) {
|
|
return FALSE;
|
|
}
|
|
} else {
|
|
|
|
//
|
|
// There is no one waiting for shared access so it's only ours
|
|
//
|
|
|
|
Resource->NumberOfActive = 1;
|
|
|
|
}
|
|
|
|
LeaveCriticalSection(&Resource->CriticalSection);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
//
|
|
// The resource is not currently acquired for exclusive, or we've
|
|
// recursively acquired it, so this must be a spurious call
|
|
//
|
|
|
|
#if DBG
|
|
OutputDebugString(TEXT("[ConvertExclusiveToShared] Failed error - SHARED_RESOURCE_CONV_ERROR\n"));
|
|
DebugBreak();
|
|
#endif
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
VOID
|
|
DeleteResource (
|
|
IN PRTL_RESOURCE Resource
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine deletes (i.e., uninitializes) the input resource variable
|
|
|
|
|
|
Arguments:
|
|
|
|
Resource - Supplies the resource variable being deleted
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
DeleteCriticalSection( &Resource->CriticalSection );
|
|
CloseHandle(Resource->SharedSemaphore);
|
|
CloseHandle(Resource->ExclusiveSemaphore);
|
|
|
|
RtlZeroMemory( Resource, sizeof( *Resource ) );
|
|
|
|
return;
|
|
}
|
|
|