Generic 0.3.1 Changes

* Unicode corrections (Johannes Anderwald)
* Start removing Bitstream font from ReactOS. Only console apps are using Bitstream font but that will change once a few other issues are resolved. The rest of ROS is using DejaVu, a unicode font (Magnus Olsen)
* Enable pnpmgr in livecd (Hervé Poussineau)
* mkhive: use cmlib instead of duplicating code (Hervé Poussineau)
* VMWare properly detected (Alex Ionescu)
* Added the Wallpaper picture lake.bmp by Andreas Bjerkeholt

[edit]
RBUILD

* Dependency Map added by (Christoph von Wittich) and checking implemented by (Johannes Anderwald)
* Clean Log added and Help for individual commands (Peter Ward)
* Space in name issues fixed (Christoph von Wittich)
* ROS_PREFIX allowed on MS Windows platforms for cross compiling (Hervé Poussineau)
* compatibility header. Implements Visual C++ intrinsics in GCC (KJK::Hyperion)
* Work towards MSVC compatibility (entrypoint name underscoring if needed) (Aleksey Bragin)
* Add initial support for a Code::Blocks backend, allowing the entire project to be built and managed within the IDE (Christoph von Wittich)

[edit]
Translations

* Added and updated French Translation for Control Panel, Devmgmt, Downloader, ibrowser, Notepad, Reporterror, Rundll32, Solitaire, Syssetup, Timedate.cpl and Userinit (Pierre Schweitzer)
* Added French Translation to Ipconfig (Sylvain Petreolle)
* Thai keyboard layout added (Dmitry G. Gorbachev)
* Dutch Translations for Explorer, ibrowser, Mmsys.cpl, Reporterror and Welcome from i386DX
* Patches from Signouret Jerome for Bugs #1312 and #1370: French Translations for FreeLoader´s fdebug and WineMine
* Patch from Sylvain Petreolle for Bug #1539: French Translation for Newdev.dll
* Patches from Paolo Devoti for Bugs #1921 to #1935 and #1974 to #1976: Italian Translations for Cacls, Control Panel, Devmgmt, Downloader, Expand, Format, ImageSoft, Regsvr32, Reporterror, Rundll32, Sndvol32, Taskmgr, Userinit, Vmwinst, Winlogon and WordPad
* Patch from Kamil Hornicek for Bug #1959: Czech translation for Control Panel
* Swedish translation of getfirefox by Andreas Bjerkeholt
* Patch from Sylvain Petreolle for Bug #1539: Recommit french translations
* Patches from Apostolos Alexiadis for Bugs #1429, #1509 and #1630: Greek Translations for Calc, Expand, Explorer, Hdwwiz, Oleaut32.dll, Rundll32, Userinit
* Patches from Apostolos Alexiadis for Bugs #1631 and #1831: Greek Keyboard layout rewrite. Punctuation stuff and other similar issues fixed
* Patches from Artyom Reznikov for Bugs #1279, #1624 and #1635: Added and updated Ukrainian Translations for Appwiz, Comdlg32.dll, Desk.cpl, Explorer, GetFirefox, Hdwwiz, Intl.cpl, Mmsys.cpl, Notepad, Regedit, Taskmgr, Timedate.cpl, User32.dll, Welcome and Wininit.dll
* Patches from Lars Martin Hambro for Bugs #1606, #1607, #1637, #1641 to #1644, #1674 to #1687, #1695, #1696, #1698 and #1700: Norwegian Translations for Cacls, Calc, Cmd, Expand, Explorer, Format, GetFirefox, ibrowser, Imagesoft, Msconfig, Notepad, Ntvdm, "reactos.exe" (Setup tool under Windows), Regedit´s Column List Box, Regsvr32, Reporterror, Rundll32, sm, Taskmgr, Userinit, Welcome, WineFile, WineMine, Winlogon and WordPad
* Patch from Fork for Bug #1633: Norwegian Translation for Syssetup.dll, Winmm.dll, User32.dll and Userenv.dll
* Patch from Simon Hanae for Bug #1795 and #1876: Japanese keyboard driver added
* Updated Italian translation of Calc by Gabriel Ilardi
* Patch from arzi for Bug #1367: Finnish Translation for Control and "reactos.exe" (Setup tool under Windows)
* Patch from Emil Kaczmarek for Bug #1315: Polish Translation for WineMine

[edit]
ReactOS Core
[edit]
Kernel and Executive (NTOSKRNL)

