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

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) {

18 years, 8 months

[ion] 20436: - Fix InterlockedBitTestAndReset and InterlockedBitTestAndSet

by ion＠svn.reactos.org

- 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)

18 years, 8 months

[ion] 20435: - Implemented InterlockedBitTestAndReset, InterlockedBitTestAndSet, InterlockedExchangeAddSizeT.

by ion＠svn.reactos.org

- 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]

18 years, 8 months

[ion] 20434: - Fix formatting and a bug in NtSetSystemTime.

by ion＠svn.reactos.org

- 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 */

18 years, 8 months

[ion] 20433: Forgot to commit this file

by ion＠svn.reactos.org

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,

18 years, 8 months

[ion] 20432: - Fix some small formatting issues.

by ion＠svn.reactos.org

- 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) {

18 years, 8 months

[ion] 20431: Fix build

by ion＠svn.reactos.org

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

18 years, 8 months

[ion] 20430: Move pushlock definition. It is gone from MS headers now.

by ion＠svn.reactos.org

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))

18 years, 8 months

[ion] 20429: - Formatting fixes

by ion＠svn.reactos.org

- 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; }

18 years, 8 months

[ion] 20428: - Fix some formatting.

by ion＠svn.reactos.org

- 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,

18 years, 8 months

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

Jump to page:

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