[tfaber] 66281: [KMTESTS] - Add KmtGetSystemRoutineAddress and use it to avoid importing functions that are not available in some versions of Windows. This allows running kmtests on Windows XP SP3 ...
Author: tfaber Date: Sun Feb 15 10:23:21 2015 New Revision: 66281
URL: http://svn.reactos.org/svn/reactos?rev=66281&view=rev Log: [KMTESTS] - Add KmtGetSystemRoutineAddress and use it to avoid importing functions that are not available in some versions of Windows. This allows running kmtests on Windows XP SP3 (and probably Server 2003 SP0/SP2). Note that failures on XP are still not valid bugs, this is purely for convenience! Dedicated to Jérôme. ROSTESTS-150
Modified: trunk/rostests/kmtests/include/kmt_test.h trunk/rostests/kmtests/include/kmt_test_kernel.h trunk/rostests/kmtests/kmtest_drv/testlist.c trunk/rostests/kmtests/ntos_ex/ExFastMutex.c trunk/rostests/kmtests/ntos_ex/ExResource.c trunk/rostests/kmtests/ntos_ke/KeApc.c trunk/rostests/kmtests/ntos_ke/KeGuardedMutex.c trunk/rostests/kmtests/ntos_ke/KeMutex.c trunk/rostests/kmtests/ntos_ke/KeSpinLock.c
Modified: trunk/rostests/kmtests/include/kmt_test.h URL: http://svn.reactos.org/svn/reactos/trunk/rostests/kmtests/include/kmt_test.h... ============================================================================== --- trunk/rostests/kmtests/include/kmt_test.h [iso-8859-1] (original) +++ trunk/rostests/kmtests/include/kmt_test.h [iso-8859-1] Sun Feb 15 10:23:21 2015 @@ -132,6 +132,7 @@ BOOLEAN KmtAreInterruptsEnabled(VOID); ULONG KmtGetPoolTag(PVOID Memory); USHORT KmtGetPoolType(PVOID Memory); +PVOID KmtGetSystemRoutineAddress(IN PCWSTR RoutineName); PKTHREAD KmtStartThread(IN PKSTART_ROUTINE StartRoutine, IN PVOID StartContext OPTIONAL); VOID KmtFinishThread(IN PKTHREAD Thread OPTIONAL, IN PKEVENT Event OPTIONAL); #elif defined KMT_USER_MODE
Modified: trunk/rostests/kmtests/include/kmt_test_kernel.h URL: http://svn.reactos.org/svn/reactos/trunk/rostests/kmtests/include/kmt_test_k... ============================================================================== --- trunk/rostests/kmtests/include/kmt_test_kernel.h [iso-8859-1] (original) +++ trunk/rostests/kmtests/include/kmt_test_kernel.h [iso-8859-1] Sun Feb 15 10:23:21 2015 @@ -126,6 +126,13 @@ return Header->PoolType; }
+PVOID KmtGetSystemRoutineAddress(IN PCWSTR RoutineName) +{ + UNICODE_STRING RoutineNameString; + RtlInitUnicodeString(&RoutineNameString, (PWSTR)RoutineName); + return MmGetSystemRoutineAddress(&RoutineNameString); +} + PKTHREAD KmtStartThread(IN PKSTART_ROUTINE StartRoutine, IN PVOID StartContext OPTIONAL) { NTSTATUS Status;
Modified: trunk/rostests/kmtests/kmtest_drv/testlist.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/kmtests/kmtest_drv/testlis... ============================================================================== --- trunk/rostests/kmtests/kmtest_drv/testlist.c [iso-8859-1] (original) +++ trunk/rostests/kmtests/kmtest_drv/testlist.c [iso-8859-1] Sun Feb 15 10:23:21 2015 @@ -94,7 +94,7 @@ { "KeIrql", Test_KeIrql }, { "KeMutex", Test_KeMutex }, { "-KeProcessor", Test_KeProcessor }, - { "KeSpinLock", Test_KeSpinLock }, + { "KeSpinLock", Test_KeSpinLock }, { "KeTimer", Test_KeTimer }, { "-KernelType", Test_KernelType }, { "MmSection", Test_MmSection },
Modified: trunk/rostests/kmtests/ntos_ex/ExFastMutex.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/kmtests/ntos_ex/ExFastMute... ============================================================================== --- trunk/rostests/kmtests/ntos_ex/ExFastMutex.c [iso-8859-1] (original) +++ trunk/rostests/kmtests/ntos_ex/ExFastMutex.c [iso-8859-1] Sun Feb 15 10:23:21 2015 @@ -10,9 +10,23 @@ //#define NDEBUG #include <debug.h>
-NTKERNELAPI VOID FASTCALL ExiAcquireFastMutex(IN OUT PFAST_MUTEX FastMutex); -NTKERNELAPI VOID FASTCALL ExiReleaseFastMutex(IN OUT PFAST_MUTEX FastMutex); -NTKERNELAPI BOOLEAN FASTCALL ExiTryToAcquireFastMutex(IN OUT PFAST_MUTEX FastMutex); +static +VOID +(FASTCALL +*pExEnterCriticalRegionAndAcquireFastMutexUnsafe)( + _Inout_ PFAST_MUTEX FastMutex +); + +static +VOID +(FASTCALL +*pExReleaseFastMutexUnsafeAndLeaveCriticalRegion)( + _Inout_ PFAST_MUTEX FastMutex +); + +static VOID (FASTCALL *pExiAcquireFastMutex)(IN OUT PFAST_MUTEX FastMutex); +static VOID (FASTCALL *pExiReleaseFastMutex)(IN OUT PFAST_MUTEX FastMutex); +static BOOLEAN (FASTCALL *pExiTryToAcquireFastMutex)(IN OUT PFAST_MUTEX FastMutex);
#define CheckMutex(Mutex, ExpectedCount, ExpectedOwner, \ ExpectedContention, ExpectedOldIrql, \ @@ -44,15 +58,18 @@ ExReleaseFastMutex(Mutex); CheckMutex(Mutex, 1L, NULL, 0LU, OriginalIrql, OriginalIrql);
-#ifdef _M_IX86 /* ntoskrnl's fastcall version */ - ExiAcquireFastMutex(Mutex); - CheckMutex(Mutex, 0L, Thread, 0LU, OriginalIrql, APC_LEVEL); - ok_bool_false(ExiTryToAcquireFastMutex(Mutex), "ExiTryToAcquireFastMutex returned"); - CheckMutex(Mutex, 0L, Thread, 0LU, OriginalIrql, APC_LEVEL); - ExiReleaseFastMutex(Mutex); - CheckMutex(Mutex, 1L, NULL, 0LU, OriginalIrql, OriginalIrql); -#endif + if (!skip(pExiAcquireFastMutex && + pExiReleaseFastMutex && + pExiTryToAcquireFastMutex, "No fastcall fast mutex functions\n")) + { + pExiAcquireFastMutex(Mutex); + CheckMutex(Mutex, 0L, Thread, 0LU, OriginalIrql, APC_LEVEL); + ok_bool_false(pExiTryToAcquireFastMutex(Mutex), "ExiTryToAcquireFastMutex returned"); + CheckMutex(Mutex, 0L, Thread, 0LU, OriginalIrql, APC_LEVEL); + pExiReleaseFastMutex(Mutex); + CheckMutex(Mutex, 1L, NULL, 0LU, OriginalIrql, OriginalIrql); + }
/* try to acquire */ ok_bool_true(ExTryToAcquireFastMutex(Mutex), "ExTryToAcquireFastMutex returned"); @@ -61,9 +78,14 @@ CheckMutex(Mutex, 1L, NULL, 0LU, OriginalIrql, OriginalIrql);
/* shortcut functions with critical region */ - ExEnterCriticalRegionAndAcquireFastMutexUnsafe(Mutex); - ok_bool_true(KeAreApcsDisabled(), "KeAreApcsDisabled returned"); - ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(Mutex); + if (!skip(pExEnterCriticalRegionAndAcquireFastMutexUnsafe && + pExReleaseFastMutexUnsafeAndLeaveCriticalRegion, + "Shortcut functions not available")) + { + pExEnterCriticalRegionAndAcquireFastMutexUnsafe(Mutex); + ok_bool_true(KeAreApcsDisabled(), "KeAreApcsDisabled returned"); + pExReleaseFastMutexUnsafeAndLeaveCriticalRegion(Mutex); + }
/* acquire/release unsafe */ if (!KmtIsCheckedBuild || OriginalIrql == APC_LEVEL) @@ -291,6 +313,13 @@ FAST_MUTEX Mutex; KIRQL Irql;
+ pExEnterCriticalRegionAndAcquireFastMutexUnsafe = KmtGetSystemRoutineAddress(L"ExEnterCriticalRegionAndAcquireFastMutexUnsafe"); + pExReleaseFastMutexUnsafeAndLeaveCriticalRegion = KmtGetSystemRoutineAddress(L"ExReleaseFastMutexUnsafeAndLeaveCriticalRegion"); + + pExiAcquireFastMutex = KmtGetSystemRoutineAddress(L"ExiAcquireFastMutex"); + pExiReleaseFastMutex = KmtGetSystemRoutineAddress(L"ExiReleaseFastMutex"); + pExiTryToAcquireFastMutex = KmtGetSystemRoutineAddress(L"ExiTryToAcquireFastMutex"); + memset(&Mutex, 0x55, sizeof Mutex); ExInitializeFastMutex(&Mutex); CheckMutex(&Mutex, 1L, NULL, 0LU, 0x55555555LU, PASSIVE_LEVEL);
Modified: trunk/rostests/kmtests/ntos_ex/ExResource.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/kmtests/ntos_ex/ExResource... ============================================================================== --- trunk/rostests/kmtests/ntos_ex/ExResource.c [iso-8859-1] (original) +++ trunk/rostests/kmtests/ntos_ex/ExResource.c [iso-8859-1] Sun Feb 15 10:23:21 2015 @@ -9,6 +9,49 @@
//#define NDEBUG #include <debug.h> + +static +_IRQL_requires_max_(APC_LEVEL) +_Acquires_lock_(_Global_critical_region_) +PVOID +(NTAPI +*pExEnterCriticalRegionAndAcquireResourceShared)( + _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_shared_lock_(*_Curr_) + PERESOURCE Resource); + +static +_IRQL_requires_max_(APC_LEVEL) +_Acquires_lock_(_Global_critical_region_) +PVOID +(NTAPI +*pExEnterCriticalRegionAndAcquireResourceExclusive)( + _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_exclusive_lock_(*_Curr_) + PERESOURCE Resource); + +static +_IRQL_requires_max_(APC_LEVEL) +_Acquires_lock_(_Global_critical_region_) +PVOID +(NTAPI +*pExEnterCriticalRegionAndAcquireSharedWaitForExclusive)( + _Inout_ _Requires_lock_not_held_(*_Curr_) _Acquires_lock_(*_Curr_) + PERESOURCE Resource); + +static +_IRQL_requires_max_(DISPATCH_LEVEL) +_Releases_lock_(_Global_critical_region_) +VOID +(FASTCALL +*pExReleaseResourceAndLeaveCriticalRegion)( + _Inout_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_) + PERESOURCE Resource); + +static +_IRQL_requires_min_(PASSIVE_LEVEL) +_IRQL_requires_max_(DISPATCH_LEVEL) +BOOLEAN +(NTAPI +*pKeAreAllApcsDisabled)(VOID);
/* TODO: This is getting pretty long, make it somehow easier to read if possible */
@@ -137,65 +180,83 @@ LONG Count = 0;
ok_bool_false(KeAreApcsDisabled(), "KeAreApcsDisabled returned"); - ok_eq_uint(KeAreAllApcsDisabled(), AreApcsDisabled); - + if (pKeAreAllApcsDisabled) + ok_eq_uint(pKeAreAllApcsDisabled(), AreApcsDisabled); + + if (skip(pExEnterCriticalRegionAndAcquireResourceShared && + pExEnterCriticalRegionAndAcquireSharedWaitForExclusive && + pExEnterCriticalRegionAndAcquireResourceExclusive && + pExReleaseResourceAndLeaveCriticalRegion, "No shortcuts\n")) + { + return; + } /* ExEnterCriticalRegionAndAcquireResourceShared, ExEnterCriticalRegionAndAcquireSharedWaitForExclusive */ Count = 0; - Ret = ExEnterCriticalRegionAndAcquireResourceShared(Res); ++Count; + Ret = pExEnterCriticalRegionAndAcquireResourceShared(Res); ++Count; ok_eq_pointer(Ret, KeGetCurrentThread()->Win32Thread); ok_bool_true(KeAreApcsDisabled(), "KeAreApcsDisabled returned"); - ok_eq_bool(KeAreAllApcsDisabled(), AreApcsDisabled); - CheckResourceStatus(Res, FALSE, Count, 0LU, 0LU); - - Ret = ExEnterCriticalRegionAndAcquireResourceShared(Res); ++Count; + if (pKeAreAllApcsDisabled) + ok_eq_bool(pKeAreAllApcsDisabled(), AreApcsDisabled); + CheckResourceStatus(Res, FALSE, Count, 0LU, 0LU); + + Ret = pExEnterCriticalRegionAndAcquireResourceShared(Res); ++Count; ok_eq_pointer(Ret, KeGetCurrentThread()->Win32Thread); ok_bool_true(KeAreApcsDisabled(), "KeAreApcsDisabled returned"); - ok_eq_bool(KeAreAllApcsDisabled(), AreApcsDisabled); - CheckResourceStatus(Res, FALSE, Count, 0LU, 0LU); - - ExEnterCriticalRegionAndAcquireSharedWaitForExclusive(Res); ++Count; + if (pKeAreAllApcsDisabled) + ok_eq_bool(pKeAreAllApcsDisabled(), AreApcsDisabled); + CheckResourceStatus(Res, FALSE, Count, 0LU, 0LU); + + pExEnterCriticalRegionAndAcquireSharedWaitForExclusive(Res); ++Count; ok_eq_pointer(Ret, KeGetCurrentThread()->Win32Thread); ok_bool_true(KeAreApcsDisabled(), "KeAreApcsDisabled returned"); - ok_eq_bool(KeAreAllApcsDisabled(), AreApcsDisabled); + if (pKeAreAllApcsDisabled) + ok_eq_bool(pKeAreAllApcsDisabled(), AreApcsDisabled); CheckResourceStatus(Res, FALSE, Count, 0LU, 0LU);
while (Count-- > 1) { - ExReleaseResourceAndLeaveCriticalRegion(Res); + pExReleaseResourceAndLeaveCriticalRegion(Res); ok_bool_true(KeAreApcsDisabled(), "KeAreApcsDisabled returned"); - ok_eq_bool(KeAreAllApcsDisabled(), AreApcsDisabled); + if (pKeAreAllApcsDisabled) + ok_eq_bool(pKeAreAllApcsDisabled(), AreApcsDisabled); CheckResourceStatus(Res, FALSE, Count, 0LU, 0LU); }
- ExReleaseResourceAndLeaveCriticalRegion(Res); + pExReleaseResourceAndLeaveCriticalRegion(Res); ok_bool_false(KeAreApcsDisabled(), "KeAreApcsDisabled returned"); - ok_eq_bool(KeAreAllApcsDisabled(), AreApcsDisabled); + if (pKeAreAllApcsDisabled) + ok_eq_bool(pKeAreAllApcsDisabled(), AreApcsDisabled); CheckResourceStatus(Res, FALSE, Count, 0LU, 0LU);
/* ExEnterCriticalRegionAndAcquireResourceExclusive */ Count = 0; ok_bool_false(KeAreApcsDisabled(), "KeAreApcsDisabled returned"); - ok_eq_bool(KeAreAllApcsDisabled(), AreApcsDisabled); - Ret = ExEnterCriticalRegionAndAcquireResourceExclusive(Res); ++Count; + if (pKeAreAllApcsDisabled) + ok_eq_bool(pKeAreAllApcsDisabled(), AreApcsDisabled); + Ret = pExEnterCriticalRegionAndAcquireResourceExclusive(Res); ++Count; ok_eq_pointer(Ret, KeGetCurrentThread()->Win32Thread); ok_bool_true(KeAreApcsDisabled(), "KeAreApcsDisabled returned"); - ok_eq_bool(KeAreAllApcsDisabled(), AreApcsDisabled); + if (pKeAreAllApcsDisabled) + ok_eq_bool(pKeAreAllApcsDisabled(), AreApcsDisabled); CheckResourceStatus(Res, TRUE, Count, 0LU, 0LU);
- Ret = ExEnterCriticalRegionAndAcquireResourceExclusive(Res); ++Count; + Ret = pExEnterCriticalRegionAndAcquireResourceExclusive(Res); ++Count; ok_eq_pointer(Ret, KeGetCurrentThread()->Win32Thread); ok_bool_true(KeAreApcsDisabled(), "KeAreApcsDisabled returned"); - ok_eq_bool(KeAreAllApcsDisabled(), AreApcsDisabled); + if (pKeAreAllApcsDisabled) + ok_eq_bool(pKeAreAllApcsDisabled(), AreApcsDisabled); CheckResourceStatus(Res, TRUE, Count, 0LU, 0LU);
- ExReleaseResourceAndLeaveCriticalRegion(Res); --Count; + pExReleaseResourceAndLeaveCriticalRegion(Res); --Count; ok_bool_true(KeAreApcsDisabled(), "KeAreApcsDisabled returned"); - ok_eq_bool(KeAreAllApcsDisabled(), AreApcsDisabled); + if (pKeAreAllApcsDisabled) + ok_eq_bool(pKeAreAllApcsDisabled(), AreApcsDisabled); CheckResourceStatus(Res, TRUE, Count, 0LU, 0LU);
- ExReleaseResourceAndLeaveCriticalRegion(Res); --Count; + pExReleaseResourceAndLeaveCriticalRegion(Res); --Count; ok_bool_false(KeAreApcsDisabled(), "KeAreApcsDisabled returned"); - ok_eq_uint(KeAreAllApcsDisabled(), AreApcsDisabled); + if (pKeAreAllApcsDisabled) + ok_eq_uint(pKeAreAllApcsDisabled(), AreApcsDisabled); CheckResourceStatus(Res, FALSE, Count, 0LU, 0LU); }
@@ -400,6 +461,17 @@ ERESOURCE Res; KIRQL Irql;
+ pExEnterCriticalRegionAndAcquireResourceShared = KmtGetSystemRoutineAddress(L"ExEnterCriticalRegionAndAcquireResourceShared"); + pExEnterCriticalRegionAndAcquireSharedWaitForExclusive = KmtGetSystemRoutineAddress(L"ExEnterCriticalRegionAndAcquireSharedWaitForExclusive"); + pExEnterCriticalRegionAndAcquireResourceExclusive = KmtGetSystemRoutineAddress(L"ExEnterCriticalRegionAndAcquireResourceExclusive"); + pExReleaseResourceAndLeaveCriticalRegion = KmtGetSystemRoutineAddress(L"ExReleaseResourceAndLeaveCriticalRegion"); + pKeAreAllApcsDisabled = KmtGetSystemRoutineAddress(L"KeAreAllApcsDisabled"); + + if (skip(pKeAreAllApcsDisabled != NULL, "KeAreAllApcsDisabled unavailable\n")) + { + /* We can live without this function here */ + } + /* this must be true even with the different structure versions */ ASSERT(sizeof(ERESOURCE) == sizeof(ERESOURCE_2K3));
Modified: trunk/rostests/kmtests/ntos_ke/KeApc.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/kmtests/ntos_ke/KeApc.c?re... ============================================================================== --- trunk/rostests/kmtests/ntos_ke/KeApc.c [iso-8859-1] (original) +++ trunk/rostests/kmtests/ntos_ke/KeApc.c [iso-8859-1] Sun Feb 15 10:23:21 2015 @@ -7,11 +7,33 @@
#include <kmt_test.h>
+static +_IRQL_requires_min_(PASSIVE_LEVEL) +_IRQL_requires_max_(DISPATCH_LEVEL) +BOOLEAN +(NTAPI +*pKeAreAllApcsDisabled)(VOID); + +static +_Acquires_lock_(_Global_critical_region_) +_IRQL_requires_max_(APC_LEVEL) +VOID +(NTAPI +*pKeEnterGuardedRegion)(VOID); + +static +_Releases_lock_(_Global_critical_region_) +_IRQL_requires_max_(APC_LEVEL) +VOID +(NTAPI +*pKeLeaveGuardedRegion)(VOID); + #define CheckApcs(KernelApcsDisabled, SpecialApcsDisabled, AllApcsDisabled, Irql) do \ { \ ok_eq_bool(KeAreApcsDisabled(), KernelApcsDisabled || SpecialApcsDisabled); \ ok_eq_int(Thread->KernelApcDisable, KernelApcsDisabled); \ - ok_eq_bool(KeAreAllApcsDisabled(), AllApcsDisabled); \ + if (pKeAreAllApcsDisabled) \ + ok_eq_bool(pKeAreAllApcsDisabled(), AllApcsDisabled); \ ok_eq_int(Thread->SpecialApcDisable, SpecialApcsDisabled); \ ok_irql(Irql); \ } while (0) @@ -19,7 +41,18 @@ START_TEST(KeApc) { KIRQL Irql; - PKTHREAD Thread = KeGetCurrentThread(); + PKTHREAD Thread; + + pKeAreAllApcsDisabled = KmtGetSystemRoutineAddress(L"KeAreAllApcsDisabled"); + pKeEnterGuardedRegion = KmtGetSystemRoutineAddress(L"KeEnterGuardedRegion"); + pKeLeaveGuardedRegion = KmtGetSystemRoutineAddress(L"KeLeaveGuardedRegion"); + + if (skip(pKeAreAllApcsDisabled != NULL, "KeAreAllApcsDisabled unavailable\n")) + { + /* We can live without this function here */ + } + + Thread = KeGetCurrentThread();
CheckApcs(0, 0, FALSE, PASSIVE_LEVEL);
@@ -38,37 +71,41 @@ CheckApcs(0, 0, FALSE, PASSIVE_LEVEL);
/* guarded region */ - KeEnterGuardedRegion(); - CheckApcs(0, -1, TRUE, PASSIVE_LEVEL); - KeEnterGuardedRegion(); - CheckApcs(0, -2, TRUE, PASSIVE_LEVEL); - KeEnterGuardedRegion(); - CheckApcs(0, -3, TRUE, PASSIVE_LEVEL); - KeLeaveGuardedRegion(); - CheckApcs(0, -2, TRUE, PASSIVE_LEVEL); - KeLeaveGuardedRegion(); - CheckApcs(0, -1, TRUE, PASSIVE_LEVEL); - KeLeaveGuardedRegion(); - CheckApcs(0, 0, FALSE, PASSIVE_LEVEL); - - /* mix them */ - KeEnterGuardedRegion(); - CheckApcs(0, -1, TRUE, PASSIVE_LEVEL); - KeEnterCriticalRegion(); - CheckApcs(-1, -1, TRUE, PASSIVE_LEVEL); - KeLeaveCriticalRegion(); - CheckApcs(0, -1, TRUE, PASSIVE_LEVEL); - KeLeaveGuardedRegion(); - CheckApcs(0, 0, FALSE, PASSIVE_LEVEL); - - KeEnterCriticalRegion(); - CheckApcs(-1, 0, FALSE, PASSIVE_LEVEL); - KeEnterGuardedRegion(); - CheckApcs(-1, -1, TRUE, PASSIVE_LEVEL); - KeLeaveGuardedRegion(); - CheckApcs(-1, 0, FALSE, PASSIVE_LEVEL); - KeLeaveCriticalRegion(); - CheckApcs(0, 0, FALSE, PASSIVE_LEVEL); + if (!skip(pKeEnterGuardedRegion && + pKeLeaveGuardedRegion, "Guarded regions not available\n")) + { + pKeEnterGuardedRegion(); + CheckApcs(0, -1, TRUE, PASSIVE_LEVEL); + pKeEnterGuardedRegion(); + CheckApcs(0, -2, TRUE, PASSIVE_LEVEL); + pKeEnterGuardedRegion(); + CheckApcs(0, -3, TRUE, PASSIVE_LEVEL); + pKeLeaveGuardedRegion(); + CheckApcs(0, -2, TRUE, PASSIVE_LEVEL); + pKeLeaveGuardedRegion(); + CheckApcs(0, -1, TRUE, PASSIVE_LEVEL); + pKeLeaveGuardedRegion(); + CheckApcs(0, 0, FALSE, PASSIVE_LEVEL); + + /* mix them */ + pKeEnterGuardedRegion(); + CheckApcs(0, -1, TRUE, PASSIVE_LEVEL); + KeEnterCriticalRegion(); + CheckApcs(-1, -1, TRUE, PASSIVE_LEVEL); + KeLeaveCriticalRegion(); + CheckApcs(0, -1, TRUE, PASSIVE_LEVEL); + pKeLeaveGuardedRegion(); + CheckApcs(0, 0, FALSE, PASSIVE_LEVEL); + + KeEnterCriticalRegion(); + CheckApcs(-1, 0, FALSE, PASSIVE_LEVEL); + pKeEnterGuardedRegion(); + CheckApcs(-1, -1, TRUE, PASSIVE_LEVEL); + pKeLeaveGuardedRegion(); + CheckApcs(-1, 0, FALSE, PASSIVE_LEVEL); + KeLeaveCriticalRegion(); + CheckApcs(0, 0, FALSE, PASSIVE_LEVEL); + }
/* leave without entering */ if (!KmtIsCheckedBuild) @@ -78,19 +115,23 @@ KeEnterCriticalRegion(); CheckApcs(0, 0, FALSE, PASSIVE_LEVEL);
- KeLeaveGuardedRegion(); - CheckApcs(0, 1, TRUE, PASSIVE_LEVEL); - KeEnterGuardedRegion(); - CheckApcs(0, 0, FALSE, PASSIVE_LEVEL); - - KeLeaveCriticalRegion(); - CheckApcs(1, 0, FALSE, PASSIVE_LEVEL); - KeLeaveGuardedRegion(); - CheckApcs(1, 1, TRUE, PASSIVE_LEVEL); - KeEnterCriticalRegion(); - CheckApcs(0, 1, TRUE, PASSIVE_LEVEL); - KeEnterGuardedRegion(); - CheckApcs(0, 0, FALSE, PASSIVE_LEVEL); + if (!skip(pKeEnterGuardedRegion && + pKeLeaveGuardedRegion, "Guarded regions not available\n")) + { + pKeLeaveGuardedRegion(); + CheckApcs(0, 1, TRUE, PASSIVE_LEVEL); + pKeEnterGuardedRegion(); + CheckApcs(0, 0, FALSE, PASSIVE_LEVEL); + + KeLeaveCriticalRegion(); + CheckApcs(1, 0, FALSE, PASSIVE_LEVEL); + pKeLeaveGuardedRegion(); + CheckApcs(1, 1, TRUE, PASSIVE_LEVEL); + KeEnterCriticalRegion(); + CheckApcs(0, 1, TRUE, PASSIVE_LEVEL); + pKeEnterGuardedRegion(); + CheckApcs(0, 0, FALSE, PASSIVE_LEVEL); + } }
/* manually disable APCs */ @@ -130,38 +171,42 @@ CheckApcs(0, 0, TRUE, HIGH_LEVEL);
/* Ke*GuardedRegion assert at > APC_LEVEL */ - if (!KmtIsCheckedBuild) + if (!KmtIsCheckedBuild && + !skip(pKeEnterGuardedRegion && + pKeLeaveGuardedRegion, "Guarded regions not available\n")) { - KeEnterGuardedRegion(); + pKeEnterGuardedRegion(); CheckApcs(0, -1, TRUE, HIGH_LEVEL); - KeLeaveGuardedRegion(); + pKeLeaveGuardedRegion(); } CheckApcs(0, 0, TRUE, HIGH_LEVEL); KeLowerIrql(Irql); CheckApcs(0, 0, FALSE, PASSIVE_LEVEL);
- if (!KmtIsCheckedBuild) + if (!KmtIsCheckedBuild && + !skip(pKeEnterGuardedRegion && + pKeLeaveGuardedRegion, "Guarded regions not available\n")) { KeRaiseIrql(HIGH_LEVEL, &Irql); CheckApcs(0, 0, TRUE, HIGH_LEVEL); KeEnterCriticalRegion(); CheckApcs(-1, 0, TRUE, HIGH_LEVEL); - KeEnterGuardedRegion(); + pKeEnterGuardedRegion(); CheckApcs(-1, -1, TRUE, HIGH_LEVEL); KeLowerIrql(Irql); CheckApcs(-1, -1, TRUE, PASSIVE_LEVEL); KeLeaveCriticalRegion(); CheckApcs(0, -1, TRUE, PASSIVE_LEVEL); - KeLeaveGuardedRegion(); - CheckApcs(0, 0, FALSE, PASSIVE_LEVEL); - - KeEnterGuardedRegion(); + pKeLeaveGuardedRegion(); + CheckApcs(0, 0, FALSE, PASSIVE_LEVEL); + + pKeEnterGuardedRegion(); CheckApcs(0, -1, TRUE, PASSIVE_LEVEL); KeRaiseIrql(HIGH_LEVEL, &Irql); CheckApcs(0, -1, TRUE, HIGH_LEVEL); KeEnterCriticalRegion(); CheckApcs(-1, -1, TRUE, HIGH_LEVEL); - KeLeaveGuardedRegion(); + pKeLeaveGuardedRegion(); CheckApcs(-1, 0, TRUE, HIGH_LEVEL); KeLowerIrql(Irql); CheckApcs(-1, 0, FALSE, PASSIVE_LEVEL); @@ -172,13 +217,13 @@ CheckApcs(-1, 0, FALSE, PASSIVE_LEVEL); KeRaiseIrql(HIGH_LEVEL, &Irql); CheckApcs(-1, 0, TRUE, HIGH_LEVEL); - KeEnterGuardedRegion(); + pKeEnterGuardedRegion(); CheckApcs(-1, -1, TRUE, HIGH_LEVEL); KeLeaveCriticalRegion(); CheckApcs(0, -1, TRUE, HIGH_LEVEL); KeLowerIrql(Irql); CheckApcs(0, -1, TRUE, PASSIVE_LEVEL); - KeLeaveGuardedRegion(); + pKeLeaveGuardedRegion(); CheckApcs(0, 0, FALSE, PASSIVE_LEVEL); }
Modified: trunk/rostests/kmtests/ntos_ke/KeGuardedMutex.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/kmtests/ntos_ke/KeGuardedM... ============================================================================== --- trunk/rostests/kmtests/ntos_ke/KeGuardedMutex.c [iso-8859-1] (original) +++ trunk/rostests/kmtests/ntos_ke/KeGuardedMutex.c [iso-8859-1] Sun Feb 15 10:23:21 2015 @@ -9,6 +9,86 @@
#define NDEBUG #include <debug.h> + +static +_IRQL_requires_min_(PASSIVE_LEVEL) +_IRQL_requires_max_(DISPATCH_LEVEL) +BOOLEAN +(NTAPI +*pKeAreAllApcsDisabled)(VOID); + +static +_Acquires_lock_(_Global_critical_region_) +_Requires_lock_not_held_(*Mutex) +_Acquires_lock_(*Mutex) +_IRQL_requires_max_(APC_LEVEL) +_IRQL_requires_min_(PASSIVE_LEVEL) +VOID +(FASTCALL +*pKeAcquireGuardedMutex)( + _Inout_ PKGUARDED_MUTEX GuardedMutex); + +static +_Requires_lock_not_held_(*FastMutex) +_Acquires_lock_(*FastMutex) +_IRQL_requires_max_(APC_LEVEL) +_IRQL_requires_min_(PASSIVE_LEVEL) +VOID +(FASTCALL +*pKeAcquireGuardedMutexUnsafe)( + _Inout_ PKGUARDED_MUTEX GuardedMutex); + +static +_Acquires_lock_(_Global_critical_region_) +_IRQL_requires_max_(APC_LEVEL) +VOID +(NTAPI +*pKeEnterGuardedRegion)(VOID); + +static +_Releases_lock_(_Global_critical_region_) +_IRQL_requires_max_(APC_LEVEL) +VOID +(NTAPI +*pKeLeaveGuardedRegion)(VOID); + +static +_IRQL_requires_max_(APC_LEVEL) +_IRQL_requires_min_(PASSIVE_LEVEL) +VOID +(FASTCALL +*pKeInitializeGuardedMutex)( + _Out_ PKGUARDED_MUTEX GuardedMutex); + +static +_Requires_lock_held_(*FastMutex) +_Releases_lock_(*FastMutex) +_IRQL_requires_max_(APC_LEVEL) +VOID +(FASTCALL +*pKeReleaseGuardedMutexUnsafe)( + _Inout_ PKGUARDED_MUTEX GuardedMutex); + +static +_Releases_lock_(_Global_critical_region_) +_Requires_lock_held_(*Mutex) +_Releases_lock_(*Mutex) +_IRQL_requires_max_(APC_LEVEL) +VOID +(FASTCALL +*pKeReleaseGuardedMutex)( + _Inout_ PKGUARDED_MUTEX GuardedMutex); + +static +_Must_inspect_result_ +_Success_(return != FALSE) +_IRQL_requires_max_(APC_LEVEL) +_Post_satisfies_(return == 1 || return == 0) +BOOLEAN +(FASTCALL +*pKeTryToAcquireGuardedMutex)( + _When_ (return, _Requires_lock_not_held_(*_Curr_) _Acquires_exclusive_lock_(*_Curr_)) _Acquires_lock_(_Global_critical_region_) + _Inout_ PKGUARDED_MUTEX GuardedMutex);
#define CheckMutex(Mutex, ExpectedCount, ExpectedOwner, ExpectedContention, \ ExpectedKernelApcDisable, ExpectedSpecialApcDisable, \ @@ -25,7 +105,7 @@ ok_eq_int((Mutex)->SpecialApcDisable, 0x5555); \ ok_eq_bool(KeAreApcsDisabled(), KernelApcsDisabled || SpecialApcsDisabled); \ ok_eq_int(Thread->KernelApcDisable, KernelApcsDisabled); \ - ok_eq_bool(KeAreAllApcsDisabled(), AllApcsDisabled); \ + ok_eq_bool(pKeAreAllApcsDisabled(), AllApcsDisabled); \ ok_eq_int(Thread->SpecialApcDisable, SpecialApcsDisabled); \ ok_irql(ExpectedIrql); \ } while (0) @@ -48,17 +128,17 @@ if (!KmtIsCheckedBuild || OriginalIrql <= APC_LEVEL) { /* acquire/release normally */ - KeAcquireGuardedMutex(Mutex); + pKeAcquireGuardedMutex(Mutex); CheckMutex(Mutex, 0L, Thread, 0LU, 0x5555, SpecialApcsDisabled - 1, KernelApcsDisabled, SpecialApcsDisabled - 1, TRUE, OriginalIrql); - ok_bool_false(KeTryToAcquireGuardedMutex(Mutex), "KeTryToAcquireGuardedMutex returned"); + ok_bool_false(pKeTryToAcquireGuardedMutex(Mutex), "KeTryToAcquireGuardedMutex returned"); CheckMutex(Mutex, 0L, Thread, 0LU, 0x5555, SpecialApcsDisabled - 1, KernelApcsDisabled, SpecialApcsDisabled - 1, TRUE, OriginalIrql); - KeReleaseGuardedMutex(Mutex); + pKeReleaseGuardedMutex(Mutex); CheckMutex(Mutex, 1L, NULL, 0LU, 0x5555, SpecialApcsDisabled - 1, KernelApcsDisabled, SpecialApcsDisabled, AllApcsDisabled, OriginalIrql);
/* try to acquire */ - ok_bool_true(KeTryToAcquireGuardedMutex(Mutex), "KeTryToAcquireGuardedMutex returned"); + ok_bool_true(pKeTryToAcquireGuardedMutex(Mutex), "KeTryToAcquireGuardedMutex returned"); CheckMutex(Mutex, 0L, Thread, 0LU, 0x5555, SpecialApcsDisabled - 1, KernelApcsDisabled, SpecialApcsDisabled - 1, TRUE, OriginalIrql); - KeReleaseGuardedMutex(Mutex); + pKeReleaseGuardedMutex(Mutex); CheckMutex(Mutex, 1L, NULL, 0LU, 0x5555, SpecialApcsDisabled - 1, KernelApcsDisabled, SpecialApcsDisabled, AllApcsDisabled, OriginalIrql); } else @@ -69,9 +149,9 @@ if (!KmtIsCheckedBuild || OriginalIrql == APC_LEVEL || SpecialApcsDisabled < 0) { /* acquire/release unsafe */ - KeAcquireGuardedMutexUnsafe(Mutex); + pKeAcquireGuardedMutexUnsafe(Mutex); CheckMutex(Mutex, 0L, Thread, 0LU, 0x5555, SpecialApcsDisabled - 1, KernelApcsDisabled, SpecialApcsDisabled, AllApcsDisabled, OriginalIrql); - KeReleaseGuardedMutexUnsafe(Mutex); + pKeReleaseGuardedMutexUnsafe(Mutex); CheckMutex(Mutex, 1L, NULL, 0LU, 0x5555, SpecialApcsDisabled - 1, KernelApcsDisabled, SpecialApcsDisabled, AllApcsDisabled, OriginalIrql); }
@@ -79,29 +159,29 @@ if (!KmtIsCheckedBuild) { /* mismatched acquire/release */ - KeAcquireGuardedMutex(Mutex); + pKeAcquireGuardedMutex(Mutex); CheckMutex(Mutex, 0L, Thread, 0LU, 0x5555, SpecialApcsDisabled - 1, KernelApcsDisabled, SpecialApcsDisabled - 1, TRUE, OriginalIrql); - KeReleaseGuardedMutexUnsafe(Mutex); + pKeReleaseGuardedMutexUnsafe(Mutex); CheckMutex(Mutex, 1L, NULL, 0LU, 0x5555, SpecialApcsDisabled - 1, KernelApcsDisabled, SpecialApcsDisabled - 1, TRUE, OriginalIrql); - KeLeaveGuardedRegion(); + pKeLeaveGuardedRegion(); CheckMutex(Mutex, 1L, NULL, 0LU, 0x5555, SpecialApcsDisabled - 1, KernelApcsDisabled, SpecialApcsDisabled, AllApcsDisabled, OriginalIrql);
- KeAcquireGuardedMutexUnsafe(Mutex); + pKeAcquireGuardedMutexUnsafe(Mutex); CheckMutex(Mutex, 0L, Thread, 0LU, 0x5555, SpecialApcsDisabled - 1, KernelApcsDisabled, SpecialApcsDisabled, AllApcsDisabled, OriginalIrql); - KeReleaseGuardedMutex(Mutex); + pKeReleaseGuardedMutex(Mutex); CheckMutex(Mutex, 1L, NULL, 0LU, 0x5555, SpecialApcsDisabled - 1, KernelApcsDisabled, SpecialApcsDisabled + 1, OriginalIrql >= APC_LEVEL || SpecialApcsDisabled != -1, OriginalIrql); - KeEnterGuardedRegion(); + pKeEnterGuardedRegion(); CheckMutex(Mutex, 1L, NULL, 0LU, 0x5555, SpecialApcsDisabled - 1, KernelApcsDisabled, SpecialApcsDisabled, AllApcsDisabled, OriginalIrql);
/* release without acquire */ - KeReleaseGuardedMutexUnsafe(Mutex); + pKeReleaseGuardedMutexUnsafe(Mutex); CheckMutex(Mutex, 0L, NULL, 0LU, 0x5555, SpecialApcsDisabled - 1, KernelApcsDisabled, SpecialApcsDisabled, AllApcsDisabled, OriginalIrql); - KeReleaseGuardedMutex(Mutex); + pKeReleaseGuardedMutex(Mutex); CheckMutex(Mutex, 1L, NULL, 0LU, 0x5555, SpecialApcsDisabled, KernelApcsDisabled, SpecialApcsDisabled + 1, OriginalIrql >= APC_LEVEL || SpecialApcsDisabled != -1, OriginalIrql); - KeReleaseGuardedMutex(Mutex); + pKeReleaseGuardedMutex(Mutex); /* TODO: here we see that Mutex->Count isn't actually just a count. Test the bits correctly! */ CheckMutex(Mutex, 0L, NULL, 0LU, 0x5555, SpecialApcsDisabled, KernelApcsDisabled, SpecialApcsDisabled + 2, OriginalIrql >= APC_LEVEL || SpecialApcsDisabled != -2, OriginalIrql); - KeReleaseGuardedMutex(Mutex); + pKeReleaseGuardedMutex(Mutex); CheckMutex(Mutex, 1L, NULL, 0LU, 0x5555, SpecialApcsDisabled, KernelApcsDisabled, SpecialApcsDisabled + 3, OriginalIrql >= APC_LEVEL || SpecialApcsDisabled != -3, OriginalIrql); Thread->SpecialApcDisable -= 3; } @@ -242,10 +322,10 @@ LARGE_INTEGER Timeout; Timeout.QuadPart = -50 * 1000 * 10; /* 50 ms */
- InitThreadData(&ThreadData, Mutex, KeAcquireGuardedMutex, NULL, KeReleaseGuardedMutex); - InitThreadData(&ThreadData2, Mutex, KeAcquireGuardedMutex, NULL, KeReleaseGuardedMutex); - InitThreadData(&ThreadDataUnsafe, Mutex, KeAcquireGuardedMutexUnsafe, NULL, KeReleaseGuardedMutexUnsafe); - InitThreadData(&ThreadDataTry, Mutex, NULL, KeTryToAcquireGuardedMutex, KeReleaseGuardedMutex); + InitThreadData(&ThreadData, Mutex, pKeAcquireGuardedMutex, NULL, pKeReleaseGuardedMutex); + InitThreadData(&ThreadData2, Mutex, pKeAcquireGuardedMutex, NULL, pKeReleaseGuardedMutex); + InitThreadData(&ThreadDataUnsafe, Mutex, pKeAcquireGuardedMutexUnsafe, NULL, pKeReleaseGuardedMutexUnsafe); + InitThreadData(&ThreadDataTry, Mutex, NULL, pKeTryToAcquireGuardedMutex, pKeReleaseGuardedMutex);
/* have a thread acquire the mutex */ Status = StartThread(&ThreadData, NULL, PASSIVE_LEVEL, FALSE, FALSE); @@ -337,6 +417,29 @@ }; int i;
+ pKeAreAllApcsDisabled = KmtGetSystemRoutineAddress(L"KeAreAllApcsDisabled"); + pKeInitializeGuardedMutex = KmtGetSystemRoutineAddress(L"KeInitializeGuardedMutex"); + pKeAcquireGuardedMutex = KmtGetSystemRoutineAddress(L"KeAcquireGuardedMutex"); + pKeAcquireGuardedMutexUnsafe = KmtGetSystemRoutineAddress(L"KeAcquireGuardedMutexUnsafe"); + pKeEnterGuardedRegion = KmtGetSystemRoutineAddress(L"KeEnterGuardedRegion"); + pKeLeaveGuardedRegion = KmtGetSystemRoutineAddress(L"KeLeaveGuardedRegion"); + pKeReleaseGuardedMutex = KmtGetSystemRoutineAddress(L"KeReleaseGuardedMutex"); + pKeReleaseGuardedMutexUnsafe = KmtGetSystemRoutineAddress(L"KeReleaseGuardedMutexUnsafe"); + pKeTryToAcquireGuardedMutex = KmtGetSystemRoutineAddress(L"KeTryToAcquireGuardedMutex"); + + if (skip(pKeAreAllApcsDisabled && + pKeInitializeGuardedMutex && + pKeAcquireGuardedMutex && + pKeAcquireGuardedMutexUnsafe && + pKeEnterGuardedRegion && + pKeLeaveGuardedRegion && + pKeReleaseGuardedMutex && + pKeReleaseGuardedMutexUnsafe && + pKeTryToAcquireGuardedMutex, "No guarded mutexes\n")) + { + return; + } + for (i = 0; i < sizeof TestIterations / sizeof TestIterations[0]; ++i) { trace("Run %d\n", i); @@ -345,7 +448,7 @@ Thread->SpecialApcDisable = TestIterations[i].SpecialApcsDisabled;
RtlFillMemory(&Mutex, sizeof Mutex, 0x55); - KeInitializeGuardedMutex(&Mutex); + pKeInitializeGuardedMutex(&Mutex); CheckMutex(&Mutex, 1L, NULL, 0LU, 0x5555, 0x5555, TestIterations[i].KernelApcsDisabled, TestIterations[i].SpecialApcsDisabled, TestIterations[i].AllApcsDisabled, TestIterations[i].Irql); TestGuardedMutex(&Mutex, TestIterations[i].KernelApcsDisabled, TestIterations[i].SpecialApcsDisabled, TestIterations[i].AllApcsDisabled, TestIterations[i].Irql);
@@ -356,6 +459,6 @@
trace("Concurrent test\n"); RtlFillMemory(&Mutex, sizeof Mutex, 0x55); - KeInitializeGuardedMutex(&Mutex); + pKeInitializeGuardedMutex(&Mutex); TestGuardedMutexConcurrent(&Mutex); }
Modified: trunk/rostests/kmtests/ntos_ke/KeMutex.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/kmtests/ntos_ke/KeMutex.c?... ============================================================================== --- trunk/rostests/kmtests/ntos_ke/KeMutex.c [iso-8859-1] (original) +++ trunk/rostests/kmtests/ntos_ke/KeMutex.c [iso-8859-1] Sun Feb 15 10:23:21 2015 @@ -6,6 +6,13 @@ */
#include <kmt_test.h> + +static +_IRQL_requires_min_(PASSIVE_LEVEL) +_IRQL_requires_max_(DISPATCH_LEVEL) +BOOLEAN +(NTAPI +*pKeAreAllApcsDisabled)(VOID);
#define ULONGS_PER_POINTER (sizeof(PVOID) / sizeof(ULONG)) #define MUTANT_SIZE (2 + 6 * ULONGS_PER_POINTER) @@ -55,7 +62,8 @@ { \ ok_eq_bool(KeAreApcsDisabled(), KernelApcsDisabled || SpecialApcsDisabled); \ ok_eq_int(Thread->KernelApcDisable, KernelApcsDisabled); \ - ok_eq_bool(KeAreAllApcsDisabled(), AllApcsDisabled); \ + if (pKeAreAllApcsDisabled) \ + ok_eq_bool(pKeAreAllApcsDisabled(), AllApcsDisabled); \ ok_eq_int(Thread->SpecialApcDisable, SpecialApcsDisabled); \ ok_irql(Irql); \ } while (0) @@ -137,6 +145,12 @@
START_TEST(KeMutex) { + pKeAreAllApcsDisabled = KmtGetSystemRoutineAddress(L"KeAreAllApcsDisabled"); + if (skip(pKeAreAllApcsDisabled != NULL, "KeAreAllApcsDisabled unavailable\n")) + { + /* We can live without this function here */ + } + TestMutant(); TestMutex(); }
Modified: trunk/rostests/kmtests/ntos_ke/KeSpinLock.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/kmtests/ntos_ke/KeSpinLock... ============================================================================== --- trunk/rostests/kmtests/ntos_ke/KeSpinLock.c [iso-8859-1] (original) +++ trunk/rostests/kmtests/ntos_ke/KeSpinLock.c [iso-8859-1] Sun Feb 15 10:23:21 2015 @@ -20,19 +20,36 @@ //#define NDEBUG #include <debug.h>
-/* TODO: these are documented for Vista+ */ -NTKERNELAPI +static +_Must_inspect_result_ +_IRQL_requires_min_(DISPATCH_LEVEL) +_Post_satisfies_(return == 1 || return == 0) +BOOLEAN +(FASTCALL +*pKeTryToAcquireSpinLockAtDpcLevel)( + _Inout_ _Requires_lock_not_held_(*_Curr_) + _When_(return!=0, _Acquires_lock_(*_Curr_)) + PKSPIN_LOCK SpinLock); + +static VOID -FASTCALL -KeAcquireInStackQueuedSpinLockForDpc( +(FASTCALL +*pKeAcquireInStackQueuedSpinLockForDpc)( IN OUT PKSPIN_LOCK SpinLock, OUT PKLOCK_QUEUE_HANDLE LockHandle);
-NTKERNELAPI +static VOID -FASTCALL -KeReleaseInStackQueuedSpinLockForDpc( +(FASTCALL +*pKeReleaseInStackQueuedSpinLockForDpc)( IN PKLOCK_QUEUE_HANDLE LockHandle); + +static +_Must_inspect_result_ +BOOLEAN +(FASTCALL +*pKeTestSpinLock)( + _In_ PKSPIN_LOCK SpinLock);
/* TODO: multiprocessor testing */
@@ -119,8 +136,8 @@ DEFINE_RELEASE(ReleaseForDpc, TRUE, KeReleaseSpinLockForDpc(SpinLock, CheckData->Irql)) #endif
-DEFINE_ACQUIRE(AcquireInStackForDpc, FALSE, KeAcquireInStackQueuedSpinLockForDpc(SpinLock, &CheckData->QueueHandle)) -DEFINE_RELEASE(ReleaseInStackForDpc, FALSE, KeReleaseInStackQueuedSpinLockForDpc(&CheckData->QueueHandle)) +DEFINE_ACQUIRE(AcquireInStackForDpc, FALSE, pKeAcquireInStackQueuedSpinLockForDpc(SpinLock, &CheckData->QueueHandle)) +DEFINE_RELEASE(ReleaseInStackForDpc, FALSE, pKeReleaseInStackQueuedSpinLockForDpc(&CheckData->QueueHandle))
#ifdef _X86_ DEFINE_ACQUIRE(AcquireInt, FALSE, KiAcquireSpinLock(SpinLock)) @@ -142,7 +159,7 @@ return Ret; } BOOLEAN TryNoRaise(PKSPIN_LOCK SpinLock, PCHECK_DATA CheckData) { - BOOLEAN Ret = KeTryToAcquireSpinLockAtDpcLevel(SpinLock); + BOOLEAN Ret = pKeTryToAcquireSpinLockAtDpcLevel(SpinLock); return Ret; }
@@ -197,7 +214,7 @@
#define CheckSpinLock(SpinLock, CheckData, Value) do \ { \ - BOOLEAN Ret = SpinLock ? KeTestSpinLock(SpinLock) : TRUE; \ + BOOLEAN Ret = SpinLock && pKeTestSpinLock ? pKeTestSpinLock(SpinLock) : TRUE; \ KIRQL ExpectedIrql = (CheckData)->OriginalIrql; \ \ switch ((CheckData)->Check) \ @@ -257,7 +274,10 @@ }
if (CheckData->AcquireNoRaise && - (CheckData->OriginalIrql >= DISPATCH_LEVEL || !KmtIsCheckedBuild)) + (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); @@ -279,7 +299,8 @@ CheckData->IsAcquired = FALSE; KmtSetIrql(CheckData->OriginalIrql);
- if (CheckData->TryAcquireNoRaise) + if (CheckData->TryAcquireNoRaise && + !skip(pKeTryToAcquireSpinLockAtDpcLevel != NULL, "KeTryToAcquireSpinLockAtDpcLevel unavailable\n")) { CheckSpinLock(SpinLock, CheckData, 0); ok_bool_true(CheckData->TryAcquireNoRaise(SpinLock, CheckData), "TryAcquireNoRaise returned"); @@ -320,7 +341,14 @@ { CheckQueue, SynchIrql, AcquireQueuedSynch, ReleaseQueued, TryQueuedSynch, NULL, NULL, NULL, LockQueuePfnLock }, }; int i, iIrql; - PKPRCB Prcb = KeGetCurrentPrcb(); + 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); @@ -328,17 +356,20 @@ ok_eq_ulongptr(SpinLock, 0);
/* KeTestSpinLock */ - ok_bool_true(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned"); - SpinLock = 1; - ok_bool_false(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned"); - SpinLock = 2; - ok_bool_false(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned"); - SpinLock = (ULONG_PTR)-1; - ok_bool_false(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned"); - SpinLock = (ULONG_PTR)1 << (sizeof(ULONG_PTR) * CHAR_BIT - 1); - ok_bool_false(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned"); - SpinLock = 0; - ok_bool_true(KeTestSpinLock(&SpinLock), "KeTestSpinLock returned"); + 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)
-
tfaber＠svn.reactos.org