Ros-diffs December 2005

ros-diffs@reactos.org

40 participants
704 discussions

[greatlrd] 20437: do not call on NtQuerySecurityObject in RegQueryInfoKey for it will always fail on reactos.
by greatlrd＠svn.reactos.org 29 Dec '05

29 Dec '05

do not call on NtQuerySecurityObject in RegQueryInfoKey for it will always fail on reactos. adding #ifndef __REACTOS__ around that code and should be remove when we have that call implement in reactos. Modified: trunk/reactos/lib/advapi32/reg/reg.c _____ Modified: trunk/reactos/lib/advapi32/reg/reg.c --- trunk/reactos/lib/advapi32/reg/reg.c 2005-12-29 19:54:42 UTC (rev 20436) +++ trunk/reactos/lib/advapi32/reg/reg.c 2005-12-29 20:31:22 UTC (rev 20437) @@ -3184,7 +3184,7 @@ { *lpcbMaxValueLen = FullInfo->MaxValueDataLen; } - +#ifndef __REACTOS__ if (lpcbSecurityDescriptor != NULL) { Status = NtQuerySecurityObject(KeyHandle, @@ -3207,6 +3207,7 @@ goto Cleanup; } } +#endif if (lpftLastWriteTime != NULL) {

1 0

[ion] 20436: - Fix InterlockedBitTestAndReset and InterlockedBitTestAndSet
by ion＠svn.reactos.org 29 Dec '05

29 Dec '05

- Fix InterlockedBitTestAndReset and InterlockedBitTestAndSet - Implement YieldProcessor - Fix formatting in spinlock.c - KiAcquireSpinlock and KiReleaseSpinLock should be no-op functions on uniprocessor machines. - KiReleaseSpinLock does not need interlocked access to release the lock. - Use portable code for KiAcquireSpinLock. Also use interlocked bit operations since they are faster. Modified: trunk/reactos/ntoskrnl/ke/spinlock.c Modified: trunk/reactos/w32api/include/winnt.h _____ Modified: trunk/reactos/ntoskrnl/ke/spinlock.c --- trunk/reactos/ntoskrnl/ke/spinlock.c 2005-12-29 19:12:09 UTC (rev 20435) +++ trunk/reactos/ntoskrnl/ke/spinlock.c 2005-12-29 19:54:42 UTC (rev 20436) @@ -1,34 +1,28 @@ -/* $Id$ - * +/* * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel + * PROJECT: ReactOS Kernel * FILE: ntoskrnl/ke/spinlock.c * PURPOSE: Implements spinlocks - * - * PROGRAMMERS: David Welch (welch(a)cwcom.net) + * PROGRAMMERS: Alex Ionescu (alex(a)relsoft.net) + * David Welch (welch(a)cwcom.net) */ -/* - * NOTE: On a uniprocessor machine spinlocks are implemented by raising - * the irq level - */ - /* INCLUDES ****************************************************************/ #include <ntoskrnl.h> #define NDEBUG #include <internal/debug.h> +#undef KefAcquireSpinLockAtDpcLevel +#undef KeAcquireSpinLockAtDpcLevel +#undef KefReleaseSpinLockFromDpcLevel +#undef KeReleaseSpinLockFromDpcLevel + /* FUNCTIONS ***************************************************************/ /* * @implemented - */ -BOOLEAN STDCALL -KeSynchronizeExecution (PKINTERRUPT Interrupt, - PKSYNCHRONIZE_ROUTINE SynchronizeRoutine, - PVOID SynchronizeContext) -/* + * * FUNCTION: Synchronizes the execution of a given routine with the ISR * of a given interrupt object * ARGUMENTS: @@ -38,17 +32,26 @@ * SynchronizeContext = Parameter to pass to the synchronized routine * RETURNS: TRUE if the operation succeeded */ +BOOLEAN +STDCALL +KeSynchronizeExecution(PKINTERRUPT Interrupt, + PKSYNCHRONIZE_ROUTINE SynchronizeRoutine, + PVOID SynchronizeContext) { - KIRQL oldlvl; - BOOLEAN ret; + KIRQL OldIrql; + BOOLEAN Status; - oldlvl = KeAcquireInterruptSpinLock(Interrupt); + /* Raise IRQL and acquire lock on MP */ + OldIrql = KeAcquireInterruptSpinLock(Interrupt); - ret = SynchronizeRoutine(SynchronizeContext); + /* Call the routine */ + Status = SynchronizeRoutine(SynchronizeContext); - KeReleaseInterruptSpinLock(Interrupt, oldlvl); + /* Release lock and lower IRQL */ + KeReleaseInterruptSpinLock(Interrupt, OldIrql); - return(ret); + /* Return routine status */ + return Status; } /* @@ -56,176 +59,156 @@ */ KIRQL STDCALL -KeAcquireInterruptSpinLock( - IN PKINTERRUPT Interrupt - ) +KeAcquireInterruptSpinLock(IN PKINTERRUPT Interrupt) { - KIRQL oldIrql; + KIRQL OldIrql; - KeRaiseIrql(Interrupt->SynchronizeIrql, &oldIrql); - KiAcquireSpinLock(Interrupt->ActualLock); - return oldIrql; + /* Raise IRQL */ + KeRaiseIrql(Interrupt->SynchronizeIrql, &OldIrql); + + /* Acquire spinlock on MP */ + KiAcquireSpinLock(Interrupt->ActualLock); + return OldIrql; } /* * @implemented - */ -VOID STDCALL -KeInitializeSpinLock (PKSPIN_LOCK SpinLock) -/* + * * FUNCTION: Initalizes a spinlock * ARGUMENTS: * SpinLock = Caller supplied storage for the spinlock */ +VOID +STDCALL +KeInitializeSpinLock(PKSPIN_LOCK SpinLock) { - *SpinLock = 0; + *SpinLock = 0; } -#undef KefAcquireSpinLockAtDpcLevel - /* * @implemented */ -VOID FASTCALL +VOID +FASTCALL KefAcquireSpinLockAtDpcLevel(PKSPIN_LOCK SpinLock) { - ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL); - KiAcquireSpinLock(SpinLock); + ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL); + KiAcquireSpinLock(SpinLock); } -#undef KeAcquireSpinLockAtDpcLevel - /* * @implemented - */ -VOID STDCALL -KeAcquireSpinLockAtDpcLevel (PKSPIN_LOCK SpinLock) -/* + * * FUNCTION: Acquires a spinlock when the caller is already running at * dispatch level * ARGUMENTS: * SpinLock = Spinlock to acquire */ -{ - KefAcquireSpinLockAtDpcLevel(SpinLock); -} - - -/* - * @unimplemented - */ VOID -FASTCALL -KeAcquireInStackQueuedSpinLockAtDpcLevel( - IN PKSPIN_LOCK SpinLock, - IN PKLOCK_QUEUE_HANDLE LockHandle - ) +STDCALL +KeAcquireSpinLockAtDpcLevel (PKSPIN_LOCK SpinLock) { - UNIMPLEMENTED; + KefAcquireSpinLockAtDpcLevel(SpinLock); } - -#undef KefReleaseSpinLockFromDpcLevel - /* * @implemented */ -VOID FASTCALL +VOID +FASTCALL KefReleaseSpinLockFromDpcLevel(PKSPIN_LOCK SpinLock) { - ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL); - KiReleaseSpinLock(SpinLock); + ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL); + KiReleaseSpinLock(SpinLock); } -#undef KeReleaseSpinLockFromDpcLevel - /* * @implemented - */ -VOID STDCALL -KeReleaseSpinLockFromDpcLevel (PKSPIN_LOCK SpinLock) -/* + * * FUNCTION: Releases a spinlock when the caller was running at dispatch * level before acquiring it * ARGUMENTS: * SpinLock = Spinlock to release */ +VOID +STDCALL +KeReleaseSpinLockFromDpcLevel (PKSPIN_LOCK SpinLock) { - KefReleaseSpinLockFromDpcLevel(SpinLock); + KefReleaseSpinLockFromDpcLevel(SpinLock); } /* - * @unimplemented + * @implemented */ VOID FASTCALL -KeReleaseInStackQueuedSpinLockFromDpcLevel( - IN PKLOCK_QUEUE_HANDLE LockHandle - ) +KiAcquireSpinLock(PKSPIN_LOCK SpinLock) { - UNIMPLEMENTED; +#ifdef CONFIG_SMP + for (;;) + { + /* Try to acquire it */ + if (InterlockedBitTestAndSet((PLONG)SpinLock, 0)) + { + /* Value changed... wait until it's locked */ + while (*SpinLock == 1) YieldProcessor(); + } + else + { + /* All is well, break out */ + break; + } + } +#endif /* CONFIG_SMP */ } /* * @implemented */ -VOID FASTCALL -KiAcquireSpinLock(PKSPIN_LOCK SpinLock) +VOID +STDCALL +KeReleaseInterruptSpinLock(IN PKINTERRUPT Interrupt, + IN KIRQL OldIrql) { - ULONG i; + /* Release lock on MP */ + KiReleaseSpinLock(Interrupt->ActualLock); - /* - * FIXME: This depends on gcc assembling this test to a single load from - * the spinlock's value. - */ - ASSERT(*SpinLock < 2); + /* Lower IRQL */ + KeLowerIrql(OldIrql); +} - while ((i = InterlockedExchangeUL(SpinLock, 1)) == 1) - { +/* + * @implemented + */ +VOID +FASTCALL +KiReleaseSpinLock(PKSPIN_LOCK SpinLock) +{ #ifdef CONFIG_SMP - /* Avoid reading the value again too fast */ -#if 1 - __asm__ __volatile__ ("1:\n\t" - "cmpl $0,(%0)\n\t" - "jne 1b\n\t" - : - : "r" (SpinLock)); -#else - while (0 != *(volatile KSPIN_LOCK*)SpinLock); + /* Simply clear it */ + *SpinLock = 0; #endif -#else - DbgPrint("Spinning on spinlock %x current value %x\n", SpinLock, i); - KEBUGCHECKEX(SPIN_LOCK_ALREADY_OWNED, (ULONG)SpinLock, 0, 0, 0); -#endif /* CONFIG_SMP */ - } } /* - * @implemented + * @unimplemented */ VOID -STDCALL -KeReleaseInterruptSpinLock( - IN PKINTERRUPT Interrupt, - IN KIRQL OldIrql - ) +FASTCALL +KeAcquireInStackQueuedSpinLockAtDpcLevel(IN PKSPIN_LOCK SpinLock, + IN PKLOCK_QUEUE_HANDLE LockHandle) { - KiReleaseSpinLock(Interrupt->ActualLock); - KeLowerIrql(OldIrql); + UNIMPLEMENTED; } /* - * @implemented + * @unimplemented */ -VOID FASTCALL -KiReleaseSpinLock(PKSPIN_LOCK SpinLock) +VOID +FASTCALL +KeReleaseInStackQueuedSpinLockFromDpcLevel(IN PKLOCK_QUEUE_HANDLE LockHandle) { - if (*SpinLock != 1) - { - DbgPrint("Releasing unacquired spinlock %x\n", SpinLock); - KEBUGCHECKEX(SPIN_LOCK_NOT_OWNED, (ULONG)SpinLock, 0, 0, 0); - } - (void)InterlockedExchangeUL(SpinLock, 0); + UNIMPLEMENTED; } /* EOF */ _____ Modified: trunk/reactos/w32api/include/winnt.h --- trunk/reactos/w32api/include/winnt.h 2005-12-29 19:12:09 UTC (rev 20435) +++ trunk/reactos/w32api/include/winnt.h 2005-12-29 19:54:42 UTC (rev 20436) @@ -3700,7 +3700,7 @@ { LONG OldBit; - __asm__ __volatile__("lock" + __asm__ __volatile__("lock " "btsl %2,%1\n\t" "sbbl %0,%0\n\t" :"=r" (OldBit),"=m" (*Base) @@ -3715,7 +3715,7 @@ { LONG OldBit; - __asm__ __volatile__("lock" + __asm__ __volatile__("lock " "btrl %2,%1\n\t" "sbbl %0,%0\n\t" :"=r" (OldBit),"=m" (*Base) @@ -3726,6 +3726,8 @@ #endif +#define YieldProcessor() __asm__ __volatile__("pause"); + #if defined(_AMD64_) #if defined(_M_AMD64)

1 0

[ion] 20435: - Implemented InterlockedBitTestAndReset, InterlockedBitTestAndSet, InterlockedExchangeAddSizeT.
by ion＠svn.reactos.org 29 Dec '05

29 Dec '05

