- Initialize WaitBlock->Thread during thread creation.
- Make APCs queuable for the thread after it's created
- Enable Timer Block optimization since it works now. This allows us not to always set-up for each wait, since most of its fields can remain static.
- Properly link wait block together with the waitlist of the timer.
svn path=/trunk/; revision=20632
- Remove KiBlockThread and replace by more elegant KiSwapThread which will also make moving to the new scheduler easier.
- Handle special case where we have kernel apcs pending and your previous irql was below apc_level during the wait code.
- Remove hack to manually unwait a thread during a status of kernel apc.
svn path=/trunk/; revision=20605
* KeRemoveQueue did not set Thread->WaitNext = FALSE if it was called with WaitNext = TRUE.
* KeRemoveQueue did not handle the case where a kernel-mode APC is pending and the previous IRQL was below APC_LEVEL.
* KeRemoveQueue did not set the thread's wait status to 0.
* KiInsertQueue did not set the Thread's wait status to the entry being inserted.
* KiInsertQueue did not remove the thread from its wait list.
* KeRemoveQueue did not properly link the wait blocks.
svn path=/trunk/; revision=20601
-start to macrofy list enums in ntoskrnl using LIST_FOR_EACH macros
-use IsListEmpty some places instead of manual coding
-profile.c:KeStartProfile() zero correct buffer in (and not the NULL ptr;-)
-improve LIST_FOR_EACH macros so that the iterator is set to NULL at end of enum
-kthread.c:KiServiceCheck() set the shadowtable before calling the win32k proc/thread init funcs
-apc.c:KiInsertQueueApc() insert special apcs in correct fifo order
-apc.c:KeFlushQueueApc() simplify
-timer.c:KiExpireTimers() calling RemoveEntryList on a possibly empty list is not ok
svn path=/trunk/; revision=18113
---------------------------------------------------
- ps/cid.c:
* Moved CID Lookup functions here
- ps/security.c:
* Moved all security related functions here. Makes other files neater and security functions
easier to locate.
- ps/thread.c:
* Moved most of the Thread Scheduling/Dispatching code that belongs in the Kernel to /ke and
renamed functions from Ps to Ki.
* Implemented PsIsSystemThread.
* Removed Reaper Thread Init (now obsolete).
* Renamed PiDeleteThread to PspDeleteThread.
* Moved Thread State functions from tinfo.c to here.
- ps/process.c:
* Removed Query/Set Process functions and moved to ps/query.c
* Renamed PiDeletePRocess to PspDeleteProcess
* Removed obsoleted Process Termination functions, moved persistent one to kill.c
- ps/create.c:
* Moved the security APIs to security.c
* Correctly implemented PsCreateSystemThread to actually create system threads.
- ps/suspend.c
* Rewrote Nt Executive functions to use Kernel functions.
* Moved Ps* Routines into ke/kthread.c and fixed them. The implementation was wrong in
some aspects, especially the issue of the APC looping around the KeWaitXxx call and the
fact that the routines excluded/ignored the FreezeCount.
- ps/debug.c
* Fixed completely broken implementation of Get/SetThreadContext. The old version crashed
when called and did not work at all. Suspend Regression test now works.
* Moved Context<->TrapFrame functions to ke/i386/
* Combined Set/GetThreadContext APCs into a single one, and used special context structure.
- ps/query.c:
* Moved Thread/Process Query/Set Routines here.
- ps/tinfo.c:
* Removed.
- ps/kill.c
* Removed complicated Process Termination semantics and useless Attach/Detach in favor for
a much more lightweight function which performs the same tasks as before and actually works.
TaskManager can now terminate foreign processes.
* Rewrote Thread Reaping to use the HyperCritical Work Queue instead of manually controlled
thread. This results in much less code as well as an increase in speed and less micro
management. The reaper is PspReapRoutine. Closing CMD.EXE now works properly without
requiring masks that were added as hacks to allow it.
* Renamed PiTerminateProcessThreads to PspTerminateProcessThreads. Fixed it to work with new
termination code.
* Added PspDeleteProcess to handle Process Object deletion. Kills the CID Handle here as done
by Hartmut.
* Added PspDeletethread here.
* Renamed and rewrote PsTerminateCurrentThread to PspExitThread. Used NT Implementation out-
lined in Windows Internals, Chapter 13. Uses less locks, a more concise order of actions,
actually parses the Termination Ports, handles Dbgk notification. Timers are now rundown,
and Mutex rundown is in a dedicated Kernel function. Final termination handled by KeTerminate
Thread as documented.
* Renamed PsTerminateOtherThread to PspTerminateThreadByPointer and modified implementation to
be compatible with the changes above.
* Renamed and regrouped Process Termination into PspExitProcess. Also implemented as described
above, and moved each subsystem specific termination helper into its own subsytem.
* Improved NtTerminateProcess and added more debugging messages.
* Improved NtTerminateThread and added check against System Thread and made it compatible with
new implementation.
* Corrected PsTerminateSystemThread now that we support System Threads.
* Corrected NtRegisterThreadTerminatePort to use same structure name as on windows for the
port, and added tag to pool allocation (documented in pooltag.txt)
include/internal/*.h:
* Defined Scheduler Functions and misc new functions or renamed functions.
ke/apc.c:
* Fixed critical bug where APCs were not delivered at all if the thread wastion and cancels any timers that are associated
to a thread, as well as their APCs and DPCs.
REGRESSIONS FOUND: NONE
BUGS/REGRESSIOSN FIXED:
* Thread/Get Set Context now works.
* Suspend Regression test now works.
* Task manager can now kill foreign processes, even hung ones (like it should).
* ExitProcess/closing cmd.exe with the 'x' button now works correctly without hacks.
KNOWN ISSUES: I left a bit of a mess in the headers and some stuff still needs to be moved into the right
places. I just wanted to have this first part ready first, so that it won't get too big.
svn path=/trunk/; revision=14174
- Rewrote wait code. It is now cleaner, more optimized and faster. All waiting
functions are now clearly differentiated instead of sharing code. These functions
are called up to a dozen times a second, so having dedicated code for each of
them is a real boost in speed.
- Fixed several queue issues, made a dedicated queue wait/wake function (you are not
supposed to use KeWaitFor on a queue, and this is also a speed boost), and make it
compatible with new wait code.
- Optimized Work Queue code to be much smaller and better organized, by using an
array instead of hard-coded multiple static variables. Also, add support for the
real NT structures and implementation, paving the road for Dynamic Work Items, which
also have timeouts, and deadlock dection + debug info.
- Simplified PsBlockThread and made it compatible with wait code.
- Added support for priority boosting when unwaiting a thread; will use later, as well
as put proper boosting for dispatch objects.
- Inlined all dispatcher lock functions and header initialization for speed.
- Moved executive wait code into ob.
svn path=/trunk/; revision=14047
Dispatcher Objects Rewrite (minus Queues, coming in next patch).
Global Changes:
- Use KOBJECT enumerations for all objects, remove obsoleted ros-internal enumeration.
- Reformatting, commenting, and addition of Debug Prints for easier debugging
- Properly create Executive Objects. They don't need a creation routine.
- Make sure to properly lock and release the Dispatcher Database.
Mutex/Mutant:
- Correct MUTANT_BASIC_INFORMATION
- Return previous state in Kernel Functions, intead of 1 or 0 all the time.
- Initialize listhead properly
- Removed code duplication between mutant and mutex release.
- Fix bugs in release
- Add proper exeption if the mutex is not owned.
Kernel Queues:
- Optimize the code
- Use Inserted Flag
Timers:
- Some changes in setting the default data to allow KiInsertTimer to be called internally
by the wait code in the next patch.
Events:
- Optimize and simplify KeInitializeEvent
- Implement KeInitializeEventPair
- Fix KePulseEvent. It was completely messed up and also used unneeded Interlocked function.
- Fix KeResetEvent. It was not locking the dispatcher lock but using Interlocked.
- Fix KeSetEvent. It was not differentiating between Notification and Sycronization events
and also signaling the Event even if nobody was waiting on it.
Semaphores:
- Fix KeReleaseSemaphore. It was not checking if nobody was waiting on it before unwaiting the thread.
- Fix not releasing dispatcher database before raising an exception.
- Add check to NtCreateSemaphore to make sure the counts make sense.
Event Pairs:
- Remove Thread Event Pair. They are only used for NT4 QuickLPC which is obsoleted.
- Use KeInitializeEventPair
svn path=/trunk/; revision=14045
I've modified ReactOS' headers and source files to match W32API's headers, and fully recompiled and booted ReactOS without them, so it does still work.
A more detailed log of changes will be sent to the ros-kernel mailing list shortly.
svn path=/trunk/; revision=5572
