ReactOS 0.4.16-dev-1520-gb558596
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)
unsigned char BOOLEAN
#define GetNTVersion()
Definition: apitest.h:17
#define TRUE
Definition: types.h:120
UCHAR KIRQL
Definition: env_spec_w32.h:591
BOOLEAN KmtAreInterruptsEnabled(VOID)
int Check()
Definition: movefile.cpp:196
BOOLEAN NTAPI KeAreApcsDisabled(VOID)
Definition: apc.c:958
#define _WIN32_WINNT_WS03
Definition: sdkddkver.h:23
#define _WIN32_WINNT_WIN8
Definition: sdkddkver.h:29
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFSPINLOCK * SpinLock
Definition: wdfsync.h:228

Definition at line 221 of file KeSpinLock.c.

◆ CheckSpinLockLock

#define CheckSpinLockLock (   SpinLock,
  CheckData,
  Value 
)
Value:
do \
{ \
{ \
ok_eq_bool(Ret, (Value) == 0); \
if (SpinLock) \
{ \
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)
#define VOID
Definition: acefi.h:82
_Out_ PKIRQL Irql
Definition: csq.h:179
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
#define KeGetCurrentThread
Definition: hal.h:55
BOOLEAN KmtIsCheckedBuild
BOOLEAN KmtIsMultiProcessorBuild
uint32_t ULONG_PTR
Definition: typedefs.h:65

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)
#define NULL
Definition: types.h:112
_Must_inspect_result_ _In_ WDFDEVICE _In_ PIRP _In_ WDFQUEUE Queue
Definition: wdfdevice.h:2225

Definition at line 191 of file KeSpinLock.c.

◆ CheckSpinLockQueueHandle

#define CheckSpinLockQueueHandle (   SpinLock,
  CheckData,
  Value 
)
Value:
do \
{ \
{ \
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; \
}
KSPIN_LOCK * PKSPIN_LOCK
Definition: env_spec_w32.h:73

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; \
}
#define FALSE
Definition: types.h:117

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.

65{
66 enum
67 {
68 CheckQueueHandle,
69 CheckQueue,
70 CheckLock
71 } Check;
72 KIRQL IrqlWhenAcquired;
73 PACQUIRE_FUNCTION Acquire;
74 PRELEASE_FUNCTION Release;
75 PTRY_FUNCTION TryAcquire;
76 PACQUIRE_FUNCTION AcquireNoRaise;
77 PRELEASE_FUNCTION ReleaseNoLower;
78 PTRY_FUNCTION TryAcquireNoRaise;
79 KSPIN_LOCK_QUEUE_NUMBER QueueNumber;
80 BOOLEAN TryRetOnFailure;
81 KIRQL OriginalIrql;
82 BOOLEAN IsAcquired;
84 {
85 KLOCK_QUEUE_HANDLE QueueHandle;
87 KIRQL Irql;
89 PVOID UntouchedValue;
90};
BOOLEAN(NTAPI * PACQUIRE_FUNCTION)(PERESOURCE, BOOLEAN)
Definition: ExResource.c:263
_In_ BOOLEAN Release
Definition: cdrom.h:920
#define DUMMYUNIONNAME
Definition: ntbasedef.h:32
#define _ANONYMOUS_UNION
Definition: ntbasedef.h:30
enum _KSPIN_LOCK_QUEUE_NUMBER KSPIN_LOCK_QUEUE_NUMBER

◆ DEFINE_ACQUIRE()

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

Definition at line 128 of file KeSpinLock.c.

151 {
152 LOGICAL Ret = KeTryToAcquireQueuedSpinLock(CheckData->QueueNumber, &CheckData->Irql);
153 CheckData->IsAcquired = TRUE;
154 ASSERT(Ret == FALSE || Ret == TRUE);
155 return (BOOLEAN)Ret;
156}
LOGICAL FASTCALL KeTryToAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber, OUT PKIRQL OldIrql)
Definition: spinlock.c:192
#define ASSERT(a)
Definition: mode.c:44