- Implemented InterlockedBitTestAndReset, InterlockedBitTestAndSet, InterlockedExchangeAddSizeT. - Rundown re-implementation: * Added inlined functions for internal system use for quickest path. * Correctly named all functions Exf instead of Ex. * Removed PAGED_CODE(); macro where it shouldn't be used. * Addded multiple ASSERTS for sanity checks. * Used macros for win64/32 portability. * Fixed the following bugs/features: * ExfAcquireRundownProtection: ** Added specific code instead of calling the generic function. Rundown locks are performance critical and a dedicated path is prefered. * ExfAcquireRundownProtectionEx: ** Added a quick immediate check to see if the rundown is active. * ExfReleaseRundownProtection: ** Added specific code instead of calling the generic function. Rundown locks are performance critical and a dedicated path is prefered. * ExfReleaseRundownProtectionEx: ** Simplified the loop code. ** Fixed a bug in signaling of the event during waitblock count removal * ExfWaitForRundownProtectionRelease: ** Add quick case when we don't actually need a full wait. ** Simplified loop code. * Added stubs for cache-aware implementation. * Documented the functions. Modified: trunk/reactos/include/ndk/exfuncs.h Modified: trunk/reactos/ntoskrnl/cm/ntfunc.c Modified: trunk/reactos/ntoskrnl/ex/rundown.c Modified: trunk/reactos/ntoskrnl/include/internal/ex.h Modified: trunk/reactos/ntoskrnl/ntoskrnl.def Modified: trunk/reactos/ntoskrnl/ntoskrnl.xml Modified: trunk/reactos/w32api/include/winnt.h _____ Modified: trunk/reactos/include/ndk/exfuncs.h --- trunk/reactos/include/ndk/exfuncs.h 2005-12-29 19:02:06 UTC (rev 20434) +++ trunk/reactos/include/ndk/exfuncs.h 2005-12-29 19:12:09 UTC (rev 20435) @@ -37,11 +37,62 @@ // VOID FASTCALL -ExEnterCriticalRegionAndAcquireFastMutexUnsafe(PFAST_MUTEX FastMutex); +ExEnterCriticalRegionAndAcquireFastMutexUnsafe( + PFAST_MUTEX FastMutex +); VOID FASTCALL -ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(PFAST_MUTEX FastMutex); +ExReleaseFastMutexUnsafeAndLeaveCriticalRegion( + PFAST_MUTEX FastMutex +); + +// +// Pushlock functions +// +VOID +FASTCALL +ExfAcquirePushLockExclusive( + PEX_PUSH_LOCK PushLock +); + +VOID +FASTCALL +ExfAcquirePushLockShared( + PEX_PUSH_LOCK PushLock +); + +VOID +FASTCALL +ExfReleasePushLock( + PEX_PUSH_LOCK PushLock +); + +VOID +FASTCALL +ExfReleasePushLockExclusive( + PEX_PUSH_LOCK PushLock +); + +VOID +FASTCALL +ExfReleasePushLockShared( + PEX_PUSH_LOCK PushLock +); + +VOID +FASTCALL +ExfTryToWakePushLock( + PEX_PUSH_LOCK PushLock +); + +VOID +FASTCALL +ExfUnblockPushLock( + PEX_PUSH_LOCK PushLock, + PVOID CurrentWaitBlock +); + #endif // _____ Modified: trunk/reactos/ntoskrnl/cm/ntfunc.c --- trunk/reactos/ntoskrnl/cm/ntfunc.c 2005-12-29 19:02:06 UTC (rev 20434) +++ trunk/reactos/ntoskrnl/cm/ntfunc.c 2005-12-29 19:12:09 UTC (rev 20435) @@ -147,7 +147,7 @@ CurrentCallback = CONTAINING_RECORD(CurrentEntry, REGISTRY_CALLBACK, ListEntry); if(!CurrentCallback->PendingDelete && - ExAcquireRundownProtectionEx(&CurrentCallback->RundownRef, 1)) + ExAcquireRundownProtection(&CurrentCallback->RundownRef)) { /* don't hold locks during the callbacks! */ ExReleaseFastMutex(&CmiCallbackLock); @@ -160,7 +160,7 @@ /* don't release the rundown protection before holding the callback lock so the pointer to the next callback isn't cleared in case this callback get's deleted */ - ExReleaseRundownProtectionEx(&CurrentCallback->RundownRef, 1); + ExReleaseRundownProtection(&CurrentCallback->RundownRef); if(!NT_SUCCESS(Status)) { /* one callback returned failure, don't call any more callbacks */ _____ Modified: trunk/reactos/ntoskrnl/ex/rundown.c --- trunk/reactos/ntoskrnl/ex/rundown.c 2005-12-29 19:02:06 UTC (rev 20434) +++ trunk/reactos/ntoskrnl/ex/rundown.c 2005-12-29 19:12:09 UTC (rev 20435) @@ -1,10 +1,10 @@ /* * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel + * PROJECT: ReactOS Kernel * FILE: ntoskrnl/ex/rundown.c - * PURPOSE: Rundown Protection Functions - * - * PROGRAMMERS: Alex Ionescu & Thomas Weidenmueller - Implementation + * PURPOSE: Rundown and Cache-Aware Rundown Protection + * PROGRAMMERS: Alex Ionescu (alex(a)relsoft.net) + * Thomas Weidenmueller */ /* INCLUDES *****************************************************************/ @@ -15,261 +15,489 @@ /* FUNCTIONS *****************************************************************/ -/* - * @implemented - */ +/*++ + * @name ExfAcquireRundownProtection + * @implemented NT5.1 + * + * The ExfAcquireRundownProtection routine acquires rundown protection for + * the specified descriptor. + * + * @param RunRef + * Pointer to a rundown reference descriptor. + * + * @return TRUE if access to the protected structure was granted, FALSE otherwise. + * + * @remarks Callers of ExfAcquireRundownProtection can be running at any IRQL. + * + *--*/ BOOLEAN FASTCALL -ExAcquireRundownProtection ( - IN PEX_RUNDOWN_REF RunRef - ) +ExfAcquireRundownProtection(IN PEX_RUNDOWN_REF RunRef) { - /* Call the general function with only one Reference add */ - return ExAcquireRundownProtectionEx(RunRef, 1); + ULONG_PTR Value = RunRef->Count, NewValue; + + /* Make sure a rundown is not active */ + if (Value & EX_RUNDOWN_ACTIVE) return FALSE; + + /* Loop until successfully incremented the counter */ + for (;;) + { + /* Add a reference */ + NewValue = Value + EX_RUNDOWN_COUNT_INC; + + /* Change the value */ + Value = ExpChangeRundown(RunRef, NewValue, Value); + if (Value == NewValue) return TRUE; + + /* Make sure a rundown is not active */ + if (Value & EX_RUNDOWN_ACTIVE) return FALSE; + } } -/* - * @implemented - */ +/*++ + * @name ExfAcquireRundownProtectionEx + * @implemented NT5.2 + * + * The ExfAcquireRundownProtectionEx routine acquires multiple rundown + * protection references for the specified descriptor. + * + * @param RunRef + * Pointer to a rundown reference descriptor. + * + * @param Count + * Number of times to reference the descriptor. + * + * @return TRUE if access to the protected structure was granted, FALSE otherwise. + * + * @remarks Callers of ExfAcquireRundownProtectionEx can be running at any IRQL. + * + *--*/ BOOLEAN FASTCALL -ExAcquireRundownProtectionEx ( - IN PEX_RUNDOWN_REF RunRef, - IN ULONG Count - ) +ExfAcquireRundownProtectionEx(IN PEX_RUNDOWN_REF RunRef, + IN ULONG Count) { - ULONG_PTR PrevCount, Current; + ULONG_PTR Value = RunRef->Count, NewValue; - PAGED_CODE(); + /* Make sure a rundown is not active */ + if (Value & EX_RUNDOWN_ACTIVE) return FALSE; + /* Convert the count to our internal representation */ Count <<= EX_RUNDOWN_COUNT_SHIFT; /* Loop until successfully incremented the counter */ - do + for (;;) { - Current = RunRef->Count; + /* Add references */ + NewValue = Value + Count; + /* Change the value */ + Value = ExpChangeRundown(RunRef, NewValue, Value); + if (Value == NewValue) return TRUE; + /* Make sure a rundown is not active */ - if (Current & EX_RUNDOWN_ACTIVE) - { - return FALSE; - } - -#ifdef _WIN64 - PrevCount = (ULONG_PTR)InterlockedExchangeAdd64((LONGLONG*)&RunRef->Count, (LONGLONG)Count); -#else - PrevCount = (ULONG_PTR)InterlockedExchangeAdd((LONG*)&RunRef->Count, (LONG)Count); -#endif - } while (PrevCount != Current); - - /* Return Success */ - return TRUE; + if (Value & EX_RUNDOWN_ACTIVE) return FALSE; + } } -/* - * @implemented - */ +/*++ + * @name ExfInitializeRundownProtection + * @implemented NT5.1 + * + * The ExfInitializeRundownProtection routine initializes a rundown + * protection descriptor. + * + * @param RunRef + * Pointer to a rundown reference descriptor. + * + * @return None. + * + * @remarks Callers of ExfInitializeRundownProtection can be running at any IRQL. + * + *--*/ VOID FASTCALL -ExInitializeRundownProtection ( - IN PEX_RUNDOWN_REF RunRef - ) +ExfInitializeRundownProtection(IN PEX_RUNDOWN_REF RunRef) { - PAGED_CODE(); - /* Set the count to zero */ RunRef->Count = 0; } -/* - * @implemented - */ +/*++ + * @name ExfReInitializeRundownProtection + * @implemented NT5.1 + * + * The ExfReInitializeRundownProtection routine re-initializes a rundown + * protection descriptor. + * + * @param RunRef + * Pointer to a rundown reference descriptor. + * + * @return None. + * + * @remarks Callers of ExfReInitializeRundownProtection can be running at any IRQL. + * + *--*/ VOID FASTCALL -ExReInitializeRundownProtection ( - IN PEX_RUNDOWN_REF RunRef - ) +ExfReInitializeRundownProtection(IN PEX_RUNDOWN_REF RunRef) { PAGED_CODE(); + /* Sanity check */ + ASSERT((RunRef->Count & EX_RUNDOWN_ACTIVE) != 0); + /* Reset the count */ -#ifdef _WIN64 - InterlockedExchange64((LONGLONG*)&RunRef->Count, 0LL); -#else - InterlockedExchange((LONG*)&RunRef->Count, 0); -#endif + InterlockedExchange((PLONG)&RunRef->Count, 0); } - -/* - * @implemented - */ +/*++ + * @name ExfRundownCompleted + * @implemented NT5.1 + * + * The ExfRundownCompleted routine completes the rundown of the specified + * descriptor by setting the active bit. + * + * @param RunRef + * Pointer to a rundown reference descriptor. + * + * @return None. + * + * @remarks Callers of ExfRundownCompleted must be running at IRQL <= APC_LEVEL. + * + *--*/ VOID FASTCALL -ExReleaseRundownProtectionEx ( - IN PEX_RUNDOWN_REF RunRef, - IN ULONG Count - ) +ExfRundownCompleted(IN PEX_RUNDOWN_REF RunRef) { PAGED_CODE(); - Count <<= EX_RUNDOWN_COUNT_SHIFT; + /* Sanity check */ + ASSERT((RunRef->Count & EX_RUNDOWN_ACTIVE) != 0); - for (;;) + /* Mark the counter as active */ + InterlockedExchange((PLONG)&RunRef->Count, EX_RUNDOWN_ACTIVE); +} + +/*++ + * @name ExfReleaseRundownProtection + * @implemented NT5.1 + * + * The ExfReleaseRundownProtection routine releases the rundown protection + * reference for the specified descriptor. + * + * @param RunRef + * Pointer to a rundown reference descriptor. + * + * @return None. + * + * @remarks Callers of ExfReleaseRundownProtection can be running at any IRQL. + * + *--*/ +VOID +FASTCALL +ExfReleaseRundownProtection(IN PEX_RUNDOWN_REF RunRef) +{ + ULONG_PTR Value = RunRef->Count, NewValue; + PEX_RUNDOWN_WAIT_BLOCK WaitBlock; + + /* Check if rundown is not active */ + if (!(Value & EX_RUNDOWN_ACTIVE)) { - ULONG_PTR Current = RunRef->Count; + /* Loop until successfully incremented the counter */ + for (;;) + { + /* Sanity check */ + ASSERT((Value >= EX_RUNDOWN_COUNT_INC) || (KeNumberProcessors > 1)); - /* Check if Rundown is active */ - if (Current & EX_RUNDOWN_ACTIVE) + /* Get the new value */ + NewValue = Value - EX_RUNDOWN_COUNT_INC; + + /* Change the value */ + Value = ExpChangeRundown(RunRef, NewValue, Value); + if (Value == NewValue) return; + + /* Loop again if we're still not active */ + if (Value & EX_RUNDOWN_ACTIVE) break; + } + } + + /* Get the wait block */ + WaitBlock = (PEX_RUNDOWN_WAIT_BLOCK)(Value & ~EX_RUNDOWN_ACTIVE); + ASSERT((WaitBlock->Count > 0) || (KeNumberProcessors > 1)); + + /* Remove the one count */ + if (InterlockedExchangeAddSizeT(&WaitBlock->Count, -1)) + { + /* We're down to 0 now, so signal the event */ + KeSetEvent(&WaitBlock->RundownEvent, IO_NO_INCREMENT, FALSE); + } +} + +/*++ + * @name ExfReleaseRundownProtectionEx + * @implemented NT5.2 + * + * The ExfReleaseRundownProtectionEx routine releases multiple rundown + * protection references for the specified descriptor. + * + * @param RunRef + * Pointer to a rundown reference descriptor. + * + * @param Count + * Number of times to dereference the descriptor. + * + * @return None. + * + * @remarks Callers of ExfAcquireRundownProtectionEx can be running at any IRQL. + * + *--*/ +VOID +FASTCALL +ExfReleaseRundownProtectionEx(IN PEX_RUNDOWN_REF RunRef, + IN ULONG Count) +{ + ULONG_PTR Value = RunRef->Count, NewValue; + PEX_RUNDOWN_WAIT_BLOCK WaitBlock; + + /* Check if rundown is not active */ + if (!(Value & EX_RUNDOWN_ACTIVE)) + { + /* Loop until successfully incremented the counter */ + for (;;) { - /* Get Pointer */ - PEX_RUNDOWN_WAIT_BLOCK RundownDescriptor = (PEX_RUNDOWN_WAIT_BLOCK)(Current & ~EX_RUNDOWN_ACTIVE); + /* Sanity check */ + ASSERT((Value >= EX_RUNDOWN_COUNT_INC * Count) || (KeNumberProcessors > 1)); - if (RundownDescriptor == NULL) - { - /* the rundown was completed and there's no one to notify */ - break; - } + /* Get the new value */ + NewValue = Value - (Count * EX_RUNDOWN_COUNT_INC); - Current = RundownDescriptor->Count; + /* Change the value */ + Value = ExpChangeRundown(RunRef, NewValue, Value); + if (Value == NewValue) return; - /* Decrease RundownDescriptor->Count by Count Count */ - for (;;) - { - ULONG_PTR PrevCount, NewCount; + /* Loop again if we're still not active */ + if (Value & EX_RUNDOWN_ACTIVE) break; + } + } - if ((Count >> EX_RUNDOWN_COUNT_SHIFT) == Current) - { - NewCount = 0; - } - else - { - NewCount = ((RundownDescriptor->Count - (Count >> EX_RUNDOWN_COUNT_SHIFT)) << EX_RUNDOWN_COUNT_SHIFT) | EX_RUNDOWN_ACTIVE; - } -#ifdef _WIN64 - PrevCount = (ULONG_PTR)InterlockedCompareExchange64((LONGLONG*)&RundownDescriptor->C ount, (LONGLONG)NewCount, (LONGLONG)Current); -#else - PrevCount = (ULONG_PTR)InterlockedCompareExchange((LONG*)&RundownDescriptor->Count, (LONG)NewCount, (LONG)Current); -#endif - if (PrevCount == Current) - { - if (NewCount == 0) - { - /* Signal the event so anyone waiting on it can now kill it */ - KeSetEvent(&RundownDescriptor->RundownEvent, 0, FALSE); - } + /* Get the wait block */ + WaitBlock = (PEX_RUNDOWN_WAIT_BLOCK)(Value & ~EX_RUNDOWN_ACTIVE); + ASSERT((WaitBlock->Count >= Count) || (KeNumberProcessors > 1)); - /* Successfully decremented the counter, so bail! */ - break; - } + /* Remove the count */ + if (InterlockedExchangeAddSizeT(WaitBlock->Count, -(LONG)Count) == + (LONG)Count) + { + /* We're down to 0 now, so signal the event */ + KeSetEvent(&WaitBlock->RundownEvent, IO_NO_INCREMENT, FALSE); + } +} - Current = PrevCount; - } +/*++ + * @name ExfWaitForRundownProtectionRelease + * @implemented NT5.1 + * + * The ExfWaitForRundownProtectionRelease routine waits until the specified + * rundown descriptor has been released. + * + * @param RunRef + * Pointer to a rundown reference descriptor. + * + * @return None. + * + * @remarks Callers of ExfWaitForRundownProtectionRelease must be running + * at IRQL <= APC_LEVEL. + * + *--*/ +VOID +FASTCALL +ExfWaitForRundownProtectionRelease(IN PEX_RUNDOWN_REF RunRef) +{ + ULONG_PTR Value, Count, NewValue; + EX_RUNDOWN_WAIT_BLOCK WaitBlock; + PEX_RUNDOWN_WAIT_BLOCK WaitBlockPointer; + PKEVENT Event; + PAGED_CODE(); - break; - } - else + /* Set the active bit */ + Value = ExpChangeRundown(RunRef, EX_RUNDOWN_ACTIVE, 0); + if ((Value == 0) || (Value == EX_RUNDOWN_ACTIVE)) return; + + /* No event for now */ + Event = NULL; + WaitBlockPointer = (PEX_RUNDOWN_WAIT_BLOCK)((ULONG_PTR)&WaitBlock | + EX_RUNDOWN_ACTIVE); + + /* Start waitblock set loop */ + for(;;) + { + /* Save the count */ + Count = Value >> EX_RUNDOWN_COUNT_SHIFT; + + /* If the count is over one or we don't have en event yet, create it */ + if (Count || !Event) { - ULONG_PTR PrevCount, NewCount = Current - (ULONG_PTR)Count; -#ifdef _WIN64 - PrevCount = (ULONG_PTR)InterlockedCompareExchange64((LONGLONG*)&RunRef->Count, (LONGLONG)NewCount, (LONGLONG)Current); -#else - PrevCount = (ULONG_PTR)InterlockedCompareExchange((LONG*)&RunRef->Count, (LONG)NewCount, (LONG)Current); -#endif - if (PrevCount == Current) - { - /* Successfully decremented the counter, so bail! */ - break; - } + /* Initialize the event */ + KeInitializeEvent(&WaitBlock.RundownEvent, + NotificationEvent, + FALSE); + + /* Set the pointer */ + Event = &WaitBlock.RundownEvent; } + + /* Set the count */ + WaitBlock.Count = Count; + + /* Now set the pointer */ + NewValue = ExpChangeRundown(RunRef, PtrToUlong(WaitBlockPointer), Value); + if (NewValue == Value) break; + + /* Loop again */ + Value = NewValue; + ASSERT((Value & EX_RUNDOWN_ACTIVE) == 0); } + + /* If the count was 0, we're done */ + if (!Count) return; + + /* Wait for whoever needs to release to notify us */ + KeWaitForSingleObject(Event, Executive, KernelMode, FALSE, NULL); + ASSERT(WaitBlock.Count == 0); } +/* FIXME: STUBS **************************************************************/ + /* -* @implemented -*/ + * @unimplemented NT5.2 + */ +BOOLEAN +FASTCALL +ExfAcquireRundownProtectionCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware) +{ + DBG_UNREFERENCED_PARAMETER(RunRefCacheAware); + UNIMPLEMENTED; + return FALSE; +} + +/* + * @unimplemented NT5.2 + */ +BOOLEAN +FASTCALL +ExfAcquireRundownProtectionCacheAwareEx(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware, + IN ULONG Count) +{ + DBG_UNREFERENCED_PARAMETER(RunRefCacheAware); + DBG_UNREFERENCED_PARAMETER(Count); + UNIMPLEMENTED; + return FALSE; +} + +/* + * @unimplemented NT5.2 + */ VOID FASTCALL -ExReleaseRundownProtection ( - IN PEX_RUNDOWN_REF RunRef - ) +ExfReleaseRundownProtectionCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware) { - /* Call the general function with only 1 reference removal */ - ExReleaseRundownProtectionEx(RunRef, 1); + DBG_UNREFERENCED_PARAMETER(RunRefCacheAware); + UNIMPLEMENTED; } /* - * @implemented + * @unimplemented NT5.2 */ VOID FASTCALL -ExRundownCompleted ( - IN PEX_RUNDOWN_REF RunRef - ) +ExfReleaseRundownProtectionCacheAwareEx(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware, + IN ULONG Count) { - PAGED_CODE(); + DBG_UNREFERENCED_PARAMETER(RunRefCacheAware); + DBG_UNREFERENCED_PARAMETER(Count); + UNIMPLEMENTED; +} - /* mark the counter as active */ -#ifdef _WIN64 - InterlockedExchange64((LONGLONG*)&RunRef->Count, (LONGLONG)EX_RUNDOWN_ACTIVE); -#else - InterlockedExchange((LONG*)&RunRef->Count, EX_RUNDOWN_ACTIVE); -#endif +/* + * @unimplemented NT5.2 + */ +VOID +FASTCALL +ExfWaitForRundownProtectionReleaseCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware) +{ + DBG_UNREFERENCED_PARAMETER(RunRefCacheAware); + UNIMPLEMENTED; } /* - * @implemented + * @unimplemented NT5.2 */ VOID FASTCALL -ExWaitForRundownProtectionRelease ( - IN PEX_RUNDOWN_REF RunRef - ) +ExfRundownCompletedCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware) { - ULONG_PTR PrevCount, NewPtr, PrevPtr; - EX_RUNDOWN_WAIT_BLOCK RundownDescriptor; + DBG_UNREFERENCED_PARAMETER(RunRefCacheAware); + UNIMPLEMENTED; +} - PAGED_CODE(); +/* + * @unimplemented NT5.2 + */ +VOID +FASTCALL +ExfReInitializeRundownProtectionCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware) +{ + DBG_UNREFERENCED_PARAMETER(RunRefCacheAware); + UNIMPLEMENTED; +} - PrevCount = RunRef->Count; +/* + * @unimplemented NT5.2 + */ +PEX_RUNDOWN_REF_CACHE_AWARE +NTAPI +ExAllocateCacheAwareRundownProtection(IN POOL_TYPE PoolType, + IN ULONG Tag) +{ + DBG_UNREFERENCED_PARAMETER(PoolType); + DBG_UNREFERENCED_PARAMETER(Tag); + UNIMPLEMENTED; + return NULL; +} - if (PrevCount != 0 && !(PrevCount & EX_RUNDOWN_ACTIVE)) - { - /* save the reference counter */ - RundownDescriptor.Count = PrevCount >> EX_RUNDOWN_COUNT_SHIFT; +/* + * @unimplemented NT5.2 + */ +VOID +NTAPI +ExFreeCacheAwareRundownProtection(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware) +{ + DBG_UNREFERENCED_PARAMETER(RunRefCacheAware); + UNIMPLEMENTED; +} - /* Pending Count... wait on them to be closed with an event */ - KeInitializeEvent(&RundownDescriptor.RundownEvent, NotificationEvent, FALSE); +/* + * @unimplemented NT5.2 + */ +VOID +NTAPI +ExInitializeRundownProtectionCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware, + IN ULONG Count) +{ + DBG_UNREFERENCED_PARAMETER(RunRefCacheAware); + DBG_UNREFERENCED_PARAMETER(Count); + UNIMPLEMENTED; +} - ASSERT(!((ULONG_PTR)&RundownDescriptor & EX_RUNDOWN_ACTIVE)); - - NewPtr = (ULONG_PTR)&RundownDescriptor | EX_RUNDOWN_ACTIVE; - - for (;;) - { -#ifdef _WIN64 - PrevPtr = (ULONG_PTR)InterlockedCompareExchange64((LONGLONG*)&RunRef->Ptr, (LONGLONG)NewPtr, (LONGLONG)PrevCount); -#else - PrevPtr = (ULONG_PTR)InterlockedCompareExchange((LONG*)&RunRef->Ptr, (LONG)NewPtr, (LONG)PrevCount); -#endif - if (PrevPtr == PrevCount) - { - /* Wait for whoever needs to release to notify us */ - KeWaitForSingleObject(&RundownDescriptor.RundownEvent, Executive, KernelMode, FALSE, NULL); - break; - } - else if (PrevPtr == 0 || (PrevPtr & EX_RUNDOWN_ACTIVE)) - { - /* some one else was faster, let's just bail */ - break; - } - - PrevCount = PrevPtr; - - /* save the changed reference counter and try again */ - RundownDescriptor.Count = PrevCount >> EX_RUNDOWN_COUNT_SHIFT; - } - } +/* + * @unimplemented NT5.2 + */ +SIZE_T +NTAPI +ExSizeOfRundownProtectionCacheAware(VOID) +{ + UNIMPLEMENTED; + return 0; } -/* EOF */ _____ Modified: trunk/reactos/ntoskrnl/include/internal/ex.h --- trunk/reactos/ntoskrnl/include/internal/ex.h 2005-12-29 19:02:06 UTC (rev 20434) +++ trunk/reactos/ntoskrnl/include/internal/ex.h 2005-12-29 19:12:09 UTC (rev 20435) @@ -77,6 +77,58 @@ STDCALL ExpInitializeProfileImplementation(VOID); +/* Rundown Functions ********************************************************/ + +VOID +FASTCALL +ExfInitializeRundownProtection( + OUT PEX_RUNDOWN_REF RunRef +); + +VOID +FASTCALL +ExfReInitializeRundownProtection( + OUT PEX_RUNDOWN_REF RunRef +); + +BOOLEAN +FASTCALL +ExfAcquireRundownProtection( + IN OUT PEX_RUNDOWN_REF RunRef +); + +BOOLEAN +FASTCALL +ExfAcquireRundownProtectionEx( + IN OUT PEX_RUNDOWN_REF RunRef, + IN ULONG Count +); + +VOID +FASTCALL +ExfReleaseRundownProtection( + IN OUT PEX_RUNDOWN_REF RunRef +); + +VOID +FASTCALL +ExfReleaseRundownProtectionEx( + IN OUT PEX_RUNDOWN_REF RunRef, + IN ULONG Count +); + +VOID +FASTCALL +ExfRundownCompleted( + OUT PEX_RUNDOWN_REF RunRef +); + +VOID +FASTCALL +ExfWaitForRundownProtectionRelease( + IN OUT PEX_RUNDOWN_REF RunRef +); + /* HANDLE TABLE FUNCTIONS ***************************************************/ #define EX_HANDLE_ENTRY_LOCKED (1 << ((sizeof(PVOID) * 8) - 1)) @@ -192,6 +244,184 @@ return ExSystemExceptionFilter(); } +/* RUNDOWN *******************************************************************/ + +#ifdef _WIN64 +#define ExpChangeRundown(x, y, z) InterlockedCompareExchange64((PLONGLONG)x, y, z) +#define ExpSetRundown(x, y) InterlockedExchange64((PLONGLONG)x, y) +#else +#define ExpChangeRundown(x, y, z) InterlockedCompareExchange((PLONG)x, y, z) +#define ExpSetRundown(x, y) InterlockedExchange((PLONG)x, y) +#endif + +/*++ + * @name ExfAcquireRundownProtection + * INTERNAL MACRO + * + * The ExfAcquireRundownProtection routine acquires rundown protection for + * the specified descriptor. + * + * @param RunRef + * Pointer to a rundown reference descriptor. + * + * @return TRUE if access to the protected structure was granted, FALSE otherwise. + * + * @remarks This is the internal macro for system use only.In case the rundown + * was active, then the slow-path will be called through the exported + * function. + * + *--*/ +BOOLEAN +FORCEINLINE +ExAcquireRundownProtection(IN PEX_RUNDOWN_REF RunRef) +{ + ULONG_PTR Value, NewValue, OldValue; + + /* Get the current value and mask the active bit */ + Value = RunRef->Count &~ EX_RUNDOWN_ACTIVE; + + /* Add a reference */ + NewValue = Value + EX_RUNDOWN_COUNT_INC; + + /* Change the value */ + OldValue = ExpChangeRundown(RunRef, NewValue, Value); + if (OldValue != Value) + { + /* Rundown was active, use long path */ + return ExfAcquireRundownProtection(RunRef); + } + + /* Success */ + return TRUE; +} + +/*++ + * @name ExReleaseRundownProtection + * INTERNAL MACRO + * + * The ExReleaseRundownProtection routine releases rundown protection for + * the specified descriptor. + * + * @param RunRef + * Pointer to a rundown reference descriptor. + * + * @return TRUE if access to the protected structure was granted, FALSE otherwise. + * + * @remarks This is the internal macro for system use only.In case the rundown + * was active, then the slow-path will be called through the exported + * function. + * + *--*/ +VOID +FORCEINLINE +ExReleaseRundownProtection(IN PEX_RUNDOWN_REF RunRef) +{ + ULONG_PTR Value, NewValue, OldValue; + + /* Get the current value and mask the active bit */ + Value = RunRef->Count &~ EX_RUNDOWN_ACTIVE; + + /* Remove a reference */ + NewValue = Value - EX_RUNDOWN_COUNT_INC; + + /* Change the value */ + OldValue = ExpChangeRundown(RunRef, NewValue, Value); + + /* Check if the rundown was active */ + if (OldValue != Value) + { + /* Rundown was active, use long path */ + ExfReleaseRundownProtection(RunRef); + } + else + { + /* Sanity check */ + ASSERT((Value >= EX_RUNDOWN_COUNT_INC) || (KeNumberProcessors > 1)); + } +} + +/*++ + * @name ExInitializeRundownProtection + * INTERNAL MACRO + * + * The ExInitializeRundownProtection routine initializes a rundown + * protection descriptor. + * + * @param RunRef + * Pointer to a rundown reference descriptor. + * + * @return None. + * + * @remarks This is the internal macro for system use only. + * + *--*/ +VOID +FORCEINLINE +ExInitializeRundownProtection(IN PEX_RUNDOWN_REF RunRef) +{ + /* Set the count to zero */ + RunRef->Count = 0; +} + +/*++ + * @name ExWaitForRundownProtectionRelease + * INTERNAL MACRO + * + * The ExWaitForRundownProtectionRelease routine waits until the specified + * rundown descriptor has been released. + * + * @param RunRef + * Pointer to a rundown reference descriptor. + * + * @return None. + * + * @remarks This is the internal macro for system use only. If a wait is actually + * necessary, then the slow path is taken through the exported function. + * + *--*/ +VOID +FORCEINLINE +ExWaitForRundownProtectionRelease(IN PEX_RUNDOWN_REF RunRef) +{ + ULONG_PTR Value; + + /* Set the active bit */ + Value = ExpChangeRundown(RunRef, EX_RUNDOWN_ACTIVE, 0); + if ((Value) || (Value != EX_RUNDOWN_ACTIVE)) + { + /* If the the rundown wasn't already active, then take the long path */ + ExfWaitForRundownProtectionRelease(RunRef); + } +} + +/*++ + * @name ExRundownCompleted + * INTERNAL MACRO + * + * The ExRundownCompleted routine completes the rundown of the specified [truncated at 1000 lines; 168 more skipped]

