KeSpinLock.c File Reference

#include <kmt_test.h>
#include <limits.h>
#include <debug.h>

Include dependency graph for KeSpinLock.c:

Go to the source code of this file.

Macros
#define	WIN9X_COMPAT_SPINLOCK
#define	DEFINE_ACQUIRE(LocalName, SetIsAcquired, DoCall)
#define	DEFINE_RELEASE(LocalName, SetIsAcquired, DoCall)
#define	CheckSpinLockLock(SpinLock, CheckData, Value)
#define	CheckSpinLockQueue(SpinLock, CheckData, Value)
#define	CheckSpinLockQueueHandle(SpinLock, CheckData, Value)
#define	CheckSpinLock(SpinLock, CheckData, Value)

Functions
	__declspec (dllimport)
	DEFINE_ACQUIRE (AcquireExpNoRaise, DEFINE_RELEASE(FALSE,(KeAcquireSpinLockAtDpcLevel)(SpinLock))
BOOLEAN	TryQueuedSynch (PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData)
BOOLEAN	TryNoRaise (PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData)
static VOID	TestSpinLock (PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData)
	START_TEST (KeSpinLock)

Macro Definition Documentation

CheckSpinLock

#define CheckSpinLock	(		SpinLock,
			CheckData,
			Value
	)

Value:

do                                \
{                                                                                   \
    BOOLEAN Ret = SpinLock && pKeTestSpinLock ? pKeTestSpinLock(SpinLock) : TRUE;   \
    KIRQL ExpectedIrql = (CheckData)->OriginalIrql;                                 \
                                                                                    \
    switch ((CheckData)->Check)                                                     \
    {                                                                               \
        case CheckLock:                                                             \
            CheckSpinLockLock(SpinLock, CheckData, Value);                          \
            break;                                                                  \
        case CheckQueue:                                                            \
            CheckSpinLockQueue(SpinLock, CheckData, Value);                         \
            break;                                                                  \
        case CheckQueueHandle:                                                      \
            CheckSpinLockQueueHandle(SpinLock, CheckData, Value);                   \
            break;                                                                  \
    }                                                                               \
                                                                                    \
    if ((CheckData)->IsAcquired)                                                    \
        ExpectedIrql = (CheckData)->IrqlWhenAcquired;                               \
    ok_irql(ExpectedIrql);                                                          \
    ok_bool_false(KeAreApcsDisabled(), "KeAreApcsDisabled returned");               \
    ok_bool_true(KmtAreInterruptsEnabled(), "Interrupts enabled:");                 \
} while (0)

Definition at line 221 of file KeSpinLock.c.

CheckSpinLockLock

#define CheckSpinLockLock	(		SpinLock,
			CheckData,
			Value
	)

Value:

do                            \
{                                                                                   \
    PKTHREAD Thread = KeGetCurrentThread();                                         \
    (VOID)Thread;                                                                   \
    if (KmtIsMultiProcessorBuild || KmtIsCheckedBuild)                              \
    {                                                                               \
        ok_eq_bool(Ret, (Value) == 0);                                              \
        if (SpinLock)                                                               \
        {                                                                           \
            if (KmtIsCheckedBuild)                                                  \
                ok_eq_ulongptr(*(SpinLock), (Value) ? (ULONG_PTR)Thread | 1 : 0);   \
            else                                                                    \
                ok_eq_ulongptr(*(SpinLock), (Value) ? 1 : 0);                       \
        }                                                                           \
    }                                                                               \
    else                                                                            \
    {                                                                               \
        ok_bool_true(Ret, "KeTestSpinLock returned");                               \
        if (SpinLock)                                                               \
            ok_eq_ulongptr(*(SpinLock), 0);                                         \
    }                                                                               \
    ok_eq_uint((CheckData)->Irql, (CheckData)->OriginalIrql);                       \
} while (0)

Definition at line 167 of file KeSpinLock.c.

CheckSpinLockQueue

#define CheckSpinLockQueue	(		SpinLock,
			CheckData,
			Value
	)

