/**
* Releases a queued lock in exclusive mode.
*
* \param QueuedLock A queued lock.
*/
VOID FASTCALL PhfReleaseQueuedLockExclusive(
__inout PPH_QUEUED_LOCK QueuedLock
)
{
ULONG_PTR value;
ULONG_PTR newValue;
ULONG_PTR currentValue;
value = QueuedLock->Value;
while (TRUE)
{
assert(value & PH_QUEUED_LOCK_OWNED);
assert((value & PH_QUEUED_LOCK_WAITERS) || (PhGetQueuedLockSharedOwners(value) == 0));
if ((value & (PH_QUEUED_LOCK_WAITERS | PH_QUEUED_LOCK_TRAVERSING)) != PH_QUEUED_LOCK_WAITERS)
{
// There are no waiters or someone is traversing the list.
//
// If there are no waiters, we're simply releasing ownership.
// If someone is traversing the list, clearing the owned bit
// is a signal for them to wake waiters.
newValue = value - PH_QUEUED_LOCK_OWNED;
if ((newValue = (ULONG_PTR)_InterlockedCompareExchangePointer(
(PPVOID)&QueuedLock->Value,
(PVOID)newValue,
(PVOID)value
)) == value)
break;
}
else
{
// We need to wake waiters and no one is traversing the list.
// Try to set the traversing bit and wake waiters.
newValue = value - PH_QUEUED_LOCK_OWNED + PH_QUEUED_LOCK_TRAVERSING;
currentValue = newValue;
if ((newValue = (ULONG_PTR)_InterlockedCompareExchangePointer(
(PPVOID)&QueuedLock->Value,
(PVOID)newValue,
(PVOID)value
)) == value)
{
PhpfWakeQueuedLock(QueuedLock, currentValue);
break;
}
}
value = newValue;
}
}
HANDLE PhpGetSemaphoreWorkQueue(
_Inout_ PPH_WORK_QUEUE WorkQueue
)
{
HANDLE semaphoreHandle;
semaphoreHandle = WorkQueue->SemaphoreHandle;
if (!semaphoreHandle)
{
NtCreateSemaphore(&semaphoreHandle, SEMAPHORE_ALL_ACCESS, NULL, 0, MAXLONG);
assert(semaphoreHandle);
if (_InterlockedCompareExchangePointer(
&WorkQueue->SemaphoreHandle,
semaphoreHandle,
NULL
) != NULL)
{
// Someone else created the semaphore before we did.
NtClose(semaphoreHandle);
semaphoreHandle = WorkQueue->SemaphoreHandle;
}
}
return semaphoreHandle;
}
PET_PROCESS_ICON EtProcIconReferenceSmallProcessIcon(
__inout PET_PROCESS_BLOCK Block
)
{
PET_PROCESS_ICON smallProcessIcon;
smallProcessIcon = Block->SmallProcessIcon;
if (!smallProcessIcon && PhTestEvent(&Block->ProcessItem->Stage1Event))
{
smallProcessIcon = EtProcIconCreateProcessIcon(Block->ProcessItem->SmallIcon);
if (_InterlockedCompareExchangePointer(
&Block->SmallProcessIcon,
smallProcessIcon,
NULL
) != NULL)
{
EtProcIconDereferenceProcessIcon(smallProcessIcon);
smallProcessIcon = Block->SmallProcessIcon;
}
}
if (smallProcessIcon)
{
EtProcIconReferenceProcessIcon(smallProcessIcon);
}
return smallProcessIcon;
}
/**
* Wakes waiters in a queued lock, making no assumptions
* about the state of the lock.
*
* \param QueuedLock A queued lock.
*
* \remarks This function exists only for compatibility reasons.
*/
VOID FASTCALL PhfTryWakeQueuedLock(
__inout PPH_QUEUED_LOCK QueuedLock
)
{
ULONG_PTR value;
ULONG_PTR newValue;
value = QueuedLock->Value;
if (
!(value & PH_QUEUED_LOCK_WAITERS) ||
(value & PH_QUEUED_LOCK_TRAVERSING) ||
(value & PH_QUEUED_LOCK_OWNED)
)
return;
newValue = value + PH_QUEUED_LOCK_TRAVERSING;
if ((ULONG_PTR)_InterlockedCompareExchangePointer(
(PPVOID)&QueuedLock->Value,
(PVOID)newValue,
(PVOID)value
) == value)
{
PhpfWakeQueuedLock(QueuedLock, newValue);
}
}
/**
* Queues a wait block to a wake event.
*
* \param WakeEvent A wake event.
* \param WaitBlock A wait block.
*
* \remarks If you later determine that the wait should
* not occur, you must call PhfSetWakeEvent() to dequeue
* the wait block.
*/
VOID FASTCALL PhfQueueWakeEvent(
__inout PPH_QUEUED_LOCK WakeEvent,
__out PPH_QUEUED_WAIT_BLOCK WaitBlock
)
{
PPH_QUEUED_WAIT_BLOCK value;
PPH_QUEUED_WAIT_BLOCK newValue;
WaitBlock->Flags = PH_QUEUED_WAITER_SPINNING;
value = (PPH_QUEUED_WAIT_BLOCK)WakeEvent->Value;
while (TRUE)
{
WaitBlock->Next = value;
if ((newValue = _InterlockedCompareExchangePointer(
(PPVOID)&WakeEvent->Value,
WaitBlock,
value
)) == value)
break;
value = newValue;
}
}
/**
* Acquires a queued lock in shared mode.
*
* \param QueuedLock A queued lock.
*/
VOID FASTCALL PhfAcquireQueuedLockShared(
__inout PPH_QUEUED_LOCK QueuedLock
)
{
ULONG_PTR value;
ULONG_PTR newValue;
ULONG_PTR currentValue;
BOOLEAN optimize;
PH_QUEUED_WAIT_BLOCK waitBlock;
value = QueuedLock->Value;
while (TRUE)
{
// We can't acquire if there are waiters for two reasons:
//
// We want to prioritize exclusive acquires over shared acquires.
// There's currently no fast, safe way of finding the last wait
// block and incrementing the shared owners count here.
if (
!(value & PH_QUEUED_LOCK_WAITERS) &&
(!(value & PH_QUEUED_LOCK_OWNED) || (PhGetQueuedLockSharedOwners(value) > 0))
)
{
newValue = (value + PH_QUEUED_LOCK_SHARED_INC) | PH_QUEUED_LOCK_OWNED;
if ((newValue = (ULONG_PTR)_InterlockedCompareExchangePointer(
(PPVOID)&QueuedLock->Value,
(PVOID)newValue,
(PVOID)value
)) == value)
break;
}
else
{
if (PhpPushQueuedWaitBlock(
QueuedLock,
value,
FALSE,
&waitBlock,
&optimize,
&newValue,
¤tValue
))
{
if (optimize)
PhpfOptimizeQueuedLockList(QueuedLock, currentValue);
PHLIB_INC_STATISTIC(QlAcquireSharedBlocks);
PhpBlockOnQueuedWaitBlock(&waitBlock, TRUE, NULL);
}
}
value = newValue;
}
}
static LFDS611_INLINE lfds611_atom_t lfds611_abstraction_cas( volatile lfds611_atom_t *destination, lfds611_atom_t exchange, lfds611_atom_t compare )
{
lfds611_atom_t
rv;
assert( destination != NULL );
// TRD : exchange can be any value in its range
// TRD : compare can be any value in its range
LFDS611_BARRIER_COMPILER_FULL;
rv = (lfds611_atom_t) _InterlockedCompareExchangePointer( (void * volatile *) destination, (void *) exchange, (void *) compare );
LFDS611_BARRIER_COMPILER_FULL;
return( rv );
}
/**
* Acquires a queued lock in exclusive mode.
*
* \param QueuedLock A queued lock.
*/
VOID FASTCALL PhfAcquireQueuedLockExclusive(
__inout PPH_QUEUED_LOCK QueuedLock
)
{
ULONG_PTR value;
ULONG_PTR newValue;
ULONG_PTR currentValue;
BOOLEAN optimize;
PH_QUEUED_WAIT_BLOCK waitBlock;
value = QueuedLock->Value;
while (TRUE)
{
if (!(value & PH_QUEUED_LOCK_OWNED))
{
if ((newValue = (ULONG_PTR)_InterlockedCompareExchangePointer(
(PPVOID)&QueuedLock->Value,
(PVOID)(value + PH_QUEUED_LOCK_OWNED),
(PVOID)value
)) == value)
break;
}
else
{
if (PhpPushQueuedWaitBlock(
QueuedLock,
value,
TRUE,
&waitBlock,
&optimize,
&newValue,
¤tValue
))
{
if (optimize)
PhpfOptimizeQueuedLockList(QueuedLock, currentValue);
PHLIB_INC_STATISTIC(QlAcquireExclusiveBlocks);
PhpBlockOnQueuedWaitBlock(&waitBlock, TRUE, NULL);
}
}
value = newValue;
}
}
/**
* Wakes waiters in a queued lock for releasing it in exclusive mode.
*
* \param QueuedLock A queued lock.
* \param Value The current value of the queued lock.
*
* \remarks The function assumes the following flags are set:
* \ref PH_QUEUED_LOCK_WAITERS.
* The function assumes the following flags are not set:
* \ref PH_QUEUED_LOCK_MULTIPLE_SHARED, \ref PH_QUEUED_LOCK_TRAVERSING.
*/
VOID FASTCALL PhfWakeForReleaseQueuedLock(
__inout PPH_QUEUED_LOCK QueuedLock,
__in ULONG_PTR Value
)
{
ULONG_PTR newValue;
newValue = Value + PH_QUEUED_LOCK_TRAVERSING;
if ((ULONG_PTR)_InterlockedCompareExchangePointer(
(PPVOID)&QueuedLock->Value,
(PVOID)newValue,
(PVOID)Value
) == Value)
{
PhpfWakeQueuedLock(QueuedLock, newValue);
}
}
/**
* Queues an object for deletion.
*
* \param ObjectHeader A pointer to the object header of the object
* to delete.
*/
VOID PhpDeferDeleteObject(
__in PPH_OBJECT_HEADER ObjectHeader
)
{
PPH_OBJECT_HEADER nextToFree;
/* Add the object to the list while saving the old value, atomically.
* Note that it is first-in, last-out.
*/
while (TRUE)
{
nextToFree = PhObjectNextToFree;
ObjectHeader->NextToFree = nextToFree;
/* Attempt to set the global next-to-free variable. */
if (_InterlockedCompareExchangePointer(
&PhObjectNextToFree,
ObjectHeader,
nextToFree
) == nextToFree)
{
/* Success. */
break;
}
/* Someone else changed the next-to-free variable.
* Go back and try again.
*/
}
REF_STAT_UP(RefObjectsDeleteDeferred);
/* Was the to-free list empty before? If so, we need to queue
* a work item.
*/
if (!nextToFree)
{
PhQueueItemGlobalWorkQueue(PhpDeferDeleteObjectRoutine, NULL);
}
}
void *test_InterlockedCompareExchangePointer(void * volatile *Destination,
void *Exchange, void *Comparand) {
return _InterlockedCompareExchangePointer(Destination, Exchange, Comparand);
}
NTSTATUS PhpGetObjectTypeName(
__in HANDLE ProcessHandle,
__in HANDLE Handle,
__in ULONG ObjectTypeNumber,
__out PPH_STRING *TypeName
)
{
NTSTATUS status = STATUS_SUCCESS;
PPH_STRING typeName = NULL;
// If the cache contains the object type name, use it. Otherwise,
// query the type name.
if (ObjectTypeNumber != -1 && ObjectTypeNumber < MAX_OBJECT_TYPE_NUMBER)
typeName = PhObjectTypeNames[ObjectTypeNumber];
if (typeName)
{
PhReferenceObject(typeName);
}
else
{
POBJECT_TYPE_INFORMATION buffer;
ULONG returnLength = 0;
PPH_STRING oldTypeName;
// Get the needed buffer size.
if (KphIsConnected())
{
status = KphQueryInformationObject(
ProcessHandle,
Handle,
KphObjectTypeInformation,
NULL,
0,
&returnLength
);
}
else
{
status = NtQueryObject(
Handle,
ObjectTypeInformation,
NULL,
0,
&returnLength
);
}
if (returnLength == 0)
return status;
buffer = PhAllocate(returnLength);
if (KphIsConnected())
{
status = KphQueryInformationObject(
ProcessHandle,
Handle,
KphObjectTypeInformation,
buffer,
returnLength,
&returnLength
);
}
else
{
status = NtQueryObject(
Handle,
ObjectTypeInformation,
buffer,
returnLength,
&returnLength
);
}
if (!NT_SUCCESS(status))
{
PhFree(buffer);
return status;
}
// Create a copy of the type name.
typeName = PhCreateStringEx(buffer->TypeName.Buffer, buffer->TypeName.Length);
if (ObjectTypeNumber != -1 && ObjectTypeNumber < MAX_OBJECT_TYPE_NUMBER)
{
// Try to store the type name in the cache.
oldTypeName = _InterlockedCompareExchangePointer(
&PhObjectTypeNames[ObjectTypeNumber],
typeName,
NULL
);
// Add a reference if we stored the type name
// successfully.
if (!oldTypeName)
PhReferenceObject(typeName);
}
PhFree(buffer);
}
// At this point typeName should contain a type name
// with one additional reference.
*TypeName = typeName;
return status;
}
/**
* Releases a queued lock in shared mode.
*
* \param QueuedLock A queued lock.
*/
VOID FASTCALL PhfReleaseQueuedLockShared(
__inout PPH_QUEUED_LOCK QueuedLock
)
{
ULONG_PTR value;
ULONG_PTR newValue;
ULONG_PTR currentValue;
PPH_QUEUED_WAIT_BLOCK waitBlock;
value = QueuedLock->Value;
while (!(value & PH_QUEUED_LOCK_WAITERS))
{
assert(value & PH_QUEUED_LOCK_OWNED);
assert((value & PH_QUEUED_LOCK_WAITERS) || (PhGetQueuedLockSharedOwners(value) > 0));
if (PhGetQueuedLockSharedOwners(value) > 1)
newValue = value - PH_QUEUED_LOCK_SHARED_INC;
else
newValue = 0;
if ((newValue = (ULONG_PTR)_InterlockedCompareExchangePointer(
(PPVOID)&QueuedLock->Value,
(PVOID)newValue,
(PVOID)value
)) == value)
return;
value = newValue;
}
if (value & PH_QUEUED_LOCK_MULTIPLE_SHARED)
{
// Unfortunately we have to find the last wait block and
// decrement the shared owners count.
waitBlock = PhpFindLastQueuedWaitBlock(value);
if ((ULONG)_InterlockedDecrement((PLONG)&waitBlock->SharedOwners) > 0)
return;
}
while (TRUE)
{
if (value & PH_QUEUED_LOCK_TRAVERSING)
{
newValue = value & ~(PH_QUEUED_LOCK_OWNED | PH_QUEUED_LOCK_MULTIPLE_SHARED);
if ((newValue = (ULONG_PTR)_InterlockedCompareExchangePointer(
(PPVOID)&QueuedLock->Value,
(PVOID)newValue,
(PVOID)value
)) == value)
break;
}
else
{
newValue = (value & ~(PH_QUEUED_LOCK_OWNED | PH_QUEUED_LOCK_MULTIPLE_SHARED)) |
PH_QUEUED_LOCK_TRAVERSING;
currentValue = newValue;
if ((newValue = (ULONG_PTR)_InterlockedCompareExchangePointer(
(PPVOID)&QueuedLock->Value,
(PVOID)newValue,
(PVOID)value
)) == value)
{
PhpfWakeQueuedLock(QueuedLock, currentValue);
break;
}
}
value = newValue;
}
}
/**
* Dequeues the appropriate number of wait blocks in
* a queued lock.
*
* \param QueuedLock A queued lock.
* \param Value The current value of the queued lock.
* \param IgnoreOwned TRUE to ignore lock state, FALSE
* to conduct normal checks.
* \param WakeAll TRUE to remove all wait blocks, FALSE
* to decide based on the wait block type.
*/
FORCEINLINE PPH_QUEUED_WAIT_BLOCK PhpPrepareToWakeQueuedLock(
__inout PPH_QUEUED_LOCK QueuedLock,
__in ULONG_PTR Value,
__in BOOLEAN IgnoreOwned,
__in BOOLEAN WakeAll
)
{
ULONG_PTR value;
ULONG_PTR newValue;
PPH_QUEUED_WAIT_BLOCK waitBlock;
PPH_QUEUED_WAIT_BLOCK firstWaitBlock;
PPH_QUEUED_WAIT_BLOCK lastWaitBlock;
PPH_QUEUED_WAIT_BLOCK previousWaitBlock;
value = Value;
while (TRUE)
{
// If there are multiple shared owners, no one is going
// to wake waiters since the lock would still be owned.
// Also if there are multiple shared owners they may be
// traversing the list. While that is safe when
// done concurrently with list optimization, we may be
// removing and waking waiters.
assert(!(value & PH_QUEUED_LOCK_MULTIPLE_SHARED));
assert(IgnoreOwned || (value & PH_QUEUED_LOCK_TRAVERSING));
// There's no point in waking a waiter if the lock
// is owned. Clear the traversing bit.
while (!IgnoreOwned && (value & PH_QUEUED_LOCK_OWNED))
{
newValue = value - PH_QUEUED_LOCK_TRAVERSING;
if ((newValue = (ULONG_PTR)_InterlockedCompareExchangePointer(
(PPVOID)&QueuedLock->Value,
(PVOID)newValue,
(PVOID)value
)) == value)
return NULL;
value = newValue;
}
// Finish up any needed optimization (setting the
// Previous pointers) while finding the last wait
// block.
waitBlock = PhGetQueuedLockWaitBlock(value);
firstWaitBlock = waitBlock;
while (TRUE)
{
lastWaitBlock = waitBlock->Last;
if (lastWaitBlock)
{
waitBlock = lastWaitBlock;
break;
}
previousWaitBlock = waitBlock;
waitBlock = waitBlock->Next;
waitBlock->Previous = previousWaitBlock;
}
// Unlink the relevant wait blocks and clear the
// traversing bit before we wake waiters.
if (
!WakeAll &&
(waitBlock->Flags & PH_QUEUED_WAITER_EXCLUSIVE) &&
(previousWaitBlock = waitBlock->Previous)
)
{
// We have an exclusive waiter and there are
// multiple waiters.
// We'll only be waking this waiter.
// Unlink the wait block from the list.
// Although other wait blocks may have their
// Last pointers set to this wait block,
// the algorithm to find the last wait block
// will stop here. Likewise the Next pointers
// are never followed beyond this point, so
// we don't need to clear those.
firstWaitBlock->Last = previousWaitBlock;
// Make sure we only wake this waiter.
waitBlock->Previous = NULL;
if (!IgnoreOwned)
{
// Clear the traversing bit.
_InterlockedExchangeAddPointer((PLONG_PTR)&QueuedLock->Value, -(LONG_PTR)PH_QUEUED_LOCK_TRAVERSING);
}
break;
}
else
{
// We're waking an exclusive waiter and there
// is only one waiter, or we are waking
// a shared waiter and possibly others.
newValue = 0;
if ((newValue = (ULONG_PTR)_InterlockedCompareExchangePointer(
(PPVOID)&QueuedLock->Value,
(PVOID)newValue,
(PVOID)value
)) == value)
break;
// Someone changed the lock (acquired it or
// pushed a wait block).
value = newValue;
}
}
return waitBlock;
}
/**
* Optimizes a queued lock waiters list.
*
* \param QueuedLock A queued lock.
* \param Value The current value of the queued lock.
* \param IgnoreOwned TRUE to ignore lock state, FALSE
* to conduct normal checks.
*
* \remarks The function assumes the following flags are set:
* \ref PH_QUEUED_LOCK_WAITERS, \ref PH_QUEUED_LOCK_TRAVERSING.
*/
FORCEINLINE VOID PhpOptimizeQueuedLockListEx(
__inout PPH_QUEUED_LOCK QueuedLock,
__in ULONG_PTR Value,
__in BOOLEAN IgnoreOwned
)
{
ULONG_PTR value;
ULONG_PTR newValue;
PPH_QUEUED_WAIT_BLOCK waitBlock;
PPH_QUEUED_WAIT_BLOCK firstWaitBlock;
PPH_QUEUED_WAIT_BLOCK lastWaitBlock;
PPH_QUEUED_WAIT_BLOCK previousWaitBlock;
value = Value;
while (TRUE)
{
assert(value & PH_QUEUED_LOCK_TRAVERSING);
if (!IgnoreOwned && !(value & PH_QUEUED_LOCK_OWNED))
{
// Someone has requested that we wake waiters.
PhpfWakeQueuedLock(QueuedLock, value);
break;
}
// Perform the optimization.
waitBlock = PhGetQueuedLockWaitBlock(value);
firstWaitBlock = waitBlock;
while (TRUE)
{
lastWaitBlock = waitBlock->Last;
if (lastWaitBlock)
{
// Save a pointer to the last wait block in
// the first wait block and stop optimizing.
//
// We don't need to continue setting Previous
// pointers because the last optimization run
// would have set them already.
firstWaitBlock->Last = lastWaitBlock;
break;
}
previousWaitBlock = waitBlock;
waitBlock = waitBlock->Next;
waitBlock->Previous = previousWaitBlock;
}
// Try to clear the traversing bit.
newValue = value - PH_QUEUED_LOCK_TRAVERSING;
if ((newValue = (ULONG_PTR)_InterlockedCompareExchangePointer(
(PPVOID)&QueuedLock->Value,
(PVOID)newValue,
(PVOID)value
)) == value)
break;
// Either someone pushed a wait block onto the list
// or someone released ownership. In either case we
// need to go back.
value = newValue;
}
}
/**
* Pushes a wait block onto a queued lock's waiters list.
*
* \param QueuedLock A queued lock.
* \param Value The current value of the queued lock.
* \param Exclusive Whether the wait block is in exclusive
* mode.
* \param WaitBlock A variable which receives the resulting
* wait block structure.
* \param Optimize A variable which receives a boolean
* indicating whether to optimize the waiters list.
* \param NewValue The old value of the queued lock. This
* value is useful only if the function returns FALSE.
* \param CurrentValue The new value of the queued lock. This
* value is useful only if the function returns TRUE.
*
* \return TRUE if the wait block was pushed onto the waiters
* list, otherwise FALSE.
*
* \remarks
* \li The function assumes the following flags are set:
* \ref PH_QUEUED_LOCK_OWNED.
* \li Do not move the wait block location after this
* function is called.
* \li The \a Optimize boolean is a hint to call
* PhpfOptimizeQueuedLockList() if the function succeeds. It is
* recommended, but not essential that this occurs.
* \li Call PhpBlockOnQueuedWaitBlock() to wait for the wait
* block to be unblocked.
*/
FORCEINLINE BOOLEAN PhpPushQueuedWaitBlock(
__inout PPH_QUEUED_LOCK QueuedLock,
__in ULONG_PTR Value,
__in BOOLEAN Exclusive,
__out PPH_QUEUED_WAIT_BLOCK WaitBlock,
__out PBOOLEAN Optimize,
__out PULONG_PTR NewValue,
__out PULONG_PTR CurrentValue
)
{
ULONG_PTR newValue;
BOOLEAN optimize;
WaitBlock->Previous = NULL; // set later by optimization
optimize = FALSE;
if (Exclusive)
WaitBlock->Flags = PH_QUEUED_WAITER_EXCLUSIVE | PH_QUEUED_WAITER_SPINNING;
else
WaitBlock->Flags = PH_QUEUED_WAITER_SPINNING;
if (Value & PH_QUEUED_LOCK_WAITERS)
{
// We're not the first waiter.
WaitBlock->Last = NULL; // set later by optimization
WaitBlock->Next = PhGetQueuedLockWaitBlock(Value);
WaitBlock->SharedOwners = 0;
// Push our wait block onto the list.
// Set the traversing bit because we'll be optimizing the list.
newValue = ((ULONG_PTR)WaitBlock) | (Value & PH_QUEUED_LOCK_FLAGS) |
PH_QUEUED_LOCK_TRAVERSING;
if (!(Value & PH_QUEUED_LOCK_TRAVERSING))
optimize = TRUE;
}
else
{
// We're the first waiter.
WaitBlock->Last = WaitBlock; // indicate that this is the last wait block
if (Exclusive)
{
// We're the first waiter. Save the shared owners count.
WaitBlock->SharedOwners = (ULONG)PhGetQueuedLockSharedOwners(Value);
if (WaitBlock->SharedOwners > 1)
{
newValue = ((ULONG_PTR)WaitBlock) | PH_QUEUED_LOCK_OWNED |
PH_QUEUED_LOCK_WAITERS | PH_QUEUED_LOCK_MULTIPLE_SHARED;
}
else
{
newValue = ((ULONG_PTR)WaitBlock) | PH_QUEUED_LOCK_OWNED |
PH_QUEUED_LOCK_WAITERS;
}
}
else
{
// We're waiting in shared mode, which means there can't
// be any shared owners (otherwise we would've acquired
// the lock already).
WaitBlock->SharedOwners = 0;
newValue = ((ULONG_PTR)WaitBlock) | PH_QUEUED_LOCK_OWNED |
PH_QUEUED_LOCK_WAITERS;
}
}
*Optimize = optimize;
*CurrentValue = newValue;
newValue = (ULONG_PTR)_InterlockedCompareExchangePointer(
(PPVOID)&QueuedLock->Value,
(PVOID)newValue,
(PVOID)Value
);
*NewValue = newValue;
return newValue == Value;
}