1 0

[ion] 20434: - Fix formatting and a bug in NtSetSystemTime.
by ion＠svn.reactos.org 29 Dec '05

29 Dec '05

- Fix formatting and a bug in NtSetSystemTime. Modified: trunk/reactos/ntoskrnl/ex/time.c _____ Modified: trunk/reactos/ntoskrnl/ex/time.c --- trunk/reactos/ntoskrnl/ex/time.c 2005-12-29 18:56:09 UTC (rev 20433) +++ trunk/reactos/ntoskrnl/ex/time.c 2005-12-29 19:02:06 UTC (rev 20434) @@ -1,11 +1,10 @@ -/* $Id$ - * +/* * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel + * PROJECT: ReactOS Kernel * FILE: ntoskrnl/ex/time.c - * PURPOSE: Time - * - * PROGRAMMERS: David Welch (welch(a)mcmail.com) + * PURPOSE: Time and Timezone Management + * PROGRAMMERS: Eric Kohl + * Thomas Weidenmueller */ /* INCLUDES *****************************************************************/ @@ -14,7 +13,6 @@ #define NDEBUG #include <internal/debug.h> - #define TICKSPERMINUTE 600000000 #if defined (ALLOC_PRAGMA) @@ -28,115 +26,110 @@ LARGE_INTEGER ExpTimeZoneBias; ULONG ExpTimeZoneId; - /* FUNCTIONS ****************************************************************/ VOID INIT_FUNCTION -STDCALL +NTAPI ExpInitTimeZoneInfo(VOID) { - LARGE_INTEGER CurrentTime; - NTSTATUS Status; + LARGE_INTEGER CurrentTime; + NTSTATUS Status; - /* Read time zone information from the registry */ - Status = RtlQueryTimeZoneInformation(&ExpTimeZoneInfo); - if (!NT_SUCCESS(Status)) + /* Read time zone information from the registry */ + Status = RtlQueryTimeZoneInformation(&ExpTimeZoneInfo); + if (!NT_SUCCESS(Status)) { - memset(&ExpTimeZoneInfo, 0, sizeof(TIME_ZONE_INFORMATION)); - - ExpTimeZoneBias.QuadPart = (LONGLONG)0; - ExpTimeZoneId = TIME_ZONE_ID_UNKNOWN; + /* Failed, clear all data */ + RtlZeroMemory(&ExpTimeZoneInfo, sizeof(TIME_ZONE_INFORMATION)); + ExpTimeZoneBias.QuadPart = (LONGLONG)0; + ExpTimeZoneId = TIME_ZONE_ID_UNKNOWN; } - else + else { - /* FIXME: Calculate transition dates */ + /* FIXME: Calculate transition dates */ - ExpTimeZoneBias.QuadPart = - ((LONGLONG)(ExpTimeZoneInfo.Bias + ExpTimeZoneInfo.StandardBias)) * TICKSPERMINUTE; - ExpTimeZoneId = TIME_ZONE_ID_STANDARD; + /* Set bias and ID */ + ExpTimeZoneBias.QuadPart = ((LONGLONG)(ExpTimeZoneInfo.Bias + + ExpTimeZoneInfo.StandardBias)) * + TICKSPERMINUTE; + ExpTimeZoneId = TIME_ZONE_ID_STANDARD; } - SharedUserData->TimeZoneBias.High1Time = ExpTimeZoneBias.u.HighPart; - SharedUserData->TimeZoneBias.High2Time = ExpTimeZoneBias.u.HighPart; - SharedUserData->TimeZoneBias.LowPart = ExpTimeZoneBias.u.LowPart; - SharedUserData->TimeZoneId = ExpTimeZoneId; + /* Change it for user-mode applications */ + SharedUserData->TimeZoneBias.High1Time = ExpTimeZoneBias.u.HighPart; + SharedUserData->TimeZoneBias.High2Time = ExpTimeZoneBias.u.HighPart; + SharedUserData->TimeZoneBias.LowPart = ExpTimeZoneBias.u.LowPart; + SharedUserData->TimeZoneId = ExpTimeZoneId; - /* Convert boot time from local time to UTC */ - SystemBootTime.QuadPart += ExpTimeZoneBias.QuadPart; + /* Convert boot time from local time to UTC */ + SystemBootTime.QuadPart += ExpTimeZoneBias.QuadPart; - /* Convert sytem time from local time to UTC */ - do + /* Convert system time from local time to UTC */ + do { - CurrentTime.u.HighPart = SharedUserData->SystemTime.High1Time; - CurrentTime.u.LowPart = SharedUserData->SystemTime.LowPart; - } - while (CurrentTime.u.HighPart != SharedUserData->SystemTime.High2Time); + CurrentTime.u.HighPart = SharedUserData->SystemTime.High1Time; + CurrentTime.u.LowPart = SharedUserData->SystemTime.LowPart; + } while (CurrentTime.u.HighPart != SharedUserData->SystemTime.High2Time); - CurrentTime.QuadPart += ExpTimeZoneBias.QuadPart; - - SharedUserData->SystemTime.LowPart = CurrentTime.u.LowPart; - SharedUserData->SystemTime.High1Time = CurrentTime.u.HighPart; - SharedUserData->SystemTime.High2Time = CurrentTime.u.HighPart; + /* Change it for user-mode applications */ + CurrentTime.QuadPart += ExpTimeZoneBias.QuadPart; + SharedUserData->SystemTime.LowPart = CurrentTime.u.LowPart; + SharedUserData->SystemTime.High1Time = CurrentTime.u.HighPart; + SharedUserData->SystemTime.High2Time = CurrentTime.u.HighPart; } - NTSTATUS ExpSetTimeZoneInformation(PTIME_ZONE_INFORMATION TimeZoneInformation) { - LARGE_INTEGER LocalTime; - LARGE_INTEGER SystemTime; - TIME_FIELDS TimeFields; + LARGE_INTEGER LocalTime, SystemTime; + TIME_FIELDS TimeFields; + DPRINT("ExpSetTimeZoneInformation() called\n"); - DPRINT("ExpSetTimeZoneInformation() called\n"); + DPRINT("Old time zone bias: %d minutes\n", ExpTimeZoneInfo.Bias); + DPRINT("Old time zone standard bias: %d minutes\n", + ExpTimeZoneInfo.StandardBias); + DPRINT("New time zone bias: %d minutes\n", TimeZoneInformation->Bias); + DPRINT("New time zone standard bias: %d minutes\n", + TimeZoneInformation->StandardBias); - DPRINT("Old time zone bias: %d minutes\n", - ExpTimeZoneInfo.Bias); - DPRINT("Old time zone standard bias: %d minutes\n", - ExpTimeZoneInfo.StandardBias); + /* Get the local time */ + HalQueryRealTimeClock(&TimeFields); + RtlTimeFieldsToTime(&TimeFields, &LocalTime); - DPRINT("New time zone bias: %d minutes\n", - TimeZoneInformation->Bias); - DPRINT("New time zone standard bias: %d minutes\n", - TimeZoneInformation->StandardBias); + /* FIXME: Calculate transition dates */ - /* Get the local time */ - HalQueryRealTimeClock(&TimeFields); - RtlTimeFieldsToTime(&TimeFields, - &LocalTime); + /* Calculate the bias and set the ID */ + ExpTimeZoneBias.QuadPart = ((LONGLONG)(TimeZoneInformation->Bias + + TimeZoneInformation->StandardBias)) * + TICKSPERMINUTE; + ExpTimeZoneId = TIME_ZONE_ID_STANDARD; - /* FIXME: Calculate transition dates */ + /* Copy the timezone information */ + RtlMoveMemory(&ExpTimeZoneInfo, + TimeZoneInformation, + sizeof(TIME_ZONE_INFORMATION)); - ExpTimeZoneBias.QuadPart = - ((LONGLONG)(TimeZoneInformation->Bias + TimeZoneInformation->StandardBias)) * TICKSPERMINUTE; - ExpTimeZoneId = TIME_ZONE_ID_STANDARD; + /* Set the new time zone information */ + SharedUserData->TimeZoneBias.High1Time = ExpTimeZoneBias.u.HighPart; + SharedUserData->TimeZoneBias.High2Time = ExpTimeZoneBias.u.HighPart; + SharedUserData->TimeZoneBias.LowPart = ExpTimeZoneBias.u.LowPart; + SharedUserData->TimeZoneId = ExpTimeZoneId; - memcpy(&ExpTimeZoneInfo, - TimeZoneInformation, - sizeof(TIME_ZONE_INFORMATION)); + DPRINT("New time zone bias: %I64d minutes\n", + ExpTimeZoneBias.QuadPart / TICKSPERMINUTE); - /* Set the new time zone information */ - SharedUserData->TimeZoneBias.High1Time = ExpTimeZoneBias.u.HighPart; - SharedUserData->TimeZoneBias.High2Time = ExpTimeZoneBias.u.HighPart; - SharedUserData->TimeZoneBias.LowPart = ExpTimeZoneBias.u.LowPart; - SharedUserData->TimeZoneId = ExpTimeZoneId; + /* Calculate the new system time */ + ExLocalTimeToSystemTime(&LocalTime, &SystemTime); - DPRINT("New time zone bias: %I64d minutes\n", - ExpTimeZoneBias.QuadPart / TICKSPERMINUTE); + /* Set the new system time */ + KiSetSystemTime(&SystemTime); - /* Calculate the new system time */ - ExLocalTimeToSystemTime(&LocalTime, - &SystemTime); - - /* Set the new system time */ - KiSetSystemTime(&SystemTime); - - DPRINT("ExpSetTimeZoneInformation() done\n"); - - return STATUS_SUCCESS; + /* Return success */ + DPRINT("ExpSetTimeZoneInformation() done\n"); + return STATUS_SUCCESS; } - /* * FUNCTION: Sets the system time. * PARAMETERS: @@ -146,170 +139,159 @@ * old time of day in the standard time format. * RETURNS: Status */ -NTSTATUS STDCALL +NTSTATUS +NTAPI NtSetSystemTime(IN PLARGE_INTEGER SystemTime, - OUT PLARGE_INTEGER PreviousTime OPTIONAL) + OUT PLARGE_INTEGER PreviousTime OPTIONAL) { - LARGE_INTEGER OldSystemTime; - LARGE_INTEGER NewSystemTime; - LARGE_INTEGER LocalTime; - TIME_FIELDS TimeFields; - KPROCESSOR_MODE PreviousMode; - NTSTATUS Status = STATUS_SUCCESS; + LARGE_INTEGER OldSystemTime; + LARGE_INTEGER NewSystemTime; + LARGE_INTEGER LocalTime; + TIME_FIELDS TimeFields; + KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); + NTSTATUS Status = STATUS_SUCCESS; + PAGED_CODE(); - PAGED_CODE(); - - PreviousMode = ExGetPreviousMode(); - - if(PreviousMode != KernelMode) - { - _SEH_TRY + /* Check if we were called from user-mode */ + if(PreviousMode != KernelMode) { - NewSystemTime = ProbeForReadLargeInteger(SystemTime); - if(PreviousTime != NULL) - { - ProbeForWriteLargeInteger(PreviousTime); - } + _SEH_TRY + { + /* Verify the time pointers */ + NewSystemTime = ProbeForReadLargeInteger(SystemTime); + if(PreviousTime) ProbeForWriteLargeInteger(PreviousTime); + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { + Status = _SEH_GetExceptionCode(); + } + _SEH_END; + + /* If the pointers were invalid, bail out */ + if(!NT_SUCCESS(Status)) return Status; } - _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + else { - Status = _SEH_GetExceptionCode(); + /* Reuse the pointer */ + NewSystemTime = *SystemTime; } - _SEH_END; - if(!NT_SUCCESS(Status)) + /* Make sure we have permission to change the time */ + if(!SeSinglePrivilegeCheck(SeSystemtimePrivilege, PreviousMode)) { - return Status; + DPRINT1("NtSetSystemTime: Caller requires the " + "SeSystemtimePrivilege privilege!\n"); + return STATUS_PRIVILEGE_NOT_HELD; } - } - else - { - NewSystemTime = *SystemTime; - } - if(!SeSinglePrivilegeCheck(SeSystemtimePrivilege, - PreviousMode)) - { - DPRINT1("NtSetSystemTime: Caller requires the SeSystemtimePrivilege privilege!\n"); - return STATUS_PRIVILEGE_NOT_HELD; - } + /* Check if caller wants the old time */ + if(PreviousTime) KeQuerySystemTime(&OldSystemTime); - if(PreviousTime != NULL) - { - KeQuerySystemTime(&OldSystemTime); - } + /* Convert the time and set it in HAL */ + ExSystemTimeToLocalTime(&NewSystemTime, &LocalTime); + RtlTimeToTimeFields(&LocalTime, &TimeFields); + HalSetRealTimeClock(&TimeFields); - ExSystemTimeToLocalTime(&NewSystemTime, - &LocalTime); - RtlTimeToTimeFields(&LocalTime, - &TimeFields); - HalSetRealTimeClock(&TimeFields); + /* Now set system time */ + KiSetSystemTime(&NewSystemTime); - /* Set system time */ - KiSetSystemTime(&NewSystemTime); - - if(PreviousTime != NULL) - { - _SEH_TRY + /* Check if caller wanted previous time */ + if(PreviousTime) { - *PreviousTime = OldSystemTime; + /* Enter SEH Block for return */ + _SEH_TRY + { + /* Return the previous time */ + *PreviousTime = OldSystemTime; + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { + Status = _SEH_GetExceptionCode(); + } + _SEH_END; } - _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - } - return STATUS_SUCCESS; + /* Return status */ + return Status; } - /* * FUNCTION: Retrieves the system time. * PARAMETERS: * CurrentTime - Points to a variable that receives the current * time of day in the standard time format. */ -NTSTATUS STDCALL +NTSTATUS +NTAPI NtQuerySystemTime(OUT PLARGE_INTEGER SystemTime) { - KPROCESSOR_MODE PreviousMode; - NTSTATUS Status = STATUS_SUCCESS; + KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); + NTSTATUS Status = STATUS_SUCCESS; + PAGED_CODE(); - PAGED_CODE(); - - PreviousMode = ExGetPreviousMode(); - - if(PreviousMode != KernelMode) - { - _SEH_TRY + /* Check if we were called from user-mode */ + if(PreviousMode != KernelMode) { - ProbeForWriteLargeInteger(SystemTime); + _SEH_TRY + { + /* Verify the time pointer */ + ProbeForWriteLargeInteger(SystemTime); - /* it's safe to pass the pointer directly to KeQuerySystemTime as it's just - a basic copy to these pointer, if it raises an exception nothing dangerous - can happen! */ - KeQuerySystemTime(SystemTime); + /* + * It's safe to pass the pointer directly to KeQuerySystemTime as + * it's just a basic copy to this pointer. If it raises an + * exception nothing dangerous can happen! + */ + KeQuerySystemTime(SystemTime); + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { + Status = _SEH_GetExceptionCode(); + } + _SEH_END; } - _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + else { - Status = _SEH_GetExceptionCode(); + /* Query the time directly */ + KeQuerySystemTime(SystemTime); } - _SEH_END; - } - else - { - KeQuerySystemTime(SystemTime); - } - return Status; + /* Return status to caller */ + return Status; } - /* * @implemented */ VOID -STDCALL -ExLocalTimeToSystemTime ( - PLARGE_INTEGER LocalTime, - PLARGE_INTEGER SystemTime - ) +NTAPI +ExLocalTimeToSystemTime(PLARGE_INTEGER LocalTime, + PLARGE_INTEGER SystemTime) { - SystemTime->QuadPart = - LocalTime->QuadPart + ExpTimeZoneBias.QuadPart; + SystemTime->QuadPart = LocalTime->QuadPart + ExpTimeZoneBias.QuadPart; } - /* * @unimplemented */ ULONG -STDCALL -ExSetTimerResolution ( - IN ULONG DesiredTime, - IN BOOLEAN SetResolution - ) +NTAPI +ExSetTimerResolution(IN ULONG DesiredTime, + IN BOOLEAN SetResolution) { - UNIMPLEMENTED; - + UNIMPLEMENTED; return 0; } - /* * @implemented */ VOID -STDCALL -ExSystemTimeToLocalTime ( - PLARGE_INTEGER SystemTime, - PLARGE_INTEGER LocalTime - ) +NTAPI +ExSystemTimeToLocalTime(PLARGE_INTEGER SystemTime, + PLARGE_INTEGER LocalTime) { - LocalTime->QuadPart = - SystemTime->QuadPart - ExpTimeZoneBias.QuadPart; + LocalTime->QuadPart = SystemTime->QuadPart - ExpTimeZoneBias.QuadPart; } /* EOF */