Value:

do                           \
{                                                                                   \
    ok_eq_pointer((CheckData)->Queue->Next, NULL);                                  \
    ok_eq_pointer((CheckData)->Queue->Lock, NULL);                                  \
    ok_eq_uint((CheckData)->Irql, (CheckData)->OriginalIrql);                       \
} while (0)

Definition at line 191 of file KeSpinLock.c.

CheckSpinLockQueueHandle

#define CheckSpinLockQueueHandle	(		SpinLock,
			CheckData,
			Value
	)

Value:

do                     \
{                                                                                   \
    if (KmtIsMultiProcessorBuild || KmtIsCheckedBuild)                              \
    {                                                                               \
        ok_eq_bool(Ret, (Value) == 0);                                              \
        if (SpinLock)                                                               \
            ok_eq_ulongptr(*(SpinLock),                                             \
                        (Value) ? &(CheckData)->QueueHandle : 0);                   \
        ok_eq_pointer((CheckData)->QueueHandle.LockQueue.Next, NULL);               \
        ok_eq_pointer((CheckData)->QueueHandle.LockQueue.Lock,                      \
                (PVOID)((ULONG_PTR)SpinLock | ((Value) ? 2 : 0)));                  \
    }                                                                               \
    else                                                                            \
    {                                                                               \
        ok_bool_true(Ret, "KeTestSpinLock returned");                               \
        if (SpinLock)                                                               \
            ok_eq_ulongptr(*(SpinLock), 0);                                         \
        ok_eq_pointer((CheckData)->QueueHandle.LockQueue.Next, (CheckData)->UntouchedValue);                \
        ok_eq_pointer((CheckData)->QueueHandle.LockQueue.Lock, (CheckData)->UntouchedValue);                \
    }                                                                               \
    ok_eq_uint((CheckData)->QueueHandle.OldIrql, (CheckData)->OriginalIrql);        \
} while (0)

Definition at line 198 of file KeSpinLock.c.

DEFINE_ACQUIRE

#define DEFINE_ACQUIRE	(		LocalName,
			SetIsAcquired,
			DoCall
	)

Value:

static VOID LocalName(PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData)  \
{                                                                   \
    ASSERT(!CheckData->IsAcquired);                                 \
    DoCall;                                                         \
    if (SetIsAcquired) CheckData->IsAcquired = TRUE;                \
}

Definition at line 92 of file KeSpinLock.c.

DEFINE_RELEASE

#define DEFINE_RELEASE	(		LocalName,
			SetIsAcquired,
			DoCall
	)

Value:

static VOID LocalName(PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData)  \
{                                                                   \
    DoCall;                                                         \
    if (SetIsAcquired) CheckData->IsAcquired = FALSE;               \
}

Definition at line 100 of file KeSpinLock.c.

WIN9X_COMPAT_SPINLOCK

#define WIN9X_COMPAT_SPINLOCK

Function Documentation

__declspec()

__declspec

(

dllimport

)

Definition at line 10 of file KeSpinLock.c.

{
    enum
    {
        CheckQueueHandle,
        CheckQueue,
        CheckLock
    } Check;
    KIRQL IrqlWhenAcquired;
    PACQUIRE_FUNCTION Acquire;
    PRELEASE_FUNCTION Release;
    PTRY_FUNCTION TryAcquire;
    PACQUIRE_FUNCTION AcquireNoRaise;
    PRELEASE_FUNCTION ReleaseNoLower;
    PTRY_FUNCTION TryAcquireNoRaise;
    KSPIN_LOCK_QUEUE_NUMBER QueueNumber;
    BOOLEAN TryRetOnFailure;
    KIRQL OriginalIrql;
    BOOLEAN IsAcquired;
    _ANONYMOUS_UNION union
    {
        KLOCK_QUEUE_HANDLE QueueHandle;
        PKSPIN_LOCK_QUEUE Queue;
        KIRQL Irql;
    } DUMMYUNIONNAME;
    PVOID UntouchedValue;
};