◆ START_TEST()

START_TEST ( KeSpinLock  )

Definition at line 366 of file KeSpinLock.c.

367{
368 KSPIN_LOCK SpinLock = (KSPIN_LOCK)0x5555555555555555LL;
369 PKSPIN_LOCK pSpinLock = &SpinLock;
371 KIRQL OriginalIrqls[] = { PASSIVE_LEVEL, APC_LEVEL, DISPATCH_LEVEL, HIGH_LEVEL };
372 CHECK_DATA TestDataWS03[] =
373 {
374 { CheckLock, DISPATCH_LEVEL, AcquireNormal, ReleaseNormal, NULL, AcquireNoRaise, ReleaseNoLower, TryNoRaise },
375 { CheckLock, DISPATCH_LEVEL, AcquireExp, ReleaseExp, NULL, AcquireExpNoRaise, ReleaseExpNoLower, NULL },
376 /* TODO: this one is just weird!
377 { CheckLock, DISPATCH_LEVEL, AcquireNormal, ReleaseNormal, NULL, AcquireForDpc, ReleaseForDpc, NULL },*/
378 { CheckLock, DISPATCH_LEVEL, AcquireNormal, ReleaseNormal, NULL, AcquireInt, ReleaseInt, NULL },
379 { CheckLock, SynchIrql, AcquireSynch, ReleaseNormal, NULL, NULL, NULL, NULL },
380 { CheckQueueHandle, DISPATCH_LEVEL, AcquireInStackQueued, ReleaseInStackQueued, NULL, AcquireInStackNoRaise, ReleaseInStackNoRaise, NULL },
381 { CheckQueueHandle, SynchIrql, AcquireInStackSynch, ReleaseInStackQueued, NULL, NULL, NULL, NULL },
382 { CheckQueueHandle, DISPATCH_LEVEL, AcquireInStackQueued, ReleaseInStackQueued, NULL, AcquireInStackForDpc, ReleaseInStackForDpc, NULL },
383 { CheckQueue, DISPATCH_LEVEL, AcquireQueued, ReleaseQueued, TryQueued, NULL, NULL, NULL, LockQueuePfnLock },
384 { CheckQueue, SynchIrql, AcquireQueuedSynch, ReleaseQueued, TryQueuedSynch, NULL, NULL, NULL, LockQueuePfnLock },
385 };
386 CHECK_DATA TestDataWin7[] =
387 {
388 { CheckLock, DISPATCH_LEVEL, AcquireNormal, ReleaseNormal, NULL, AcquireNoRaise, ReleaseNoLower, TryNoRaise },
389 { CheckLock, DISPATCH_LEVEL, AcquireExp, ReleaseExp, NULL, AcquireExpNoRaise, ReleaseExpNoLower, NULL },
390 { CheckLock, DISPATCH_LEVEL, AcquireNormal, ReleaseNormal, NULL, AcquireInt, ReleaseInt, NULL },
391 { CheckLock, SynchIrql, AcquireSynch, ReleaseNormal, NULL, NULL, NULL, NULL },
392 { CheckQueueHandle, DISPATCH_LEVEL, AcquireInStackQueued, ReleaseInStackQueued, NULL, AcquireInStackNoRaise, ReleaseInStackNoRaise, NULL },
393 { CheckQueueHandle, SynchIrql, AcquireInStackSynch, ReleaseInStackQueued, NULL, NULL, NULL, NULL },
394 { CheckQueueHandle, DISPATCH_LEVEL, AcquireInStackQueued, ReleaseInStackQueued, NULL, AcquireInStackForDpc, ReleaseInStackForDpc, NULL },
395 };
396 CHECK_DATA *TestData;
397 ULONG TestElements;
398 int i, iIrql;
399 PKPRCB Prcb;
400
401 pKeTryToAcquireSpinLockAtDpcLevel = KmtGetSystemRoutineAddress(L"KeTryToAcquireSpinLockAtDpcLevel");
402 pKeAcquireInStackQueuedSpinLockForDpc = KmtGetSystemRoutineAddress(L"KeAcquireInStackQueuedSpinLockForDpc");
403 pKeReleaseInStackQueuedSpinLockForDpc = KmtGetSystemRoutineAddress(L"KeReleaseInStackQueuedSpinLockForDpc");
404 pKeTestSpinLock = KmtGetSystemRoutineAddress(L"KeTestSpinLock");
405
406 Prcb = KeGetCurrentPrcb();
407
408 /* KeInitializeSpinLock */
409 memset(&SpinLock, 0x55, sizeof SpinLock);
412
413 /* KeTestSpinLock */
414 if (!skip(pKeTestSpinLock != NULL, "KeTestSpinLock unavailable\n"))
415 {
416 ok_bool_true(pKeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
417 SpinLock = 1;
418 ok_bool_false(pKeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
419 SpinLock = 2;
420 ok_bool_false(pKeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
421 SpinLock = (ULONG_PTR)-1;
422 ok_bool_false(pKeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
423 SpinLock = (ULONG_PTR)1 << (sizeof(ULONG_PTR) * CHAR_BIT - 1);
424 ok_bool_false(pKeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
425 SpinLock = 0;
426 ok_bool_true(pKeTestSpinLock(&SpinLock), "KeTestSpinLock returned");
427 }
428
429 /* on UP none of the following functions actually looks at the spinlock! */
431 pSpinLock = NULL;
432
433 switch (GetNTVersion())
434 {
436#ifdef _M_X64
437 skip(FALSE, "This test is broken on Vista x64.\n");
438 goto done;
439#endif
441 TestData = TestDataWS03;
442 TestElements = RTL_NUMBER_OF(TestDataWS03);
443 break;
448 TestData = TestDataWin7;
449 TestElements = RTL_NUMBER_OF(TestDataWin7);
450 break;
451 default:
452 skip(FALSE, "Unknown NT version (0x%X).\n", GetNTVersion());
453 goto done;
454 }
455
456 for (i = 0; i < TestElements; ++i)
457 {
458 memset(&SpinLock, 0x55, sizeof SpinLock);
460 if (TestData[i].Check == CheckQueueHandle)
461 memset(&TestData[i].QueueHandle, 0x55, sizeof TestData[i].QueueHandle);
462 if (TestData[i].Check == CheckQueue)
463 {
464 TestData[i].Queue = &Prcb->LockQueue[TestData[i].QueueNumber];
465 TestData[i].UntouchedValue = NULL;
466 }
467 else
468 TestData[i].UntouchedValue = (PVOID)0x5555555555555555LL;
469
470 for (iIrql = 0; iIrql < sizeof OriginalIrqls / sizeof OriginalIrqls[0]; ++iIrql)
471 {
472 if (KmtIsCheckedBuild && OriginalIrqls[iIrql] > DISPATCH_LEVEL)
473 continue;
474 KeRaiseIrql(OriginalIrqls[iIrql], &Irql);
475 TestData[i].OriginalIrql = OriginalIrqls[iIrql];
476 TestData[i].IsAcquired = FALSE;
477 TestSpinLock(pSpinLock, &TestData[i]);
479 }
480 }
481done:
483}
static VOID TestSpinLock(PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData)
Definition: KeSpinLock.c:250
BOOLEAN TryNoRaise(PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData)
Definition: KeSpinLock.c:162
BOOLEAN TryQueuedSynch(PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData)
Definition: KeSpinLock.c:157
#define RTL_NUMBER_OF(x)
Definition: RtlRegistry.c:12
#define ok_bool_false(value, desc)
Definition: apitest.h:64
#define ok_bool_true(value, desc)
Definition: apitest.h:63
#define ok_eq_ulongptr(value, expected)
Definition: apitest.h:56
#define skip(...)
Definition: atltest.h:64
#define CHAR_BIT
Definition: urlcache.c:62
#define L(x)
Definition: resources.c:13
#define ULONG_PTR
Definition: config.h:101
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
#define IPI_LEVEL
Definition: env_spec_w32.h:701
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
#define HIGH_LEVEL
Definition: env_spec_w32.h:703
#define APC_LEVEL
Definition: env_spec_w32.h:695
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
#define KeInitializeSpinLock(sl)
Definition: env_spec_w32.h:604
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
PVOID KmtGetSystemRoutineAddress(IN PCWSTR RoutineName)
VOID KmtSetIrql(IN KIRQL NewIrql)
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1187
#define memset(x, y, z)
Definition: compat.h:39
#define _WIN32_WINNT_WIN10
Definition: sdkddkver.h:32
#define _WIN32_WINNT_WINBLUE
Definition: sdkddkver.h:30
#define _WIN32_WINNT_WIN7
Definition: sdkddkver.h:28
#define _WIN32_WINNT_VISTA
Definition: sdkddkver.h:25
KSPIN_LOCK_QUEUE LockQueue[LockQueueMaximumLock]
Definition: ketypes.h:721
void * PVOID
Definition: typedefs.h:50
uint32_t ULONG
Definition: typedefs.h:59
@ LockQueuePfnLock
Definition: ketypes.h:660

◆ TestSpinLock()

static VOID TestSpinLock ( PKSPIN_LOCK  SpinLock,
PCHECK_DATA  CheckData 
)
static

Definition at line 250 of file KeSpinLock.c.

253{
254 static INT Run = 0;
255 trace("Test SpinLock run %d\n", Run++);
256
257 ok_irql(CheckData->OriginalIrql);
258
259 if (SpinLock)
261 CheckData->Acquire(SpinLock, CheckData);
262#ifdef _M_IX86
264 CheckSpinLock(SpinLock, CheckData, 1);
265#endif
266 CheckData->Release(SpinLock, CheckData);
267#ifdef _M_IX86
269 CheckSpinLock(SpinLock, CheckData, 0);
270#endif
271
272 if (CheckData->TryAcquire)
273 {
274 CheckSpinLock(SpinLock, CheckData, 0);
275 ok_bool_true(CheckData->TryAcquire(SpinLock, CheckData), "TryAcquire returned");
276 CheckSpinLock(SpinLock, CheckData, 1);
277 /* A second TryToAcquire results in SPINLOCK_ALREADY_OWNED on checked builds */
279 {
281 {
282 /* In MP, this fails as you would expect */
283 ok_bool_false(CheckData->TryAcquire(SpinLock, CheckData), "TryAcquire returned");
284 }
285 else
286 {
287 /* In UP, this always succeeds: recursive acquires are illegal and parallel processors don't exist */
288 ok_bool_true(CheckData->TryAcquire(SpinLock, CheckData), "TryAcquire returned");
289 ok_eq_uint(CheckData->Irql, CheckData->IrqlWhenAcquired);
290 CheckData->Irql = CheckData->OriginalIrql;
291 }
292 CheckSpinLock(SpinLock, CheckData, 1);
293 }
294 CheckData->Release(SpinLock, CheckData);
295 CheckSpinLock(SpinLock, CheckData, 0);
296 }
297
298 if (CheckData->AcquireNoRaise &&
299 (CheckData->OriginalIrql >= DISPATCH_LEVEL || !KmtIsCheckedBuild) &&
300 (CheckData->AcquireNoRaise != AcquireInStackForDpc ||
301 !skip(pKeAcquireInStackQueuedSpinLockForDpc &&
302 pKeReleaseInStackQueuedSpinLockForDpc, "No DPC spinlock functions\n")))
303 {
304 /* acquire/release without irql change */
305 CheckData->AcquireNoRaise(SpinLock, CheckData);
306#ifdef _M_IX86
307 // Fails on x64 and Windows 8+
309 CheckSpinLock(SpinLock, CheckData, 1);
310#endif
311 CheckData->ReleaseNoLower(SpinLock, CheckData);
312 CheckSpinLock(SpinLock, CheckData, 0);
313
314 /* acquire without raise, but normal release */
315 CheckData->AcquireNoRaise(SpinLock, CheckData);
316#ifdef _M_IX86
317 // Fails on x64 and Windows 8+
319 CheckSpinLock(SpinLock, CheckData, 1);
320#endif
321 CheckData->Release(SpinLock, CheckData);
322 CheckSpinLock(SpinLock, CheckData, 0);
323
324 /* acquire normally but release without lower */
325 CheckData->Acquire(SpinLock, CheckData);
326#ifdef _M_IX86
327 // Fails on x64 and Windows 8+
329 CheckSpinLock(SpinLock, CheckData, 1);
330#endif
331 CheckData->ReleaseNoLower(SpinLock, CheckData);
332 CheckSpinLock(SpinLock, CheckData, 0);
333 CheckData->IsAcquired = FALSE;
334 KmtSetIrql(CheckData->OriginalIrql);
335
336 if (CheckData->TryAcquireNoRaise &&
337 !skip(pKeTryToAcquireSpinLockAtDpcLevel != NULL, "KeTryToAcquireSpinLockAtDpcLevel unavailable\n"))
338 {
339 CheckSpinLock(SpinLock, CheckData, 0);
340 ok_bool_true(CheckData->TryAcquireNoRaise(SpinLock, CheckData), "TryAcquireNoRaise returned");
341 CheckSpinLock(SpinLock, CheckData, 1);
343 {
345 {
346 /* In MP, this fails as you would expect */
347 ok_bool_false(CheckData->TryAcquireNoRaise(SpinLock, CheckData), "TryAcquireNoRaise returned");
348 }
349 else
350 {
351 /* In UP, this always succeeds: recursive acquires are illegal and parallel processors don't exist */
352 ok_bool_true(CheckData->TryAcquireNoRaise(SpinLock, CheckData), "TryAcquireNoRaise returned");
353 }
354 CheckSpinLock(SpinLock, CheckData, 1);
355 }
356 CheckData->ReleaseNoLower(SpinLock, CheckData);
357 CheckSpinLock(SpinLock, CheckData, 0);
358 }
359 }
360
361 ok_irql(CheckData->OriginalIrql);
362 /* make sure we survive this in case of error */
363 KmtSetIrql(CheckData->OriginalIrql);
364}
#define CheckSpinLock(SpinLock, CheckData, Value)
Definition: KeSpinLock.c:221
#define ok_eq_uint(value, expected)
Definition: apitest.h:46
#define trace
Definition: atltest.h:70
Definition: bidi.c:434
int32_t INT
Definition: typedefs.h:58

Referenced by START_TEST().

◆ TryNoRaise()

BOOLEAN TryNoRaise ( PKSPIN_LOCK  SpinLock,
PCHECK_DATA  CheckData 
)

Definition at line 162 of file KeSpinLock.c.

162 {
163 BOOLEAN Ret = pKeTryToAcquireSpinLockAtDpcLevel(SpinLock);
164 return Ret;
165}

Referenced by START_TEST().

◆ TryQueuedSynch()

BOOLEAN TryQueuedSynch ( PKSPIN_LOCK  SpinLock,
PCHECK_DATA  CheckData 
)

Definition at line 157 of file KeSpinLock.c.

157 {
158 BOOLEAN Ret = KeTryToAcquireQueuedSpinLockRaiseToSynch(CheckData->QueueNumber, &CheckData->Irql);
159 CheckData->IsAcquired = TRUE;
160 return Ret;
161}
BOOLEAN FASTCALL KeTryToAcquireQueuedSpinLockRaiseToSynch(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber, IN PKIRQL OldIrql)
Definition: spinlock.c:177

Referenced by START_TEST().