1 0

[ion] 20433: Forgot to commit this file
by ion＠svn.reactos.org 29 Dec '05

29 Dec '05

Forgot to commit this file Modified: trunk/reactos/include/ndk/ifssupp.h _____ Modified: trunk/reactos/include/ndk/ifssupp.h --- trunk/reactos/include/ndk/ifssupp.h 2005-12-29 18:47:14 UTC (rev 20432) +++ trunk/reactos/include/ndk/ifssupp.h 2005-12-29 18:56:09 UTC (rev 20433) @@ -117,8 +117,6 @@ LIST_ENTRY ThreadListHead; } KQUEUE, *PKQUEUE, *RESTRICTED_POINTER PRKQUEUE; -typedef PVOID EX_PUSH_LOCK; - typedef enum _RTL_GENERIC_COMPARE_RESULTS { GenericLessThan,

1 0

[ion] 20432: - Fix some small formatting issues.
by ion＠svn.reactos.org 29 Dec '05

29 Dec '05

- Fix some small formatting issues. Modified: trunk/reactos/ntoskrnl/ex/event.c Modified: trunk/reactos/ntoskrnl/ex/mutant.c Modified: trunk/reactos/ntoskrnl/ex/sem.c _____ Modified: trunk/reactos/ntoskrnl/ex/event.c --- trunk/reactos/ntoskrnl/ex/event.c 2005-12-29 18:45:16 UTC (rev 20431) +++ trunk/reactos/ntoskrnl/ex/event.c 2005-12-29 18:47:14 UTC (rev 20432) @@ -153,11 +153,13 @@ &hEvent); ObDereferenceObject(Event); - /* Check for success and return handle */ + /* Check for success */ if(NT_SUCCESS(Status)) { + /* Enter SEH for return */ _SEH_TRY { + /* Return the handle to the caller */ *EventHandle = hEvent; } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) @@ -320,14 +322,16 @@ PKEVENT Event; KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status = STATUS_SUCCESS; - PEVENT_BASIC_INFORMATION BasicInfo = (PEVENT_BASIC_INFORMATION)EventInformation; + PEVENT_BASIC_INFORMATION BasicInfo = + (PEVENT_BASIC_INFORMATION)EventInformation; PAGED_CODE(); DPRINT("NtQueryEvent(0x%p, 0x%x)\n", EventHandle, EventInformationClass); /* Check buffers and class validity */ Status = DefaultQueryInfoBufferCheck(EventInformationClass, ExEventInfoClass, - sizeof(ExEventInfoClass) / sizeof(ExEventInfoClass[0]), + sizeof(ExEventInfoClass) / + sizeof(ExEventInfoClass[0]), EventInformation, EventInformationLength, ReturnLength, _____ Modified: trunk/reactos/ntoskrnl/ex/mutant.c --- trunk/reactos/ntoskrnl/ex/mutant.c 2005-12-29 18:45:16 UTC (rev 20431) +++ trunk/reactos/ntoskrnl/ex/mutant.c 2005-12-29 18:47:14 UTC (rev 20432) @@ -1,12 +1,10 @@ /* * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel + * PROJECT: ReactOS Kernel * FILE: ntoskrnl/ex/mutant.c * PURPOSE: Executive Management of Mutants - * - * PROGRAMMERS: Alex Ionescu - Fix tab/space mismatching, tiny fixes to query function and - * add more debug output. - * David Welch (welch(a)cwcom.net) + * PROGRAMMERS: Alex Ionescu (alex(a)relsoft.net) + * Thomas Weidenmueller */ /* INCLUDES *****************************************************************/ @@ -19,31 +17,30 @@ #pragma alloc_text(INIT, ExpInitializeMutantImplementation) #endif -#ifndef MUTANT_INCREMENT -#define MUTANT_INCREMENT 1 -#endif +/* DATA **********************************************************************/ POBJECT_TYPE ExMutantObjectType = NULL; -static GENERIC_MAPPING ExpMutantMapping = { +GENERIC_MAPPING ExpMutantMapping = +{ STANDARD_RIGHTS_READ | SYNCHRONIZE | MUTANT_QUERY_STATE, STANDARD_RIGHTS_WRITE | SYNCHRONIZE, STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE | MUTANT_QUERY_STATE, - MUTANT_ALL_ACCESS}; + MUTANT_ALL_ACCESS +}; -static const INFORMATION_CLASS_INFO ExMutantInfoClass[] = { - +static const INFORMATION_CLASS_INFO ExMutantInfoClass[] = +{ /* MutantBasicInformation */ - ICI_SQ_SAME( sizeof(MUTANT_BASIC_INFORMATION), sizeof(ULONG), ICIF_QUERY ), + ICI_SQ_SAME( sizeof(MUTANT_BASIC_INFORMATION), sizeof(ULONG), ICIF_QUERY), }; /* FUNCTIONS *****************************************************************/ VOID -STDCALL +NTAPI ExpDeleteMutant(PVOID ObjectBody) { - DPRINT("ExpDeleteMutant(ObjectBody 0x%p)\n", ObjectBody); /* Make sure to release the Mutant */ @@ -55,14 +52,13 @@ VOID INIT_FUNCTION -STDCALL +NTAPI ExpInitializeMutantImplementation(VOID) { OBJECT_TYPE_INITIALIZER ObjectTypeInitializer; UNICODE_STRING Name; + DPRINT("Creating Mutant Object Type\n"); - DPRINT("Creating Mutant Object Type\n"); - /* Create the Event Pair Object Type */ RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer)); RtlInitUnicodeString(&Name, L"Mutant"); @@ -79,7 +75,7 @@ * @implemented */ NTSTATUS -STDCALL +NTAPI NtCreateMutant(OUT PHANDLE MutantHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, @@ -89,22 +85,26 @@ HANDLE hMutant; PKMUTANT Mutant; NTSTATUS Status = STATUS_SUCCESS; - PAGED_CODE(); - DPRINT("NtCreateMutant(0x%p, 0x%x, 0x%p)\n", MutantHandle, DesiredAccess, ObjectAttributes); + DPRINT("NtCreateMutant(0x%p, 0x%x, 0x%p)\n", + MutantHandle, DesiredAccess, ObjectAttributes); - /* Check Output Safety */ - if(PreviousMode != KernelMode) { - - _SEH_TRY { - + /* Check if we were called from user-mode */ + if(PreviousMode != KernelMode) + { + /* Enter SEH Block */ + _SEH_TRY + { + /* Check handle pointer */ ProbeForWriteHandle(MutantHandle); - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); + } + _SEH_END; - } _SEH_END; - + /* Bail out if pointer was invalid */ if(!NT_SUCCESS(Status)) return Status; } @@ -120,8 +120,8 @@ (PVOID*)&Mutant); /* Check for success */ - if(NT_SUCCESS(Status)) { - + if(NT_SUCCESS(Status)) + { /* Initalize the Kernel Mutant */ DPRINT("Initializing the Mutant\n"); KeInitializeMutant(Mutant, InitialOwner); @@ -135,18 +135,20 @@ &hMutant); ObDereferenceObject(Mutant); - /* Check for success and return handle */ - if(NT_SUCCESS(Status)) { - - _SEH_TRY { - + /* Check for success */ + if(NT_SUCCESS(Status)) + { + /* Enter SEH for return */ + _SEH_TRY + { + /* Return the handle to the caller */ *MutantHandle = hMutant; - - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); - - } _SEH_END; + } + _SEH_END; } } @@ -158,7 +160,7 @@ * @implemented */ NTSTATUS -STDCALL +NTAPI NtOpenMutant(OUT PHANDLE MutantHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes) @@ -166,22 +168,26 @@ HANDLE hMutant; KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status = STATUS_SUCCESS; - PAGED_CODE(); - DPRINT("NtOpenMutant(0x%p, 0x%x, 0x%p)\n", MutantHandle, DesiredAccess, ObjectAttributes); + DPRINT("NtOpenMutant(0x%p, 0x%x, 0x%p)\n", + MutantHandle, DesiredAccess, ObjectAttributes); - /* Check Output Safety */ - if(PreviousMode != KernelMode) { - - _SEH_TRY { - + /* Check if we were called from user-mode */ + if(PreviousMode != KernelMode) + { + /* Enter SEH Block */ + _SEH_TRY + { + /* Check handle pointer */ ProbeForWriteHandle(MutantHandle); - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); + } + _SEH_END; - } _SEH_END; - + /* Bail out if pointer was invalid */ if(!NT_SUCCESS(Status)) return Status; } @@ -194,18 +200,20 @@ NULL, &hMutant); - /* Check for success and return handle */ - if(NT_SUCCESS(Status)) { - - _SEH_TRY { - + /* Check for success */ + if(NT_SUCCESS(Status)) + { + /* Enter SEH for return */ + _SEH_TRY + { + /* Return the handle to the caller */ *MutantHandle = hMutant; - - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); - - } _SEH_END; + } + _SEH_END; } /* Return Status */ @@ -216,7 +224,7 @@ * @implemented */ NTSTATUS -STDCALL +NTAPI NtQueryMutant(IN HANDLE MutantHandle, IN MUTANT_INFORMATION_CLASS MutantInformationClass, OUT PVOID MutantInformation, @@ -226,20 +234,21 @@ PKMUTANT Mutant; KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status = STATUS_SUCCESS; - PMUTANT_BASIC_INFORMATION BasicInfo = (PMUTANT_BASIC_INFORMATION)MutantInformation; - + PMUTANT_BASIC_INFORMATION BasicInfo = + (PMUTANT_BASIC_INFORMATION)MutantInformation; PAGED_CODE(); /* Check buffers and parameters */ Status = DefaultQueryInfoBufferCheck(MutantInformationClass, ExMutantInfoClass, - sizeof(ExMutantInfoClass) / sizeof(ExMutantInfoClass[0]), + sizeof(ExMutantInfoClass) / + sizeof(ExMutantInfoClass[0]), MutantInformation, MutantInformationLength, ResultLength, PreviousMode); - if(!NT_SUCCESS(Status)) { - + if(!NT_SUCCESS(Status)) + { DPRINT("NtQueryMutant() failed, Status: 0x%x\n", Status); return Status; } @@ -252,25 +261,27 @@ (PVOID*)&Mutant, NULL); /* Check for Status */ - if(NT_SUCCESS(Status)) { - - _SEH_TRY { - + if(NT_SUCCESS(Status)) + { + /* Enter SEH Block for return */ + _SEH_TRY + { /* Fill out the Basic Information Requested */ DPRINT("Returning Mutant Information\n"); BasicInfo->CurrentCount = KeReadStateMutant(Mutant); - BasicInfo->OwnedByCaller = (Mutant->OwnerThread == KeGetCurrentThread()); + BasicInfo->OwnedByCaller = (Mutant->OwnerThread == + KeGetCurrentThread()); BasicInfo->AbandonedState = Mutant->Abandoned; /* Return the Result Length if requested */ if(ResultLength) *ResultLength = sizeof(MUTANT_BASIC_INFORMATION); - - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); + } + _SEH_END; - } _SEH_END; - /* Release the Object */ ObDereferenceObject(Mutant); } @@ -279,39 +290,38 @@ return Status; } - /* * @implemented */ NTSTATUS -STDCALL +NTAPI NtReleaseMutant(IN HANDLE MutantHandle, - IN PLONG PreviousCount OPTIONAL) + IN PLONG PreviousCount OPTIONAL) { PKMUTANT Mutant; - KPROCESSOR_MODE PreviousMode; + KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status = STATUS_SUCCESS; - PAGED_CODE(); - - PreviousMode = ExGetPreviousMode(); - DPRINT("NtReleaseMutant(MutantHandle 0x%p PreviousCount 0x%p)\n", MutantHandle, PreviousCount); - /* Check Output Safety */ - if(PreviousMode != KernelMode && PreviousCount) { - - _SEH_TRY { - + /* Check if we were called from user-mode */ + if((PreviousCount) && (PreviousMode != KernelMode)) + { + /* Entry SEH Block */ + _SEH_TRY + { + /* Make sure the state pointer is valid */ ProbeForWriteLong(PreviousCount); - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); + } + _SEH_END; - } _SEH_END; - + /* Bail out if pointer was invalid */ if(!NT_SUCCESS(Status)) return Status; } @@ -324,25 +334,30 @@ NULL); /* Check for Success and release if such */ - if(NT_SUCCESS(Status)) { + if(NT_SUCCESS(Status)) + { + /* + * Release the mutant. doing so might raise an exception which we're + * required to catch! + */ + _SEH_TRY + { + /* Release the mutant */ + LONG Prev = KeReleaseMutant(Mutant, + MUTANT_INCREMENT, + FALSE, + FALSE); - /* release the mutant. doing so might raise an exception which we're - required to catch! */ - _SEH_TRY { - - LONG Prev = KeReleaseMutant(Mutant, MUTANT_INCREMENT, FALSE, FALSE); - - if(PreviousCount) { - - *PreviousCount = Prev; - } - - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + /* Return the previous count if requested */ + if(PreviousCount) *PreviousCount = Prev; + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); + } + _SEH_END; - } _SEH_END; - + /* Dereference it */ ObDereferenceObject(Mutant); } _____ Modified: trunk/reactos/ntoskrnl/ex/sem.c --- trunk/reactos/ntoskrnl/ex/sem.c 2005-12-29 18:45:16 UTC (rev 20431) +++ trunk/reactos/ntoskrnl/ex/sem.c 2005-12-29 18:47:14 UTC (rev 20432) @@ -1,11 +1,10 @@ /* * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel + * PROJECT: ReactOS Kernel * FILE: ntoskrnl/ex/sem.c * PURPOSE: Semaphore Implementation - * * PROGRAMMERS: Alex Ionescu (alex(a)relsoft.net) - * David Welch (welch(a)mcmail.com) + * Thomas Weidenmueller */ /* INCLUDES *****************************************************************/ @@ -22,7 +21,7 @@ POBJECT_TYPE ExSemaphoreObjectType; -static GENERIC_MAPPING ExSemaphoreMapping = +GENERIC_MAPPING ExSemaphoreMapping = { STANDARD_RIGHTS_READ | SEMAPHORE_QUERY_STATE, STANDARD_RIGHTS_WRITE | SEMAPHORE_MODIFY_STATE, @@ -33,19 +32,20 @@ static const INFORMATION_CLASS_INFO ExSemaphoreInfoClass[] = { /* SemaphoreBasicInformation */ - ICI_SQ_SAME( sizeof(SEMAPHORE_BASIC_INFORMATION), sizeof(ULONG), ICIF_QUERY ), + ICI_SQ_SAME( sizeof(SEMAPHORE_BASIC_INFORMATION), sizeof(ULONG), ICIF_QUERY), }; +/* FUNCTIONS *****************************************************************/ + VOID INIT_FUNCTION -STDCALL +NTAPI ExpInitializeSemaphoreImplementation(VOID) { OBJECT_TYPE_INITIALIZER ObjectTypeInitializer; UNICODE_STRING Name; + DPRINT("Creating Semaphore Object Type\n"); - DPRINT("Creating Semaphore Object Type\n"); - /* Create the Event Pair Object Type */ RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer)); RtlInitUnicodeString(&Name, L"Semaphore"); @@ -62,10 +62,10 @@ * @implemented */ NTSTATUS -STDCALL +NTAPI NtCreateSemaphore(OUT PHANDLE SemaphoreHandle, IN ACCESS_MASK DesiredAccess, - IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, + IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN LONG InitialCount, IN LONG MaximumCount) { @@ -75,11 +75,13 @@ NTSTATUS Status = STATUS_SUCCESS; PAGED_CODE(); - /* Check Output Safety */ + /* Check if we were called from user-mode */ if(PreviousMode != KernelMode) { - _SEH_TRY + /* Enter SEH Block */ + _SEH_TRY { + /* Check handle pointer */ ProbeForWriteHandle(SemaphoreHandle); } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) @@ -88,11 +90,14 @@ } _SEH_END; + /* Bail out if pointer was invalid */ if(!NT_SUCCESS(Status)) return Status; } /* Make sure the counts make sense */ - if (MaximumCount <= 0 || InitialCount < 0 || InitialCount > MaximumCount) + if ((MaximumCount <= 0) || + (InitialCount < 0) || + (InitialCount > MaximumCount)) { DPRINT("Invalid Count Data!\n"); return STATUS_INVALID_PARAMETER; @@ -126,11 +131,13 @@ &hSemaphore); ObDereferenceObject(Semaphore); - /* Check for success and return handle */ + /* Check for success */ if(NT_SUCCESS(Status)) { + /* Enter SEH Block for return */ _SEH_TRY { + /* Return the handle */ *SemaphoreHandle = hSemaphore; } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) @@ -149,7 +156,7 @@ * @implemented */ NTSTATUS -STDCALL +NTAPI NtOpenSemaphore(OUT PHANDLE SemaphoreHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes) @@ -159,11 +166,13 @@ NTSTATUS Status = STATUS_SUCCESS; PAGED_CODE(); - /* Check Output Safety */ + /* Check if we were called from user-mode */ if(PreviousMode != KernelMode) { + /* Enter SEH Block */ _SEH_TRY { + /* Check handle pointer */ ProbeForWriteHandle(SemaphoreHandle); } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) @@ -172,6 +181,7 @@ } _SEH_END; + /* Bail out if pointer was invalid */ if(!NT_SUCCESS(Status)) return Status; } @@ -184,17 +194,20 @@ NULL, &hSemaphore); - /* Check for success and return handle */ + /* Check for success */ if(NT_SUCCESS(Status)) { + /* Enter SEH Block for return */ _SEH_TRY { + /* Return the handle */ *SemaphoreHandle = hSemaphore; } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { Status = _SEH_GetExceptionCode(); - } _SEH_END; + } + _SEH_END; } /* Return Status */ @@ -205,7 +218,7 @@ * @implemented */ NTSTATUS -STDCALL +NTAPI NtQuerySemaphore(IN HANDLE SemaphoreHandle, IN SEMAPHORE_INFORMATION_CLASS SemaphoreInformationClass, OUT PVOID SemaphoreInformation, @@ -215,13 +228,13 @@ PKSEMAPHORE Semaphore; KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status = STATUS_SUCCESS; - PAGED_CODE(); /* Check buffers and class validity */ Status = DefaultQueryInfoBufferCheck(SemaphoreInformationClass, ExSemaphoreInfoClass, - sizeof(ExSemaphoreInfoClass) / sizeof(ExSemaphoreInfoClass[0]), + sizeof(ExSemaphoreInfoClass) / + sizeof(ExSemaphoreInfoClass[0]), SemaphoreInformation, SemaphoreInformationLength, ReturnLength, @@ -244,22 +257,24 @@ /* Check for success */ if(NT_SUCCESS(Status)) { + /* Entry SEH Block */ _SEH_TRY { - PSEMAPHORE_BASIC_INFORMATION BasicInfo = (PSEMAPHORE_BASIC_INFORMATION)SemaphoreInformation; + PSEMAPHORE_BASIC_INFORMATION BasicInfo = + (PSEMAPHORE_BASIC_INFORMATION)SemaphoreInformation; /* Return the basic information */ BasicInfo->CurrentCount = KeReadStateSemaphore(Semaphore); BasicInfo->MaximumCount = Semaphore->Limit; - /* Return length */ - if(ReturnLength) *ReturnLength = sizeof(SEMAPHORE_BASIC_INFORMATION); - + /* Return the length */ + if(ReturnLength) *ReturnLength = sizeof(*BasicInfo); } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { Status = _SEH_GetExceptionCode(); - } _SEH_END; + } + _SEH_END; /* Dereference the Object */ ObDereferenceObject(Semaphore); @@ -273,22 +288,23 @@ * @implemented */ NTSTATUS -STDCALL +NTAPI NtReleaseSemaphore(IN HANDLE SemaphoreHandle, IN LONG ReleaseCount, - OUT PLONG PreviousCount OPTIONAL) + OUT PLONG PreviousCount OPTIONAL) { KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); PKSEMAPHORE Semaphore; NTSTATUS Status = STATUS_SUCCESS; - PAGED_CODE(); - /* Check buffer validity */ - if(PreviousCount && PreviousMode != KernelMode) + /* Check if we were called from user-mode */ + if((PreviousCount) && (PreviousMode != KernelMode)) { + /* Entry SEH Block */ _SEH_TRY { + /* Make sure the state pointer is valid */ ProbeForWriteLong(PreviousCount); } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) @@ -297,6 +313,7 @@ } _SEH_END; + /* Bail out if pointer was invalid */ if(!NT_SUCCESS(Status)) return Status; } @@ -318,9 +335,10 @@ /* Check for success */ if (NT_SUCCESS(Status)) { - /* Release the semaphore */ + /* Enter SEH Block */ _SEH_TRY { + /* Release the semaphore */ LONG PrevCount = KeReleaseSemaphore(Semaphore, IO_NO_INCREMENT, ReleaseCount, @@ -328,10 +346,7 @@ ObDereferenceObject(Semaphore); /* Return the old count if requested */ - if(PreviousCount) - { - *PreviousCount = PrevCount; - } + if(PreviousCount) *PreviousCount = PrevCount; } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) {

1 0

[ion] 20431: Fix build
by ion＠svn.reactos.org 29 Dec '05

29 Dec '05

Fix build Modified: trunk/reactos/ntoskrnl/ke/profile.c _____ Modified: trunk/reactos/ntoskrnl/ke/profile.c --- trunk/reactos/ntoskrnl/ke/profile.c 2005-12-29 18:45:00 UTC (rev 20430) +++ trunk/reactos/ntoskrnl/ke/profile.c 2005-12-29 18:45:16 UTC (rev 20431) @@ -122,7 +122,7 @@ if (!FreeBuffer) ExFreePool(SourceBuffer); } -VOID +BOOLEAN STDCALL KeStopProfile(PKPROFILE Profile) { @@ -161,6 +161,9 @@ /* Free the Source Object */ if (CurrentSource) ExFreePool(CurrentSource); + + /* FIXME */ + return FALSE; } ULONG

