Ros-diffs

ros-diffs@reactos.org

81390 discussions

[ion] 20557: - Implement Pushlocks. Only Waking, and Exclusive Acquire/Release + Waits have been tested. The shared paths and block/unblock are still untested and may probably contain bugs. Pushlocks are not yet used in the kernel and they won't be until all paths are tested and validated.
by ion＠svn.reactos.org 03 Jan '06

03 Jan '06

- Implement Pushlocks. Only Waking, and Exclusive Acquire/Release + Waits have been tested. The shared paths and block/unblock are still untested and may probably contain bugs. Pushlocks are not yet used in the kernel and they won't be until all paths are tested and validated. - Public DDIs Implemented: ExfAcquirePushLockExclusive, ExfAcquirePushLockShared, ExfTryToWakePushLock, ExfReleasePushLock, ExfReleasePushLockExclusive, ExfReleasePushLockShared, ExfUnblockPushLock. Added: trunk/reactos/ntoskrnl/ex/pushlock.c Modified: trunk/reactos/ntoskrnl/include/internal/ex.h Modified: trunk/reactos/ntoskrnl/include/internal/ntoskrnl.h Modified: trunk/reactos/ntoskrnl/ntoskrnl.xml _____ Copied: trunk/reactos/ntoskrnl/ex/pushlock.c (from rev 20362, trunk/reactos/ntoskrnl/ex/synch.c) --- trunk/reactos/ntoskrnl/ex/synch.c 2005-12-27 01:14:55 UTC (rev 20362) +++ trunk/reactos/ntoskrnl/ex/pushlock.c 2006-01-03 23:36:05 UTC (rev 20557) @@ -0,0 +1,1164 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS Kernel + * FILE: ntoskrnl/ex/pushlock.c + * PURPOSE: Pushlock and Cache-Aware Pushlock Implementation + * PROGRAMMER: Alex Ionescu (alex.ionescu(a)reactos.com) + */ + +/* INCLUDES *****************************************************************/ + +#include <ntoskrnl.h> +#define NDEBUG +#include <internal/debug.h> + +/* DATA **********************************************************************/ + +ULONG ExPushLockSpinCount; + +/* PRIVATE FUNCTIONS *********************************************************/ + +/*++ + * @name ExpInitializePushLocks + * + * The ExpInitializePushLocks routine initialized Pushlock support. + * + * @param None. + * + * @return None. + * + * @remarks The ExpInitializePushLocks routine sets up the spin on SMP machines. + * + *--*/ +VOID +NTAPI +ExpInitializePushLocks(VOID) +{ + /* Initialize an internal 1024-iteration spin for MP CPUs */ + ExPushLockSpinCount = (KeNumberProcessors == 1) ? 0 : 1024; +} + +/*++ + * @name ExfWakePushLock + * + * The ExfWakePushLock routine wakes a Pushlock that is in the waiting + * state. + * + * @param PushLock + * Pointer to a pushlock that is waiting. + * + * @param OldValue + * Last known value of the pushlock before this routine was called. + * + * @return None. + * + * @remarks This is an internal routine; do not call it manually. Only the system + * can properly know if the pushlock is ready to be awakened or not. + * External callers should use ExfTrytoWakePushLock. + * + *--*/ +VOID +FASTCALL +ExfWakePushLock(PEX_PUSH_LOCK PushLock, + EX_PUSH_LOCK OldValue) +{ + EX_PUSH_LOCK NewValue; + PEX_PUSH_LOCK_WAIT_BLOCK PreviousWaitBlock, FirstWaitBlock, NextWaitBlock; + PEX_PUSH_LOCK_WAIT_BLOCK WaitBlock; + KIRQL OldIrql; + + /* Start main wake loop */ + for (;;) + { + /* Sanity checks */ + ASSERT(!OldValue.MultipleShared); + + /* Check if it's locked */ + if (OldValue.Locked) + { + /* If it's locked we must simply un-wake it*/ + for (;;) + { + /* It's not waking anymore */ + NewValue.Value = OldValue.Value &~ EX_PUSH_LOCK_WAKING; + + /* Sanity checks */ + ASSERT(!NewValue.Waking); + ASSERT(NewValue.Locked); + ASSERT(NewValue.Waiting); + + /* Write the New Value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value == OldValue.Value) return; + + /* Someone changed the value behind our back, update it*/ + OldValue = NewValue; + + /* Check if it's still locked */ + if (OldValue.Locked) continue; + } + } + + /* Save the First Block */ + FirstWaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr & + ~EX_PUSH_LOCK_PTR_BITS); + NextWaitBlock = FirstWaitBlock; + WaitBlock = NextWaitBlock->Last; + + /* Try to find a wait block */ + while (!WaitBlock) + { + /* Save the previous block */ + PreviousWaitBlock = NextWaitBlock; + + /* Move to next block */ + NextWaitBlock = NextWaitBlock->Next; + + /* Save the previous block */ + NextWaitBlock->Previous = PreviousWaitBlock; + + /* Move to the next one */ + WaitBlock = NextWaitBlock->Last; + } + + /* Check if the last Wait Block is not Exclusive or if it's the only one */ + PreviousWaitBlock = WaitBlock->Previous; + if (!(WaitBlock->Flags & EX_PUSH_LOCK_FLAGS_EXCLUSIVE) || + !(PreviousWaitBlock)) + { + /* Destroy the pushlock */ + if (InterlockedCompareExchangePointer(PushLock, 0, OldValue.Ptr) == + OldValue.Ptr) break; + } + else + { + /* Link the wait blocks */ + FirstWaitBlock->Last = PreviousWaitBlock; + WaitBlock->Previous = NULL; + + /* Sanity checks */ + ASSERT(FirstWaitBlock != WaitBlock); + ASSERT(PushLock->Waiting); + + /* Remove waking bit from pushlock */ + InterlockedAnd((PLONG)PushLock, ~EX_PUSH_LOCK_WAKING); + } + } + + /* Check if there's a previous block */ + OldIrql = DISPATCH_LEVEL; + if (WaitBlock->Previous) + { + /* Raise to Dispatch */ + KeRaiseIrql(DISPATCH_LEVEL, &OldIrql); + } + + /* Signaling loop */ + for (;;) + { + /* Get the previous Wait block */ + PreviousWaitBlock = WaitBlock->Previous; + + /* Sanity check */ + ASSERT(!WaitBlock->Signaled); + + /* We are about to get signaled */ + WaitBlock->Signaled = TRUE; + + /* Set the Wait Bit in the Wait Block */ + if (!InterlockedBitTestAndReset(&WaitBlock->Flags, 1)) + { + /* Nobody signaled us, so do it */ + KeSignalGateBoostPriority(&WaitBlock->WakeGate); + } + + /* Set the wait block and check if there still is one to loop*/ + WaitBlock = PreviousWaitBlock; + if (!WaitBlock) break; + } + + /* Check if we have to lower back the IRQL */ + if (OldIrql != DISPATCH_LEVEL) KeLowerIrql(OldIrql); +} + +/*++ + * @name ExpOptimizePushLockList + * + * The ExpOptimizePushLockList routine optimizes the list of waiters + * associated to a pushlock's wait block. + * + * @param PushLock + * Pointer to a pushlock whose waiter list needs to be optimized. + * + * @param OldValue + * Last known value of the pushlock before this routine was called. + * + * @return None. + * + * @remarks At the end of the optimization, the pushlock will also be wakened. + * + *--*/ +VOID +FASTCALL +ExpOptimizePushLockList(PEX_PUSH_LOCK PushLock, + EX_PUSH_LOCK OldValue) +{ + PEX_PUSH_LOCK_WAIT_BLOCK WaitBlock, LastWaitBlock, PreviousWaitBlock; + EX_PUSH_LOCK NewValue; + + /* Check if the pushlock is locked */ + if (OldValue.Locked) + { + /* Start main loop */ + for (;;) + { + /* Get the wait block */ + WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr & + ~EX_PUSH_LOCK_PTR_BITS); + + /* Loop the blocks */ + LastWaitBlock = WaitBlock->Last; + while (LastWaitBlock) + { + /* Save the block */ + PreviousWaitBlock = WaitBlock; + + /* Get the next block */ + WaitBlock = WaitBlock->Next; + + /* Save the previous */ + WaitBlock->Previous = PreviousWaitBlock; + + /* Move to the next */ + LastWaitBlock = WaitBlock->Last; + } + + /* Remove the wake bit */ + NewValue.Value = OldValue.Value &~ EX_PUSH_LOCK_WAKING; + + /* Sanity checks */ + ASSERT(NewValue.Locked); + ASSERT(!NewValue.Waking); + + /* Update the value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + + /* If we updated correctly, leave */ + if (NewValue.Value == OldValue.Value) return; + + /* If the value is now locked, loop again */ + if (NewValue.Locked) continue; + } + } + + /* Wake the push lock */ + ExfWakePushLock(PushLock, OldValue); +} + +/*++ + * @name ExTimedWaitForUnblockPushLock + * + * The ExTimedWaitForUnblockPushLock routine waits for a pushlock + * to be unblocked, for a specified internal. + * + * @param PushLock + * Pointer to a pushlock whose waiter list needs to be optimized. + * + * @param WaitBlock + * Pointer to the pushlock's wait block. + * + * @param Timeout + * Amount of time to wait for this pushlock to be unblocked. + * + * @return STATUS_SUCCESS is the pushlock is now unblocked, otherwise the error + * code returned by KeWaitForSingleObject. + * + * @remarks If the wait fails, then a manual unblock is attempted. + * + *--*/ +NTSTATUS +FASTCALL +ExTimedWaitForUnblockPushLock(IN PEX_PUSH_LOCK PushLock, + IN PVOID WaitBlock, + IN PLARGE_INTEGER Timeout) +{ + ULONG i; + NTSTATUS Status; + + /* Initialize the wait event */ + KeInitializeEvent(&((PEX_PUSH_LOCK_WAIT_BLOCK)WaitBlock)->WakeEvent, + NotificationEvent, + FALSE); + + /* Spin on the push lock if necessary */ + i = ExPushLockSpinCount; + if (i) + { + /* Spin */ + while (--i) + { + /* Check if we got lucky and can leave early */ + if (!(((PEX_PUSH_LOCK_WAIT_BLOCK)WaitBlock)->Flags & + EX_PUSH_LOCK_WAITING)) + { + /* This wait block isn't waiting anymore, we can leave */ + return STATUS_SUCCESS; + } + YieldProcessor(); + } + } + + /* Now try to remove the wait bit */ + if (InterlockedBitTestAndReset(&((PEX_PUSH_LOCK_WAIT_BLOCK)WaitBlock)->Flag s, + 1)) + { + /* Nobody removed it already, let's do a full wait */ + Status = KeWaitForSingleObject(&((PEX_PUSH_LOCK_WAIT_BLOCK)WaitBlock)-> + WakeEvent, + WrPushLock, + KernelMode, + FALSE, + Timeout); + if (!NT_SUCCESS(Status)) + { + /* Try unblocking the pushlock */ + ExfUnblockPushLock(PushLock, WaitBlock); + } + } + else + { + /* Someone beat us to it, no need to wait */ + Status = STATUS_SUCCESS; + } + + /* Return status */ + return Status; +} + +/*++ + * @name ExBlockPushLock + * + * The ExBlockPushLock routine blocks a pushlock. + * + * @param PushLock + * Pointer to a pushlock whose waiter list needs to be optimized. + * + * @param WaitBlock + * Pointer to the pushlock's wait block. + * + * @return None. + * + * @remarks None. + * + *--*/ +VOID +FASTCALL +ExBlockPushLock(PEX_PUSH_LOCK PushLock, + PVOID WaitBlock) +{ + PVOID NewValue, OldValue; + + /* Set the waiting bit */ + ((PEX_PUSH_LOCK_WAIT_BLOCK)WaitBlock)->Flags |= EX_PUSH_LOCK_FLAGS_WAIT; + + /* Link the wait blocks */ + ((PEX_PUSH_LOCK_WAIT_BLOCK)WaitBlock)->Next = PushLock->Ptr; + + /* Try to set this one as the wait block now */ + NewValue = PushLock->Ptr; + for (;;) + { + /* Set the new wait block value */ + OldValue = InterlockedCompareExchangePointer(&PushLock->Ptr, + WaitBlock, + NewValue); + if (OldValue == NewValue) break; + NewValue = OldValue; + } +} + +/* PUBLIC FUNCTIONS **********************************************************/ + +/*++ + * @name ExAcquirePushLockExclusive + * @implemented NT5.1 + * + * The ExAcquirePushLockExclusive macro exclusively acquires a PushLock. + * + * @params PushLock + * Pointer to the pushlock which is to be acquired. + * + * @return None. + * + * @remarks Callers of ExAcquirePushLockShared must be running at IRQL <= APC_LEVEL. + * This macro should usually be paired up with KeAcquireCriticalRegion. + * + *--*/ +VOID +FASTCALL +ExfAcquirePushLockExclusive(PEX_PUSH_LOCK PushLock) +{ + EX_PUSH_LOCK_WAIT_BLOCK WaitBlock; + EX_PUSH_LOCK OldValue = *PushLock, NewValue, TempValue; + BOOLEAN NeedWake; + ULONG i; + + /* Start main loop */ + for (;;) + { + /* Check if it's unlocked */ + if (!OldValue.Locked) + { + /* Lock it */ + NewValue.Value = OldValue.Value | EX_PUSH_LOCK_LOCK; + ASSERT(NewValue.Locked); + + /* Set the new value */ + if (InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr) != OldValue.Ptr) + { + /* Retry */ + OldValue = *PushLock; + continue; + } + + /* Break out of the loop */ + break; + } + else + { + /* We'll have to create a Waitblock */ + WaitBlock.Flags = EX_PUSH_LOCK_FLAGS_EXCLUSIVE | + EX_PUSH_LOCK_FLAGS_WAIT; + WaitBlock.Previous = NULL; + NeedWake = FALSE; + + /* Check if there is already a waiter */ + if (OldValue.Waiting) + { + /* Nobody is the last waiter yet */ + WaitBlock.Last = NULL; + + /* We are an exclusive waiter */ + WaitBlock.ShareCount = 0; + + /* Set the current Wait Block pointer */ + WaitBlock.Next = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR) + OldValue.Ptr &~ EX_PUSH_LOCK_PTR_BITS); + + /* Point to ours */ + NewValue.Value = (OldValue.Value & EX_PUSH_LOCK_MULTIPLE_SHARED) | + EX_PUSH_LOCK_LOCK | + EX_PUSH_LOCK_WAKING | + EX_PUSH_LOCK_WAITING | + PtrToUlong(&WaitBlock); + + /* Check if the pushlock was already waking */ + if (OldValue.Waking) NeedWake = TRUE; + } + else + { + /* We are the first waiter, so loop the wait block */ + WaitBlock.Last = &WaitBlock; + + /* Set the share count */ + WaitBlock.ShareCount = OldValue.Shared; + + /* Check if someone is sharing this pushlock */ + if (OldValue.Shared > 1) + { + /* Point to our wait block */ + NewValue.Value = EX_PUSH_LOCK_MULTIPLE_SHARED | + EX_PUSH_LOCK_LOCK | + EX_PUSH_LOCK_WAITING | + PtrToUlong(&WaitBlock); + } + else + { + /* No shared count */ + WaitBlock.ShareCount = 0; + + /* Point to our wait block */ + NewValue.Value = EX_PUSH_LOCK_LOCK | + EX_PUSH_LOCK_WAITING | + PtrToUlong(&WaitBlock); + } + } + +#if DBG + /* Setup the Debug Wait Block */ + WaitBlock.Signaled = 0; + WaitBlock.OldValue = OldValue; + WaitBlock.NewValue = NewValue; + WaitBlock.PushLock = PushLock; +#endif + + /* Sanity check */ + ASSERT(NewValue.Waiting); + ASSERT(NewValue.Locked); + + /* Write the new value */ + TempValue = NewValue; + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value != OldValue.Value) + { + /* Retry */ + OldValue = *PushLock; + continue; + } + + /* Check if the pushlock needed waking */ + if (NeedWake) + { + /* Scan the Waiters and Wake PushLocks */ + ExpOptimizePushLockList(PushLock, TempValue); + } + + /* Set up the Wait Gate */ + KeInitializeGate(&WaitBlock.WakeGate); + + /* Now spin on the push lock if necessary */ + i = ExPushLockSpinCount; + if ((i) && (WaitBlock.Flags & EX_PUSH_LOCK_WAITING)) + { + /* Spin */ + while (--i) YieldProcessor(); + } + + /* Now try to remove the wait bit */ + if (InterlockedBitTestAndReset(&WaitBlock.Flags, 1)) + { + /* Nobody removed it already, let's do a full wait */ + KeWaitForGate(&WaitBlock.WakeGate, WrPushLock, KernelMode); + ASSERT(WaitBlock.Signaled); + } + + /* We shouldn't be shared anymore */ + ASSERT((WaitBlock.ShareCount == 0)); + + /* Loop again */ + OldValue = NewValue; + } + } +} + +/*++ + * @name ExAcquirePushLockExclusive + * @implemented NT5.1 + * + * The ExAcquirePushLockShared macro acquires a shared PushLock. + * + * @params PushLock + * Pointer to the pushlock which is to be acquired. + * + * @return None. + * + * @remarks Callers of ExAcquirePushLockShared must be running at IRQL <= APC_LEVEL. + * This macro should usually be paired up with KeAcquireCriticalRegion. + * + *--*/ +VOID +FASTCALL +ExfAcquirePushLockShared(PEX_PUSH_LOCK PushLock) +{ + EX_PUSH_LOCK_WAIT_BLOCK WaitBlock; + EX_PUSH_LOCK OldValue = *PushLock, NewValue; + BOOLEAN NeedWake; + ULONG i; + + /* Start main loop */ + for (;;) + { + /* Check if it's unlocked or if it's waiting without any sharers */ + if (!(OldValue.Locked) || (OldValue.Waiting && OldValue.Shared == 0)) + { + /* Check if anyone is waiting on it */ + if (!OldValue.Waiting) + { + /* Increase the share count and lock it */ + NewValue.Value = OldValue.Value | EX_PUSH_LOCK_LOCK; + NewValue.Shared++; + } + else + { + /* Simply set the lock bit */ + NewValue.Value = OldValue.Value | EX_PUSH_LOCK_LOCK; + } + + /* Sanity check */ + ASSERT(NewValue.Locked); + + /* Set the new value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value != OldValue.Value) + { + /* Retry */ + OldValue = NewValue; + continue; + } + + /* Break out of the loop */ + break; + } + else + { + /* We'll have to create a Waitblock */ + WaitBlock.Flags = EX_PUSH_LOCK_FLAGS_WAIT; + WaitBlock.ShareCount = 0; + NeedWake = FALSE; + WaitBlock.Previous = NULL; + + /* Check if there is already a waiter */ + if (OldValue.Waiting) + { + /* Set the current Wait Block pointer */ + WaitBlock.Next = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR) + OldValue.Ptr &~ EX_PUSH_LOCK_PTR_BITS); + + /* Nobody is the last waiter yet */ + WaitBlock.Last = NULL; + + /* Point to ours */ + NewValue.Value = (OldValue.Value & (EX_PUSH_LOCK_MULTIPLE_SHARED | + EX_PUSH_LOCK_LOCK)) | + EX_PUSH_LOCK_WAKING | + EX_PUSH_LOCK_WAITING | + PtrToUlong(&WaitBlock); + + /* Check if the pushlock was already waking */ + if (OldValue.Waking) NeedWake = TRUE; + } + else + { + /* We are the first waiter, so loop the wait block */ + WaitBlock.Last = &WaitBlock; + + /* Point to our wait block */ + NewValue.Value = (OldValue.Value & (EX_PUSH_LOCK_MULTIPLE_SHARED | + EX_PUSH_LOCK_WAKING)) | + EX_PUSH_LOCK_WAITING | + PtrToUlong(&WaitBlock); + } + + /* Sanity check */ + ASSERT(NewValue.Waiting); + +#if DBG + /* Setup the Debug Wait Block */ + WaitBlock.Signaled = 0; + WaitBlock.OldValue = OldValue; + WaitBlock.NewValue = NewValue; + WaitBlock.PushLock = PushLock; +#endif + + /* Write the new value */ + if (InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr) != OldValue.Ptr) + { + /* Retry */ + OldValue = NewValue; + continue; + } + + /* Update the value now */ + OldValue = NewValue; + + /* Check if the pushlock needed waking */ + if (NeedWake) + { + /* Scan the Waiters and Wake PushLocks */ + ExpOptimizePushLockList(PushLock, OldValue); + } + + /* Set up the Wait Gate */ + KeInitializeGate(&WaitBlock.WakeGate); + + /* Now spin on the push lock if necessary */ + i = ExPushLockSpinCount; + if ((i) && (WaitBlock.Flags & EX_PUSH_LOCK_WAITING)) + { + /* Spin */ + while (--i) YieldProcessor(); + } + + /* Now try to remove the wait bit */ + if (InterlockedBitTestAndReset(&WaitBlock.Flags, 1)) + { + /* Fast-path did not work, we need to do a full wait */ + KeWaitForGate(&WaitBlock.WakeGate, WrPushLock, KernelMode); + ASSERT(WaitBlock.Signaled); + } + + /* We shouldn't be shared anymore */ + ASSERT((WaitBlock.ShareCount == 0)); + } + } +} + +/*++ + * @name ExfReleasePushLock + * @implemented NT5.1 + * + * The ExReleasePushLockExclusive routine releases a previously + * exclusively acquired PushLock. + * + * @params PushLock + * Pointer to a previously acquired pushlock. + * + * @return None. + * + * @remarks Callers of ExReleasePushLockExclusive must be running at IRQL <= APC_LEVEL. + * This macro should usually be paired up with KeLeaveCriticalRegion. + * + *--*/ +VOID +FASTCALL +ExfReleasePushLock(PEX_PUSH_LOCK PushLock) +{ + EX_PUSH_LOCK OldValue = *PushLock; + EX_PUSH_LOCK NewValue; + PEX_PUSH_LOCK_WAIT_BLOCK WaitBlock; + + /* Sanity check */ + ASSERT(OldValue.Locked); + + /* Check if someone is waiting on the lock */ + if (!OldValue.Waiting) + { + /* Nobody is waiting on it, so we'll try a quick release */ + for (;;) + { + /* Check if it's shared */ + if (OldValue.Shared > 1) + { + /* Write the Old Value but decrease share count */ + NewValue = OldValue; + NewValue.Shared--; + } + else + { + /* Simply clear the lock */ + NewValue.Value = 0; + } + + /* Write the New Value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value == OldValue.Value) + { + /* No waiters left, we're done */ + goto quit; + } + + /* Did it enter a wait state? */ + OldValue = NewValue; + if (NewValue.Waiting) break; + } + } + + /* Ok, we do know someone is waiting on it. Are there more then one? */ + if (OldValue.MultipleShared) + { + /* Find the last Wait Block */ + for (WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr & + ~EX_PUSH_LOCK_PTR_BITS); + WaitBlock->Last; + WaitBlock = WaitBlock->Next); + + /* Make sure the Share Count is above 0 */ + if (WaitBlock->ShareCount) + { + /* This shouldn't be an exclusive wait block */ + ASSERT(WaitBlock->Flags&EX_PUSH_LOCK_FLAGS_EXCLUSIVE); + + /* Do the decrease and check if the lock isn't shared anymore */ + if (InterlockedExchangeAdd(&WaitBlock->ShareCount, -1)) + { + /* Someone is still holding the lock */ + goto quit; + } + } + } + + /* + * If nobody was waiting on the block, then we possibly reduced the number + * of times the pushlock was shared, and we unlocked it. + * If someone was waiting, and more then one person is waiting, then we + * reduced the number of times the pushlock is shared in the wait block. + * Therefore, at this point, we can now 'satisfy' the wait. + */ + for (;;) + { + /* Now we need to see if it's waking */ + if (OldValue.Waking) + { + /* Remove the lock and multiple shared bits */ + NewValue.Value = OldValue.Value; + NewValue.MultipleShared = FALSE; + NewValue.Locked = FALSE; + + /* Sanity check */ + ASSERT(NewValue.Waking && !NewValue.Locked && !NewValue.MultipleShared); + + /* Write the new value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value == OldValue.Value) break; + + /* The value changed, try the unlock again */ + continue; + } + else + { + /* Remove the lock and multiple shared bits */ + NewValue.Value = OldValue.Value; + NewValue.MultipleShared = FALSE; + NewValue.Locked = FALSE; + + /* It's not already waking, so add the wake bit */ + NewValue.Waking = TRUE; + + /* Sanity check */ + ASSERT(NewValue.Waking && !NewValue.Locked && !NewValue.MultipleShared); + + /* Write the new value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value != OldValue.Value) continue; + + /* The write was successful. The pushlock is Unlocked and Waking */ + ExfWakePushLock(PushLock, NewValue); + break; + } + } +quit: + /* Done! */ + return; +} + +/*++ + * @name ExfReleasePushLockShared + * @implemented NT5.2 + * + * The ExfReleasePushLockShared macro releases a previously acquired PushLock. + * + * @params PushLock + * Pointer to a previously acquired pushlock. + * + * @return None. + * + * @remarks Callers of ExReleasePushLockShared must be running at IRQL <= APC_LEVEL. + * This macro should usually be paired up with KeLeaveCriticalRegion. + * + *--*/ +VOID +FASTCALL +ExfReleasePushLockShared(PEX_PUSH_LOCK PushLock) +{ + EX_PUSH_LOCK OldValue = *PushLock; + EX_PUSH_LOCK NewValue; + PEX_PUSH_LOCK_WAIT_BLOCK WaitBlock; + + /* Check if someone is waiting on the lock */ + if (!OldValue.Waiting) + { + /* Nobody is waiting on it, so we'll try a quick release */ + for (;;) + { + /* Check if it's shared */ + if (OldValue.Shared > 1) + { + /* Write the Old Value but decrease share count */ + NewValue = OldValue; + NewValue.Shared--; + } + else + { + /* Simply clear the lock */ + NewValue.Value = 0; + } + + /* Write the New Value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value == OldValue.Value) + { + /* No waiters left, we're done */ + goto quit; + } + + /* Did it enter a wait state? */ + OldValue = NewValue; + if (NewValue.Waiting) break; + } + } + + /* Ok, we do know someone is waiting on it. Are there more then one? */ + if (OldValue.MultipleShared) + { + /* Find the last Wait Block */ + for (WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr & + ~EX_PUSH_LOCK_PTR_BITS); + WaitBlock->Last; + WaitBlock = WaitBlock->Next); + + /* Sanity checks */ + ASSERT(WaitBlock->ShareCount > 0); + ASSERT(WaitBlock->Flags&EX_PUSH_LOCK_FLAGS_EXCLUSIVE); + + /* Do the decrease and check if the lock isn't shared anymore */ + if (InterlockedExchangeAdd(&WaitBlock->ShareCount, -1)) goto quit; + } + + /* + * If nobody was waiting on the block, then we possibly reduced the number + * of times the pushlock was shared, and we unlocked it. + * If someone was waiting, and more then one person is waiting, then we + * reduced the number of times the pushlock is shared in the wait block. + * Therefore, at this point, we can now 'satisfy' the wait. + */ + for (;;) + { + /* Now we need to see if it's waking */ + if (OldValue.Waking) + { + /* Remove the lock and multiple shared bits */ + NewValue.Value = OldValue.Value; + NewValue.MultipleShared = FALSE; + NewValue.Locked = FALSE; + + /* Sanity check */ + ASSERT(NewValue.Waking && !NewValue.Locked && !NewValue.MultipleShared); + + /* Write the new value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value == OldValue.Value) break; + + /* The value changed, try the unlock again */ + continue; + } + else + { + /* Remove the lock and multiple shared bits */ + NewValue.Value = OldValue.Value; + NewValue.MultipleShared = FALSE; + NewValue.Locked = FALSE; + + /* It's not already waking, so add the wake bit */ + NewValue.Waking = TRUE; + + /* Sanity check */ + ASSERT(NewValue.Waking && !NewValue.Locked && !NewValue.MultipleShared); + + /* Write the new value */ + NewValue.Ptr = InterlockedCompareExchangePointer(PushLock, + NewValue.Ptr, + OldValue.Ptr); + if (NewValue.Value != OldValue.Value) continue; + + /* The write was successful. The pushlock is Unlocked and Waking */ + ExfWakePushLock(PushLock, NewValue); + break; + } + } +quit: + /* Done! */ + return; +} + +/*++ + * ExfReleasePushLockExclusive + * @implemented NT5.2 + * + * The ExfReleasePushLockExclusive routine releases a previously + * exclusively acquired PushLock. + * + * @params PushLock + * Pointer to a previously acquired pushlock. + * + * @return None. [truncated at 1000 lines; 463 more skipped]