* Implemented ObReferenceProcessHandleTable (Alex Ionescu)
* Implemented ObDereferenceProcessHandleTable (Alex Ionescu)
* Implemented ObpReferenceProcessObjectByHandle (Alex Ionescu)
* Simplified ObDuplicateObject (Alex Ionescu)
* Patch from (Dmitry G. Gorbachev) for Bug #1953: fixes invalid sync after loading BLUE.SYS
* Various warnings fixed (Thomas Weidenmueller)
* Cleanup of locking and lookup macros (Alex Ionescu)
* Adjustments in SeAccessCheck, returning STATUS_SUCCESS (Alex Ionescu)
* Various optimizations of lookup context and lock (Alex Ionescu)
* Patch from Thomas Weidenmueller for Bug #1667: NTOSKRNL: Fix GCC4 warning and return correct error code in NtSignalAndWaitForSingleObject
* Fix incorrect loop of race conditions in the rundown protection implementation, requiring the value to have been changed and inactive before slow path is taken (Alex Ionescu)
* Fix locking bugs in guarded mutex implementation where operations were not reattempted (Alex Ionescu)
* Fix inverted result bug in KeTrytoAcquireGuardedMutex (Alex Ionescu)
* Fix KiMask32Array, value off and caused errors in priority/affinity masks (Alex Ionescu)
* Patch from Art Yerkes for memory management page referencing.
* Handle leaks fixed in ExDestroyHandleEntry (Alex Ionescu)
* Imitate success for WMI calls and add a stubbed wmilib.sys, so that drivers relying on WMI can feel comfortable (Aleksey Bragin)
* Improve IoRegisterDeviceInterface() error-handling abilities and fix its behaviour so it´s compatible with 3rd party drivers (Aleksey Bragin, Hervé Poussineau)
* NDK 0.98, now with versioned headers. Too many changes to list, see the TinyKRNL SVN Logs for more detailed information. Thanks to Andrew (Wax), Thomas and Aleksey for testing. (Alex Ionescu)
* Check the Image Config Data in MmCreatePeb for address abusing (bug #1487). (Alex Ionescu)
* Speed-up the ElfpIsPowerOf2 function (bug #1464). (Alex Ionescu)
* Use the Spare0 array, present in EPROCESS instead of ReactOS-specific members for Process Locking (temporary fix until pushlocks are used). (Alex Ionescu)
* Use EPROCESS´s AddressCreationLock instead of the MADDRESS_SPACE Lock. (Alex Ionescu)
* Overlay MADDRES_SPACE over MM_AVL_NODE. Even though our structures are currently incompatible, they represent the same thing (The EPROCESS´s Address space). (Alex Ionescu)
* Get rid of ROS_EPROCESS and all the ugly type-casting that was being done, now that the last two hacks allow us to properly use EPROCESS. (Alex Ionescu)
* Use the proper HANDLE_TABLE and HANDLE_TABLE_ENTRY structures. (Alex Ionescu)
* Cleanup the formatting, code and function headers of most of the Object Manager interfaces. (Alex Ionescu)
* SymTest: The Symbolic Link kernel implementation tester. Tests for really wacky symlink API properties. 8 failures on ROS. (Alex Ionescu)
* SymLink Rewrite: Use OBJECT_SYMBOLIC_LINK structure as used by Windows NT (and added the structure to the NDK) (Alex Ionescu)
* SymLink Rewrite: Changed code to use the new names in the structure (Alex Ionescu)
* SymLink Rewrite: Only free the symlink´s name if it has one, to avoid a bugcheck. (Alex Ionescu)
* SymLink Rewrite: Optimize parsing: if the new name is actually shorter then the target name, then don´t allocate from pool, but re-use the buffer. This improves symlink parsing speed. Also fix a bug which made it depend on the incorrect implementation of NtCreateSymbolicLinkObject (Alex Ionescu)
* SymLink Rewrite: Re-align the link target maximum length in NtCreateSymbolicLinkObject if it´s odd, and fail if the length is odd, smaller then the maximum, or if the maximum is zero. (Alex Ionescu)
* SymLink Rewrite: Originally allocate the symlink name in Paged Pool. (Alex Ionescu)
* SymLink Rewrite: Initialize new members of the structure. (Alex Ionescu)
* SymLink Rewrite: Fail in no-memory case, instead of continuing. (Alex Ionescu)
* SymLink Rewrite: Properly probe the LinkTarget in NtQuerySymbolicLinkObject. (Alex Ionescu)
* SymLink Rewrite: Properly handle which length is chosen for the copy and for the return in NtQuerySymbolicObject. (Alex Ionescu)
* SymLink Rewrite: Lock the symbolic link object type while querying it. Eventually many more parts of Ob need to do this kind of locking. (Alex Ionescu)
* Fix some NDK bugs (Alex Ionescu)
* Rewrote the Object Directory implementation to follow the NT Structures in the NDK. This got rid of the last remaining OBJECT_HEADER difference and switched over to OBJECT_DIRECTORY. (Alex Ionescu)
* Wipe out PROS_OBJECT_HEADER and use OBJECT_HEADER since we are now compatible. (Alex Ionescu)
* Cleanup profiling and debugging code, add function comment headers and comment the functions in obdir.c (Alex Ionescu)
* Remove directory object parsing. Directory objects don´t have parse routines. Instead, inline the lookup in ObFindObject (this hasn´t been optimized yet, a lot of the code is now setting a = b, c = a, c = b. (Alex Ionescu)
* Get rid of OB_ROS_PARSE_METHOD and use OB_PARSE_METHOD instead. Hacked the current parse methods to keep using a PWSTR, however they should be modified to use the UNICODE_STRING instead. (Alex Ionescu)
* Fix ObReferenceObjectByName and ObOpenObjectByName not to ignore the AccessState and ParseContext parameters. (Alex Ionescu)
* Change ObFindObject´s prototype to be able to accommodate these two parameters so that they can be sent to the parse routine. (Alex Ionescu)
* Rewrite Desktop/WindowsStation parsing to follow the NT Object Model, with some minor hacks to respect ROS´s current parsing semantics. (Alex Ionescu)
* Thanks to this, the long-lasting ExpDesktopCreate hack is gone, and so is OB_ROS_FIND_METHOD and OB_ROS_CREATE_METHOD in win32k. Next patch can fully remove WIN32_CALLOUT_DATA and use the NT type instead. (Alex Ionescu)
* Convert all Win32k Object callback functions to the correct NT prototypes. (Alex Ionescu)
* Get rid of ROS-internal WIN32_CALLOUT_DATA and use the real WIN32_CALLOUTS_FPNS type. (Alex Ionescu)
* Get rid of the callout.h hack. (Alex Ionescu)
* Get rid of the intriguing idea that exported/public APIs should have prototypes with inversed parameters (fix ObOpenObjectByName and all its callers). (Alex Ionescu)
* Isolate ObFindObject into CmFindObject for the registry routines. Because of their well-known abuse of Ob, it´s better to give them their internal routine so that when/if Ob ever gets fixed to parse properly, it won´t force a re-write of Cm´s object routines. (Alex Ionescu)
* Add SecurityQoS and PreviousMode parameters to ObFindObject, so that these can be sent to the parse routine. Also don´t send OBJECT_CREATE_INFORMATION to it, but each needed member separately. This avoids having to create a "Fake" structure in some calls which don´t actually use the captured information. (Alex Ionescu)
* Also remove RemainingPath and stop exposing it to public APIs. Move all ObInsertObject/ObOpen,ReferenceByName hacks to ObFindObject, and add a small one there. Basically trade 4 hacks for 1. (Alex Ionescu)
* Re-implement delayed object deletion by using an optimized Object Reaper based on OBJECT_HEADER->NextToFree. Thanks to Thomas for the algorithm. (Alex Ionescu)
* Refactor object deletion into two operations: Removal and de-allocation (this is needed for failure during allocation, which we don´t do yet). (Alex Ionescu)
* After freeing an object header structure, also clear the pointer so we don´t attempt it again. (Alex Ionescu)
* Clear the handle database if there is one (Alex Ionescu)
* Make sure the create info flag is set before deleting captured attributes. (Alex Ionescu)
* Use the allocation pool tag when de-allocating. (Alex Ionescu)
* Use OBJECT_TYPE accounting for tracking the numbef of objects. (Alex Ionescu)
* Remove the object from it´s typelist if it has creator information. (Alex Ionescu)
* Call the security procedure to delete the security descriptor. (Alex Ionescu)
* Set the CreatorUniqueProcess (Alex Ionescu)
* Do a privilege check of OB_FLAG_PERMANENT is being used, and de-allocate the object if this failed. (Alex Ionescu)
* Send the PreviousMode to ObpAllocateObject so that it can honor it and set the OB_FLAG_KERNEL_MODE flag. (Alex Ionescu)
* Use OBJECT_TYPE accounting to increase TotalNumberOfObjects. (Alex Ionescu)
* Fail ObCreateObject in low-memory situations instead of ignoring it. (Alex Ionescu)
* Respect OBJECT_TYPE.TypeInfo.InvalidAttributes if an attempt to create an object with invalid attributes is detected. (Alex Ionescu)
* Respect PagedPoolCharge and NonPagedPoolCharge parameters and save them in the OBJECT_CREATE_INFORMATION structure. (Alex Ionescu)
* Implement Per-Processor Lookaside List based allocation and de-allocation of the Object Create Information (object attributes capture) and of the object name. I counted over 4000 allocations for only 30 seconds of runtime, so this change greatly reduces pool fragmentation and increases speed. (Implementation is similar to the IRP lookaside list implementation, but inlined for speed). (Alex Ionescu)
* Fix some cases where we weren´t freeing captured information properly. This patch should also decrease memory leaks/usage. (Alex Ionescu)
* Fix ExChangeHandle not to send NULL but the actual context to the callback function (fix by Thomas Weidenmueller ) (Alex Ionescu)
* Re-implement NtSetInformationObject based on ExChangeHandle and using ObpSetHandleAttributes as a callback. (Alex Ionescu)
* Re-implement NtQueryObject´s ObjectHandleInformation case to simply return the information that´s already in HandleAttributes; there is no point in querying for it all over again. (Alex Ionescu)
* Fix NtSetInformationObject not to allow a user-mode call to modify kernel-mode handle attributes. Add FIXME for Inheritance permissions check. (Alex Ionescu)
* Fix NtQueryObject to properly return OBJ_PERMANENT and OBJ_EXCLUSIVE; these flags are not stored in Handle Attributes. (Alex Ionescu)
* Fix NtQueryObject not to attempt referencing the handle if the caller specified AllTypesInformation, because then a handle is not needed. (Alex Ionescu)
* Simplify ObGetObjectPointerCode and ObfReferenceObject. (Alex Ionescu)
* Fix ObReferenceObjectByPointer to actually work like documented instead of doing random incorrect checks. Also add special case for Symbolic Link objects as documented by Caz Yokoyama at Microsoft. (Alex Ionescu)
* ObReferenceObjectByHandle: Remove MAXIMUM_ALLOWEDGENERIC_ALL conversion, I could find no mention of this in the docs. (Alex Ionescu)
* ObReferenceObjectByHandle: Remove GENERIC_ACCESS RtlMapGenericMask conversion, I could find no mention of this in the docs, and this mapping is only required when creating handles, not when referencing pointers. (Alex Ionescu)
* ObReferenceObjectByHandle: Do not attach/detach from the system process, this isn´t required since we´re merely getting a kernel pointer from the handle netry. (Alex Ionescu)
* ObReferenceObjectByHandle: Directly increase the pointer count instead of calling ObReferenceObject, since we already have the object header in a variable. (Alex Ionescu)
* ObReferenceObjectByHandle: Cache ObpKernelHandleTable/Process->ObjectTable and use those directly instead of always de-referencing the process. (Alex Ionescu)
* Rename ObpCreateTypeObject to ObCreateObjectType and fix definition. The latter is actually exported in NT, and there´s no reason not to export it while having our own internally renamed version. (Alex Ionescu)
* Added stub exports for ObCloseHandle, ObReferenceSecurityDesciptor, ObSetHandleAttributes, ObSetSecurityObjectByPointer so that someday someone can know what needs to be implemented. (Alex Ionescu)
* Removed ObGetObjectPointerCount. It is not exported in newer OSes and was always undocumented. (Alex Ionescu)
* Move ObQueryObjecctAuditingByHandle to security.c and optimized it not to attach to the system process, as well as to cache the handle table instead of dereferencing the owner process all the time. (Alex Ionescu)
* Fix bug in IoCreateFile which my (correct) ObReferenceObjectByHandle bugfix patch uncovered. Bootcd/installation works again. (Alex Ionescu)
* Make sure callers of NtMakeTemporaryObject have DELETE privileges, otherwise they could end up illegaly killing objects (in certain situations) (Alex Ionescu)
* Make sure callers of NtMakePermanentObject have SeCreatePermanentPrivilege. (Alex Ionescu)
* Implement ObpDeleteNameCheck as described in Gl00my´s Ob Documentation (using such documentation falls under US Reverse Engineering Law * Clean rooming). (Alex Ionescu)
* Remove duplicated code in ObpDecrementHandleCount and ObpSetPermanentObject and have them use ObpDeleteNameCheck instead. (Alex Ionescu)
* Name-check is now properly done. (Alex Ionescu)
* The keep-alive reference is now deleted when going from permanent->temporary object. (Alex Ionescu)
* The parent directory is now dereferenced and cleared when deleting the object. (Alex Ionescu)
* The security procedure is now called to delete the SD, and the name buffer is freed. (Alex Ionescu)
* Remove ObGetObjectHandleCount, it´s not a public function. (Alex Ionescu)
* Modified ObpDecrementHandleCount to accept Process and GrantedAccess paraemters since the definition for the Close Procedure Callback requires them (and we were currently sending NULL). Also send 0 for process handle count, since we don´t yet parse/support per-process handle databases. (Alex Ionescu)
* Minor optimization: All objects have an object type, don´t actually check if the object has one when decrementing a handle. (Alex Ionescu)
* Minor accounting fix: Decrement the total number of handles for the object type whose handle count is being decreased. (Alex Ionescu)
* Call the OkayToClose Procedure, if one is present, to allow the object owner a chance to disallow closing this handle. I believe this is required for properly protecting Winsta/Desktop handles (instead of using the regular protection mode, since that one can be bypassed). (Alex Ionescu)
* Make ObpCreateHandleTable return NTSTATUS instead of VOID, so that it can return STATUS_INSUFFIENT_RESOURCES if the handle table couldn´t be allocated. (Alex Ionescu)
* Clone ObpCreateHandle to CmpCreateHandle. I am about to fix its implementation and since Cm* currently abuses Ob I feel it safer to give it its own internal function. (Alex Ionescu)
* Make ObpCreateHandle internal to Ob as it should be. Change NtCreateProcessTokenEx to use ObOpenObjectByPointer, it has no business manually trying to create a handle. Same goes for ExpLoadInitialProcess. (Alex Ionescu)
* Add some trace macros to monitor handle/pointer counts for fixing regressions/bugs later. (Alex Ionescu)
* Change ObpCreateHandle to use an ACCESS_STATE structure instead of DesiredAccess. This is to help moving to an updated model where creating and incrementing a handle are 2 operations, so that code can be refactored (similar to how we now have Delete/Decrement as 2 operations). (Alex Ionescu)
* Fix functions that were not creating an ACCESS_STATE Structure to create one locally now, or use the one passed as a parameter, if available. (Alex Ionescu)
* Change ObpCreateHandle to the one documented and explained in the Gl00my documentation. It also fits the re-factored split create/increment model better, supports open reasons, and allows (to do) type-checking and extra object referencing from within one routine. (Alex Ionescu)
* Add code to ObOpenObjectByName to detect the OpenReason. Experimental, since I´m not sure when to clear the flag. (Alex Ionescu)
* ObpCreateHandle: Honour ObjectType passed to the function and fail if it doesn´t match. (Alex Ionescu)
* ObpCreateHandle: Use table-based logic instead of process-based logic for Kernel vs User-mode handles (same change that´s been done all over the place, since it requires only one dereference of the process object). (Alex Ionescu)
* ObpCreateHandle: Do the GENERIC/MAXIMUM_ALLOWED logic directly inside the ACCESS_STATE structure. (Alex Ionescu)
* ObpCreateHandle: Increase the object type´s number of handles as well. (Alex Ionescu)
* ObpCreateHandle: Set the handle table entry´s ObAttributes correctly; the old code seems to have been messing that up. (Alex Ionescu)
* ObpCreateHandle: Honour the AdditionalReferences parameter and do referencing bias if requested. (Alex Ionescu)
* ObpCreateHandle: Honour the ReturnedObject parameter to return the object pointer back to the caller. (Alex Ionescu)
* ObpCreateHandle: If we failed because a handle couldn´t be allocated, use the distinguied STATUS_INSUFFICIENT_RESOURCES error code instead of the generic STATUS_UNSCUCESFFUL, and backout all the changes we made by calling ObpDecrementHandleCount. (Alex Ionescu)
* Split ObpCreateHandle into two distinct operations: Incrementing and Creating (like we have Delete/Decrement). No code additions, just splitting. (Alex Ionescu)
* Because of the split, we can now directly only do an Increment when duplicating the handle, since we don´t need to create a brand new one. Also, when inheriting, we can now properly do an increment as well, instead of simply manually increasing the handle count (because for each inherited handle, access checks and openprocedure should´ve still been called). (Alex Ionescu)
* Use PagedPool instead of NonPagedPool memory, and also tag the allocation for debugging. (Alex Ionescu)
* Send needed data to the security procedure instead of NULL/0, including the Generic Mapping, and the actual Security Decriptor. (Alex Ionescu)
* Only un-assign the descriptor in case of failure, not all the time (the whole point of the API is to assign it!) (Alex Ionescu)
* Tell the caller that memory was NOT allocated if we failed to get the security descriptor. (Alex Ionescu)
* ObInsertObject: Create the ACCESS_STATE structure much earlier. (Alex Ionescu)
* ObInsertObject: Actually send the access state and parse context to ObFindObject, when called from ObInsertObject (this should fix some hidden regressions, since they finally get an access state with access masks now). (Alex Ionescu)
* ObInsertObject: Remove some deprecated hacks. (Alex Ionescu)
* ObInsertObject: If inserting the handle failed, cleanup the name and remove it from the directory entry. (Alex Ionescu)
* ObInsertObject: Fix a memory leak because we weren´t deleting the access state. (Alex Ionescu)
* Fix ObGetObjectSecurity to use the object type´s pool type instead of assuming PagedPool. (Alex Ionescu)
* Re-wrote the way ObInsertObject handles security as described in Chapters 6 and 9 of Gl00my (ie: made it use ObGetObjectSecurity and ObAssignObjectSecurity; ironically, these functions already existed/are exported and could´ve been used since the start instead of duplicating code). (Alex Ionescu)
* Fix ObpReferenceCachedSecurityDescriptor only to touch the cached entry if it actually gets a non-NULL descriptor. Also improved it to return the referenced SD, instead of requiring the caller to do it manually. (Alex Ionescu)
* ObFindObject should return the actual object being inserted, in the insert case (otherwise it always returns the root-directory instead.) (Alex Ionescu)
* Add check for optimized case for objects with no name and no security, but not implemented (ObpIncrementUnnamedHandleCount in Gl00my docs), since I need a better translation then babelfish´s. (Alex Ionescu)
* Fix ObInsertObject to save the Security Descriptor in the Access State structure. Gl00my mentions this isn´t absorbed by SeCreateAccessCheck and I just noticed that too. (Alex Ionescu)
* We only need to perform security checks for a new object, in ObInsertObject, not if the object already existed. (Alex Ionescu)
* Added proper backout+failure code in ObInsertObject if lookup failed, and also look out for mismatch/exists/collision cases (implemented using simple logic). (Alex Ionescu)
* Rename ObpDeleteHandle to ObpCloseHandleTableEntry and change semantics so that it deals directly with the entry and table. This re-factoring optimizes the case where we already have the entry and don´t want to use the handle to get the kernel table and then attach/detach/enter/exit critcal regions (such as when sweeping). (Alex Ionescu)
* Implement ObCloseHandle, a new XP Export (Alex Ionescu)
* Take old NtClose code and write it in ObpCloseHandle, which is the master function that Ntclose/ObCloseHandle share. (Alex Ionescu)
* Complete patch requires ExSweepHandleTable to be modified to return the Handle instead of the entry, so that sweeping can be fixed to properly destroy handles and call their OkayToClose, instead of just decrementing a count. (Alex Ionescu)
* Add Object Header Quota structure/define (Alex Ionescu)
* Give Files/Devices a parse routine and currently stubplement it for debugging purposes and trying to figure out a way to kill the IopCreateFile hack. (Alex Ionescu)
* Implement ObpChargeQuotaForObject. Using a memory breakpoint in WinDBG I´ve finally found where the OB_FLAG_CREATE_INFO flag gets masked out. Also attempted a very naive quota charging implementation, but it´s a guess and probably wrong (but at least it does...something.) (Alex Ionescu)
* Remove the heart (but not the brain) of the IopCreateFile hack. A much ´nicer´ hack now detects if a filename can´t be found, and instead of inserting it into the object directory (wrong!), calling IopCreateFile (wrong!), then having it fail, only to then remove the newly inserted object entry (wrong wrong wrong!), IopCreateFile is now *only* called for real files, otherwise Ob detects the invalid name and fails nicely and quickly. (Alex Ionescu)
* Add the OPEN_PACKET structure to internal headers. Used for the I/O Parse Routine. (Alex Ionescu)
* Gut down IopCreateFile to the strict minimum so that only the critical parts remain. (Alex Ionescu)
* NT Compatiblity fix in ObFindObject: stop parsing if remaining path is null, this means that the parse routine is done parsing and that -this* is the final object. (Alex Ionescu)
* Fix the CmpObjectDelete bugcheck by hacking away some code reponsible for it. The bugcheck is probably the result of the current ref-count bug. (Alex Ionescu)
* Remove some more code in IoCreateFile/IopCreateFile to help with deprecating it later. (Alex Ionescu)
* Update sweep callback to send the handle number. Patch by Thomas Weidenmueller (w3seek@reactos.org) (Alex Ionescu)
* Export ObCloseHandle since it´s implemented now (Alex Ionescu)
* Implement ObpCreateUnnamedHandle and ObpIncrementUnnamedHandleCount as optimizations for ObInsertObject with unnamed objects. (Alex Ionescu)
* Fix definitions of OB_QUERYNAME_METHOD and OB_OKAYTOCLOSE_METHOD. Add fixme for OB_SECURITY_METHOD, will change it later. (Alex Ionescu)
* Simplified NtDuplicateObject to a simple stub around ObDuplicateObject, there is no need to have lengthy hacks for NtCurrentProcess/NtCurrentThread(). (Alex Ionescu)
* Cleanup ObDuplicateObject to use normal Ob routines instead of grovelling through handle table structures and manually touching the handle count: It now calls ObpIncrementHandleCount and all the underlying operations are done on the duplicated handle. Also access state creation is done if the duplicated handle has different desired access. (Alex Ionescu)
* Get rid of a dozen of debug prints that have been straying along for a long time (some for years), most of which I must shamefully admit I am responsible for. (Alex Ionescu)
* Fix a critical bug subsystem bug in smss and don´t hang the system 15 seconds on boot-up. (Alex Ionescu)
* Rebase some problematic modules (and fix wshtcpip´s rbuild file) to avoid relocations on bootup and some process startup. (Alex Ionescu)
* Enable lsass startup in winlogon and the registry. (Alex Ionescu)
* Only show debug log header when actually debugging to a file. (Alex Ionescu)
* Bring out the champagne... one of my first-ever and most ancient ReactOS TODOs: the IopCreateFile hack has been totally removed and we now have a file/device parse routine. It´s still nothing like NT´s but it´s not a hack anymore, and actually works like it should. (Alex Ionescu)
* Pretty much the last Ob implementation/optimization patch (Except for a minor fix by Thomas to fix handle sweeping), re-implemented the ObFindObject routine by using some code that I had written almost 2 years ago with help from Thomas and Filip, plus some fixes discovered today while testing. (Alex Ionescu)
* Fixed symbolic link and desktop/winsta parse procedures to become NT-compatible now that ObFindObject is as well. Also fixed file/device parse routine for these changes. (Alex Ionescu)
* ObFindObject now supports STATUS_REPARSE_OBJECT, and has an optimized path for parsing when a root directory is given, as well as is entirely unicode_string-based. (Alex Ionescu)
* Cleaned up ob.h and added ob_x.h for the inlined functions. (Alex Ionescu)
* Implemented new Ob tracing system. (Alex Ionescu)
* Enable ROS_LEAN_AND_MEAN if you want 50% smaller binaries and a 20MB reduction in memory usage. (Alex Ionescu) (Note: ROS_LEAN_AND_MEAN may not work due to hidden bugs in debug symbols)
* Create a new module type: exportdriver for drivers which also export files. Not supremely useful right now, but it helps us decrease compilation time of normal drivers by not running useless commands on them. Later we´ll also strip out their export table. We can also make exportdrivers automatically read their .def file instead of specfiygone one. (Alex Ionescu)
* Fix some referencing/bugs in Ob functions that I wrote which were known fixmes. (Alex Ionescu)
* Remove every instance of ObDereferenceObject after an ObInsertObject that I could find. This temporarily will make the object leaks even worse, but it´s better to increase leaks and then fix the ref bug, then to decrease references while missing spots that forgot to reference them (you´d end up with hard to debug randomly dying objects). (Alex Ionescu)
* Handle mount failure (such as when a CDROM isn´t actually inside the drive) instead of assuming success and setting a NULL device object. Fixes regression seen by Arty/James when winefiling, dir d:-ing or hardware device wizarding. (Alex Ionescu)
* Check for valid access in NtSignalAndWaitForSingleObject and don´t check if ResultLength isn´t NULL in NtQueryObject, because it´s not optional. (Alex Ionescu)
* ObpCreateUnnamedHandle/ObpCreateHandle => Reference the object before calling ExCreateHandle. (Alex Ionescu)
* Fix two critical bugs in ObInsertObject: We were creating a handle for the wrong object (in ObInsertObject) and we were not passing the ReferencedObject parameter to ObpCreateHandle, so that object was never being returned properly to the caller. (Alex Ionescu)
* ObfDereferenceObject shouldn´t check for the OB_FLAG_PERMANENT flag, or else it would never be possible to kill permanent objects while in kernel mode (permanent objects only apply to user-mode handles). (Alex Ionescu)
* Fix another critical bug in ObInsertObject: don´t overwrite the lookup status with the handle creation status. If the lookup returned something like OBJECT_NAME_EXISTS (which is a success + warning), we don´t want to overwrite it with ObpCreateHandle´s STATUS_SUCCESS. This should fix a large number of regressions (and also fixes many WINE ntdll "om" tests). (Alex Ionescu)
* We also now correctly dereference the object in ObInsertObject, which should reduce one source of leaks (But there is still one). OTOH, this makes the Cm code crash at shutdown (I´ll fix this ASAP, this fix is worth having atm.) (Alex Ionescu)
* Catch illegal call to Ob functions when ObjectAttributes == NULL and return distinguished status code for this situation (STATUS_INVALID_PARAMETER), instead of failing due to access violation. (Alex Ionescu)
* Add some hacks to Cm to allow creating registry keys that finish with a backslash (this works under NT). (Alex Ionescu)
* Also add a REALLY nasty hack that forces OBJ_CASE_INSENSITIVE on all Registry APIs... this is needed because we seem to completely mess up case sensitivity otherwise and any user-mode caller that doesn´t specify that flag will fail. (Alex Ionescu)
* Implement ObCheckObjectAccess and call it to perform access verification checks. (Alex Ionescu)
* Properly create devices, processes and controllers with an extra reference count, so that when the code closes their handle they don´t die. (Alex Ionescu)
* Check for invalid uses of ObfDereferenceObject for our current debugging purposes. (Alex Ionescu)
* Add SEH to NtQueryObject. (Alex Ionescu)
* ObCreateObjectType: Fix a check in ObpFreeObject which was causing a bugcheck if the object had a handle database (fixes another kmtest failure/crash). (Alex Ionescu)
* ObCreateObjectType: Verify parameters passed to ObCreateObjectType based on behaviour seen on Windows 2003 (I might´ve missed some, these are the ones I tested for). This fixes 2 of the kmtest failures. (Alex Ionescu)
* ObCreateObjectType: Also make sure the object type´s name doesn´t have a slash in the name. (Alex Ionescu)
* ObCreateObjectType: Also make sure we don´t allow creating two object types with the same name. (Alex Ionescu)
* ObCreateObjectType: Also use our own local copy of the object name and copy it. (Alex Ionescu)
* IopRemoveThreadIrp: Get the DeviceObject and I/O Stack *before* going back to dispatch, otherwise race conditions will happen. (Alex Ionescu)
* IopRemoveThreadIrp: Don´t complete and IRP if it´s already been through two stacks. (Alex Ionescu)
* IopRemoveThreadIrp: Remove the IRP from the thread´s IRP list before re-initializing the list, or else the IRP was lost. (Alex Ionescu)
* IopRemoveThreadIrp: Make sure we have an error log entry before writing to it. (Alex Ionescu)
* IopCompleteRequest: Don´t read pointers from the file object or IRP before they are actually used, because in some parts of the code, these pointers could change before we actually use them. (Alex Ionescu)
* IopCompleteRequest: Get rid of the #if 1/#if 0 nonsense hbirr had added. (Alex Ionescu)
* IopCompleteRequest: Properly check for success/warning/failure cases (thanks to Filip for checking this out with me last year) (Alex Ionescu)
* IopCompleteRequest: Handle scenarios when the IRP is marked IRP_CREATE_OPERATION (Alex Ionescu)
* IopCompleteRequest: Bugcheck if IofCompleteRequest is called twice on the same IRP (Alex Ionescu)
* IopCompleteRequest: Copy the master IRP´s thread to the associated IRP (Alex Ionescu)
* IopCompleteRequest: Free the Auxiliary Buffer if there is one. (Alex Ionescu)
* Add more name/prototype decoration and API tracing. (Alex Ionescu)
* Don´t handle IRP_MJ_POWER in IoBuildAsyncronousFsdRequest. (Alex Ionescu)
* Use IoAllocateMdl instead of being a cowboy and using MmCreateMdl. (Alex Ionescu)
* Handle failure/out-of-memory cases in IoBuildAsyncronousFsdRequest (Alex Ionescu)
* Free the input buffer on failure in IoBuildDeviceIoControlRequest (Alex Ionescu)
* Handle failure in IoBuildSyncronousFsdREquest. (Alex Ionescu)
* Bugcheck if cancelling and IRP that´s already been completed. (Alex Ionescu)
* Bugcheck if attempting to call a driver with an IRP that´s already past its maximum stack size. (Alex Ionescu)
* Make sure that when we free an IRP, it´s not associated to a thread anymore, nor having any drivers that think it´s valid. (Alex Ionescu)
* Fix IRP/Completion packet lookaside allocation. We weren´t setting a zone size, and I/O Completion packets were also using the wrong size. (Alex Ionescu)
* Rewrite I/O MDl support to use lookaside lists for allocations below 23 pages (same as on NT). This is is an incredible performance optimization because MDLs are often allocated and de-allocated during I/O operations, and using the lookaside list decreases pool fragmentation and slowdown. (Alex Ionescu)
* Rewrite IoBuildPartialMdl. It did not work like documented in the DDK and also had a bug documented by Microsoft as being in XP. (Alex Ionescu)
* Refactor Io*Event APIs to call an internal worker function instead of duplicating the same code twice. (Alex Ionescu)
* Optimize Io*Work APIs and initialize the event on allocation, not on queue!! (Alex Ionescu)
* Use only one SEH block in NtRemoveIoCompletion (Alex Ionescu)
* Get the completion status from the IRP, not from the Mini-Packet, if the completion came from an IRP and not a Mini-Packet. (Alex Ionescu)
* Io*SymbolicLink should use OBJ_CASE_INSENSITIVE (Alex Ionescu)
* Use DELETE instead of SYMBOLIC_LINK_ALL_ACCESS when deleting. (Alex Ionescu)
* Clear the IO_TIMER structure when creating it. (Alex Ionescu)
* Add basic support/detection for debug I/O remove blocks (we bugcheck if we identify one though). (Alex Ionescu)
* Simplify IoReleaseRemoveLockAndWaitEx (Alex Ionescu)
* Remove locks are SYNCH events, not Notification events! (Alex Ionescu)
* Make sure IoConnectInterrupt returns NULL to the caller on failure. (Alex Ionescu)
* Add some missing IO_ERROR definitions to the DDK and add some tags (Alex Ionescu)
* Fix IoSetThreadHardErrorMode... it was reading the TEB instead of the PETHREAD. (Alex Ionescu)
* Optimize Error Logging: Use a static work item instead of allocating one each time, and don´t use a spinlock for the buffer count, when we can use interlocked functions instead. (Alex Ionescu)
* Log Entries can have Device AND/OR Driver Objects, not just a single one. They must also be referenced/dereferenced on allocation/free. (Alex Ionescu)
* Rewrite IopLogWorker to properly deal with Device/Driver objects and querying their names, as well as with additional strings that the caller might be sending. (Alex Ionescu)
* IopGetDevicePointer: Close the handle if we were able to acquire it. (Alex Ionescu)
* IoAttachDevice/IoAttachDeviceByPointer: Fail with STATUS_NO_SUCH_DEVICE if we couldn´t attach. (Alex Ionescu)
* IoAttachDEviceTodEviceStackSafe: VPBs don´t get inherited. (Alex Ionescu)
* IoCreateDevice: Only set OBJ_PERMAMENT if the caller requested it. (Alex Ionescu)
* IoCreateDevice: Return a NULL Device object if we failed to create it. (Alex Ionescu)
* IoCreateDevice: Set alignment requirement to 0, x86 doesn´t need it. (Alex Ionescu)
* Add IoGetDevObjExtension for getting the PEXTENDED_DEVOBJ_EXTENSION from a device object instead of always doing a huge typecast. (Alex Ionescu)
* Implement device unloading through IopUnloadDevice and device referencing through IopReferenceDeviceObject and IopDereferenceDeviceObject, and make IoDeleteDevice and IoDetachDevice unload the device on 0 reference count. Doesn´t fully work yet. (Alex Ionescu)
* Simplify IoGetAttachedDEvice/IoGetAttachedDeviceReference not to use an extra stack variable. (Alex Ionescu)
* Fix some bugs in IoGetRelatedDeviceObject: We should make sure that FO_DIRECT_DEVICE_OPEN isn´t set when reading from the VPB´s DO, otherwise we return the FO´s DO directly. Also check for attachment before trying to get any attached device. (Alex Ionescu)
* Implement IoRegisterLastchanceShutdownNotification based on IoRegisterShutdownNotification (Alex Ionescu)
* Modify IoUnregisterShudownNotification to loop both lists now. (Alex Ionescu)
* Used the lock in IoShutdownREgisteredDevices when looping the list, and changed it to send IRP_MJ_SHUTDOWN to the attached DO. Also fixed a memory leak where the shutdown entry wasn´t being freed, and optimized the function only to initialize the event once (And simply clear it each time). (Alex Ionescu) (Alex Ionescu)
* Clear the current IRP before parsing the Device Queues (Alex Ionescu)
* Respect Cancelable parameter in IoStartNextPacket(ByKey) instead of ignoring it (acquire the cancel lock when it´s requested) (Alex Ionescu)
* Raise IRQL to DISPATCH_LEVEL in IoStartPacket instead of expecting the caller to do it and crashing. Also only use Cancel Lock if a Cancel Function was specified. (Alex Ionescu)
* Actually handle the case where the IRP Was cancelled right after insert and the Cancel Routine has to be called. (Alex Ionescu)
* Add definitions for additional DOE flags to NDK. (Alex Ionescu)
* Implement IoSetStartIoAttributes (Alex Ionescu)
* Obey StartIo Flags set by IoSetStartIoAttributes and change Packet functions to Windows XP/2003 semantics by supporting non-cancelable packets and deferred Start I/O calling. (Alex Ionescu)
* Implement some functions to handle VPB Referencing/Dereferencing. (Alex Ionescu)
* IoVerifyVolume: Send the IRP to the base FSD, in case the current FSD is an attachee (Alex Ionescu)
* IoVerifyVolume: Set correct flags in the IRP to notify that this is a mount operation using PAGING I/O semantics. (Alex Ionescu)
* IoVerifyVolume: Don´t ignore AllowRawMount parameter. (Alex Ionescu)
* IoVerifyVolume: We want to mount the File System on *FAILURE*, not on SUCCESS! (Alex Ionescu)
* IoVerifyVolume: Add reference/dereferencing to the VPB. (Alex Ionescu)
* IoVerifyVolume: Get rid of the stupid LIST_FOR_EACH macros in FS Notifcation APIs. (Alex Ionescu)
* Each new change request should be queued at the end of the list, not at the head. (Alex Ionescu)
* Also, reference the device object for each registration, since one more object is holding a pointer to it, likewise, dereference the object on deregistration. (Alex Ionescu)
* IopLoadFileSystem should use the base FSD in case the device object is an attachee. Also, use IoBuildDEviceIoControlRequest to minimize the IRP setup to only a couple of lines. (Alex Ionescu)
* Simplify/modularize FS registration by using distinct lists for each type of FS (Tape/Disk/Network/Cdrom). (Alex Ionescu)
* Optimize by using directly the device queue instead of allocating a structure for each FS registered. (Alex Ionescu)
* Hack IopMountVolume to manage this new model. Improved version coming in next patch to deal with some bugs. (Alex Ionescu)
* Respect DeviceIsLocked flag and Alertable in IopMountVolume (Alex Ionescu)
* Don´t mount if the VPB is alread ymoutned or being removed (Alex Ionescu)
* Bugcheck the system if we failed to mount the boot partition. (Alex Ionescu)
* Mount the FS inline to avoid sending 6 parameters to a function only called once. (Alex Ionescu)
* Set the right IRP flags for a mount operation. (Alex Ionescu)
* Don´t ignore AllowRawMount flag. (Alex Ionescu)
* Don´t waste time passing or clearing unused flags/data on the IRP/Io Stack. (Alex Ionescu)
* If the device to be mounted is an attachee, find the base device object (Alex Ionescu)
* Reference the device object being mounted. (Alex Ionescu)
* If the file system being mounted is an atachee, find its base device object too, and increase the IRP Stack for each attached FSD. (Alex Ionescu)
* Fix IRP parameters with this new information. (Alex Ionescu)
* Improve list looping to remove gotos. (Alex Ionescu)
* Dereference the device object in case of failure. (Alex Ionescu)
* Add some optimizations to quickly skip invalid raw mounting. (Alex Ionescu)
* Add support for VPB_RAW_MOUNT. (Alex Ionescu)
* Allow raw mount if this is the only device on the list. (Alex Ionescu)
* Make the success case go through shared exit, otherwise the device wasn´t getting unlocked previously. (Alex Ionescu)
* Implement IopInitailizeVpbForMount for the purpose of setting up the VPB for a newly mounted DO. It properly references the VPB and sets up its stack size and flags, adding support for VPB_RAW_MOUNT. Also sets the VPB pointer in the DevObjExtension. (Alex Ionescu)
* Fix a bug which was causing us to incorrectly unlock the device if it was already locked by the caller instead of by IopMountVolume. (Alex Ionescu)
* When loading the file system, make sure to unlock the device object if we had locked it in IopMountVolume, as well as to re-lock it afterwards. Also handle a potential race condition due to this unloacking, in which the VPB might´ve become mounted behind our back, and simply return success if this happened. (Alex Ionescu)
* Use IoIsErrorUserInoduced to check if we couldn´t mount the device because it was not actually inserted, was unrocognized, write-protected, etc... and completely break out of the mounting procedure if so. (Alex Ionescu)
* Also use FsRtlIsTotalDeviceFailure to check if the error was a fatal device error (like a CRC error) and abandon mounting in this case as well. (Alex Ionescu)
* Small optimization: don´t bother to get the File System Listhead we´ll parse if we´re going to fail because of wrong VPB flags later... get the list only after we´re sure we need it. (Alex Ionescu)
* Move IoGetBaseFileSystemDeviceObject to device.c and make it check for FO_DIRECT_DEVICE_OPEN, which it wasn´t before (and also code it in a less confusing way like the other IoGetXxxDeviceObject APIs) (Alex Ionescu)
* Mask out the DO_VERIFY_VOLUME flag when mounting a device. (Alex Ionescu)
* Start of heavy work on iofunc.c: (Alex Ionescu)
* Created our new friends: IopCleanupFailedIrp, IopAbortInterruptedIrp, IopPerformSynchronousRequest, IopLockFileObject, IopUnlockFileObject, IopQueueIrpToThread, IopUpdateOperationCount. (Alex Ionescu)
* What does this mean: We actually queue IRPs to their thread! We actually respect I/O transfers being interrupted/alerted! We actually respect I/O operation counts! We actually LOCK FILE OBJECTS instead of randomly using them! We now support Deferred (read: MUCH faster) I/O completion. (Alex Ionescu)
* First function blessed: IopDeviceFsIoControl. (Alex Ionescu)
* Also simplified access rights check and fixedup some formatting. (Alex Ionescu)
* Combine IoQueryVolumeInformation and IoQueryFileInformation (Alex Ionescu)
* Fix them to lock the fileobject for synch operations, use IopCleanupFailedIrp, queue the IRP in the thread´s list, support aborting the I/o operation through IopAbortInterruptedIrp, and properly wait for comlpetion. (Alex Ionescu)
* Same changes for IoSertInformation: Lock the FO, queue the IRP, support alerted I/O, etc... (Alex Ionescu)
* Create IopFinalizeAsynchronousIo to deal with Sync APIs working on Async file objects, which need to be waited on differently and have the IOSB copied manually. (Alex Ionescu)
* Update NtFlushBuffersFile to new semantics (ie, usage of the new implemented functions). (Alex Ionescu)
* NtLockFile: Add proper sync operation. (Alex Ionescu)
* NtLockFile: Set the APC Routine/Context in the IRP instead of ignoring them. (Alex Ionescu)
* NtLockFile: Dereference the event on failure. (Alex Ionescu)
* NtLockFile: Set the allocated buffer as AuxiliaryBuffer so the I/O manager fres it. (Alex Ionescu)
* Add proper sync handling to NtUnlockFile. (Alex Ionescu)
* Fix sync usage in NtQueryVolumeInformationFile, set the right IRP flags so that the I/O manager can handle copying the data back and freeing the buffer, and enable deferred completion. (Alex Ionescu)
* Same sort of changes for NtSetVolumeInformationFile. (Alex Ionescu)
* NtReadFile: Allow async i/o access on mailslots, without a byte offset. (Alex Ionescu)
* NtReadFile: Fix sync semantics just like for the other functions until now. (Alex Ionescu)
* NtReadFile: Fix a potential object leak in a failure case. (Alex Ionescu)
* NtReadFile: Don´t call IoBuildSyncronousFsdRequest since we want to build the IRP ourselves. (Alex Ionescu)
* NtReadFile: Use deferred I/O as an optimization. (Alex Ionescu)
* NtWriteFile: Allow async i/o access on mailslots, without a byte offset. (Alex Ionescu)
* NtWriteFile: Fix sync semantics just like for the other functions until now. (Alex Ionescu)
* NtWriteFile: Fix a potential object leak in a failure case. (Alex Ionescu)
* NtWriteFile: Don´t call IoBuildSyncronousFsdRequest since we want to build the IRP ourselves. (Alex Ionescu)
* NtWriteFile: Use deferred I/O as an optimization. (Alex Ionescu)
* NtQueryDirectoryFile: Setup a buffer/MDL and the correct IRP flags so that that I/O manager can handle allocation, copy, free for us. (Alex Ionescu)
* NtQueryDirectoryFile: Setup the search pattern as an auxiliary buffer so that the I/O Mgr can track that one for us as well. (Alex Ionescu)
* NtQueryDirectoryFile: Update to use the correct sync semantics/routines. (Alex Ionescu)
* NtQueryDirectoryFile: Use deferred I/O completion. (Alex Ionescu)
* Fix NtQueryInformationFile to use correct sync/async semantics and use deferred I/O completion. This routine doesn´t use IopSyncronous/Asyncronous helper routines because it can be optimized to handle some Information classes in-line (not currently being done). (Alex Ionescu)
* Fix NtSetInformationFile to use correct sync/async semantics and use deferred I/O completion. This routine doesn´t use IopSyncronous/Asyncronous helper routines because it can be optimized to handle some Information classes in-line (not currently being done except for Completion Ports, like the previous code). (Alex Ionescu)
* Add locking in IopDeleteFile, and only check for completion context or name if the file has a DO, otherwise those shouldn´t exist. (Alex Ionescu)
* Added support for device objects as well in IopSecurityFile, since the code is similar. Also fixed sync semantics for file objects, and made other little small fixes. (Alex Ionescu)
* Fix and combine the creation of I/O Object Types, it was a complete mess with missing attributes and dangerous bugs (Adapters and Controllers had IopParseDevice as a parse routine and the same pool charge as a deivice object, etc.) (Alex Ionescu)
* Fix IopQueryNameFile to properly validate and calculate lengths at each step of the way and to support incomplete buffers. Previously, dangerous assumptions were made about the buffers and the actual required length was never returned. (Alex Ionescu)
* Finally fix IoCreateStreamFileObject. I had fixed it a long time ago but back then it was causing regressions. It now properly creates a handle for the FO and sets the right flags. (Alex Ionescu)
* The FO´s lock is a Synch event, not a notification event! (Alex Ionescu)
* Fix IopcloseFile... I´m not sure it was working right after the Ob changes, so it´s possible some devices weren´t getting IRP_MJ_CLEANUP... also made it lock the FO and detect malformed FOs (more spam for you on the debug logs!) -* but this is one problem I´m planning on fixing. (Alex Ionescu)
* IoCreateFile: Start with empty object (Alex Ionescu)
* IoCreateFile: Set the type/size in the object header (Alex Ionescu)
* IoCreateFile: Don´t rudely ignore the following flags: FILE_WRITE_THROUGH, FILE_SEQUENTIAL_ONLY, FILE_RANDOM_ACCESS, OBJ_CASE_INSENSITIVE; they are not merely decorative. (Alex Ionescu)
* IoCreateFile: Set correct IRP flags for IRP_CREATE_OPERATION so that the I/O manager knows how to deal with the request (also set SYNCH_API flag). (Alex Ionescu)
* IoCreateFile: Deferred mode not yet enabled. (Alex Ionescu)
* IoCreateFile: Simplify the way we set the parameters for pipes/mailslots/files. (Alex Ionescu)
* IoCreateFile: Don´t close the handle of an invalid FO. (Alex Ionescu)
* Make IoCreateFile use deferred I/O completion. (Alex Ionescu)
* Simplify IopParseDevice by removing duplicate code. (Alex Ionescu)
* Begin attempt at usage of the OPEN_PACKET for I/O Create operations. Currently we only build it and verify it, and I´ve fixed up IopCreateFile. (Alex Ionescu)
* Move the code in IoCreateFile inside IopParseDevice where it belongs. Currently only a raw move and hacks to make it not regress anything, but in the future we can now finally start applying some important fixes for proper communication with FSDs and setting a myriad of flags and settings required. Will also allow for some nice optimizations in the future. (Alex Ionescu)
* Allocate a copy of the EA buffer even for kernel-mode requests, also make the call use a tagged buffer. (Alex Ionescu)
* Detect if the FSD is reparsing, which we don´t support now (we´ll bugcheck for now, so we can quickly detect this later instead of handling it wrong). (Alex Ionescu)
* Use a simpler and more robust way to detect direct device opens and save it in a variable that´s read when needed, instead of having multiple large code paths. (Alex Ionescu)
* Implement IopCheckVpbMounted and use it in IopParseDevice as documented in NT File System Internals. (Alex Ionescu)
* Add some missing ref/deref calls for DOs and VPBs. (Alex Ionescu)
* Add some more proper handling of ref/dereferencing in IopParseDevice. (Alex Ionescu)
* Add proper failure case for IRP allocation failure (Alex Ionescu)
* Only initialize the FO´s lock for Synch I/O (Alex Ionescu)
* Add some missing comments (Alex Ionescu)
* Fixup some formatting (Alex Ionescu)
* Massively improve File I/O by using deferred I/O completion for MJ_(MAILSLOT/FILE/NAMEDPIPE)CREATE and manually completing the IRP. (Alex Ionescu)
* Uber-optimize IopQueryAttributesFile by using the OPEN_PACKET mechanism to query file attributes, instead of doing lots of slow native calls. (Alex Ionescu)
* Modify IopParseDevice to detect when OPEN_PACKET optimizations are in use (query or deletion (deletion not yet implemented)) and have some codepaths be slightly different and use DUMMY_FILE_OBJECT. (Alex Ionescu)
* Implement QueryOnly case in IopParseDevice to handle attribute queries. (Alex Ionescu)
* Add a missing dereference, and remove an extra DO reference. (Alex Ionescu)
* Remove a ROS hack in IopCloseFile. (Alex Ionescu)
* Add support for cases when the FSD that actually did the FO create wasn´t the one to whom we went the IRP. (Alex Ionescu)
* Also add support for detecting volume opens and setting the FO_VOLUME_OPEN flag. (Alex Ionescu)
* Implement IoFastQueryNetworkAttributes which is now a piece of cake thanks to a properly implemented IopParseDevice. (Alex Ionescu)
* Implemented NtDeleteFile, also a piece of cake now that we have IopParseDevice done. (Alex Ionescu)
* Don´t use FILE_ATTRIBUTE_NORMAL for mailslots/namedpipes. (Alex Ionescu)
* Zero out the OPEN_PACKET and only set non-zero members in functions that use it. (Alex Ionescu)
* NtCancelIoFile: Don´t use macro-based list looping. (Alex Ionescu)
* NtCancelIoFile: Update operation counts. (Alex Ionescu)
* NtCancelIoFile: Wait 10ms instead of 100ms. (Alex Ionescu)
* Allocate Re-Init entries with a tag (Alex Ionescu)
* IoAllocateDriverObjectExtension and IoGetDriverObjectExtension: They were using the wrong structure (a made up one). (Alex Ionescu)
* IoAllocateDriverObjectExtension and IoGetDriverObjectExtension: They were saving the extension where the Driver Object´s base address should be. (Alex Ionescu)
* IoAllocateDriverObjectExtension and IoGetDriverObjectExtension: Fix Memory leaks. (Alex Ionescu)
* IoAllocateDriverObjectExtension and IoGetDriverObjectExtension: Fix sometimes holding the lock too long. (Alex Ionescu)
* Created EXTENDED_DRIVER_OBJECT structure in NDK, since parts of the documented one are hidden (much like EXTENDED_DEVICE_OBJECT). (Alex Ionescu)
* Fixed IopDeleteDriver to free what it should. (Alex Ionescu)
* Fixed IoCreateDriver to handle more failure cases. (Alex Ionescu)
* Simplify IopReinitializeBootDrivers and IopReinitializeDrivers. (Alex Ionescu)
* For some strange reason, boot drivers were re-initailized *after* system drivers. (Alex Ionescu)
* Process Manager Rewrite: Architectural changes to match information in Windows Internals 4 and other documented sources of information (Windows Internals II by Probert). Code should match Win2003 layout. (Alex Ionescu)
* Process Manager Rewrite: Handle almost any possible process/thread sub structure and add its cleanup code stubs, so that when we actually implement them, we won´t forget to clean them up in the process code. (Alex Ionescu)
* Process Manager Rewrite: Add interlocked usage of process and thread flags in order to make everything more thread-safe. (Alex Ionescu)
* Process Manager Rewrite: Better handle cases where threads die instantly, race conditions, and other weird issues. (Alex Ionescu)
* Process Manager Rewrite: Better handle process termination and thread termination. (Alex Ionescu)
* Process Manager Rewrite: Implement NtCreateProcessEx and update PspCreateProcess/NtCreateProcess. (Alex Ionescu)
* Process Manager Rewrite: Improve cleanup of process object in PspProcessDelete. (Alex Ionescu)
* Process Manager Rewrite: Optimize some things like User Thread startup. (Alex Ionescu)
* Process Manager Rewrite: Add some extra asserts, paged_code checks and also user-mode security check. (Alex Ionescu)
* Process Manager Rewrite: Implement helper API PsGetNextProcessThread (Alex Ionescu)
* Process Manager Rewrite: Optimize thread reaper (thanks Filip) (Alex Ionescu)
* Process Manager Rewrite: Do proper referencing/dereferencing of thread/processes (thanks Thomas) (Alex Ionescu)
* Fix up some stuff in Kernel Gates support. (Alex Ionescu)
* Fix up some implementation bugs in Executive Rundown support. (Alex Ionescu)
* Implement Fast Referencing and fix EX_FAST_REF definition. (Alex Ionescu)
* Implement ObReferenceEx and ObDereferenceEx. (Alex Ionescu)
* Split off ObpDeferObjectCompletion. A new win2003/vista API requires direct acess to being able to defer deletes. (Alex Ionescu)
* Fix some bugs in Process Token management and make it all properly use Fast Referencing. (Alex Ionescu)
* When duplicating a token in a new process, don´t de-reference it before it´s even created, and also insert it. (Alex Ionescu)
* Change ExpChangeRundown macro to fix warnings in msvc. (Alex Ionescu)
* Fix KiAcquireMutexContended, it was broken in contended cases. (Alex Ionescu)
* Inline Acquiring/Leaving guarded regions and the gmutex code, instead of going through 3-4 indirect calls. (Alex Ionescu)
* Add a mountain of ASSERTs to detect incorrect usage/state. (Alex Ionescu)
* Set ->SpecialApcDisable in the Guarded Mutex. (Alex Ionescu)
* Fix broken KTHREAD definition. SpecialApcDisable and KernelApcDisable were incorrectly marked as USHORT instead of SHORT, which could cause severe trouble under optimized builds (At least under MSVC, since MSVC wouldn´t allow a negative number in an unsigned short). (Alex Ionescu)
* Use GM_LOCK_BIT_V. (Alex Ionescu)
* Fix broken KeTryToAcquireGuardedMutex prototype. (Alex Ionescu)
* Fix broken KGUARDED_MUTEX typedef and add bit values. (Alex Ionescu)
* Fix broken Interlocked* prototypes in regards to volatileness. (Alex Ionescu)
* Add ASSERT_QUEUE macro. (Alex Ionescu)
* Cleanup queue.c (Alex Ionescu)
* Add some ASSERTs (Alex Ionescu)
* Properly check for SPecialApcDisable before aborting a wait. (Alex Ionescu)
* Fix a bug in KiWaitQueue which was causing us not to remove the queue from the thread´s wait list. (Alex Ionescu)
* Add some TIMER values to the ddk. (Alex Ionescu)
* Add DPC Settings (Queue Depths, Rates, etc) (Alex Ionescu)
* Cleanup System/Run Time Update code. (Alex Ionescu)
* Always increase kernel time in PRCB when inside kernel-mode code. (Alex Ionescu)
* Get rid of superflous interlocked commands when not needed. (Alex Ionescu)
* Improve detection of DPC vs non-DPC time. (Alex Ionescu)
* Respect and apply DPC queue/rate rules. (Alex Ionescu)
* Allow future use of non-fulltick time increments. (Alex Ionescu)
* Don´t make the timer signaled in KeSetTimerEx if it already expired. (Alex Ionescu)
* Only call KiWaitTest on timers if they have waiters. (Alex Ionescu)
* Fix list looping in KiExpireTimers. (Alex Ionescu)
* Add checks for special apc disabled (guarded regions) in wait code. (Alex Ionescu)
* Set the right wait status in KiAbortWaitThread. (Alex Ionescu)
* Don´t ignore priority boost (increments) when aborting waits. (Alex Ionescu)
* When satisfying a mutant, insert if into the the head of the back-link, not the forward-link. (Alex Ionescu)
* Fix utterly messed up unblocking/readying thread logic. (Alex Ionescu)
* KiUnblockThread becomes KiReadyThread and doesn´t perform priority modifications anymore. Also removed a large block of code that was #if 0ed out. (Alex Ionescu)
* KiAbortWaitThread now does priority modifications (and better then before), then calls KiReadyThread. (Alex Ionescu)
* Inserting a queue now *READIES A THREAD ONLY* instead of removing all its waits! (Alex Ionescu)
* Add KiCheckThreadStackSwap and KiAddThreadToWaitList macros (Alex Ionescu)
* Initialize PRCBs´ Wait Lists (Alex Ionescu)
* Fix a ghastly implementation fault where the the queue code was correctly removing the thread from its wait list, but where this wait list was actually connected to the _SCHEDULER_ and ended up removing a thread behind its back, causing bizarre issues and w3seek´s ASSERT(State == Ready) bug. Fixed this by using the macros above and PRCB Wait List and properly inserting a waiting thread into that list, and then removing it when unblocking it or removing a queue. (Alex Ionescu)
* Fix a serious bug in Kernel Queues. A condition existed where an inserted kernel queue with a timeout would crash the system once the thread waiting on it had its wait aborted or completed. (Alex Ionescu)
* Implement Safe Referencing (an internal method for referencing objects when race conditions are possible) (Alex Ionescu)
* Implement two Vista APIs and export them: ObIsKernelHandle and ObDeleteObjectDeferDelete. ZOMG! Vista APIs in the kernel! (Alex Ionescu)
* Add IN/OUT annotations for KeWaitForSIngleObject (Alex Ionescu)
* Set the wait block outside the loop, small optimization in case we get alerted by an APC and have to loop again. (Alex Ionescu)
* Set the wait block pointer in the KTHREAD structure only *after* checking if a wait is actually needed. That way, if the object is already signaled, we don´t set anything in the WaitBlockList. (Alex Ionescu)
* Small optimization: only set the caller´s WAitBlock as the next wait block if a timer wasn´t specificed, else we ended up overwriting the value. (Alex Ionescu)
* Small optimziation: don´t write the thread in the wait block, this is a wait for a signle object so this isn´t needed. (Alex Ionescu)
* Remove some debug prints that are not needed anymore (Alex Ionescu)
* NtCurrentTeb now returns the TEB instead of the KCPR, so re-enable the codepath that set the CurrentLocale and IdealProcessor in the TEB from the KTHREAD. (Alex Ionescu)
* Fixed a bug in PspUserThreadStartup which was causing us to notify the debugger for system threads or hidden threads, instead of vice-versa. (Alex Ionescu)
* Threads were incorrectly created with KernelMode access instead of PreviousMode. (Alex Ionescu)
* Initialize the thread´s rundown protection and use the process´s. (Alex Ionescu)
* Handle failure when TEB = NULL. (Alex Ionescu)
* The LPC Semaphore has a limit of 1, not 0x7FFF. (Alex Ionescu)
* Added very basic and skeletal NUMA code when creating a thread and process, currently only does some basic affinity checks and settings. (Alex Ionescu)
* Added a table and helper function (KeFindNextRightSetAffinity) for calculating affinity masks and sets. (Alex Ionescu)
* Split KeInitailizeThread into KeStartThread and KeInitThread, and modified Ps code to use the calls. Now added a failure case where Init fails, but we don´t have to backout the e

Related links:
[ PC Emus / Virtual Machines ][ MAC Emus ]