1 0

[ion] 20430: Move pushlock definition. It is gone from MS headers now.
by ion＠svn.reactos.org 29 Dec '05

29 Dec '05

Move pushlock definition. It is gone from MS headers now. Modified: trunk/reactos/include/ndk/extypes.h Modified: trunk/reactos/w32api/include/ddk/ntifs.h _____ Modified: trunk/reactos/include/ndk/extypes.h --- trunk/reactos/include/ndk/extypes.h 2005-12-29 18:28:05 UTC (rev 20429) +++ trunk/reactos/include/ndk/extypes.h 2005-12-29 18:45:00 UTC (rev 20430) @@ -101,6 +101,17 @@ #define MAXIMUM_HARDERROR_PARAMETERS 4 // +// Pushlock bits +// +#define EX_PUSH_LOCK_LOCK_V ((ULONG_PTR)0x0) +#define EX_PUSH_LOCK_LOCK ((ULONG_PTR)0x1) +#define EX_PUSH_LOCK_WAITING ((ULONG_PTR)0x2) +#define EX_PUSH_LOCK_WAKING ((ULONG_PTR)0x4) +#define EX_PUSH_LOCK_MULTIPLE_SHARED ((ULONG_PTR)0x8) +#define EX_PUSH_LOCK_SHARE_INC ((ULONG_PTR)0x10) +#define EX_PUSH_LOCK_PTR_BITS ((ULONG_PTR)0xf) + +// // Pushlock Wait Block Flags // #define EX_PUSH_LOCK_FLAGS_EXCLUSIVE 1 @@ -305,6 +316,26 @@ } EX_RUNDOWN_WAIT_BLOCK, *PEX_RUNDOWN_WAIT_BLOCK; // +// Executive Pushlock +// +typedef struct _EX_PUSH_LOCK +{ + union + { + struct + { + ULONG_PTR Locked:1; + ULONG_PTR Waiting:1; + ULONG_PTR Waking:1; + ULONG_PTR MultipleShared:1; + ULONG_PTR Shared:sizeof (ULONG_PTR) * 8 - 4; + }; + ULONG_PTR Value; + PVOID Ptr; + }; +} EX_PUSH_LOCK, *PEX_PUSH_LOCK; + +// // Executive Pushlock Wait Block // #ifndef __GNUC__ // WARNING! PUSHLOCKS WILL NOT WORK IN GCC FOR NOW!!! _____ Modified: trunk/reactos/w32api/include/ddk/ntifs.h --- trunk/reactos/w32api/include/ddk/ntifs.h 2005-12-29 18:28:05 UTC (rev 20429) +++ trunk/reactos/w32api/include/ddk/ntifs.h 2005-12-29 18:45:00 UTC (rev 20430) @@ -619,31 +619,6 @@ ULONG CompressedChunkSizes[ANYSIZE_ARRAY]; } COMPRESSED_DATA_INFO, *PCOMPRESSED_DATA_INFO; -#define EX_PUSH_LOCK_LOCK_V ((ULONG_PTR)0x0) -#define EX_PUSH_LOCK_LOCK ((ULONG_PTR)0x1) -#define EX_PUSH_LOCK_WAITING ((ULONG_PTR)0x2) -#define EX_PUSH_LOCK_WAKING ((ULONG_PTR)0x4) -#define EX_PUSH_LOCK_MULTIPLE_SHARED ((ULONG_PTR)0x8) -#define EX_PUSH_LOCK_SHARE_INC ((ULONG_PTR)0x10) -#define EX_PUSH_LOCK_PTR_BITS ((ULONG_PTR)0xf) - -typedef struct _EX_PUSH_LOCK -{ - union - { - struct - { - ULONG_PTR Locked:1; - ULONG_PTR Waiting:1; - ULONG_PTR Waking:1; - ULONG_PTR MultipleShared:1; - ULONG_PTR Shared:sizeof (ULONG_PTR) * 8 - 4; - }; - ULONG_PTR Value; - PVOID Ptr; - }; -} EX_PUSH_LOCK, *PEX_PUSH_LOCK; - typedef struct _SID_IDENTIFIER_AUTHORITY { BYTE Value[6]; } SID_IDENTIFIER_AUTHORITY,*PSID_IDENTIFIER_AUTHORITY,*LPSID_IDENTIFIER_AU THORITY; @@ -2186,6 +2161,7 @@ #if (VER_PRODUCTBUILD >= 2600) +#ifndef __NTOSKRNL__ NTKERNELAPI VOID FASTCALL @@ -2244,6 +2220,7 @@ IN PEX_RUNDOWN_REF RunRef ); +#endif #endif /* (VER_PRODUCTBUILD >= 2600) */ #define FlagOn(x, f) ((x) & (f))