1 0

[ion] 20556: - More proper fix for the QEMU/Abiword regression. Remove kernel32 hack. Thanks to Filip and The Munger.
by ion＠svn.reactos.org 03 Jan '06

03 Jan '06

- More proper fix for the QEMU/Abiword regression. Remove kernel32 hack. Thanks to Filip and The Munger. Modified: trunk/reactos/lib/kernel32/misc/atom.c Modified: trunk/reactos/lib/ntdll/ldr/startup.c _____ Modified: trunk/reactos/lib/kernel32/misc/atom.c --- trunk/reactos/lib/kernel32/misc/atom.c 2006-01-03 22:25:09 UTC (rev 20555) +++ trunk/reactos/lib/kernel32/misc/atom.c 2006-01-03 22:36:36 UTC (rev 20556) @@ -72,7 +72,6 @@ /* Check if we can abuse the TEB */ if (AnsiString.MaximumLength > 260) { -RosHack: /* We can't, allocate a new string */ AtomNameString = &UnicodeString; Status = RtlAnsiStringToUnicodeString(AtomNameString, @@ -84,14 +83,6 @@ /* We can! Get the TEB String */ AtomNameString = &NtCurrentTeb()->StaticUnicodeString; - /* FIXME: HACK! */ - if (!AtomNameString->MaximumLength) - { - DPRINT1("Hit the ROS TEB Static Unicode String Bug\n", - "Please try to fix the underlying problem!!!\n"); - goto RosHack; - } - /* Convert it into the TEB */ Status = RtlAnsiStringToUnicodeString(AtomNameString, &AnsiString, @@ -182,7 +173,6 @@ /* Check if we can abuse the TEB */ if (AnsiString.MaximumLength > 260) { -RosHack: /* We can't, allocate a new string */ AtomNameString = &UnicodeString; Status = RtlAnsiStringToUnicodeString(AtomNameString, @@ -194,14 +184,6 @@ /* We can! Get the TEB String */ AtomNameString = &NtCurrentTeb()->StaticUnicodeString; - /* FIXME: HACK! */ - if (!AtomNameString->MaximumLength) - { - DPRINT1("Hit the ROS TEB Static Unicode String Bug\n", - "Please try to fix the underlying problem!!!\n"); - goto RosHack; - } - /* Convert it into the TEB */ Status = RtlAnsiStringToUnicodeString(AtomNameString, &AnsiString, _____ Modified: trunk/reactos/lib/ntdll/ldr/startup.c --- trunk/reactos/lib/ntdll/ldr/startup.c 2006-01-03 22:25:09 UTC (rev 20555) +++ trunk/reactos/lib/ntdll/ldr/startup.c 2006-01-03 22:36:36 UTC (rev 20556) @@ -377,6 +377,11 @@ /* Load execution options */ LoadImageFileExecutionOptions(Peb); + /* Initialize the static teb string */ + NtCurrentTeb()->StaticUnicodeString.Length = 0; + NtCurrentTeb()->StaticUnicodeString.MaximumLength = sizeof(NtCurrentTeb()->StaticUnicodeBuffer); + NtCurrentTeb()->StaticUnicodeString.Buffer = NtCurrentTeb()->StaticUnicodeBuffer; + /* build full ntdll path */ wcscpy (FullNtDllPath, SharedUserData->NtSystemRoot); wcscat (FullNtDllPath, L"\\system32\\ntdll.dll");

1 0

[ion] 20555: - Dirty temporary fix to unregress abiword/qemu.
by ion＠svn.reactos.org 03 Jan '06

03 Jan '06

- Dirty temporary fix to unregress abiword/qemu. Modified: trunk/reactos/lib/kernel32/misc/atom.c _____ Modified: trunk/reactos/lib/kernel32/misc/atom.c --- trunk/reactos/lib/kernel32/misc/atom.c 2006-01-03 21:34:19 UTC (rev 20554) +++ trunk/reactos/lib/kernel32/misc/atom.c 2006-01-03 22:25:09 UTC (rev 20555) @@ -72,6 +72,7 @@ /* Check if we can abuse the TEB */ if (AnsiString.MaximumLength > 260) { +RosHack: /* We can't, allocate a new string */ AtomNameString = &UnicodeString; Status = RtlAnsiStringToUnicodeString(AtomNameString, @@ -80,8 +81,18 @@ } else { - /* We can! Use the TEB */ + /* We can! Get the TEB String */ AtomNameString = &NtCurrentTeb()->StaticUnicodeString; + + /* FIXME: HACK! */ + if (!AtomNameString->MaximumLength) + { + DPRINT1("Hit the ROS TEB Static Unicode String Bug\n", + "Please try to fix the underlying problem!!!\n"); + goto RosHack; + } + + /* Convert it into the TEB */ Status = RtlAnsiStringToUnicodeString(AtomNameString, &AnsiString, FALSE); @@ -171,6 +182,7 @@ /* Check if we can abuse the TEB */ if (AnsiString.MaximumLength > 260) { +RosHack: /* We can't, allocate a new string */ AtomNameString = &UnicodeString; Status = RtlAnsiStringToUnicodeString(AtomNameString, @@ -179,8 +191,18 @@ } else { - /* We can! Use the TEB */ + /* We can! Get the TEB String */ AtomNameString = &NtCurrentTeb()->StaticUnicodeString; + + /* FIXME: HACK! */ + if (!AtomNameString->MaximumLength) + { + DPRINT1("Hit the ROS TEB Static Unicode String Bug\n", + "Please try to fix the underlying problem!!!\n"); + goto RosHack; + } + + /* Convert it into the TEB */ Status = RtlAnsiStringToUnicodeString(AtomNameString, &AnsiString, FALSE);

1 0

[ion] 20554: - Fix shamefully dangerously broken Work Thread/Queue/Item implementation:
by ion＠svn.reactos.org 03 Jan '06

03 Jan '06

- Fix shamefully dangerously broken Work Thread/Queue/Item implementation: * Do not pollute the kernel with 10 real-time threads and 5 high-priority threads in order to manage work items. Work threads are very-low priority (< 7) and should never pre-empt userthreads like they do now. 1 priority 7, 5 priority 5 and 3 priority 4 threads are now properly created. * Implement a worker thread balance set manager. On SMP systems, it is able to determine when a new thread should be allocate to execute on a free CPU. On both UP and MP, it is also able to detect if a work queue has deadlocked, and will allocate new dynamic threads to unfreeze the queue. * Add check for threads returning with APC disabled, and re-enable APCs if this happend. This hack is used in NT for broken drivers. * Lots of code changes to support dynamic threads, which: - Can terminate. - Use a 10 minute timeout on the kernel queue. * Add skeleton code for swapping worker thread stacks as well as worker thread shutdown (not yet implemented). * Add WORKER_INVALID bugcheck definition. * These changes seem to make ROS a lot more responsive. - NDK: * Make more compatible with MS IFS * Fix EX_WORK_QUEUE definition. * Fix ETHREAD offsets. * Fix RtlIsNameLegalDOS8Dot3 definition. * Move splay tree defines to IFS. Modified: trunk/reactos/include/ndk/exfuncs.h Modified: trunk/reactos/include/ndk/extypes.h Modified: trunk/reactos/include/ndk/ifssupp.h Modified: trunk/reactos/include/ndk/iofuncs.h Modified: trunk/reactos/include/ndk/obfuncs.h Modified: trunk/reactos/include/ndk/pstypes.h Modified: trunk/reactos/include/ndk/rtlfuncs.h Modified: trunk/reactos/include/ndk/rtltypes.h Modified: trunk/reactos/lib/rtl/dos8dot3.c Modified: trunk/reactos/ntoskrnl/ex/work.c Modified: trunk/reactos/ntoskrnl/ntoskrnl.mc Modified: trunk/reactos/w32api/include/ddk/ntifs.h _____ Modified: trunk/reactos/include/ndk/exfuncs.h --- trunk/reactos/include/ndk/exfuncs.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/exfuncs.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -485,6 +485,7 @@ IN HANDLE EventHandle ); +NTSYSAPI NTSTATUS NTAPI ZwCreateEvent( @@ -741,6 +742,7 @@ IN HANDLE PortHandle ); +NTSYSAPI NTSTATUS NTAPI ZwSetEvent( _____ Modified: trunk/reactos/include/ndk/extypes.h --- trunk/reactos/include/ndk/extypes.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/extypes.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -273,7 +273,7 @@ typedef struct _EX_WORK_QUEUE { KQUEUE WorkerQueue; - ULONG DynamicThreadCount; + LONG DynamicThreadCount; ULONG WorkItemsProcessed; ULONG WorkItemsProcessedLastPass; ULONG QueueDepthLastPass; @@ -318,6 +318,8 @@ // // Executive Pushlock // +#undef EX_PUSH_LOCK +#undef PEX_PUSH_LOCK typedef struct _EX_PUSH_LOCK { union _____ Modified: trunk/reactos/include/ndk/ifssupp.h --- trunk/reactos/include/ndk/ifssupp.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/ifssupp.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -117,6 +117,13 @@ LIST_ENTRY ThreadListHead; } KQUEUE, *PKQUEUE, *RESTRICTED_POINTER PRKQUEUE; +typedef struct _ACE_HEADER +{ + UCHAR AceType; + UCHAR AceFlags; + USHORT AceSize; +} ACE_HEADER, *PACE_HEADER; + typedef enum _RTL_GENERIC_COMPARE_RESULTS { GenericLessThan, _____ Modified: trunk/reactos/include/ndk/iofuncs.h --- trunk/reactos/include/ndk/iofuncs.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/iofuncs.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -562,6 +562,7 @@ IN PUNICODE_STRING EntryValue ); +NTSYSAPI NTSTATUS NTAPI ZwDeleteFile( @@ -591,6 +592,7 @@ IN ULONG Unknown2 ); +NTSYSAPI NTSTATUS NTAPI ZwFlushBuffersFile( _____ Modified: trunk/reactos/include/ndk/obfuncs.h --- trunk/reactos/include/ndk/obfuncs.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/obfuncs.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -296,6 +296,7 @@ IN BOOLEAN GenerateOnClose ); +NTSYSAPI NTSTATUS NTAPI ZwDuplicateObject( @@ -321,6 +322,7 @@ IN HANDLE Handle ); +NTSYSAPI NTSTATUS NTAPI ZwOpenDirectoryObject( @@ -425,6 +427,7 @@ IN PLARGE_INTEGER Time ); +NTSYSAPI NTSTATUS NTAPI ZwWaitForSingleObject( _____ Modified: trunk/reactos/include/ndk/pstypes.h --- trunk/reactos/include/ndk/pstypes.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/pstypes.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -600,7 +600,8 @@ #include <pshpack4.h> typedef struct _ETHREAD { - KTHREAD Tcb; /* 1B8 */ + KTHREAD Tcb; /* 000 */ + PVOID Padding; /* 1B4 */ LARGE_INTEGER CreateTime; /* 1B8 */ union { _____ Modified: trunk/reactos/include/ndk/rtlfuncs.h --- trunk/reactos/include/ndk/rtlfuncs.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/rtlfuncs.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -157,8 +157,6 @@ #define RtlEqualLuid(L1, L2) (((L1)->HighPart == (L2)->HighPart) && \ ((L1)->LowPart == (L2)->LowPart)) -#endif - // // RTL Splay Tree Functions // @@ -246,6 +244,7 @@ _SplayParent->RightChild = _SplayChild; \ _SplayChild->Parent = _SplayParent; \ } +#endif // // Error and Exception Functions @@ -1694,9 +1693,9 @@ BOOLEAN NTAPI RtlIsNameLegalDOS8Dot3( - IN PUNICODE_STRING UnicodeName, - IN PANSI_STRING AnsiName, - PBOOLEAN Unknown + IN PCUNICODE_STRING Name, + IN OUT POEM_STRING OemName OPTIONAL, + IN OUT PBOOLEAN NameContainsSpaces OPTIONAL ); NTSYSAPI _____ Modified: trunk/reactos/include/ndk/rtltypes.h --- trunk/reactos/include/ndk/rtltypes.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/include/ndk/rtltypes.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -538,16 +538,6 @@ CSHORT Weekday; } TIME_FIELDS, *PTIME_FIELDS; -#else -// -// ACE Definitions -// -typedef struct _ACE_HEADER -{ - UCHAR AceType; - UCHAR AceFlags; - USHORT AceSize; -} ACE_HEADER, *PACE_HEADER; #endif typedef struct _ACE { _____ Modified: trunk/reactos/lib/rtl/dos8dot3.c --- trunk/reactos/lib/rtl/dos8dot3.c 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/lib/rtl/dos8dot3.c 2006-01-03 21:34:19 UTC (rev 20554) @@ -232,10 +232,11 @@ /* * @implemented */ -BOOLEAN NTAPI -RtlIsNameLegalDOS8Dot3(IN PUNICODE_STRING UnicodeName, - IN PANSI_STRING AnsiName, - OUT PBOOLEAN SpacesFound) +BOOLEAN +NTAPI +RtlIsNameLegalDOS8Dot3(IN PCUNICODE_STRING UnicodeName, + IN OUT POEM_STRING AnsiName OPTIONAL, + IN OUT PBOOLEAN SpacesFound OPTIONAL) { PANSI_STRING name = AnsiName; ANSI_STRING DummyString; _____ Modified: trunk/reactos/ntoskrnl/ex/work.c --- trunk/reactos/ntoskrnl/ex/work.c 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/ntoskrnl/ex/work.c 2006-01-03 21:34:19 UTC (rev 20554) @@ -1,11 +1,9 @@ /* * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel + * PROJECT: ReactOS Kernel * FILE: ntoskrnl/ex/work.c - * PURPOSE: Manage system work queues - * - * PROGRAMMERS: Alex Ionescu - Used correct work queue array and added some fixes and checks. - * Gunnar Dalsnes - Implemented + * PURPOSE: Manage system work queues and worker threads + * PROGRAMMER: Alex Ionescu (alex(a)relsoft.net) */ /* INCLUDES ******************************************************************/ @@ -18,70 +16,167 @@ #pragma alloc_text(INIT, ExpInitializeWorkerThreads) #endif -/* DEFINES *******************************************************************/ +/* DATA **********************************************************************/ -#define NUMBER_OF_WORKER_THREADS (5) +/* Number of worker threads for each Queue */ +#define EX_HYPERCRITICAL_WORK_THREADS 1 +#define EX_DELAYED_WORK_THREADS 3 +#define EX_CRITICAL_WORK_THREADS 5 -/* TYPES *********************************************************************/ +/* Magic flag for dynamic worker threads */ +#define EX_DYNAMIC_WORK_THREAD 0x80000000 -/* GLOBALS *******************************************************************/ +/* Worker thread priorities */ +#define EX_HYPERCRITICAL_QUEUE_PRIORITY 7 +#define EX_CRITICAL_QUEUE_PRIORITY 5 +#define EX_DELAYED_QUEUE_PRIORITY 4 -/* - * PURPOSE: Queue of items waiting to be processed at normal priority - */ +/* The actual worker queue array */ EX_WORK_QUEUE ExWorkerQueue[MaximumWorkQueue]; -/* FUNCTIONS ****************************************************************/ +/* Accounting of the total threads and registry hacked threads */ +ULONG ExpCriticalWorkerThreads; +ULONG ExpDelayedWorkerThreads; +ULONG ExpAdditionalCriticalWorkerThreads; +ULONG ExpAdditionalDelayedWorkerThreads; -/* - * FUNCTION: Entry point for a worker thread - * ARGUMENTS: - * context = Parameters - * RETURNS: Status - * NOTE: To kill a worker thread you must queue an item whose callback - * calls PsTerminateSystemThread - */ -static +/* Future support for stack swapping worker threads */ +BOOLEAN ExpWorkersCanSwap; +LIST_ENTRY ExpWorkerListHead; +KMUTANT ExpWorkerSwapinMutex; + +/* The worker balance set manager events */ +KEVENT ExpThreadSetManagerEvent; +KEVENT ExpThreadSetManagerShutdownEvent; + +/* Thread pointers for future worker thread shutdown support */ +PETHREAD ExpWorkerThreadBalanceManagerPtr; +PETHREAD ExpLastWorkerThread; + +/* PRIVATE FUNCTIONS *********************************************************/ + +/*++ + * @name ExpWorkerThreadEntryPoint + * + * The ExpWorkerThreadEntryPoint routine is the entrypoint for any new + * worker thread created by teh system. + * + * @param Context + * Contains the work queue type masked with a flag specifing whether the + * thread is dynamic or not. + * + * @return None. + * + * @remarks A dynamic thread can timeout after 10 minutes of waiting on a queue + * while a static thread will never timeout. + * + * Worker threads must return at IRQL == PASSIVE_LEVEL, must not have + * active impersonation info, and must not have disabled APCs. + * + * NB: We will re-enable APCs for broken threads but all other cases + * will generate a bugcheck. + * + *--*/ VOID -STDCALL +NTAPI ExpWorkerThreadEntryPoint(IN PVOID Context) { PWORK_QUEUE_ITEM WorkItem; PLIST_ENTRY QueueEntry; WORK_QUEUE_TYPE WorkQueueType; PEX_WORK_QUEUE WorkQueue; + LARGE_INTEGER Timeout; + PLARGE_INTEGER TimeoutPointer = NULL; + PETHREAD Thread = PsGetCurrentThread(); + KPROCESSOR_MODE WaitMode; + EX_QUEUE_WORKER_INFO OldValue, NewValue; + /* Check if this is a dyamic thread */ + if ((ULONG_PTR)Context & EX_DYNAMIC_WORK_THREAD) + { + /* It is, which means we will eventually time out after 10 minutes */ + Timeout.QuadPart = Int32x32To64(10, -10000000 * 60); + TimeoutPointer = &Timeout; + } + /* Get Queue Type and Worker Queue */ - WorkQueueType = (WORK_QUEUE_TYPE)Context; + WorkQueueType = (WORK_QUEUE_TYPE)((ULONG_PTR)Context & + ~EX_DYNAMIC_WORK_THREAD); WorkQueue = &ExWorkerQueue[WorkQueueType]; + /* Select the wait mode */ + WaitMode = (UCHAR)WorkQueue->Info.WaitMode; + + /* Nobody should have initialized this yet, do it now */ + ASSERT(Thread->ExWorkerCanWaitUser == 0); + if (WaitMode == UserMode) Thread->ExWorkerCanWaitUser = TRUE; + + /* If we shouldn't swap, disable that feature */ + if (!ExpWorkersCanSwap) KeSetKernelStackSwapEnable(FALSE); + + /* Set the worker flags */ + do + { + /* Check if the queue is being disabled */ + if (WorkQueue->Info.QueueDisabled) + { + /* Re-enable stack swapping and kill us */ + KeSetKernelStackSwapEnable(TRUE); + PsTerminateSystemThread(STATUS_SYSTEM_SHUTDOWN); + } + + /* Increase the worker count */ + OldValue = WorkQueue->Info; + NewValue = OldValue; + NewValue.WorkerCount++; + } + while (InterlockedCompareExchange((PLONG)&WorkQueue->Info, + *(PLONG)&NewValue, + *(PLONG)&OldValue) != *(PLONG)&OldValue); + + /* Success, you are now officially a worker thread! */ + Thread->ActiveExWorker = TRUE; + /* Loop forever */ - while (TRUE) { - +ProcessLoop: + for (;;) + { /* Wait for Something to Happen on the Queue */ - QueueEntry = KeRemoveQueue(&WorkQueue->WorkerQueue, KernelMode, NULL); + QueueEntry = KeRemoveQueue(&WorkQueue->WorkerQueue, + WaitMode, + TimeoutPointer); - /* Can't happen since we do a KernelMode wait (and we're a system thread) */ - ASSERT((NTSTATUS)QueueEntry != STATUS_USER_APC); + /* Check if we timed out and quit this loop in that case */ + if ((NTSTATUS)QueueEntry == STATUS_TIMEOUT) break; - /* this should never happen either, since we wait with NULL timeout, - * but there's a slight possibility that STATUS_TIMEOUT is returned - * at queue rundown in NT (unlikely) -Gunnar - */ - ASSERT((NTSTATUS)QueueEntry != STATUS_TIMEOUT); - /* Increment Processed Work Items */ InterlockedIncrement((PLONG)&WorkQueue->WorkItemsProcessed); /* Get the Work Item */ WorkItem = CONTAINING_RECORD(QueueEntry, WORK_QUEUE_ITEM, List); + /* Make sure nobody is trying to play smart with us */ + ASSERT((ULONG_PTR)WorkItem->WorkerRoutine > MmUserProbeAddress); + /* Call the Worker Routine */ WorkItem->WorkerRoutine(WorkItem->Parameter); + /* Make sure APCs are not disabled */ + if (Thread->Tcb.SpecialApcDisable) + { + /* We're nice and do it behind your back */ + DPRINT1("Warning: Broken Worker Thread: %p %lx %p came back " + "with APCs disabled!\n", + WorkItem->WorkerRoutine, + WorkItem->Parameter, + WorkItem); + Thread->Tcb.SpecialApcDisable = 0; + } + /* Make sure it returned at right IRQL */ - if (KeGetCurrentIrql() != PASSIVE_LEVEL) { - + if (KeGetCurrentIrql() != PASSIVE_LEVEL) + { + /* It didn't, bugcheck! */ KEBUGCHECKEX(WORKER_THREAD_RETURNED_AT_BAD_IRQL, (ULONG_PTR)WorkItem->WorkerRoutine, KeGetCurrentIrql(), @@ -90,8 +185,9 @@ } /* Make sure it returned with Impersionation Disabled */ - if (PsGetCurrentThread()->ActiveImpersonationInfo) { - + if (Thread->ActiveImpersonationInfo) + { + /* It didn't, bugcheck! */ KEBUGCHECKEX(IMPERSONATING_WORKER_THREAD, (ULONG_PTR)WorkItem->WorkerRoutine, (ULONG_PTR)WorkItem->Parameter, @@ -99,87 +195,470 @@ 0); } } + + /* This is a dynamic thread. Terminate it unless IRPs are pending */ + if (!IsListEmpty(&Thread->IrpList)) goto ProcessLoop; + + /* Don't terminate it if the queue is disabled either */ + if (WorkQueue->Info.QueueDisabled) goto ProcessLoop; + + /* Set the worker flags */ + do + { + /* Decrease the worker count */ + OldValue = WorkQueue->Info; + NewValue = OldValue; + NewValue.WorkerCount--; + } + while (InterlockedCompareExchange((PLONG)&WorkQueue->Info, + *(PLONG)&NewValue, + *(PLONG)&OldValue) != *(PLONG)&OldValue); + + /* Decrement dynamic thread count */ + InterlockedDecrement(&WorkQueue->DynamicThreadCount); + + /* We're not a worker thread anymore */ + Thread->ActiveExWorker = FALSE; + + /* Re-enable the stack swap */ + KeSetKernelStackSwapEnable(TRUE); + return; } -static +/*++ + * @name ExpCreateWorkerThread + * + * The ExpCreateWorkerThread routine creates a new worker thread for the + * specified queue. + ** + * @param QueueType + * Type of the queue to use for this thread. Valid values are: + * - DelayedWorkQueue + * - CriticalWorkQueue + * - HyperCriticalWorkQueue + * + * @param Dynamic + * Specifies whether or not this thread is a dynamic thread. + * + * @return None. + * + * @remarks HyperCritical work threads run at priority 7; Critical work threads + * run at priority 5, and delayed work threads run at priority 4. + * + * This, worker threads cannot pre-empty a normal user-mode thread. + * + *--*/ VOID -STDCALL -ExpInitializeWorkQueue(WORK_QUEUE_TYPE WorkQueueType, - KPRIORITY Priority) +NTAPI +ExpCreateWorkerThread(WORK_QUEUE_TYPE WorkQueueType, + IN BOOLEAN Dynamic) { - ULONG i; PETHREAD Thread; HANDLE hThread; + ULONG Context; + KPRIORITY Priority; - /* Loop through how many threads we need to create */ - for (i = 0; i < NUMBER_OF_WORKER_THREADS; i++) { + /* Check if this is going to be a dynamic thread */ + Context = WorkQueueType; - /* Create the System Thread */ - PsCreateSystemThread(&hThread, - THREAD_ALL_ACCESS, - NULL, - NULL, - NULL, - ExpWorkerThreadEntryPoint, - (PVOID)WorkQueueType); + /* Add the dynamic mask */ + if (Dynamic) Context |= EX_DYNAMIC_WORK_THREAD; - /* Get the Thread */ - ObReferenceObjectByHandle(hThread, - THREAD_SET_INFORMATION, - PsThreadType, + /* Create the System Thread */ + PsCreateSystemThread(&hThread, + THREAD_ALL_ACCESS, + NULL, + NULL, + NULL, + ExpWorkerThreadEntryPoint, + (PVOID)Context); + + /* If the thread is dynamic */ + if (Dynamic) + { + /* Increase the count */ + InterlockedIncrement(&ExWorkerQueue[WorkQueueType].DynamicThreadCount); + } + + /* Set the priority */ + if (WorkQueueType == DelayedWorkQueue) + { + /* Priority == 4 */ + Priority = EX_DELAYED_QUEUE_PRIORITY; + } + else if (WorkQueueType == CriticalWorkQueue) + { + /* Priority == 5 */ + Priority = EX_CRITICAL_QUEUE_PRIORITY; + } + else + { + /* Priority == 7 */ + Priority = EX_HYPERCRITICAL_QUEUE_PRIORITY; + } + + /* Get the Thread */ + ObReferenceObjectByHandle(hThread, + THREAD_SET_INFORMATION, + PsThreadType, + KernelMode, + (PVOID*)&Thread, + NULL); + + /* Set the Priority */ + KeSetPriorityThread(&Thread->Tcb, Priority); + + /* Dereference and close handle */ + ObDereferenceObject(Thread); + ZwClose(hThread); +} + +/*++ + * @name ExpCheckDynamicThreadCount + * + * The ExpCheckDynamicThreadCount routine checks every queue and creates a + * dynamic thread if the queue seems to be deadlocked. + * + * @param None + * + * @return None. + * + * @remarks The algorithm for deciding if a new thread must be created is + * based on wether the queue has processed no new items in the last + * second, and new items are still enqueued. + * + *--*/ +VOID +NTAPI +ExpDetectWorkerThreadDeadlock(VOID) +{ + ULONG i; + PEX_WORK_QUEUE Queue; + + /* Loop the 3 queues */ + for (i = 0; i < MaximumWorkQueue; i++) + { + /* Get the queue */ + Queue = &ExWorkerQueue[i]; + ASSERT(Queue->DynamicThreadCount <= 16); + + /* Check if stuff is on the queue that still is unprocessed */ + if ((Queue->QueueDepthLastPass) && + (Queue->WorkItemsProcessed == Queue->WorkItemsProcessedLastPass) && + (Queue->DynamicThreadCount < 16)) + { + /* Stuff is still on the queue and nobody did anything about it */ + DPRINT1("EX: Work Queue Deadlock detected: %d\n", i); + ExpCreateWorkerThread(i, TRUE); + DPRINT1("Dynamic threads queued %d\n", Queue->DynamicThreadCount); + } + + /* Update our data */ + Queue->WorkItemsProcessedLastPass = Queue->WorkItemsProcessed; + Queue->QueueDepthLastPass = KeReadStateQueue(&Queue->WorkerQueue); + } +} + +/*++ + * @name ExpCheckDynamicThreadCount + * + * The ExpCheckDynamicThreadCount routine checks every queue and creates a + * dynamic thread if the queue requires one. + * + * @param None + * + * @return None. + * + * @remarks The algorithm for deciding if a new thread must be created is + * documented in the ExQueueWorkItem routine. + * + *--*/ +VOID +NTAPI +ExpCheckDynamicThreadCount(VOID) +{ + ULONG i; + PEX_WORK_QUEUE Queue; + + /* Loop the 3 queues */ + for (i = 0; i < MaximumWorkQueue; i++) + { + /* Get the queue */ + Queue = &ExWorkerQueue[i]; + + /* Check if still need a new thread. See ExQueueWorkItem */ + if ((Queue->Info.MakeThreadsAsNecessary) && + (!IsListEmpty(&Queue->WorkerQueue.EntryListHead)) && + (Queue->WorkerQueue.CurrentCount < + Queue->WorkerQueue.MaximumCount) && + (Queue->DynamicThreadCount < 16)) + { + /* Create a new thread */ + DPRINT1("EX: Creating new dynamic thread as requested\n"); + ExpCreateWorkerThread(i, TRUE); + } + } +} + +/*++ + * @name ExpWorkerThreadBalanceManager + * + * The ExpWorkerThreadBalanceManager routine is the entrypoint for the + * worker thread balance set manager. + * + * @param Context + * Unused. + * + * @return None. + * + * @remarks The worker thread balance set manager listens every second, but can + * also be woken up by an event when a new thread is needed, or by the + * special shutdown event. This thread runs at priority 7. + * + * This routine must run at IRQL == PASSIVE_LEVEL. + * + *--*/ +VOID +NTAPI +ExpWorkerThreadBalanceManager(IN PVOID Context) +{ + KTIMER Timer; + LARGE_INTEGER Timeout; + NTSTATUS Status; + PVOID WaitEvents[2]; + PAGED_CODE(); + UNREFERENCED_PARAMETER(Context); + + /* Raise our priority above all other worker threads */ + KeSetBasePriorityThread(KeGetCurrentThread(), + EX_CRITICAL_QUEUE_PRIORITY + 1); + + /* Setup the timer */ + KeInitializeTimer(&Timer); + Timeout.QuadPart = Int32x32To64(-1, 10000000); + + /* We'll wait on the periodic timer and also the emergency event */ + WaitEvents[0] = &Timer; + WaitEvents[1] = &ExpThreadSetManagerEvent; + WaitEvents[2] = &ExpThreadSetManagerShutdownEvent; + + /* Start wait loop */ + for (;;) + { + /* Wait for the timer */ + KeSetTimer(&Timer, Timeout, NULL); + Status = KeWaitForMultipleObjects(3, + WaitEvents, + WaitAny, + Executive, + KernelMode, + FALSE, + NULL, + NULL); + if (Status == 0) + { + /* Our timer expired. Check for deadlocks */ + ExpDetectWorkerThreadDeadlock(); + } + else if (Status == 1) + { + /* Someone notified us, verify if we should create a new thread */ + ExpCheckDynamicThreadCount(); + } + else if (Status == 2) + { + /* We are shutting down. Cancel the timer */ + DPRINT1("System shutdown\n"); + KeCancelTimer(&Timer); + + /* Make sure we have a final thread */ + ASSERT(ExpLastWorkerThread); + + /* Wait for it */ + KeWaitForSingleObject(ExpLastWorkerThread, + Executive, KernelMode, - (PVOID*)&Thread, + FALSE, NULL); - /* Set the Priority */ - KeSetPriorityThread(&Thread->Tcb, Priority); - - /* Dereference and close handle */ - ObDereferenceObject(Thread); - ZwClose(hThread); + /* Dereference it and kill us */ + ObDereferenceObject(ExpLastWorkerThread); + PsTerminateSystemThread(STATUS_SYSTEM_SHUTDOWN); + } } } +/*++ + * @name ExpInitializeWorkerThreads + * + * The ExpInitializeWorkerThreads routine initializes worker thread and + * work queue support. + * + * @param None. + * + * @return None. + * + * @remarks This routine is only called once during system initialization. + * + *--*/ VOID INIT_FUNCTION -STDCALL +NTAPI ExpInitializeWorkerThreads(VOID) { ULONG WorkQueueType; + ULONG CriticalThreads, DelayedThreads; + HANDLE ThreadHandle; + PETHREAD Thread; + ULONG i; + /* Setup the stack swap support */ + KeInitializeMutex(&ExpWorkerSwapinMutex, FALSE); + InitializeListHead(&ExpWorkerListHead); + ExpWorkersCanSwap = TRUE; + + /* Set the number of critical and delayed threads. We shouldn't hardcode */ + DelayedThreads = EX_DELAYED_WORK_THREADS; + CriticalThreads = EX_CRITICAL_WORK_THREADS; + + /* Protect against greedy registry modifications */ + ExpAdditionalDelayedWorkerThreads = + min(ExpAdditionalCriticalWorkerThreads, 16); + ExpAdditionalCriticalWorkerThreads = + min(ExpAdditionalCriticalWorkerThreads, 16); + + /* Calculate final count */ + DelayedThreads += ExpAdditionalDelayedWorkerThreads; + CriticalThreads += ExpAdditionalCriticalWorkerThreads; + /* Initialize the Array */ - for (WorkQueueType = 0; WorkQueueType < MaximumWorkQueue; WorkQueueType++) { - + for (WorkQueueType = 0; WorkQueueType < MaximumWorkQueue; WorkQueueType++) + { + /* Clear the structure and initialize the queue */ RtlZeroMemory(&ExWorkerQueue[WorkQueueType], sizeof(EX_WORK_QUEUE)); KeInitializeQueue(&ExWorkerQueue[WorkQueueType].WorkerQueue, 0); } - /* Create the built-in worker threads for each work queue */ - ExpInitializeWorkQueue(CriticalWorkQueue, LOW_REALTIME_PRIORITY); - ExpInitializeWorkQueue(DelayedWorkQueue, LOW_PRIORITY); - ExpInitializeWorkQueue(HyperCriticalWorkQueue, HIGH_PRIORITY); + /* Dynamic threads are only used for the critical queue */ + ExWorkerQueue[CriticalWorkQueue].Info.MakeThreadsAsNecessary = TRUE; + + /* Initialize the balance set manager events */ + KeInitializeEvent(&ExpThreadSetManagerEvent, SynchronizationEvent, FALSE); + KeInitializeEvent(&ExpThreadSetManagerShutdownEvent, + NotificationEvent, + FALSE); + + /* Create the built-in worker threads for the critical queue */ + for (i = 0; i < CriticalThreads; i++) + { + /* Create the thread */ + ExpCreateWorkerThread(CriticalWorkQueue, FALSE); + ExpCriticalWorkerThreads++; + } + + /* Create the built-in worker threads for the delayed queue */ + for (i = 0; i < DelayedThreads; i++) + { + /* Create the thread */ + ExpCreateWorkerThread(DelayedWorkQueue, FALSE); + ExpDelayedWorkerThreads++; + } + + /* Create the built-in worker thread for the hypercritical queue */ + ExpCreateWorkerThread(HyperCriticalWorkQueue, FALSE); + + /* Create the balance set manager thread */ + PsCreateSystemThread(&ThreadHandle, + THREAD_ALL_ACCESS, + NULL, + 0, + NULL, + ExpWorkerThreadBalanceManager, + NULL); + + /* Get a pointer to it for the shutdown process */ + ObReferenceObjectByHandle(ThreadHandle, + THREAD_ALL_ACCESS, + NULL, + KernelMode, + (PVOID*)&Thread, + NULL); + ExpWorkerThreadBalanceManagerPtr = Thread; + + /* Close the handle and return */ + ZwClose(ThreadHandle); } -/* - * @implemented +/* PUBLIC FUNCTIONS **********************************************************/ + +/*++ + * @name ExQueueWorkItem + * @implemented NT4 * - * FUNCTION: Inserts a work item in a queue for one of the system worker - * threads to process - * ARGUMENTS: - * WorkItem = Item to insert - * QueueType = Queue to insert it in - */ + * The ExQueueWorkItem routine acquires rundown protection for + * the specified descriptor. + * + * @param WorkItem + * Pointer to an initialized Work Queue Item structure. This structure + * must be located in nonpaged pool memory. + * + * @param QueueType + * Type of the queue to use for this item. Can be one of the following: + * - DelayedWorkQueue + * - CriticalWorkQueue + * - HyperCriticalWorkQueue + * + * @return None. + * + * @remarks This routine is obsolete. Use IoQueueWorkItem instead. + * + * Callers of this routine must be running at IRQL <= DISPATCH_LEVEL. + * + *--*/ VOID -STDCALL +NTAPI ExQueueWorkItem(PWORK_QUEUE_ITEM WorkItem, WORK_QUEUE_TYPE QueueType) { - ASSERT(WorkItem!=NULL); - ASSERT_IRQL(DISPATCH_LEVEL); + PEX_WORK_QUEUE WorkQueue = &ExWorkerQueue[QueueType]; + ASSERT(QueueType < MaximumWorkQueue); ASSERT(WorkItem->List.Flink == NULL); + /* Don't try to trick us */ + if ((ULONG_PTR)WorkItem->WorkerRoutine < MmUserProbeAddress) + { + /* Bugcheck the system */ + KEBUGCHECKEX(WORKER_INVALID, + 1, + (ULONG_PTR)WorkItem, + (ULONG_PTR)WorkItem->WorkerRoutine, + 0); + } + /* Insert the Queue */ - KeInsertQueue(&ExWorkerQueue[QueueType].WorkerQueue, &WorkItem->List); + KeInsertQueue(&WorkQueue->WorkerQueue, &WorkItem->List); + ASSERT(!WorkQueue->Info.QueueDisabled); + + /* + * Check if we need a new thread. Our decision is as follows: + * - This queue type must support Dynamic Threads (duh!) + * - It actually has to have unprocessed items + * - We have CPUs which could be handling another thread + * - We haven't abused our usage of dynamic threads. + */ + if ((WorkQueue->Info.MakeThreadsAsNecessary) && + (!IsListEmpty(&WorkQueue->WorkerQueue.EntryListHead)) && + (WorkQueue->WorkerQueue.CurrentCount < + WorkQueue->WorkerQueue.MaximumCount) && + (WorkQueue->DynamicThreadCount < 16)) + { + /* Let the balance manager know about it */ + DPRINT1("Requesting a new thread. CurrentCount: %d. MaxCount: %d\n", + WorkQueue->WorkerQueue.CurrentCount, + WorkQueue->WorkerQueue.MaximumCount); + KeSetEvent(&ExpThreadSetManagerEvent, 0, FALSE); + } } /* EOF */ + _____ Modified: trunk/reactos/ntoskrnl/ntoskrnl.mc --- trunk/reactos/ntoskrnl/ntoskrnl.mc 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/ntoskrnl/ntoskrnl.mc 2006-01-03 21:34:19 UTC (rev 20554) @@ -1003,6 +1003,14 @@ WORKER_THREAD_RETURNED_AT_BAD_IRQL . +MessageId=0xE4 +Severity=Success +Facility=System +SymbolicName=WORKER_INVALID +Language=English +WORKER_INVALID +. + MessageId=0xE2 Severity=Success Facility=System _____ Modified: trunk/reactos/w32api/include/ddk/ntifs.h --- trunk/reactos/w32api/include/ddk/ntifs.h 2006-01-03 21:29:39 UTC (rev 20553) +++ trunk/reactos/w32api/include/ddk/ntifs.h 2006-01-03 21:34:19 UTC (rev 20554) @@ -1551,6 +1551,13 @@ TOKEN_CONTROL ClientTokenControl; } SECURITY_CLIENT_CONTEXT, *PSECURITY_CLIENT_CONTEXT; +typedef struct _ACE_HEADER +{ + UCHAR AceType; + UCHAR AceFlags; + USHORT AceSize; +} ACE_HEADER, *PACE_HEADER; + typedef struct _TUNNEL { FAST_MUTEX Mutex; PRTL_SPLAY_LINKS Cache; @@ -3370,6 +3377,13 @@ NTKERNELAPI BOOLEAN NTAPI +KeSetKernelStackSwapEnable( + IN BOOLEAN Enable +); + +NTKERNELAPI +BOOLEAN +NTAPI MmCanFileBeTruncated ( IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN PLARGE_INTEGER NewFileSize @@ -3885,10 +3899,10 @@ NTSYSAPI BOOLEAN NTAPI -RtlIsNameLegalDOS8Dot3 ( [truncated at 1000 lines; 104 more skipped]

1 0

[fireball] 20553: Add kbdur.dll (Ukrainian keyboard layout) to the install-cd.
by fireball＠svn.reactos.org 03 Jan '06

03 Jan '06

Add kbdur.dll (Ukrainian keyboard layout) to the install-cd. Modified: trunk/reactos/bootdata/packages/reactos.dff _____ Modified: trunk/reactos/bootdata/packages/reactos.dff --- trunk/reactos/bootdata/packages/reactos.dff 2006-01-03 21:17:28 UTC (rev 20552) +++ trunk/reactos/bootdata/packages/reactos.dff 2006-01-03 21:29:39 UTC (rev 20553) @@ -113,6 +113,7 @@ lib\keyboard\kbdse\kbdse.dll 1 lib\keyboard\kbdsg\kbdsg.dll 1 lib\keyboard\kbduk\kbduk.dll 1 +lib\keyboard\kbdur\kbdur.dll 1 lib\keyboard\kbdus\kbdus.dll 1 lib\kernel32\kernel32.dll 1 lib\lsasrv\lsasrv.dll 1

1 0

[gedmurphy] 20552: fix ugly tab formatting
by gedmurphy＠svn.reactos.org 03 Jan '06

03 Jan '06

fix ugly tab formatting Modified: trunk/reactos/lib/cpl/sysdm/resource.h _____ Modified: trunk/reactos/lib/cpl/sysdm/resource.h --- trunk/reactos/lib/cpl/sysdm/resource.h 2006-01-03 21:00:06 UTC (rev 20551) +++ trunk/reactos/lib/cpl/sysdm/resource.h 2006-01-03 21:17:28 UTC (rev 20552) @@ -13,17 +13,17 @@ #define RC_LICENSE 101 #define RTDATA 300 -#define IDI_CPLSYSTEM 100 +#define IDI_CPLSYSTEM 100 #define IDI_DEVMGR 101 -#define IDD_PROPPAGEGENERAL 100 -#define IDD_PROPPAGECOMPUTER 101 -#define IDD_PROPPAGEHARDWARE 102 -#define IDD_PROPPAGEUSERPROFILE 103 -#define IDD_PROPPAGEADVANCED 104 +#define IDD_PROPPAGEGENERAL 100 +#define IDD_PROPPAGECOMPUTER 101 +#define IDD_PROPPAGEHARDWARE 102 +#define IDD_PROPPAGEUSERPROFILE 103 +#define IDD_PROPPAGEADVANCED 104 -#define IDS_CPLSYSTEMNAME 1001 -#define IDS_CPLSYSTEMDESCRIPTION 2001 +#define IDS_CPLSYSTEMNAME 1001 +#define IDS_CPLSYSTEMDESCRIPTION 2001 /* controls */ #define IDC_LICENSEMEMO 101 @@ -32,19 +32,19 @@ #define IDC_PROCESSORSPEED 104 #define IDC_SYSTEMMEMORY 105 #define IDC_DEVMGR 106 -#define IDC_ENVVAR 107 -#define IDC_STAREC 108 -#define IDC_PERFOR 109 +#define IDC_ENVVAR 107 +#define IDC_STAREC 108 +#define IDC_PERFOR 109 #define IDC_ICON1 201 -#define IDC_COMPUTERNAME 202 -#define IDC_WORKGROUPDOMAIN_NAME 203 +#define IDC_COMPUTERNAME 202 +#define IDC_WORKGROUPDOMAIN_NAME 203 #define IDC_WORKGROUPDOMAIN 204 -#define IDC_NETWORK_ID 205 -#define IDC_NETWORK_PROPERTY 206 +#define IDC_NETWORK_ID 205 +#define IDC_NETWORK_PROPERTY 206 #define IDC_HARDWARE_WIZARD 207 -#define IDC_HARDWARE_PROFILE 210 -#define IDC_HARDWARE_DRIVER_SIGN 211 +#define IDC_HARDWARE_PROFILE 210 +#define IDC_HARDWARE_DRIVER_SIGN 211 #define IDC_HARDWARE_DEVICE_MANAGER 212 #define IDC_USERPROFILE_LIST 213

1 0

[gedmurphy] 20551: Skeleton dialog box to control system page file size
by gedmurphy＠svn.reactos.org 03 Jan '06

03 Jan '06

Skeleton dialog box to control system page file size Modified: trunk/reactos/lib/cpl/sysdm/advanced.c Modified: trunk/reactos/lib/cpl/sysdm/en.rc Modified: trunk/reactos/lib/cpl/sysdm/resource.h Modified: trunk/reactos/lib/cpl/sysdm/sysdm.h Modified: trunk/reactos/lib/cpl/sysdm/sysdm.xml Added: trunk/reactos/lib/cpl/sysdm/virtmem.c _____ Modified: trunk/reactos/lib/cpl/sysdm/advanced.c --- trunk/reactos/lib/cpl/sysdm/advanced.c 2006-01-03 18:49:10 UTC (rev 20550) +++ trunk/reactos/lib/cpl/sysdm/advanced.c 2006-01-03 21:00:06 UTC (rev 20551) @@ -48,6 +48,13 @@ case WM_COMMAND: switch(LOWORD(wParam)) { + case IDC_PERFOR: + DialogBox(hApplet, + MAKEINTRESOURCE(IDD_VIRTMEM), + hwndDlg, + VirtMemDlgProc); + break; + case IDC_ENVVAR: DialogBox(hApplet, MAKEINTRESOURCE(IDD_ENVIRONMENT_VARIABLES), @@ -60,4 +67,3 @@ } return FALSE; } - _____ Modified: trunk/reactos/lib/cpl/sysdm/en.rc --- trunk/reactos/lib/cpl/sysdm/en.rc 2006-01-03 18:49:10 UTC (rev 20550) +++ trunk/reactos/lib/cpl/sysdm/en.rc 2006-01-03 21:00:06 UTC (rev 20551) @@ -93,6 +93,34 @@ PUSHBUTTON "&Startup and Recovery...",IDC_STAREC,PROPSHEETWIDTH-(20*PROPSHEETPADDING),LABELLINE(1 9)+2,(18*PROPSHEETPADDING),14 END + +IDD_VIRTMEM DIALOGEX 6, 6, 223, 248 +STYLE DS_MODALFRAME | DS_CONTEXTHELP | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU +CAPTION "Virtual Memory" +FONT 8, "MS Sans Serif", 0, 0, 0x0 +BEGIN + CONTROL "",IDC_PAGEFILELIST,"ListBox",0x50010141,10,16,204,52,0x00000200 + LTEXT "Drive [Volume Label]", -1, 12, 5, 96, 9 + LTEXT "Paging File Size (MB)", -1, 114, 5, 100, 9 + CONTROL "Paging file size for selected drive",IDC_DRIVEGROUP,"Button",0x50000007,10,70,204,104 + LTEXT "", IDC_DRIVE, 20, 84, 100, 9 + LTEXT "", IDC_SPACEAVAIL, 20, 94, 112, 8 + CONTROL "Custom size",IDC_CUSTOM,"Button",0x50010009,20,105,54,9 + CONTROL "",IDC_INITIALSIZE,"Edit",0x50010000,100,114,44,13,0x00000200 + CONTROL "",IDC_MAXSIZE,"Edit",0x50010000,100,129,44,13,0x00000200 + LTEXT "Initial size (MB):", -1 ,22,118,54,9 + LTEXT "Maximum size (MB):", -1 ,22,131,64,9 + CONTROL "System managed size",IDC_SYSMANSIZE,"Button",0x50010009,20,145,88,9 + CONTROL "No paging file",IDC_NOPAGEFILE,"Button",0x50010009,20,158,78,9 + PUSHBUTTON "Set",IDC_SET, 158, 155, 50, 13 + CONTROL "Total paging file size for all drives", IDC_TOTALGROUP, "Button", 0x50000007, 10, 179, 204, 46 + PUSHBUTTON "OK", IDOK, 114, 232, 48, 13 + PUSHBUTTON "Cancel", IDCANCEL, 168, 232, 48, 13 + LTEXT "", IDC_MINIMUM, 18, 200, 100, 9 + LTEXT "", IDC_RECOMMENDED, 18, 200, 100, 9 + LTEXT "", IDC_CURRENT, 18, 200, 100, 9 +END + IDD_ENVIRONMENT_VARIABLES DIALOGEX 6, 18, 252, 245 STYLE DS_MODALFRAME | DS_CONTEXTHELP | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU CAPTION "Environment Variables" @@ -132,8 +160,13 @@ END -STRINGTABLE +STRINGTABLE DISCARDABLE BEGIN IDS_CPLSYSTEMNAME "System" IDS_CPLSYSTEMDESCRIPTION "See information about your computer and change various system and hardware settings." + IDS_DRIVE "Drive: %s" + IDS_SPACE "Space available %s" + IDS_MIN "Minimum allowed: %s" + IDS_REC "Recommended: %s" + IDS_CUR "Currently allocated: %s" END _____ Modified: trunk/reactos/lib/cpl/sysdm/resource.h --- trunk/reactos/lib/cpl/sysdm/resource.h 2006-01-03 18:49:10 UTC (rev 20550) +++ trunk/reactos/lib/cpl/sysdm/resource.h 2006-01-03 21:00:06 UTC (rev 20551) @@ -10,42 +10,42 @@ #define ICONSIZE 16 /* ids */ -#define RC_LICENSE 101 -#define RTDATA 300 +#define RC_LICENSE 101 +#define RTDATA 300 -#define IDI_CPLSYSTEM 100 -#define IDI_DEVMGR 101 +#define IDI_CPLSYSTEM 100 +#define IDI_DEVMGR 101 -#define IDD_PROPPAGEGENERAL 100 -#define IDD_PROPPAGECOMPUTER 101 -#define IDD_PROPPAGEHARDWARE 102 -#define IDD_PROPPAGEUSERPROFILE 103 -#define IDD_PROPPAGEADVANCED 104 +#define IDD_PROPPAGEGENERAL 100 +#define IDD_PROPPAGECOMPUTER 101 +#define IDD_PROPPAGEHARDWARE 102 +#define IDD_PROPPAGEUSERPROFILE 103 +#define IDD_PROPPAGEADVANCED 104 -#define IDS_CPLSYSTEMNAME 1001 -#define IDS_CPLSYSTEMDESCRIPTION 2001 +#define IDS_CPLSYSTEMNAME 1001 +#define IDS_CPLSYSTEMDESCRIPTION 2001 /* controls */ -#define IDC_LICENSEMEMO 101 +#define IDC_LICENSEMEMO 101 #define IDC_PROCESSORMANUFACTURER 102 -#define IDC_PROCESSOR 103 -#define IDC_PROCESSORSPEED 104 -#define IDC_SYSTEMMEMORY 105 -#define IDC_DEVMGR 106 -#define IDC_ENVVAR 107 -#define IDC_STAREC 108 -#define IDC_PERFOR 109 -#define IDC_ICON1 201 +#define IDC_PROCESSOR 103 +#define IDC_PROCESSORSPEED 104 +#define IDC_SYSTEMMEMORY 105 +#define IDC_DEVMGR 106 +#define IDC_ENVVAR 107 +#define IDC_STAREC 108 +#define IDC_PERFOR 109 +#define IDC_ICON1 201 -#define IDC_COMPUTERNAME 202 -#define IDC_WORKGROUPDOMAIN_NAME 203 -#define IDC_WORKGROUPDOMAIN 204 -#define IDC_NETWORK_ID 205 -#define IDC_NETWORK_PROPERTY 206 -#define IDC_HARDWARE_WIZARD 207 -#define IDC_HARDWARE_PROFILE 210 -#define IDC_HARDWARE_DRIVER_SIGN 211 -#define IDC_HARDWARE_DEVICE_MANAGER 212 +#define IDC_COMPUTERNAME 202 +#define IDC_WORKGROUPDOMAIN_NAME 203 +#define IDC_WORKGROUPDOMAIN 204 +#define IDC_NETWORK_ID 205 +#define IDC_NETWORK_PROPERTY 206 +#define IDC_HARDWARE_WIZARD 207 +#define IDC_HARDWARE_PROFILE 210 +#define IDC_HARDWARE_DRIVER_SIGN 211 +#define IDC_HARDWARE_DEVICE_MANAGER 212 #define IDC_USERPROFILE_LIST 213 #define IDC_USERPROFILE_DELETE 214 @@ -66,6 +66,32 @@ #define IDC_VARIABLE_NAME 230 #define IDC_VARIABLE_VALUE 231 +/* Virtual memory */ +#define IDD_VIRTMEM 107 +#define IDC_PAGEFILELIST 240 +#define IDC_DRIVEGROUP 241 +#define IDC_DRIVE 242 +#define IDC_SPACEAVAIL 243 +#define IDC_CUSTOM 244 +#define IDC_INITIALSIZE 245 +#define IDC_MAXSIZE 246 +#define IDC_SYSMANSIZE 247 +#define IDC_NOPAGEFILE 248 +#define IDC_SET 249 +#define IDC_TOTALGROUP 250 +#define IDC_MINIMUM 251 +#define IDC_RECOMMENDED 252 +#define IDC_CURRENT 253 + +#define IDS_DRIVE 1000 +#define IDS_SPACE 1001 +#define IDS_MIN 1002 +#define IDS_REC 1003 +#define IDS_CUR 1004 + + + + #endif /* __CPL_RESOURCE_H */ /* EOF */ _____ Modified: trunk/reactos/lib/cpl/sysdm/sysdm.h --- trunk/reactos/lib/cpl/sysdm/sysdm.h 2006-01-03 18:49:10 UTC (rev 20550) +++ trunk/reactos/lib/cpl/sysdm/sysdm.h 2006-01-03 21:00:06 UTC (rev 20551) @@ -22,9 +22,12 @@ INT_PTR CALLBACK UserProfilePageProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam); /* environment.c */ -INT_PTR CALLBACK EnvironmentDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam); +INT_PTR CALLBACK EnvironmentDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam); +/* virtmem.c */ +INT_PTR CALLBACK VirtMemDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam); + #endif /* __CPL_SYSDM_H */ /* EOF */ _____ Modified: trunk/reactos/lib/cpl/sysdm/sysdm.xml --- trunk/reactos/lib/cpl/sysdm/sysdm.xml 2006-01-03 18:49:10 UTC (rev 20550) +++ trunk/reactos/lib/cpl/sysdm/sysdm.xml 2006-01-03 21:00:06 UTC (rev 20551) @@ -17,5 +17,6 @@ <file>hardware.c</file> <file>sysdm.c</file> <file>userprofile.c</file> + <file>virtmem.c</file> <file>sysdm.rc</file> </module> _____ Added: trunk/reactos/lib/cpl/sysdm/virtmem.c --- trunk/reactos/lib/cpl/sysdm/virtmem.c 2006-01-03 18:49:10 UTC (rev 20550) +++ trunk/reactos/lib/cpl/sysdm/virtmem.c 2006-01-03 21:00:06 UTC (rev 20551) @@ -0,0 +1,38 @@ +#include <windows.h> +#include <commctrl.h> +#include <stdlib.h> +#include <tchar.h> + +#include "resource.h" +#include "sysdm.h" + + +/* Environment dialog procedure */ +INT_PTR CALLBACK +VirtMemDlgProc(HWND hwndDlg, + UINT uMsg, + WPARAM wParam, + LPARAM lParam) +{ + switch (uMsg) + { + case WM_INITDIALOG: + break; + + case WM_COMMAND: + switch (LOWORD(wParam)) + { + case IDCANCEL: + EndDialog(hwndDlg, 0); + return TRUE; + } + break; + + case WM_NOTIFY: + break; + } + + return FALSE; +} + +/* EOF */

1 0

[greatlrd] 20550: Commit a patch for hide and show mouse. (forget it)
by greatlrd＠svn.reactos.org 03 Jan '06

03 Jan '06

Commit a patch for hide and show mouse. (forget it) Modified: trunk/reactos/subsys/win32k/eng/mouse.c _____ Modified: trunk/reactos/subsys/win32k/eng/mouse.c --- trunk/reactos/subsys/win32k/eng/mouse.c 2006-01-03 17:59:56 UTC (rev 20549) +++ trunk/reactos/subsys/win32k/eng/mouse.c 2006-01-03 18:49:10 UTC (rev 20550) @@ -156,7 +156,19 @@ pgp->Enabled = FALSE; + + /* + * The mouse is hide from ShowCours and it is frist ?? + */ + if (pgp->ShowPointer < 0) + { + return ; + } + + /* + * Hide the cours + */ pt.x = pgp->Pos.x - pgp->HotSpot.x; pt.y = pgp->Pos.y - pgp->HotSpot.y; @@ -213,6 +225,14 @@ pgp->Enabled = TRUE; + /* + * Do not blt the mouse if it in hide + */ + if (pgp->ShowPointer < 0) + { + return ; + } + pt.x = pgp->Pos.x - pgp->HotSpot.x; pt.y = pgp->Pos.y - pgp->HotSpot.y; @@ -244,7 +264,8 @@ EngUnlockSurface(SaveSurface); } - /* + + /* * Blit the cursor on the screen. */ @@ -266,6 +287,7 @@ SrcPoint.x = max(-pt.x, 0); SrcPoint.y = max(-pt.y, 0); + if (pgp->MaskSurface) MaskSurf = EngLockSurface(pgp->MaskSurface); @@ -275,27 +297,21 @@ { if((ColorSurf = EngLockSurface(pgp->ColorSurface))) { - if (pgp->ShowPointer >= 0) - { IntEngBitBltEx(DestSurface, ColorSurf, MaskSurf, NULL, pgp->XlateObject, &DestRect, &SrcPoint, &SrcPoint, NULL, NULL, R4_MASK, FALSE); EngUnlockSurface(ColorSurf); - } } } else - { - if (pgp->ShowPointer >= 0) - { + { IntEngBitBltEx(DestSurface, MaskSurf, NULL, NULL, pgp->XlateObject, &DestRect, &SrcPoint, NULL, NULL, NULL, ROP3_TO_ROP4(SRCAND), FALSE); SrcPoint.y += pgp->Size.cy; IntEngBitBltEx(DestSurface, MaskSurf, NULL, NULL, pgp->XlateObject, &DestRect, &SrcPoint, NULL, NULL, NULL, - ROP3_TO_ROP4(SRCINVERT), FALSE); - } + ROP3_TO_ROP4(SRCINVERT), FALSE); } EngUnlockSurface(MaskSurf); }

1 0

[greatlrd] 20549: forget remove some test code.
by greatlrd＠svn.reactos.org 03 Jan '06

03 Jan '06

forget remove some test code. Modified: trunk/reactos/subsys/win32k/dib/dib16bpp.c _____ Modified: trunk/reactos/subsys/win32k/dib/dib16bpp.c --- trunk/reactos/subsys/win32k/dib/dib16bpp.c 2006-01-03 17:21:11 UTC (rev 20548) +++ trunk/reactos/subsys/win32k/dib/dib16bpp.c 2006-01-03 17:59:56 UTC (rev 20549) @@ -603,45 +603,7 @@ return TRUE; } -/* check clib region */ -BOOLEAN CheckClipRegion(CLIPOBJ *ClipRegion, RECTL* DestRect, int DesX, int DesY) -{ - BOOLEAN status = FALSE; - PSPAN ClipSpans; - UINT ClipSpansCount; - UINT SpanIndex = 0; - if (! ClipobjToSpans(&ClipSpans, &ClipSpansCount, ClipRegion, DestRect)) - { - return FALSE; - } - - if (0 == ClipSpansCount) - { - /* No clip spans == empty clipping region, everything clipped away */ - ASSERT(NULL == ClipSpans); - return FALSE; - } - - for (SpanIndex=0; SpanIndex<ClipSpansCount;SpanIndex++) - { - if (ClipSpans[SpanIndex].Y < DesY) - status = FALSE; - - if (ClipSpans[SpanIndex].Y+ClipSpans[SpanIndex].Height > DesY) - status = FALSE; - - if (ClipSpans[SpanIndex].X > DesX) - status = FALSE; - - if (ClipSpans[SpanIndex].X+ClipSpans[SpanIndex].Width > DesX) - status = FALSE; - } - - return status; -} - - //NOTE: If you change something here, please do the same in other dibXXbpp.c files! BOOLEAN DIB_16BPP_StretchBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf, RECTL* DestRect, RECTL *SourceRect,

1 0

[greatlrd] 20548: forget remove a calc value in the for loop it can do outside the loop.
by greatlrd＠svn.reactos.org 03 Jan '06

03 Jan '06

forget remove a calc value in the for loop it can do outside the loop. Modified: trunk/reactos/subsys/win32k/dib/dib16bpp.c _____ Modified: trunk/reactos/subsys/win32k/dib/dib16bpp.c --- trunk/reactos/subsys/win32k/dib/dib16bpp.c 2006-01-03 17:05:39 UTC (rev 20547) +++ trunk/reactos/subsys/win32k/dib/dib16bpp.c 2006-01-03 17:21:11 UTC (rev 20548) @@ -649,16 +649,17 @@ CLIPOBJ *ClipRegion, XLATEOBJ *ColorTranslation, ULONG Mode) { - int SrcSizeY; - int SrcSizeX; - int DesSizeY; - int DesSizeX; - int sx; - int sy; - int DesX; - int DesY; - int color; + LONG SrcSizeY; + LONG SrcSizeX; + LONG DesSizeY; + LONG DesSizeX; + LONG sx; + LONG sy; + LONG DesX; + LONG DesY; + LONG color; PULONG DestBits; + LONG DifflDelta; DPRINT("DIB_16BPP_StretchBlt: Source BPP: %u, srcRect: (%d,%d)-(%d,%d), dstRect: (%d,%d)-(%d,%d)\n", @@ -680,7 +681,9 @@ DestBits = (PULONG)((PBYTE)DestSurf->pvScan0 + (DestRect->left << 1) + DestRect->top * DestSurf->lDelta); - + + DifflDelta = DestSurf->lDelta - (DesSizeX << 1); + for (DesY=0; DesY<DesSizeY; DesY++) { sy = ((DesY * SrcSizeY) / DesSizeY) + SourceRect->top; @@ -701,7 +704,7 @@ DestBits = (PULONG)((ULONG_PTR)DestBits + 2); } } - DestBits = (PULONG)((ULONG_PTR)DestBits - (DesSizeX << 1) + DestSurf->lDelta); + DestBits = (PULONG)((ULONG_PTR)DestBits + DifflDelta); } break; @@ -711,7 +714,9 @@ DestBits = (PULONG)((PBYTE)DestSurf->pvScan0 + (DestRect->left << 1) + DestRect->top * DestSurf->lDelta); - + + DifflDelta = DestSurf->lDelta - (DesSizeX << 1); + for (DesY=0; DesY<DesSizeY; DesY++) { sy = ((DesY * SrcSizeY) / DesSizeY) + SourceRect->top; @@ -725,7 +730,7 @@ *DestBits = XLATEOBJ_iXlate(ColorTranslation, color); DestBits = (PULONG)((ULONG_PTR)DestBits + 2); } - DestBits = (PULONG)((ULONG_PTR)DestBits - (DesSizeX << 1) + DestSurf->lDelta); + DestBits = (PULONG)((ULONG_PTR)DestBits + DifflDelta); } break; @@ -735,6 +740,8 @@ DestBits = (PULONG)((PBYTE)DestSurf->pvScan0 + (DestRect->left << 1) + DestRect->top * DestSurf->lDelta); + + DifflDelta = DestSurf->lDelta - (DesSizeX << 1); for (DesY=0; DesY<DesSizeY; DesY++) { @@ -749,7 +756,7 @@ *DestBits = XLATEOBJ_iXlate(ColorTranslation, color); DestBits = (PULONG)((ULONG_PTR)DestBits + 2); } - DestBits = (PULONG)((ULONG_PTR)DestBits - (DesSizeX << 1) + DestSurf->lDelta); + DestBits = (PULONG)((ULONG_PTR)DestBits + DifflDelta); } break; @@ -760,7 +767,9 @@ DestBits = (PULONG)((PBYTE)DestSurf->pvScan0 + (DestRect->left << 1) + DestRect->top * DestSurf->lDelta); - + + DifflDelta = DestSurf->lDelta - (DesSizeX << 1); + for (DesY=0; DesY<DesSizeY; DesY++) { sy = ((DesY * SrcSizeY) / DesSizeY) + SourceRect->top; @@ -774,8 +783,9 @@ *DestBits = XLATEOBJ_iXlate(ColorTranslation, color); DestBits = (PULONG)((ULONG_PTR)DestBits + 2); } - DestBits = (PULONG)((ULONG_PTR)DestBits - (DesSizeX << 1) + DestSurf->lDelta); - } break; + DestBits = (PULONG)((ULONG_PTR)DestBits + DifflDelta); + } + break; case BMF_32BPP: /* FIXME : MaskOrigin, BrushOrigin, ClipRegion, Mode ? */ @@ -783,7 +793,9 @@ DestBits = (PULONG)((PBYTE)DestSurf->pvScan0 + (DestRect->left << 1) + DestRect->top * DestSurf->lDelta); - + + DifflDelta = DestSurf->lDelta - (DesSizeX << 1); + for (DesY=0; DesY<DesSizeY; DesY++) { sy = ((DesY * SrcSizeY) / DesSizeY) + SourceRect->top; @@ -797,7 +809,7 @@ *DestBits = XLATEOBJ_iXlate(ColorTranslation, color); DestBits = (PULONG)((ULONG_PTR)DestBits + 2); } - DestBits = (PULONG)((ULONG_PTR)DestBits - (DesSizeX << 1) + DestSurf->lDelta); + DestBits = (PULONG)((ULONG_PTR)DestBits + DifflDelta); } break;

1 0

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs