rostests/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 #ifdef _X86_
  92 DEFINE_ACQUIRE(AcquireExp,            TRUE,  (KeAcquireSpinLock)(SpinLock, &CheckData->Irql))
  93 DEFINE_RELEASE(ReleaseExp,            TRUE,  (KeReleaseSpinLock)(SpinLock, CheckData->Irql))
  94 #else
  95 DEFINE_ACQUIRE(AcquireExp,            TRUE,  KeAcquireSpinLock(SpinLock, &CheckData->Irql))
  96 DEFINE_RELEASE(ReleaseExp,            TRUE,  KeReleaseSpinLock(SpinLock, CheckData->Irql))
  97 #endif
  98 DEFINE_ACQUIRE(AcquireSynch,          TRUE,  CheckData->Irql = KeAcquireSpinLockRaiseToSynch(SpinLock))
  99
 100 DEFINE_ACQUIRE(AcquireInStackQueued,  TRUE,  KeAcquireInStackQueuedSpinLock(SpinLock, &CheckData->QueueHandle))
 101 DEFINE_ACQUIRE(AcquireInStackSynch,   TRUE,  KeAcquireInStackQueuedSpinLockRaiseToSynch(SpinLock, &CheckData->QueueHandle))
 102 DEFINE_RELEASE(ReleaseInStackQueued,  TRUE,  KeReleaseInStackQueuedSpinLock(&CheckData->QueueHandle))
 103
 104 DEFINE_ACQUIRE(AcquireQueued,         TRUE,  CheckData->Irql = KeAcquireQueuedSpinLock(CheckData->QueueNumber))
 105 DEFINE_ACQUIRE(AcquireQueuedSynch,    TRUE,  CheckData->Irql = KeAcquireQueuedSpinLockRaiseToSynch(CheckData->QueueNumber))
 106 DEFINE_RELEASE(ReleaseQueued,         TRUE,  KeReleaseQueuedSpinLock(CheckData->QueueNumber, CheckData->Irql))
 107
 108 DEFINE_ACQUIRE(AcquireNoRaise,        FALSE, KeAcquireSpinLockAtDpcLevel(SpinLock))
 109 DEFINE_RELEASE(ReleaseNoLower,        FALSE, KeReleaseSpinLockFromDpcLevel(SpinLock))
 110 DEFINE_ACQUIRE(AcquireExpNoRaise,     FALSE, (KeAcquireSpinLockAtDpcLevel)(SpinLock))
 111 DEFINE_RELEASE(ReleaseExpNoLower,     FALSE, (KeReleaseSpinLockFromDpcLevel)(SpinLock))
 112
 113 DEFINE_ACQUIRE(AcquireInStackNoRaise, FALSE, KeAcquireInStackQueuedSpinLockAtDpcLevel(SpinLock, &CheckData->QueueHandle))
 114 DEFINE_RELEASE(ReleaseInStackNoRaise, FALSE, KeReleaseInStackQueuedSpinLockFromDpcLevel(&CheckData->QueueHandle))
 115
 116 /* TODO: test these functions. They behave weirdly, though */
 117 #if 0
 118 DEFINE_ACQUIRE(AcquireForDpc,         TRUE,  CheckData->Irql = KeAcquireSpinLockForDpc(SpinLock))
 119 DEFINE_RELEASE(ReleaseForDpc,         TRUE,  KeReleaseSpinLockForDpc(SpinLock, CheckData->Irql))
 120 #endif
 121
 122 DEFINE_ACQUIRE(AcquireInStackForDpc,  FALSE, KeAcquireInStackQueuedSpinLockForDpc(SpinLock, &CheckData->QueueHandle))
 123 DEFINE_RELEASE(ReleaseInStackForDpc,  FALSE, KeReleaseInStackQueuedSpinLockForDpc(&CheckData->QueueHandle))
 124
 125 DEFINE_ACQUIRE(AcquireInt,            FALSE, KiAcquireSpinLock(SpinLock))
 126 DEFINE_RELEASE(ReleaseInt,            FALSE, KiReleaseSpinLock(SpinLock))
 127
 128 BOOLEAN TryQueued(PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData) {
 129     LOGICAL Ret = KeTryToAcquireQueuedSpinLock(CheckData->QueueNumber, &CheckData->Irql);
 130     CheckData->IsAcquired = TRUE;
 131     ASSERT(Ret == FALSE || Ret == TRUE);
 132     return (BOOLEAN)Ret;
 133 }
 134 BOOLEAN TryQueuedSynch(PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData) {
 135     BOOLEAN Ret = KeTryToAcquireQueuedSpinLockRaiseToSynch(CheckData->QueueNumber, &CheckData->Irql);
 136     CheckData->IsAcquired = TRUE;
 137     return Ret;
 138 }
 139 BOOLEAN TryNoRaise(PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData) {
 140     BOOLEAN Ret = KeTryToAcquireSpinLockAtDpcLevel(SpinLock);
 141     return Ret;
 142 }
 143
 144 #define CheckSpinLockLock(SpinLock, CheckData, Value) do                            \
 145 {                                                                                   \
 146     PKTHREAD Thread = KeGetCurrentThread();                                         \
 147     if (KmtIsMultiProcessorBuild)                                                   \
 148     {                                                                               \
 149         ok_eq_bool(Ret, (Value) == 0);                                              \
 150         if (SpinLock)                                                               \
 151             ok_eq_ulongptr(*(SpinLock),                                             \
 152                         (Value) ? (ULONG_PTR)Thread | 1 : 0);                       \
 153     }                                                                               \
 154     else                                                                            \
 155     {                                                                               \
 156         ok_bool_true(Ret, "KeTestSpinLock returned");                               \
 157         if (SpinLock)                                                               \
 158             ok_eq_ulongptr(*(SpinLock), 0);                                         \
 159     }                                                                               \
 160     ok_eq_uint((CheckData)->Irql, (CheckData)->OriginalIrql);                       \
 161 } while (0)
 162
 163 #define CheckSpinLockQueue(SpinLock, CheckData, Value) do                           \
 164 {                                                                                   \
 165     ok_eq_pointer((CheckData)->Queue->Next, NULL);                                  \
 166     ok_eq_pointer((CheckData)->Queue->Lock, NULL);                                  \
 167     ok_eq_uint((CheckData)->Irql, (CheckData)->OriginalIrql);                       \
 168 } while (0)
 169
 170 #define CheckSpinLockQueueHandle(SpinLock, CheckData, Value) do                     \
 171 {                                                                                   \
 172     if (KmtIsMultiProcessorBuild)                                                   \
 173     {                                                                               \
 174         ok_eq_bool(Ret, (Value) == 0);                                              \
 175         if (SpinLock)                                                               \
 176             ok_eq_ulongptr(*(SpinLock),                                             \
 177                         (Value) ? &(CheckData)->QueueHandle : 0);                   \
 178         ok_eq_pointer((CheckData)->QueueHandle.LockQueue.Next, NULL);               \
 179         ok_eq_pointer((CheckData)->QueueHandle.LockQueue.Lock,                      \
 180                 (PVOID)((ULONG_PTR)SpinLock | ((Value) ? 2 : 0)));                  \
 181     }                                                                               \
 182     else                                                                            \
 183     {                                                                               \
 184         ok_bool_true(Ret, "KeTestSpinLock returned");                               \
 185         if (SpinLock)                                                               \
 186             ok_eq_ulongptr(*(SpinLock), 0);                                         \
 187         ok_eq_pointer((CheckData)->QueueHandle.LockQueue.Next, (CheckData)->UntouchedValue);                \
 188         ok_eq_pointer((CheckData)->QueueHandle.LockQueue.Lock, (CheckData)->UntouchedValue);                \
 189     }                                                                               \
 190     ok_eq_uint((CheckData)->QueueHandle.OldIrql, (CheckData)->OriginalIrql);        \
 191 } while (0)
 192
 193 #define CheckSpinLock(SpinLock, CheckData, Value) do                                \
 194 {                                                                                   \
 195     BOOLEAN Ret = SpinLock ? KeTestSpinLock(SpinLock) : TRUE;                       \
 196     KIRQL ExpectedIrql = (CheckData)->OriginalIrql;                                 \
 197                                                                                     \
 198     switch ((CheckData)->Check)                                                     \
 199     {                                                                               \
 200         case CheckLock:                                                             \
 201             CheckSpinLockLock(SpinLock, CheckData, Value);                          \
 202             break;                                                                  \
 203         case CheckQueue:                                                            \
 204             CheckSpinLockQueue(SpinLock, CheckData, Value);                         \
 205             break;                                                                  \
 206         case CheckQueueHandle:                                                      \
 207             CheckSpinLockQueueHandle(SpinLock, CheckData, Value);                   \
 208             break;                                                                  \
 209     }                                                                               \
 210                                                                                     \
 211     if ((CheckData)->IsAcquired)                                                    \
 212         ExpectedIrql = (CheckData)->IrqlWhenAcquired;                               \
 213     ok_irql(ExpectedIrql);                                                          \
 214     ok_bool_false(KeAreApcsDisabled(), "KeAreApcsDisabled returned");               \
 215     ok_bool_true(KmtAreInterruptsEnabled(), "Interrupts enabled:");                 \
 216 } while (0)
 217
 218 static
 219 VOID
 220 TestSpinLock(
 221     PKSPIN_LOCK SpinLock,
 222     PCHECK_DATA CheckData)
 223 {
 224     static INT Run = 0;
 225     trace("Test SpinLock run %d\n", Run++);
 226
 227     ok_irql(CheckData->OriginalIrql);
 228
 229     if (SpinLock)
 230         ok_eq_ulongptr(*SpinLock, 0);
 231     CheckData->Acquire(SpinLock, CheckData);
 232     CheckSpinLock(SpinLock, CheckData, 1);
 233     CheckData->Release(SpinLock, CheckData);
 234     CheckSpinLock(SpinLock, CheckData, 0);
 235
 236     if (CheckData->TryAcquire)
 237     {
 238         CheckSpinLock(SpinLock, CheckData, 0);
 239         ok_bool_true(CheckData->TryAcquire(SpinLock, CheckData), "TryAcquire returned");
 240         CheckSpinLock(SpinLock, CheckData, 1);
 241         if (!KmtIsCheckedBuild)
 242         {
 243             /* SPINLOCK_ALREADY_OWNED on checked build */
 244             ok_bool_true(CheckData->TryAcquire(SpinLock, CheckData), "TryAcquire returned");
 245             /* even a failing acquire sets irql */
 246             ok_eq_uint(CheckData->Irql, CheckData->IrqlWhenAcquired);
 247             CheckData->Irql = CheckData->OriginalIrql;
 248             CheckSpinLock(SpinLock, CheckData, 1);
 249         }
 250         CheckData->Release(SpinLock, CheckData);
 251         CheckSpinLock(SpinLock, CheckData, 0);
 252     }
 253
 254     if (CheckData->AcquireNoRaise &&
 255             (CheckData->OriginalIrql >= DISPATCH_LEVEL || !KmtIsCheckedBuild))
 256     {
 257         /* acquire/release without irql change */
 258         CheckData->AcquireNoRaise(SpinLock, CheckData);
 259         CheckSpinLock(SpinLock, CheckData, 1);
 260         CheckData->ReleaseNoLower(SpinLock, CheckData);
 261         CheckSpinLock(SpinLock, CheckData, 0);
 262
 263         /* acquire without raise, but normal release */
 264         CheckData->AcquireNoRaise(SpinLock, CheckData);
 265         CheckSpinLock(SpinLock, CheckData, 1);
 266         CheckData->Release(SpinLock, CheckData);
 267         CheckSpinLock(SpinLock, CheckData, 0);
 268
 269         /* acquire normally but release without lower */
 270         CheckData->Acquire(SpinLock, CheckData);
 271         CheckSpinLock(SpinLock, CheckData, 1);
 272         CheckData->ReleaseNoLower(SpinLock, CheckData);
 273         CheckSpinLock(SpinLock, CheckData, 0);
 274         CheckData->IsAcquired = FALSE;
 275         KmtSetIrql(CheckData->OriginalIrql);
 276
 277         if (CheckData->TryAcquireNoRaise)
 278         {
 279             CheckSpinLock(SpinLock, CheckData, 0);
 280             ok_bool_true(CheckData->TryAcquireNoRaise(SpinLock, CheckData), "TryAcquireNoRaise returned");
 281             CheckSpinLock(SpinLock, CheckData, 1);
 282             if (!KmtIsCheckedBuild)
 283             {
 284                 ok_bool_true(CheckData->TryAcquireNoRaise(SpinLock, CheckData), "TryAcquireNoRaise returned");
 285                 CheckSpinLock(SpinLock, CheckData, 1);
 286             }
 287             CheckData->ReleaseNoLower(SpinLock, CheckData);
 288             CheckSpinLock(SpinLock, CheckData, 0);
 289         }
 290     }
 291
 292     ok_irql(CheckData->OriginalIrql);
 293     /* make sure we survive this in case of error */
 294     KmtSetIrql(CheckData->OriginalIrql);
 295 }
 296
 297 START_TEST(KeSpinLock)
 298 {
 299     KSPIN_LOCK SpinLock = (KSPIN_LOCK)0x5555555555555555LL;
 300     PKSPIN_LOCK pSpinLock = &SpinLock;
 301     KIRQL Irql, SynchIrql = KmtIsMultiProcessorBuild ? IPI_LEVEL - 2 : DISPATCH_LEVEL;
 302     KIRQL OriginalIrqls[] = { PASSIVE_LEVEL, APC_LEVEL, DISPATCH_LEVEL, HIGH_LEVEL };
 303     CHECK_DATA TestData[] =
 304     {
 305         { CheckLock,        DISPATCH_LEVEL, AcquireNormal,        ReleaseNormal,        NULL,           AcquireNoRaise,        ReleaseNoLower,        TryNoRaise },
 306         { CheckLock,        DISPATCH_LEVEL, AcquireExp,           ReleaseExp,           NULL,           AcquireExpNoRaise,     ReleaseExpNoLower,     NULL },
 307         /* TODO: this one is just weird!
 308         { CheckLock,        DISPATCH_LEVEL, AcquireNormal,        ReleaseNormal,        NULL,           AcquireForDpc,         ReleaseForDpc,         NULL },*/
 309         { CheckLock,        DISPATCH_LEVEL, AcquireNormal,        ReleaseNormal,        NULL,           AcquireInt,            ReleaseInt,            NULL },
 310         { CheckLock,        SynchIrql,      AcquireSynch,         ReleaseNormal,        NULL,           NULL,                  NULL,                  NULL },
 311         { CheckQueueHandle, DISPATCH_LEVEL, AcquireInStackQueued, ReleaseInStackQueued, NULL,           AcquireInStackNoRaise, ReleaseInStackNoRaise, NULL },
 312         { CheckQueueHandle, SynchIrql,      AcquireInStackSynch,  ReleaseInStackQueued, NULL,           NULL,                  NULL,                  NULL },
 313         { CheckQueueHandle, DISPATCH_LEVEL, AcquireInStackQueued, ReleaseInStackQueued, NULL,           AcquireInStackForDpc,  ReleaseInStackForDpc,  NULL },
 314         { CheckQueue,       DISPATCH_LEVEL, AcquireQueued,        ReleaseQueued,        TryQueued,      NULL,                  NULL,                  NULL,       LockQueuePfnLock },
 315         { CheckQueue,       SynchIrql,      AcquireQueuedSynch,   ReleaseQueued,        TryQueuedSynch, NULL,                  NULL,                  NULL,       LockQueuePfnLock },
 316     };
 317     int i, iIrql;
 318     PKPRCB Prcb = KeGetCurrentPrcb();
 319
 320     /* KeInitializeSpinLock */
 321     memset(&SpinLock, 0x55, sizeof SpinLock);
 322     KeInitializeSpinLock(&SpinLock);
 323     ok_eq_ulongptr(SpinLock, 0);
 324
 325     /* KeTestSpinLock */
 326     ok_bool_true(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
 327     SpinLock = 1;
 328     ok_bool_false(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
 329     SpinLock = 2;
 330     ok_bool_false(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
 331     SpinLock = (ULONG_PTR)-1;
 332     ok_bool_false(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
 333     SpinLock = (ULONG_PTR)1 << (sizeof(ULONG_PTR) * CHAR_BIT - 1);
 334     ok_bool_false(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
 335     SpinLock = 0;
 336     ok_bool_true(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
 337
 338     /* on UP none of the following functions actually looks at the spinlock! */
 339     if (!KmtIsMultiProcessorBuild && !KmtIsCheckedBuild)
 340         pSpinLock = NULL;
 341
 342     for (i = 0; i < sizeof TestData / sizeof TestData[0]; ++i)
 343     {
 344         memset(&SpinLock, 0x55, sizeof SpinLock);
 345         KeInitializeSpinLock(&SpinLock);
 346         if (TestData[i].Check == CheckQueueHandle)
 347             memset(&TestData[i].QueueHandle, 0x55, sizeof TestData[i].QueueHandle);
 348         if (TestData[i].Check == CheckQueue)
 349         {
 350             TestData[i].Queue = &Prcb->LockQueue[TestData[i].QueueNumber];
 351             TestData[i].UntouchedValue = NULL;
 352         }
 353         else
 354             TestData[i].UntouchedValue = (PVOID)0x5555555555555555LL;
 355
 356         for (iIrql = 0; iIrql < sizeof OriginalIrqls / sizeof OriginalIrqls[0]; ++iIrql)
 357         {
 358             if (KmtIsCheckedBuild && OriginalIrqls[iIrql] > DISPATCH_LEVEL)
 359                 continue;
 360             KeRaiseIrql(OriginalIrqls[iIrql], &Irql);
 361             TestData[i].OriginalIrql = OriginalIrqls[iIrql];
 362             TestData[i].IsAcquired = FALSE;
 363             TestSpinLock(pSpinLock, &TestData[i]);
 364             KeLowerIrql(Irql);
 365         }
 366     }
 367
 368     KmtSetIrql(PASSIVE_LEVEL);
 369 }