1 0

[ion] 20429: - Formatting fixes
by ion＠svn.reactos.org 29 Dec '05

29 Dec '05

- Formatting fixes - Add SEH to NtRaiseHardError. Modified: trunk/reactos/ntoskrnl/ex/error.c _____ Modified: trunk/reactos/ntoskrnl/ex/error.c --- trunk/reactos/ntoskrnl/ex/error.c 2005-12-29 18:03:24 UTC (rev 20428) +++ trunk/reactos/ntoskrnl/ex/error.c 2005-12-29 18:28:05 UTC (rev 20429) @@ -1,10 +1,9 @@ /* * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel + * PROJECT: ReactOS Kernel * FILE: ntoskrnl/ex/error.c * PURPOSE: Error Functions and Status/Exception Dispatching/Raising - * - * PROGRAMMERS: Alex Ionescu (alex(a)relsoft.net) - Created File + * PROGRAMMERS: Alex Ionescu (alex(a)relsoft.net) */ /* INCLUDES *****************************************************************/ @@ -13,6 +12,8 @@ #define NDEBUG #include <internal/debug.h> +#define TAG_ERR TAG('E', 'r', 'r', ' ') + /* GLOBALS ****************************************************************/ BOOLEAN ExReadyForErrors = FALSE; @@ -21,11 +22,23 @@ /* FUNCTIONS ****************************************************************/ +VOID +NTAPI +ExpRaiseHardError(IN NTSTATUS ErrorStatus, + IN ULONG NumberOfParameters, + IN ULONG UnicodeStringParameterMask, + IN PULONG_PTR Parameters, + IN ULONG ValidResponseOptions, + OUT PULONG Response) +{ + UNIMPLEMENTED; +} + /* * @implemented */ VOID -STDCALL +NTAPI ExRaiseAccessViolation(VOID) { /* Raise the Right Status */ @@ -36,7 +49,7 @@ * @implemented */ VOID -STDCALL +NTAPI ExRaiseDatatypeMisalignment (VOID) { /* Raise the Right Status */ @@ -47,17 +60,18 @@ * @implemented */ LONG -STDCALL +NTAPI ExSystemExceptionFilter(VOID) { - return KeGetPreviousMode() != KernelMode ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH; + return KeGetPreviousMode() != KernelMode ? + EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH; } /* * @unimplemented */ VOID -STDCALL +NTAPI ExRaiseHardError(IN NTSTATUS ErrorStatus, IN ULONG NumberOfParameters, IN ULONG UnicodeStringParameterMask, @@ -65,11 +79,19 @@ IN ULONG ValidResponseOptions, OUT PULONG Response) { - UNIMPLEMENTED; + /* FIXME: Capture to user-mode! */ + + /* Now call the worker function */ + ExpRaiseHardError(ErrorStatus, + NumberOfParameters, + UnicodeStringParameterMask, + Parameters, + ValidResponseOptions, + Response); } NTSTATUS -STDCALL +NTAPI NtRaiseHardError(IN NTSTATUS ErrorStatus, IN ULONG NumberOfParameters, IN ULONG UnicodeStringParameterMask, @@ -77,37 +99,184 @@ IN ULONG ValidResponseOptions, OUT PULONG Response) { + NTSTATUS Status; + PULONG_PTR SafeParams = NULL; + ULONG SafeResponse; + UNICODE_STRING SafeString; + ULONG i; + ULONG ParamSize; + KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); DPRINT1("Hard error %x\n", ErrorStatus); - /* Call the Executive Function (WE SHOULD PUT SEH HERE/CAPTURE!) */ - ExRaiseHardError(ErrorStatus, - NumberOfParameters, - UnicodeStringParameterMask, - Parameters, - ValidResponseOptions, - Response); + /* Validate parameter count */ + if (NumberOfParameters > MAXIMUM_HARDERROR_PARAMETERS) + { + /* Fail */ + DPRINT1("Invalid parameters\n"); + return STATUS_INVALID_PARAMETER_2; + } - /* Return Success */ - return STATUS_SUCCESS; + /* Make sure we have some at least */ + if ((Parameters) && !(NumberOfParameters)) + { + /* Fail */ + DPRINT1("Invalid parameters\n"); + return STATUS_INVALID_PARAMETER_2; + } + + /* Check if we were called from user-mode */ + if (PreviousMode != KernelMode) + { + /* First validate the responses */ + switch (ValidResponseOptions) + { + /* Check all valid cases */ + case OptionAbortRetryIgnore: + case OptionOk: + case OptionOkCancel: + case OptionRetryCancel: + case OptionYesNo: + case OptionYesNoCancel: + case OptionShutdownSystem: + break; + + /* Anything else is invalid */ + default: + return STATUS_INVALID_PARAMETER_4; + } + + /* Enter SEH Block */ + _SEH_TRY + { + /* Validate the response pointer */ + ProbeForWriteUlong(Response); + + /* Check if we have parameters */ + if (Parameters) + { + /* Validate the parameter pointers */ + ParamSize = sizeof(ULONG_PTR) * NumberOfParameters; + ProbeForRead(Parameters, ParamSize, sizeof(ULONG_PTR)); + + /* Allocate a safe buffer */ + SafeParams = ExAllocatePoolWithTag(PagedPool, + ParamSize, + TAG_ERR); + + /* Copy them */ + RtlMoveMemory(SafeParams, Parameters, ParamSize); + + /* Nowo check if there's strings in it */ + if (UnicodeStringParameterMask) + { + /* Loop every string */ + for (i = 0; i < NumberOfParameters; i++) + { + /* Check if this parameter is a string */ + if (UnicodeStringParameterMask & (1 << i)) + { + /* Probe the structure */ + ProbeForRead((PVOID)SafeParams[i], + sizeof(UNICODE_STRING), + sizeof(ULONG_PTR)); + + /* Capture it */ + RtlMoveMemory(&SafeString, + (PVOID)SafeParams[i], + sizeof(UNICODE_STRING)); + + /* Probe the buffer */ + ProbeForRead(SafeString.Buffer, + SafeString.MaximumLength, + sizeof(UCHAR)); + } + } + } + } + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { + /* Free captured buffer */ + if (SafeParams) ExFreePool(SafeParams); + Status = _SEH_GetExceptionCode(); + } + _SEH_END; + + /* If we failed to capture/probe, bail out */ + if (!NT_SUCCESS(Status)) return Status; + + /* Call the system function directly, because we probed */ + ExpRaiseHardError(ErrorStatus, + NumberOfParameters, + UnicodeStringParameterMask, + SafeParams, + ValidResponseOptions, + &SafeResponse); + } + else + { + /* Reuse variable */ + SafeParams = Parameters; + + /* + * Call the Executive Function. It will probe and copy pointers to + * user-mode + */ + ExRaiseHardError(ErrorStatus, + NumberOfParameters, + UnicodeStringParameterMask, + SafeParams, + ValidResponseOptions, + &SafeResponse); + } + + /* Check if we were called in user-mode */ + if (PreviousMode != KernelMode) + { + /* That means we have a buffer to free */ + if (SafeParams) ExFreePool(SafeParams); + + /* Enter SEH Block for return */ + _SEH_TRY + { + /* Return the response */ + *Response = SafeResponse; + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { + Status = _SEH_GetExceptionCode(); + } + _SEH_END; + } + else + { + /* Return the response */ + *Response = SafeResponse; + } + + /* Return status */ + return Status; } NTSTATUS -STDCALL +NTAPI NtSetDefaultHardErrorPort(IN HANDLE PortHandle) { KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status = STATUS_UNSUCCESSFUL; /* Check if we have the Privilege */ - if(!SeSinglePrivilegeCheck(SeTcbPrivilege, PreviousMode)) { - - DPRINT1("NtSetDefaultHardErrorPort: Caller requires the SeTcbPrivilege privilege!\n"); + if(!SeSinglePrivilegeCheck(SeTcbPrivilege, PreviousMode)) + { + DPRINT1("NtSetDefaultHardErrorPort: Caller requires " + "the SeTcbPrivilege privilege!\n"); return STATUS_PRIVILEGE_NOT_HELD; } /* Only called once during bootup, make sure we weren't called yet */ - if(!ExReadyForErrors) { - + if(!ExReadyForErrors) + { + /* Reference the port */ Status = ObReferenceObjectByHandle(PortHandle, 0, LpcPortObjectType, @@ -116,14 +285,15 @@ NULL); /* Check for Success */ - if(NT_SUCCESS(Status)) { - + if(NT_SUCCESS(Status)) + { /* Save the data */ ExpDefaultErrorPortProcess = PsGetCurrentProcess(); ExReadyForErrors = TRUE; } } + /* Return status to caller */ return Status; }