DEFINE_ACQUIRE()

DEFINE_ACQUIRE	(	AcquireExpNoRaise	,
		DEFINE_RELEASE(	FALSE,
		(KeAcquireSpinLockAtDpcLevel)(SpinLock)
	)

Definition at line 128 of file KeSpinLock.c.

                                                               {
    LOGICAL Ret = KeTryToAcquireQueuedSpinLock(CheckData->QueueNumber, &CheckData->Irql);
    CheckData->IsAcquired = TRUE;
    ASSERT(Ret == FALSE || Ret == TRUE);
    return (BOOLEAN)Ret;
}

START_TEST()

START_TEST

(

KeSpinLock

)

Definition at line 346 of file KeSpinLock.c.

{
    KSPIN_LOCK SpinLock = (KSPIN_LOCK)0x5555555555555555LL;
    PKSPIN_LOCK pSpinLock = &SpinLock;
    KIRQL Irql, SynchIrql = KmtIsMultiProcessorBuild ? IPI_LEVEL - 2 : DISPATCH_LEVEL;
    KIRQL OriginalIrqls[] = { PASSIVE_LEVEL, APC_LEVEL, DISPATCH_LEVEL, HIGH_LEVEL };
    CHECK_DATA TestData[] =
    {
        { CheckLock,        DISPATCH_LEVEL, AcquireNormal,        ReleaseNormal,        NULL,           AcquireNoRaise,        ReleaseNoLower,        TryNoRaise },
        { CheckLock,        DISPATCH_LEVEL, AcquireExp,           ReleaseExp,           NULL,           AcquireExpNoRaise,     ReleaseExpNoLower,     NULL },
        /* TODO: this one is just weird!
        { CheckLock,        DISPATCH_LEVEL, AcquireNormal,        ReleaseNormal,        NULL,           AcquireForDpc,         ReleaseForDpc,         NULL },*/
        { CheckLock,        DISPATCH_LEVEL, AcquireNormal,        ReleaseNormal,        NULL,           AcquireInt,            ReleaseInt,            NULL },
        { CheckLock,        SynchIrql,      AcquireSynch,         ReleaseNormal,        NULL,           NULL,                  NULL,                  NULL },
        { CheckQueueHandle, DISPATCH_LEVEL, AcquireInStackQueued, ReleaseInStackQueued, NULL,           AcquireInStackNoRaise, ReleaseInStackNoRaise, NULL },
        { CheckQueueHandle, SynchIrql,      AcquireInStackSynch,  ReleaseInStackQueued, NULL,           NULL,                  NULL,                  NULL },
        { CheckQueueHandle, DISPATCH_LEVEL, AcquireInStackQueued, ReleaseInStackQueued, NULL,           AcquireInStackForDpc,  ReleaseInStackForDpc,  NULL },
        { CheckQueue,       DISPATCH_LEVEL, AcquireQueued,        ReleaseQueued,        TryQueued,      NULL,                  NULL,                  NULL,       LockQueuePfnLock },
        { CheckQueue,       SynchIrql,      AcquireQueuedSynch,   ReleaseQueued,        TryQueuedSynch, NULL,                  NULL,                  NULL,       LockQueuePfnLock },
    };
    int i, iIrql;
    PKPRCB Prcb;
 
    pKeTryToAcquireSpinLockAtDpcLevel = KmtGetSystemRoutineAddress(L"KeTryToAcquireSpinLockAtDpcLevel");
    pKeAcquireInStackQueuedSpinLockForDpc = KmtGetSystemRoutineAddress(L"KeAcquireInStackQueuedSpinLockForDpc");
    pKeReleaseInStackQueuedSpinLockForDpc = KmtGetSystemRoutineAddress(L"KeReleaseInStackQueuedSpinLockForDpc");
    pKeTestSpinLock = KmtGetSystemRoutineAddress(L"KeTestSpinLock");
 
    Prcb = KeGetCurrentPrcb();
 
    /* KeInitializeSpinLock */
    memset(&SpinLock, 0x55, sizeof SpinLock);
    KeInitializeSpinLock(&SpinLock);
    ok_eq_ulongptr(SpinLock, 0);
 
    /* KeTestSpinLock */
    if (!skip(pKeTestSpinLock != NULL, "KeTestSpinLock unavailable\n"))
    {
        ok_bool_true(pKeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
        SpinLock = 1;
        ok_bool_false(pKeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
        SpinLock = 2;
        ok_bool_false(pKeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
        SpinLock = (ULONG_PTR)-1;
        ok_bool_false(pKeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
        SpinLock = (ULONG_PTR)1 << (sizeof(ULONG_PTR) * CHAR_BIT - 1);
        ok_bool_false(pKeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
        SpinLock = 0;
        ok_bool_true(pKeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
    }
 
    /* on UP none of the following functions actually looks at the spinlock! */
    if (!KmtIsMultiProcessorBuild && !KmtIsCheckedBuild)
        pSpinLock = NULL;
 
    for (i = 0; i < sizeof TestData / sizeof TestData[0]; ++i)
    {
        memset(&SpinLock, 0x55, sizeof SpinLock);
        KeInitializeSpinLock(&SpinLock);
        if (TestData[i].Check == CheckQueueHandle)
            memset(&TestData[i].QueueHandle, 0x55, sizeof TestData[i].QueueHandle);
        if (TestData[i].Check == CheckQueue)
        {
            TestData[i].Queue = &Prcb->LockQueue[TestData[i].QueueNumber];
            TestData[i].UntouchedValue = NULL;
        }
        else
            TestData[i].UntouchedValue = (PVOID)0x5555555555555555LL;
 
        for (iIrql = 0; iIrql < sizeof OriginalIrqls / sizeof OriginalIrqls[0]; ++iIrql)
        {
            if (KmtIsCheckedBuild && OriginalIrqls[iIrql] > DISPATCH_LEVEL)
                continue;
            KeRaiseIrql(OriginalIrqls[iIrql], &Irql);
            TestData[i].OriginalIrql = OriginalIrqls[iIrql];
            TestData[i].IsAcquired = FALSE;
            TestSpinLock(pSpinLock, &TestData[i]);
            KeLowerIrql(Irql);
        }
    }
 
    KmtSetIrql(PASSIVE_LEVEL);
}

TestSpinLock()

static VOID TestSpinLock ( PKSPIN_LOCK  SpinLock, PCHECK_DATA  CheckData  )

static

Definition at line 248 of file KeSpinLock.c.

{
    static INT Run = 0;
    trace("Test SpinLock run %d\n", Run++);
 
    ok_irql(CheckData->OriginalIrql);
 
    if (SpinLock)
        ok_eq_ulongptr(*SpinLock, 0);
    CheckData->Acquire(SpinLock, CheckData);
    CheckSpinLock(SpinLock, CheckData, 1);
    CheckData->Release(SpinLock, CheckData);
    CheckSpinLock(SpinLock, CheckData, 0);
 
    if (CheckData->TryAcquire)
    {
        CheckSpinLock(SpinLock, CheckData, 0);
        ok_bool_true(CheckData->TryAcquire(SpinLock, CheckData), "TryAcquire returned");
        CheckSpinLock(SpinLock, CheckData, 1);
        /* A second TryToAcquire results in SPINLOCK_ALREADY_OWNED on checked builds */
        if (!KmtIsCheckedBuild)
        {
            if (KmtIsMultiProcessorBuild)
            {
                /* In MP, this fails as you would expect */
                ok_bool_false(CheckData->TryAcquire(SpinLock, CheckData), "TryAcquire returned");
            }
            else
            {
                /* In UP, this always succeeds: recursive acquires are illegal and parallel processors don't exist */
                ok_bool_true(CheckData->TryAcquire(SpinLock, CheckData), "TryAcquire returned");
                ok_eq_uint(CheckData->Irql, CheckData->IrqlWhenAcquired);
                CheckData->Irql = CheckData->OriginalIrql;
            }
            CheckSpinLock(SpinLock, CheckData, 1);
        }
        CheckData->Release(SpinLock, CheckData);
        CheckSpinLock(SpinLock, CheckData, 0);
    }
 
    if (CheckData->AcquireNoRaise &&
        (CheckData->OriginalIrql >= DISPATCH_LEVEL || !KmtIsCheckedBuild) &&
        (CheckData->AcquireNoRaise != AcquireInStackForDpc ||
         !skip(pKeAcquireInStackQueuedSpinLockForDpc &&
               pKeReleaseInStackQueuedSpinLockForDpc, "No DPC spinlock functions\n")))
    {
        /* acquire/release without irql change */
        CheckData->AcquireNoRaise(SpinLock, CheckData);
        CheckSpinLock(SpinLock, CheckData, 1);
        CheckData->ReleaseNoLower(SpinLock, CheckData);
        CheckSpinLock(SpinLock, CheckData, 0);
 
        /* acquire without raise, but normal release */
        CheckData->AcquireNoRaise(SpinLock, CheckData);
        CheckSpinLock(SpinLock, CheckData, 1);
        CheckData->Release(SpinLock, CheckData);
        CheckSpinLock(SpinLock, CheckData, 0);
 
        /* acquire normally but release without lower */
        CheckData->Acquire(SpinLock, CheckData);
        CheckSpinLock(SpinLock, CheckData, 1);
        CheckData->ReleaseNoLower(SpinLock, CheckData);
        CheckSpinLock(SpinLock, CheckData, 0);
        CheckData->IsAcquired = FALSE;
        KmtSetIrql(CheckData->OriginalIrql);
 
        if (CheckData->TryAcquireNoRaise &&
            !skip(pKeTryToAcquireSpinLockAtDpcLevel != NULL, "KeTryToAcquireSpinLockAtDpcLevel unavailable\n"))
        {
            CheckSpinLock(SpinLock, CheckData, 0);
            ok_bool_true(CheckData->TryAcquireNoRaise(SpinLock, CheckData), "TryAcquireNoRaise returned");
            CheckSpinLock(SpinLock, CheckData, 1);
            if (!KmtIsCheckedBuild)
            {
                if (KmtIsMultiProcessorBuild)
                {
                    /* In MP, this fails as you would expect */
                    ok_bool_false(CheckData->TryAcquireNoRaise(SpinLock, CheckData), "TryAcquireNoRaise returned");
                }
                else
                {
                    /* In UP, this always succeeds: recursive acquires are illegal and parallel processors don't exist */
                    ok_bool_true(CheckData->TryAcquireNoRaise(SpinLock, CheckData), "TryAcquireNoRaise returned");
                }
                CheckSpinLock(SpinLock, CheckData, 1);
            }
            CheckData->ReleaseNoLower(SpinLock, CheckData);
            CheckSpinLock(SpinLock, CheckData, 0);
        }
    }
 
    ok_irql(CheckData->OriginalIrql);
    /* make sure we survive this in case of error */
    KmtSetIrql(CheckData->OriginalIrql);
}

Referenced by START_TEST().

TryNoRaise()

BOOLEAN TryNoRaise	(	PKSPIN_LOCK	SpinLock,
		PCHECK_DATA	CheckData
	)

Definition at line 162 of file KeSpinLock.c.

                                                                {
    BOOLEAN Ret = pKeTryToAcquireSpinLockAtDpcLevel(SpinLock);
    return Ret;
}

Referenced by START_TEST().

TryQueuedSynch()

BOOLEAN TryQueuedSynch	(	PKSPIN_LOCK	SpinLock,
		PCHECK_DATA	CheckData
	)

Definition at line 157 of file KeSpinLock.c.

                                                                    {
    BOOLEAN Ret = KeTryToAcquireQueuedSpinLockRaiseToSynch(CheckData->QueueNumber, &CheckData->Irql);
    CheckData->IsAcquired = TRUE;
    return Ret;
}

Referenced by START_TEST().