kmtests/ntos_ke/KeSpinLock.c

   1 /*
   2  * PROJECT:         ReactOS kernel-mode tests
   3  * LICENSE:         GPLv2+ - See COPYING in the top level directory
   4  * PURPOSE:         Kernel-Mode Test Suite Spin lock test
   5  * PROGRAMMER:      Thomas Faber <thfabba@gmx.de>
   6  */
   7
   8 #ifndef _WIN64
   9 __declspec(dllimport) void __stdcall KeAcquireSpinLock(unsigned long *, unsigned char *);
  10 __declspec(dllimport) void __stdcall KeReleaseSpinLock(unsigned long *, unsigned char);
  11 __declspec(dllimport) void __stdcall KeAcquireSpinLockAtDpcLevel(unsigned long *);
  12 __declspec(dllimport) void __stdcall KeReleaseSpinLockFromDpcLevel(unsigned long *);
  13 #endif
  14
  15 /* this define makes KeInitializeSpinLock not use the inlined version */
  16 #define WIN9X_COMPAT_SPINLOCK
  17 #include <kmt_test.h>
  18 #include <limits.h>
  19
  20 //#define NDEBUG
  21 #include <debug.h>
  22
  23 /* TODO: these are documented for Vista+ */
  24 NTKERNELAPI
  25 VOID
  26 FASTCALL
  27 KeAcquireInStackQueuedSpinLockForDpc(
  28   IN OUT PKSPIN_LOCK SpinLock,
  29   OUT PKLOCK_QUEUE_HANDLE LockHandle);
  30
  31 NTKERNELAPI
  32 VOID
  33 FASTCALL
  34 KeReleaseInStackQueuedSpinLockForDpc(
  35   IN PKLOCK_QUEUE_HANDLE LockHandle);
  36
  37 /* TODO: multiprocessor testing */
  38
  39 struct _CHECK_DATA;
  40 typedef struct _CHECK_DATA CHECK_DATA, *PCHECK_DATA;
  41
  42 typedef VOID (*PACQUIRE_FUNCTION)(PKSPIN_LOCK, PCHECK_DATA);
  43 typedef VOID (*PRELEASE_FUNCTION)(PKSPIN_LOCK, PCHECK_DATA);
  44 typedef BOOLEAN (*PTRY_FUNCTION)(PKSPIN_LOCK, PCHECK_DATA);
  45
  46 struct _CHECK_DATA
  47 {
  48     enum
  49     {
  50         CheckQueueHandle,
  51         CheckQueue,
  52         CheckLock
  53     } Check;
  54     KIRQL IrqlWhenAcquired;
  55     PACQUIRE_FUNCTION Acquire;
  56     PRELEASE_FUNCTION Release;
  57     PTRY_FUNCTION TryAcquire;
  58     PACQUIRE_FUNCTION AcquireNoRaise;
  59     PRELEASE_FUNCTION ReleaseNoLower;
  60     PTRY_FUNCTION TryAcquireNoRaise;
  61     KSPIN_LOCK_QUEUE_NUMBER QueueNumber;
  62     BOOLEAN TryRetOnFailure;
  63     KIRQL OriginalIrql;
  64     BOOLEAN IsAcquired;
  65     _ANONYMOUS_UNION union
  66     {
  67         KLOCK_QUEUE_HANDLE QueueHandle;
  68         PKSPIN_LOCK_QUEUE Queue;
  69         KIRQL Irql;
  70     } DUMMYUNIONNAME;
  71     PVOID UntouchedValue;
  72 };
  73
  74 #define DEFINE_ACQUIRE(LocalName, SetIsAcquired, DoCall)            \
  75 static VOID LocalName(PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData)  \
  76 {                                                                   \
  77     ASSERT(!CheckData->IsAcquired);                                 \
  78     DoCall;                                                         \
  79     if (SetIsAcquired) CheckData->IsAcquired = TRUE;                \
  80 }
  81
  82 #define DEFINE_RELEASE(LocalName, SetIsAcquired, DoCall)            \
  83 static VOID LocalName(PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData)  \
  84 {                                                                   \
  85     DoCall;                                                         \
  86     if (SetIsAcquired) CheckData->IsAcquired = FALSE;               \
  87 }
  88
  89 DEFINE_ACQUIRE(AcquireNormal,         TRUE,  KeAcquireSpinLock(SpinLock, &CheckData->Irql))
  90 DEFINE_RELEASE(ReleaseNormal,         TRUE,  KeReleaseSpinLock(SpinLock, CheckData->Irql))
  91 DEFINE_ACQUIRE(AcquireExp,            TRUE,  (KeAcquireSpinLock)(SpinLock, &CheckData->Irql))
  92 DEFINE_RELEASE(ReleaseExp,            TRUE,  (KeReleaseSpinLock)(SpinLock, CheckData->Irql))
  93 DEFINE_ACQUIRE(AcquireSynch,          TRUE,  CheckData->Irql = KeAcquireSpinLockRaiseToSynch(SpinLock))
  94
  95 DEFINE_ACQUIRE(AcquireInStackQueued,  TRUE,  KeAcquireInStackQueuedSpinLock(SpinLock, &CheckData->QueueHandle))
  96 DEFINE_ACQUIRE(AcquireInStackSynch,   TRUE,  KeAcquireInStackQueuedSpinLockRaiseToSynch(SpinLock, &CheckData->QueueHandle))
  97 DEFINE_RELEASE(ReleaseInStackQueued,  TRUE,  KeReleaseInStackQueuedSpinLock(&CheckData->QueueHandle))
  98
  99 DEFINE_ACQUIRE(AcquireQueued,         TRUE,  CheckData->Irql = KeAcquireQueuedSpinLock(CheckData->QueueNumber))
 100 DEFINE_ACQUIRE(AcquireQueuedSynch,    TRUE,  CheckData->Irql = KeAcquireQueuedSpinLockRaiseToSynch(CheckData->QueueNumber))
 101 DEFINE_RELEASE(ReleaseQueued,         TRUE,  KeReleaseQueuedSpinLock(CheckData->QueueNumber, CheckData->Irql))
 102
 103 DEFINE_ACQUIRE(AcquireNoRaise,        FALSE, KeAcquireSpinLockAtDpcLevel(SpinLock))
 104 DEFINE_RELEASE(ReleaseNoLower,        FALSE, KeReleaseSpinLockFromDpcLevel(SpinLock))
 105 DEFINE_ACQUIRE(AcquireExpNoRaise,     FALSE, (KeAcquireSpinLockAtDpcLevel)(SpinLock))
 106 DEFINE_RELEASE(ReleaseExpNoLower,     FALSE, (KeReleaseSpinLockFromDpcLevel)(SpinLock))
 107
 108 DEFINE_ACQUIRE(AcquireInStackNoRaise, FALSE, KeAcquireInStackQueuedSpinLockAtDpcLevel(SpinLock, &CheckData->QueueHandle))
 109 DEFINE_RELEASE(ReleaseInStackNoRaise, FALSE, KeReleaseInStackQueuedSpinLockFromDpcLevel(&CheckData->QueueHandle))
 110
 111 /* TODO: test these functions. They behave weirdly, though */
 112 #if 0
 113 DEFINE_ACQUIRE(AcquireForDpc,         TRUE,  CheckData->Irql = KeAcquireSpinLockForDpc(SpinLock))
 114 DEFINE_RELEASE(ReleaseForDpc,         TRUE,  KeReleaseSpinLockForDpc(SpinLock, CheckData->Irql))
 115 #endif
 116
 117 DEFINE_ACQUIRE(AcquireInStackForDpc,  FALSE, KeAcquireInStackQueuedSpinLockForDpc(SpinLock, &CheckData->QueueHandle))
 118 DEFINE_RELEASE(ReleaseInStackForDpc,  FALSE, KeReleaseInStackQueuedSpinLockForDpc(&CheckData->QueueHandle))
 119
 120 DEFINE_ACQUIRE(AcquireInt,            FALSE, KiAcquireSpinLock(SpinLock))
 121 DEFINE_RELEASE(ReleaseInt,            FALSE, KiReleaseSpinLock(SpinLock))
 122
 123 BOOLEAN TryQueued(PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData) {
 124     LOGICAL Ret = KeTryToAcquireQueuedSpinLock(CheckData->QueueNumber, &CheckData->Irql);
 125     CheckData->IsAcquired = TRUE;
 126     ASSERT(Ret == FALSE || Ret == TRUE);
 127     return (BOOLEAN)Ret;
 128 }
 129 BOOLEAN TryQueuedSynch(PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData) {
 130     BOOLEAN Ret = KeTryToAcquireQueuedSpinLockRaiseToSynch(CheckData->QueueNumber, &CheckData->Irql);
 131     CheckData->IsAcquired = TRUE;
 132     return Ret;
 133 }
 134 BOOLEAN TryNoRaise(PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData) {
 135     BOOLEAN Ret = KeTryToAcquireSpinLockAtDpcLevel(SpinLock);
 136     return Ret;
 137 }
 138
 139 #define CheckSpinLockLock(SpinLock, CheckData, Value) do                            \
 140 {                                                                                   \
 141     PKTHREAD Thread = KeGetCurrentThread();                                         \
 142     if (KmtIsMultiProcessorBuild)                                                   \
 143     {                                                                               \
 144         ok_eq_bool(Ret, (Value) == 0);                                              \
 145         if (SpinLock)                                                               \
 146             ok_eq_ulongptr(*(SpinLock),                                             \
 147                         (Value) ? (ULONG_PTR)Thread | 1 : 0);                       \
 148     }                                                                               \
 149     else                                                                            \
 150     {                                                                               \
 151         ok_bool_true(Ret, "KeTestSpinLock returned");                               \
 152         if (SpinLock)                                                               \
 153             ok_eq_ulongptr(*(SpinLock), 0);                                         \
 154     }                                                                               \
 155     ok_eq_uint((CheckData)->Irql, (CheckData)->OriginalIrql);                       \
 156 } while (0)
 157
 158 #define CheckSpinLockQueue(SpinLock, CheckData, Value) do                           \
 159 {                                                                                   \
 160     ok_eq_pointer((CheckData)->Queue->Next, NULL);                                  \
 161     ok_eq_pointer((CheckData)->Queue->Lock, NULL);                                  \
 162     ok_eq_uint((CheckData)->Irql, (CheckData)->OriginalIrql);                       \
 163 } while (0)
 164
 165 #define CheckSpinLockQueueHandle(SpinLock, CheckData, Value) do                     \
 166 {                                                                                   \
 167     if (KmtIsMultiProcessorBuild)                                                   \
 168     {                                                                               \
 169         ok_eq_bool(Ret, (Value) == 0);                                              \
 170         if (SpinLock)                                                               \
 171             ok_eq_ulongptr(*(SpinLock),                                             \
 172                         (Value) ? &(CheckData)->QueueHandle : 0);                   \
 173         ok_eq_pointer((CheckData)->QueueHandle.LockQueue.Next, NULL);               \
 174         ok_eq_pointer((CheckData)->QueueHandle.LockQueue.Lock,                      \
 175                 (PVOID)((ULONG_PTR)SpinLock | ((Value) ? 2 : 0)));                  \
 176     }                                                                               \
 177     else                                                                            \
 178     {                                                                               \
 179         ok_bool_true(Ret, "KeTestSpinLock returned");                               \
 180         if (SpinLock)                                                               \
 181             ok_eq_ulongptr(*(SpinLock), 0);                                         \
 182         ok_eq_pointer((CheckData)->QueueHandle.LockQueue.Next, (CheckData)->UntouchedValue);                \
 183         ok_eq_pointer((CheckData)->QueueHandle.LockQueue.Lock, (CheckData)->UntouchedValue);                \
 184     }                                                                               \
 185     ok_eq_uint((CheckData)->QueueHandle.OldIrql, (CheckData)->OriginalIrql);        \
 186 } while (0)
 187
 188 #define CheckSpinLock(SpinLock, CheckData, Value) do                                \
 189 {                                                                                   \
 190     BOOLEAN Ret = SpinLock ? KeTestSpinLock(SpinLock) : TRUE;                       \
 191     KIRQL ExpectedIrql = (CheckData)->OriginalIrql;                                 \
 192                                                                                     \
 193     switch ((CheckData)->Check)                                                     \
 194     {                                                                               \
 195         case CheckLock:                                                             \
 196             CheckSpinLockLock(SpinLock, CheckData, Value);                          \
 197             break;                                                                  \
 198         case CheckQueue:                                                            \
 199             CheckSpinLockQueue(SpinLock, CheckData, Value);                         \
 200             break;                                                                  \
 201         case CheckQueueHandle:                                                      \
 202             CheckSpinLockQueueHandle(SpinLock, CheckData, Value);                   \
 203             break;                                                                  \
 204     }                                                                               \
 205                                                                                     \
 206     if ((CheckData)->IsAcquired)                                                    \
 207         ExpectedIrql = (CheckData)->IrqlWhenAcquired;                               \
 208     ok_irql(ExpectedIrql);                                                          \
 209     ok_bool_false(KeAreApcsDisabled(), "KeAreApcsDisabled returned");               \
 210     ok_bool_true(KmtAreInterruptsEnabled(), "Interrupts enabled:");                 \
 211 } while (0)
 212
 213 static
 214 VOID
 215 TestSpinLock(
 216     PKSPIN_LOCK SpinLock,
 217     PCHECK_DATA CheckData)
 218 {
 219     static INT Run = 0;
 220     trace("Test SpinLock run %d\n", Run++);
 221
 222     ok_irql(CheckData->OriginalIrql);
 223
 224     if (SpinLock)
 225         ok_eq_ulongptr(*SpinLock, 0);
 226     CheckData->Acquire(SpinLock, CheckData);
 227     CheckSpinLock(SpinLock, CheckData, 1);
 228     CheckData->Release(SpinLock, CheckData);
 229     CheckSpinLock(SpinLock, CheckData, 0);
 230
 231     if (CheckData->TryAcquire)
 232     {
 233         CheckSpinLock(SpinLock, CheckData, 0);
 234         ok_bool_true(CheckData->TryAcquire(SpinLock, CheckData), "TryAcquire returned");
 235         CheckSpinLock(SpinLock, CheckData, 1);
 236         if (!KmtIsCheckedBuild)
 237         {
 238             /* SPINLOCK_ALREADY_OWNED on checked build */
 239             ok_bool_true(CheckData->TryAcquire(SpinLock, CheckData), "TryAcquire returned");
 240             /* even a failing acquire sets irql */
 241             ok_eq_uint(CheckData->Irql, CheckData->IrqlWhenAcquired);
 242             CheckData->Irql = CheckData->OriginalIrql;
 243             CheckSpinLock(SpinLock, CheckData, 1);
 244         }
 245         CheckData->Release(SpinLock, CheckData);
 246         CheckSpinLock(SpinLock, CheckData, 0);
 247     }
 248
 249     if (CheckData->AcquireNoRaise &&
 250             (CheckData->OriginalIrql >= DISPATCH_LEVEL || !KmtIsCheckedBuild))
 251     {
 252         /* acquire/release without irql change */
 253         CheckData->AcquireNoRaise(SpinLock, CheckData);
 254         CheckSpinLock(SpinLock, CheckData, 1);
 255         CheckData->ReleaseNoLower(SpinLock, CheckData);
 256         CheckSpinLock(SpinLock, CheckData, 0);
 257
 258         /* acquire without raise, but normal release */
 259         CheckData->AcquireNoRaise(SpinLock, CheckData);
 260         CheckSpinLock(SpinLock, CheckData, 1);
 261         CheckData->Release(SpinLock, CheckData);
 262         CheckSpinLock(SpinLock, CheckData, 0);
 263
 264         /* acquire normally but release without lower */
 265         CheckData->Acquire(SpinLock, CheckData);
 266         CheckSpinLock(SpinLock, CheckData, 1);
 267         CheckData->ReleaseNoLower(SpinLock, CheckData);
 268         CheckSpinLock(SpinLock, CheckData, 0);
 269         CheckData->IsAcquired = FALSE;
 270         KmtSetIrql(CheckData->OriginalIrql);
 271
 272         if (CheckData->TryAcquireNoRaise)
 273         {
 274             CheckSpinLock(SpinLock, CheckData, 0);
 275             ok_bool_true(CheckData->TryAcquireNoRaise(SpinLock, CheckData), "TryAcquireNoRaise returned");
 276             CheckSpinLock(SpinLock, CheckData, 1);
 277             if (!KmtIsCheckedBuild)
 278             {
 279                 ok_bool_true(CheckData->TryAcquireNoRaise(SpinLock, CheckData), "TryAcquireNoRaise returned");
 280                 CheckSpinLock(SpinLock, CheckData, 1);
 281             }
 282             CheckData->ReleaseNoLower(SpinLock, CheckData);
 283             CheckSpinLock(SpinLock, CheckData, 0);
 284         }
 285     }
 286
 287     ok_irql(CheckData->OriginalIrql);
 288     /* make sure we survive this in case of error */
 289     KmtSetIrql(CheckData->OriginalIrql);
 290 }
 291
 292 START_TEST(KeSpinLock)
 293 {
 294     KSPIN_LOCK SpinLock = (KSPIN_LOCK)0x5555555555555555LL;
 295     PKSPIN_LOCK pSpinLock = &SpinLock;
 296     KIRQL Irql, SynchIrql = KmtIsMultiProcessorBuild ? IPI_LEVEL - 2 : DISPATCH_LEVEL;
 297     KIRQL OriginalIrqls[] = { PASSIVE_LEVEL, APC_LEVEL, DISPATCH_LEVEL, HIGH_LEVEL };
 298     CHECK_DATA TestData[] =
 299     {
 300         { CheckLock,        DISPATCH_LEVEL, AcquireNormal,        ReleaseNormal,        NULL,           AcquireNoRaise,        ReleaseNoLower,        TryNoRaise },
 301         { CheckLock,        DISPATCH_LEVEL, AcquireExp,           ReleaseExp,           NULL,           AcquireExpNoRaise,     ReleaseExpNoLower,     NULL },
 302         /* TODO: this one is just weird!
 303         { CheckLock,        DISPATCH_LEVEL, AcquireNormal,        ReleaseNormal,        NULL,           AcquireForDpc,         ReleaseForDpc,         NULL },*/
 304         { CheckLock,        DISPATCH_LEVEL, AcquireNormal,        ReleaseNormal,        NULL,           AcquireInt,            ReleaseInt,            NULL },
 305         { CheckLock,        SynchIrql,      AcquireSynch,         ReleaseNormal,        NULL,           NULL,                  NULL,                  NULL },
 306         { CheckQueueHandle, DISPATCH_LEVEL, AcquireInStackQueued, ReleaseInStackQueued, NULL,           AcquireInStackNoRaise, ReleaseInStackNoRaise, NULL },
 307         { CheckQueueHandle, SynchIrql,      AcquireInStackSynch,  ReleaseInStackQueued, NULL,           NULL,                  NULL,                  NULL },
 308         { CheckQueueHandle, DISPATCH_LEVEL, AcquireInStackQueued, ReleaseInStackQueued, NULL,           AcquireInStackForDpc,  ReleaseInStackForDpc,  NULL },
 309         { CheckQueue,       DISPATCH_LEVEL, AcquireQueued,        ReleaseQueued,        TryQueued,      NULL,                  NULL,                  NULL,       LockQueuePfnLock },
 310         { CheckQueue,       SynchIrql,      AcquireQueuedSynch,   ReleaseQueued,        TryQueuedSynch, NULL,                  NULL,                  NULL,       LockQueuePfnLock },
 311     };
 312     int i, iIrql;
 313     PKPRCB Prcb = KeGetCurrentPrcb();
 314
 315     /* KeInitializeSpinLock */
 316     memset(&SpinLock, 0x55, sizeof SpinLock);
 317     KeInitializeSpinLock(&SpinLock);
 318     ok_eq_ulongptr(SpinLock, 0);
 319
 320     /* KeTestSpinLock */
 321     ok_bool_true(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
 322     SpinLock = 1;
 323     ok_bool_false(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
 324     SpinLock = 2;
 325     ok_bool_false(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
 326     SpinLock = (ULONG_PTR)-1;
 327     ok_bool_false(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
 328     SpinLock = (ULONG_PTR)1 << (sizeof(ULONG_PTR) * CHAR_BIT - 1);
 329     ok_bool_false(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
 330     SpinLock = 0;
 331     ok_bool_true(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
 332
 333     /* on UP none of the following functions actually looks at the spinlock! */
 334     if (!KmtIsMultiProcessorBuild && !KmtIsCheckedBuild)
 335         pSpinLock = NULL;
 336
 337     for (i = 0; i < sizeof TestData / sizeof TestData[0]; ++i)
 338     {
 339         memset(&SpinLock, 0x55, sizeof SpinLock);
 340         KeInitializeSpinLock(&SpinLock);
 341         if (TestData[i].Check == CheckQueueHandle)
 342             memset(&TestData[i].QueueHandle, 0x55, sizeof TestData[i].QueueHandle);
 343         if (TestData[i].Check == CheckQueue)
 344         {
 345             TestData[i].Queue = &Prcb->LockQueue[TestData[i].QueueNumber];
 346             TestData[i].UntouchedValue = NULL;
 347         }
 348         else
 349             TestData[i].UntouchedValue = (PVOID)0x5555555555555555LL;
 350
 351         for (iIrql = 0; iIrql < sizeof OriginalIrqls / sizeof OriginalIrqls[0]; ++iIrql)
 352         {
 353             if (KmtIsCheckedBuild && OriginalIrqls[iIrql] > DISPATCH_LEVEL)
 354                 continue;
 355             KeRaiseIrql(OriginalIrqls[iIrql], &Irql);
 356             TestData[i].OriginalIrql = OriginalIrqls[iIrql];
 357             TestData[i].IsAcquired = FALSE;
 358             TestSpinLock(pSpinLock, &TestData[i]);
 359             KeLowerIrql(Irql);
 360         }
 361     }
 362
 363     KmtSetIrql(PASSIVE_LEVEL);
 364 }