1 0

[ion] 20428: - Fix some formatting.
by ion＠svn.reactos.org 29 Dec '05

29 Dec '05

- Fix some formatting. Modified: trunk/reactos/ntoskrnl/ex/event.c Modified: trunk/reactos/ntoskrnl/ex/evtpair.c _____ Modified: trunk/reactos/ntoskrnl/ex/event.c --- trunk/reactos/ntoskrnl/ex/event.c 2005-12-29 17:57:11 UTC (rev 20427) +++ trunk/reactos/ntoskrnl/ex/event.c 2005-12-29 18:03:24 UTC (rev 20428) @@ -1,11 +1,10 @@ /* * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel - * FILE: ntoskrnl/nt/event.c - * PURPOSE: Named event support - * - * PROGRAMMERS: Alex Ionescu(alex(a)relsoft.net) - Fixed bugs/commented - * Philip Susi and David Welch + * PROJECT: ReactOS Kernel + * FILE: ntoskrnl/ex/event.c + * PURPOSE: Event support + * PROGRAMMERS: Alex Ionescu(alex(a)relsoft.net) + * Thomas Weidenmueller */ /* INCLUDES *****************************************************************/ @@ -22,14 +21,15 @@ POBJECT_TYPE ExEventObjectType = NULL; -static GENERIC_MAPPING ExpEventMapping = { +GENERIC_MAPPING ExpEventMapping = +{ STANDARD_RIGHTS_READ | SYNCHRONIZE | EVENT_QUERY_STATE, STANDARD_RIGHTS_WRITE | SYNCHRONIZE | EVENT_MODIFY_STATE, STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE | EVENT_QUERY_STATE, EVENT_ALL_ACCESS}; -static const INFORMATION_CLASS_INFO ExEventInfoClass[] = { - +static const INFORMATION_CLASS_INFO ExEventInfoClass[] = +{ /* EventBasicInformation */ ICI_SQ_SAME( sizeof(EVENT_BASIC_INFORMATION), sizeof(ULONG), ICIF_QUERY), }; @@ -38,35 +38,33 @@ VOID INIT_FUNCTION -STDCALL +NTAPI ExpInitializeEventImplementation(VOID) { - OBJECT_TYPE_INITIALIZER ObjectTypeInitializer; - UNICODE_STRING Name; + OBJECT_TYPE_INITIALIZER ObjectTypeInitializer; + UNICODE_STRING Name; + DPRINT("Creating Event Object Type\n"); - DPRINT("Creating Event Object Type\n"); - - /* Create the Event Object Type */ - RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer)); - RtlInitUnicodeString(&Name, L"Event"); - ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer); - ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KEVENT); - ObjectTypeInitializer.GenericMapping = ExpEventMapping; - ObjectTypeInitializer.PoolType = NonPagedPool; - ObjectTypeInitializer.ValidAccessMask = EVENT_ALL_ACCESS; - ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ExEventObjectType); + /* Create the Event Object Type */ + RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer)); + RtlInitUnicodeString(&Name, L"Event"); + ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer); + ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KEVENT); + ObjectTypeInitializer.GenericMapping = ExpEventMapping; + ObjectTypeInitializer.PoolType = NonPagedPool; + ObjectTypeInitializer.ValidAccessMask = EVENT_ALL_ACCESS; + ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ExEventObjectType); } /* * @implemented */ NTSTATUS -STDCALL +NTAPI NtClearEvent(IN HANDLE EventHandle) { PKEVENT Event; NTSTATUS Status; - PAGED_CODE(); /* Reference the Object */ @@ -78,8 +76,8 @@ NULL); /* Check for Success */ - if(NT_SUCCESS(Status)) { - + if(NT_SUCCESS(Status)) + { /* Clear the Event and Dereference */ KeClearEvent(Event); ObDereferenceObject(Event); @@ -89,12 +87,11 @@ return Status; } - /* * @implemented */ NTSTATUS -STDCALL +NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, @@ -105,22 +102,26 @@ PKEVENT Event; HANDLE hEvent; NTSTATUS Status = STATUS_SUCCESS; - PAGED_CODE(); - DPRINT("NtCreateEvent(0x%p, 0x%x, 0x%p)\n", EventHandle, DesiredAccess, ObjectAttributes); + DPRINT("NtCreateEvent(0x%p, 0x%x, 0x%p)\n", + EventHandle, DesiredAccess, ObjectAttributes); - /* Check Output Safety */ - if(PreviousMode != KernelMode) { - - _SEH_TRY { - + /* Check if we were called from user-mode */ + if(PreviousMode != KernelMode) + { + /* Enter SEH Block */ + _SEH_TRY + { + /* Check handle pointer */ ProbeForWriteHandle(EventHandle); - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); + } + _SEH_END; - } _SEH_END; - + /* Bail out if pointer was invalid */ if(!NT_SUCCESS(Status)) return Status; } @@ -136,8 +137,8 @@ (PVOID*)&Event); /* Check for Success */ - if(NT_SUCCESS(Status)) { - + if(NT_SUCCESS(Status)) + { /* Initalize the Event */ KeInitializeEvent(Event, EventType, @@ -153,17 +154,17 @@ ObDereferenceObject(Event); /* Check for success and return handle */ - if(NT_SUCCESS(Status)) { - - _SEH_TRY { - + if(NT_SUCCESS(Status)) + { + _SEH_TRY + { *EventHandle = hEvent; - - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); - - } _SEH_END; + } + _SEH_END; } } @@ -175,7 +176,7 @@ * @implemented */ NTSTATUS -STDCALL +NTAPI NtOpenEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes) @@ -183,22 +184,26 @@ HANDLE hEvent; KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status = STATUS_SUCCESS; - PAGED_CODE(); - DPRINT("NtOpenEvent(0x%p, 0x%x, 0x%p)\n", EventHandle, DesiredAccess, ObjectAttributes); + DPRINT("NtOpenEvent(0x%p, 0x%x, 0x%p)\n", + EventHandle, DesiredAccess, ObjectAttributes); - /* Check Output Safety */ - if(PreviousMode != KernelMode) { - - _SEH_TRY { - + /* Check if we were called from user-mode */ + if(PreviousMode != KernelMode) + { + /* Enter SEH Block */ + _SEH_TRY + { + /* Check handle pointer */ ProbeForWriteHandle(EventHandle); - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); + } + _SEH_END; - } _SEH_END; - + /* Bail out if pointer was invalid */ if(!NT_SUCCESS(Status)) return Status; } @@ -211,18 +216,20 @@ NULL, &hEvent); - /* Check for success and return handle */ - if(NT_SUCCESS(Status)) { - - _SEH_TRY { - + /* Check for success */ + if(NT_SUCCESS(Status)) + { + /* Enter SEH for return */ + _SEH_TRY + { + /* Return the handle to the caller */ *EventHandle = hEvent; - - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); - - } _SEH_END; + } + _SEH_END; } /* Return status */ @@ -233,30 +240,33 @@ * @implemented */ NTSTATUS -STDCALL +NTAPI NtPulseEvent(IN HANDLE EventHandle, OUT PLONG PreviousState OPTIONAL) { PKEVENT Event; KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status = STATUS_SUCCESS; - PAGED_CODE(); DPRINT("NtPulseEvent(EventHandle 0%x PreviousState 0%x)\n", EventHandle, PreviousState); - /* Check buffer validity */ - if(PreviousState && PreviousMode != KernelMode) { - - _SEH_TRY { - + /* Check if we were called from user-mode */ + if((PreviousState) && (PreviousMode != KernelMode)) + { + /* Entry SEH Block */ + _SEH_TRY + { + /* Make sure the state pointer is valid */ ProbeForWriteLong(PreviousState); - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); + } + _SEH_END; - } _SEH_END; - + /* Bail out if pointer was invalid */ if(!NT_SUCCESS(Status)) return Status; } @@ -269,24 +279,26 @@ NULL); /* Check for success */ - if(NT_SUCCESS(Status)) { - + if(NT_SUCCESS(Status)) + { /* Pulse the Event */ LONG Prev = KePulseEvent(Event, EVENT_INCREMENT, FALSE); ObDereferenceObject(Event); - /* Return it */ - if(PreviousState) { - - _SEH_TRY { - + /* Check if caller wants the old state back */ + if(PreviousState) + { + /* Entry SEH Block for return */ + _SEH_TRY + { + /* Return previous state */ *PreviousState = Prev; - - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); - - } _SEH_END; + } + _SEH_END; } } @@ -294,12 +306,11 @@ return Status; } - /* * @implemented */ NTSTATUS -STDCALL +NTAPI NtQueryEvent(IN HANDLE EventHandle, IN EVENT_INFORMATION_CLASS EventInformationClass, OUT PVOID EventInformation, @@ -310,7 +321,6 @@ KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status = STATUS_SUCCESS; PEVENT_BASIC_INFORMATION BasicInfo = (PEVENT_BASIC_INFORMATION)EventInformation; - PAGED_CODE(); DPRINT("NtQueryEvent(0x%p, 0x%x)\n", EventHandle, EventInformationClass); @@ -322,8 +332,8 @@ EventInformationLength, ReturnLength, PreviousMode); - if(!NT_SUCCESS(Status)) { - + if(!NT_SUCCESS(Status)) + { /* Invalid buffers */ DPRINT("NtQuerySemaphore() failed, Status: 0x%x\n", Status); return Status; @@ -338,23 +348,24 @@ NULL); /* Check for success */ - if(NT_SUCCESS(Status)) { - - _SEH_TRY { - + if(NT_SUCCESS(Status)) + { + /* Entry SEH Block */ + _SEH_TRY + { /* Return Event Type and State */ BasicInfo->EventType = Event->Header.Type; BasicInfo->EventState = KeReadStateEvent(Event); /* Return length */ if(ReturnLength) *ReturnLength = sizeof(EVENT_BASIC_INFORMATION); - - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); + } + _SEH_END; - } _SEH_END; - /* Dereference the Object */ ObDereferenceObject(Event); } @@ -367,30 +378,33 @@ * @implemented */ NTSTATUS -STDCALL +NTAPI NtResetEvent(IN HANDLE EventHandle, OUT PLONG PreviousState OPTIONAL) { PKEVENT Event; KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status = STATUS_SUCCESS; - PAGED_CODE(); DPRINT("NtResetEvent(EventHandle 0%x PreviousState 0%x)\n", EventHandle, PreviousState); - /* Check buffer validity */ - if(PreviousState && PreviousMode != KernelMode) { - - _SEH_TRY { - + /* Check if we were called from user-mode */ + if((PreviousState) && (PreviousMode != KernelMode)) + { + /* Entry SEH Block */ + _SEH_TRY + { + /* Make sure the state pointer is valid */ ProbeForWriteLong(PreviousState); - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); + } + _SEH_END; - } _SEH_END; - + /* Bail out if pointer was invalid */ if(!NT_SUCCESS(Status)) return Status; } @@ -403,24 +417,26 @@ NULL); /* Check for success */ - if(NT_SUCCESS(Status)) { - + if(NT_SUCCESS(Status)) + { /* Reset the Event */ LONG Prev = KeResetEvent(Event); ObDereferenceObject(Event); - /* Return it */ - if(PreviousState) { - - _SEH_TRY { - + /* Check if caller wants the old state back */ + if(PreviousState) + { + /* Entry SEH Block for return */ + _SEH_TRY + { + /* Return previous state */ *PreviousState = Prev; - - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); - - } _SEH_END; + } + _SEH_END; } } @@ -432,30 +448,33 @@ * @implemented */ NTSTATUS -STDCALL +NTAPI NtSetEvent(IN HANDLE EventHandle, OUT PLONG PreviousState OPTIONAL) { PKEVENT Event; KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status = STATUS_SUCCESS; - PAGED_CODE(); DPRINT("NtSetEvent(EventHandle 0%x PreviousState 0%x)\n", EventHandle, PreviousState); - /* Check buffer validity */ - if(PreviousState != NULL && PreviousMode != KernelMode) { - - _SEH_TRY { - + /* Check if we were called from user-mode */ + if((PreviousState) && (PreviousMode != KernelMode)) + { + /* Entry SEH Block */ + _SEH_TRY + { + /* Make sure the state pointer is valid */ ProbeForWriteLong(PreviousState); - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); + } + _SEH_END; - } _SEH_END; - + /* Bail out if pointer was invalid */ if(!NT_SUCCESS(Status)) return Status; } @@ -468,24 +487,26 @@ NULL); /* Check for success */ - if(NT_SUCCESS(Status)) { - + if(NT_SUCCESS(Status)) + { /* Set the Event */ LONG Prev = KeSetEvent(Event, EVENT_INCREMENT, FALSE); ObDereferenceObject(Event); - /* Return it */ - if(PreviousState) { - - _SEH_TRY { - + /* Check if caller wants the old state back */ + if(PreviousState) + { + /* Entry SEH Block for return */ + _SEH_TRY + { + /* Return previous state */ *PreviousState = Prev; - - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); - - } _SEH_END; + } + _SEH_END; } } _____ Modified: trunk/reactos/ntoskrnl/ex/evtpair.c --- trunk/reactos/ntoskrnl/ex/evtpair.c 2005-12-29 17:57:11 UTC (rev 20427) +++ trunk/reactos/ntoskrnl/ex/evtpair.c 2005-12-29 18:03:24 UTC (rev 20428) @@ -1,13 +1,10 @@ /* * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel + * PROJECT: ReactOS Kernel * FILE: ntoskrnl/ex/evtpair.c * PURPOSE: Support for event pairs - * - * PROGRAMMERS: Alex Ionescu (Commented, reorganized, removed Thread Pair, used - * KeInitializeEventPair, added SEH) - * David Welch (welch(a)mcmail.com) - * Skywing (skywing(a)valhallalegends.com) + * PROGRAMMERS: Alex Ionescu (alex(a)relsoft.net) + * Thomas Weidenmueller */ /* INCLUDES *****************************************************************/ @@ -24,39 +21,39 @@ POBJECT_TYPE ExEventPairObjectType = NULL; -static GENERIC_MAPPING ExEventPairMapping = { +GENERIC_MAPPING ExEventPairMapping = +{ STANDARD_RIGHTS_READ, STANDARD_RIGHTS_WRITE, STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE, - EVENT_PAIR_ALL_ACCESS}; + EVENT_PAIR_ALL_ACCESS +}; - /* FUNCTIONS *****************************************************************/ VOID INIT_FUNCTION -STDCALL +NTAPI ExpInitializeEventPairImplementation(VOID) { - OBJECT_TYPE_INITIALIZER ObjectTypeInitializer; - UNICODE_STRING Name; + OBJECT_TYPE_INITIALIZER ObjectTypeInitializer; + UNICODE_STRING Name; + DPRINT("Creating Event Pair Object Type\n"); - DPRINT("Creating Event Pair Object Type\n"); - - /* Create the Event Pair Object Type */ - RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer)); - RtlInitUnicodeString(&Name, L"EventPair"); - ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer); - ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KEVENT_PAIR); - ObjectTypeInitializer.GenericMapping = ExEventPairMapping; - ObjectTypeInitializer.PoolType = NonPagedPool; - ObjectTypeInitializer.ValidAccessMask = EVENT_PAIR_ALL_ACCESS; - ObjectTypeInitializer.UseDefaultObject = TRUE; - ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ExEventPairObjectType); + /* Create the Event Pair Object Type */ + RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer)); + RtlInitUnicodeString(&Name, L"EventPair"); + ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer); + ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KEVENT_PAIR); + ObjectTypeInitializer.GenericMapping = ExEventPairMapping; + ObjectTypeInitializer.PoolType = NonPagedPool; + ObjectTypeInitializer.ValidAccessMask = EVENT_PAIR_ALL_ACCESS; + ObjectTypeInitializer.UseDefaultObject = TRUE; + ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ExEventPairObjectType); } NTSTATUS -STDCALL +NTAPI NtCreateEventPair(OUT PHANDLE EventPairHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes) @@ -65,22 +62,25 @@ HANDLE hEventPair; KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status = STATUS_SUCCESS; - PAGED_CODE(); DPRINT("NtCreateEventPair: 0x%p\n", EventPairHandle); - /* Check Output Safety */ - if(PreviousMode != KernelMode) { - - _SEH_TRY { - + /* Check if we were called from user-mode */ + if(PreviousMode != KernelMode) + { + /* Enter SEH Block */ + _SEH_TRY + { + /* Check handle pointer */ ProbeForWriteHandle(EventPairHandle); - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); + } + _SEH_END; - } _SEH_END; - + /* Bail out if pointer was invalid */ if(!NT_SUCCESS(Status)) return Status; } @@ -97,8 +97,8 @@ (PVOID*)&EventPair); /* Check for Success */ - if(NT_SUCCESS(Status)) { - + if(NT_SUCCESS(Status)) + { /* Initalize the Event */ DPRINT("Initializing EventPair\n"); KeInitializeEventPair(EventPair); @@ -113,17 +113,17 @@ ObDereferenceObject(EventPair); /* Check for success and return handle */ - if(NT_SUCCESS(Status)) { - - _SEH_TRY { - + if(NT_SUCCESS(Status)) + { + _SEH_TRY + { *EventPairHandle = hEventPair; - - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); - - } _SEH_END; + } + _SEH_END; } } @@ -132,7 +132,7 @@ } NTSTATUS -STDCALL +NTAPI NtOpenEventPair(OUT PHANDLE EventPairHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes) @@ -140,21 +140,24 @@ HANDLE hEventPair; KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status = STATUS_SUCCESS; - PAGED_CODE(); - /* Check Output Safety */ - if(PreviousMode != KernelMode) { - - _SEH_TRY { - + /* Check if we were called from user-mode */ + if(PreviousMode != KernelMode) + { + /* Enter SEH Block */ + _SEH_TRY + { + /* Check handle pointer */ ProbeForWriteHandle(EventPairHandle); - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); + } + _SEH_END; - } _SEH_END; - + /* Bail out if pointer was invalid */ if(!NT_SUCCESS(Status)) return Status; } @@ -168,32 +171,30 @@ &hEventPair); /* Check for success and return handle */ - if(NT_SUCCESS(Status)) { - - _SEH_TRY { - + if(NT_SUCCESS(Status)) + { + _SEH_TRY + { *EventPairHandle = hEventPair; - - } _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) { - + } + _SEH_EXCEPT(_SEH_ExSystemExceptionFilter) + { Status = _SEH_GetExceptionCode(); - - } _SEH_END; + } + _SEH_END; } /* Return status */ return Status; } - NTSTATUS -STDCALL +NTAPI NtSetHighEventPair(IN HANDLE EventPairHandle) { PKEVENT_PAIR EventPair; KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status; - PAGED_CODE(); DPRINT("NtSetHighEventPair(EventPairHandle 0x%p)\n", EventPairHandle); @@ -206,8 +207,8 @@ NULL); /* Check for Success */ - if(NT_SUCCESS(Status)) { - + if(NT_SUCCESS(Status)) + { /* Set the Event */ KeSetEvent(&EventPair->HighEvent, EVENT_INCREMENT, FALSE); @@ -220,15 +221,14 @@ } NTSTATUS -STDCALL +NTAPI NtSetHighWaitLowEventPair(IN HANDLE EventPairHandle) { PKEVENT_PAIR EventPair; KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status; - PAGED_CODE(); - DPRINT("NtSetHighWaitLowEventPair(EventPairHandle 0x%p)\n", EventPairHandle); + DPRINT("NtSetHighWaitLowEventPair(Handle 0x%p)\n", EventPairHandle); /* Open the Object */ Status = ObReferenceObjectByHandle(EventPairHandle, @@ -239,8 +239,8 @@ NULL); /* Check for Success */ - if(NT_SUCCESS(Status)) { - + if(NT_SUCCESS(Status)) + { /* Set the Event */ KeSetEvent(&EventPair->HighEvent, EVENT_INCREMENT, FALSE); @@ -260,17 +260,13 @@ } NTSTATUS -STDCALL +NTAPI NtSetLowEventPair(IN HANDLE EventPairHandle) { PKEVENT_PAIR EventPair; - KPROCESSOR_MODE PreviousMode; + KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status; - PAGED_CODE(); - - PreviousMode = ExGetPreviousMode(); - DPRINT1("NtSetHighEventPair(EventPairHandle 0x%p)\n", EventPairHandle); /* Open the Object */ @@ -282,8 +278,8 @@ NULL); /* Check for Success */ - if(NT_SUCCESS(Status)) { - + if(NT_SUCCESS(Status)) + { /* Set the Event */ KeSetEvent(&EventPair->LowEvent, EVENT_INCREMENT, FALSE); @@ -295,16 +291,15 @@ return Status; } - -NTSTATUS STDCALL +NTSTATUS +NTAPI NtSetLowWaitHighEventPair(IN HANDLE EventPairHandle) { PKEVENT_PAIR EventPair; KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status; - PAGED_CODE(); - DPRINT("NtSetHighWaitLowEventPair(EventPairHandle 0x%p)\n", EventPairHandle); + DPRINT("NtSetHighWaitLowEventPair(Handle 0x%p)\n", EventPairHandle); /* Open the Object */ Status = ObReferenceObjectByHandle(EventPairHandle, @@ -315,8 +310,8 @@ NULL); /* Check for Success */ - if(NT_SUCCESS(Status)) { - + if(NT_SUCCESS(Status)) + { /* Set the Event */ KeSetEvent(&EventPair->LowEvent, EVENT_INCREMENT, FALSE); @@ -337,15 +332,14 @@ NTSTATUS -STDCALL +NTAPI NtWaitLowEventPair(IN HANDLE EventPairHandle) { PKEVENT_PAIR EventPair; KPROCESSOR_MODE PreviousMode = ExGetPreviousMode(); NTSTATUS Status; - PAGED_CODE(); - DPRINT("NtSetHighWaitLowEventPair(EventPairHandle 0x%p)\n", EventPairHandle); + DPRINT("NtSetHighWaitLowEventPair(Handle 0x%p)\n", EventPairHandle); /* Open the Object */ Status = ObReferenceObjectByHandle(EventPairHandle, @@ -356,8 +350,8 @@ NULL); /* Check for Success */ - if(NT_SUCCESS(Status)) { - + if(NT_SUCCESS(Status)) + { /* Wait for the Event */ KeWaitForSingleObject(&EventPair->LowEvent, WrEventPair, @@ -374,7 +368,7 @@ } NTSTATUS -STDCALL +NTAPI NtWaitHighEventPair(IN HANDLE EventPairHandle) { PKEVENT_PAIR EventPair; @@ -382,7 +376,7 @@ NTSTATUS Status; PAGED_CODE(); - DPRINT("NtSetHighWaitLowEventPair(EventPairHandle 0x%p)\n", EventPairHandle); + DPRINT("NtSetHighWaitLowEventPair(Handle 0x%p)\n", EventPairHandle); /* Open the Object */ Status = ObReferenceObjectByHandle(EventPairHandle, @@ -393,8 +387,8 @@ NULL); /* Check for Success */ - if(NT_SUCCESS(Status)) { - + if(NT_SUCCESS(Status)) + { /* Wait for the Event */ KeWaitForSingleObject(&EventPair->HighEvent, WrEventPair,

1 0

← Newer
1
...
4
5
6
7
8
9
10
...
71
Older →

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs December 2005