Ros-diffs

ros-diffs@reactos.org

81390 discussions

[turner] 23593: Fix the 'hack' that makes regedit and explorer links in the start menu to load the applications.
by turner＠svn.reactos.org 17 Aug '06

17 Aug '06

Author: turner Date: Thu Aug 17 05:26:51 2006 New Revision: 23593 URL: http://svn.reactos.org/svn/reactos?rev=23593&view=rev Log: Fix the 'hack' that makes regedit and explorer links in the start menu to load the applications. Modified: branches/ros-branch-0_3_0/reactos/dll/win32/syssetup/install.c Modified: branches/ros-branch-0_3_0/reactos/dll/win32/syssetup/install.c URL: http://svn.reactos.org/svn/reactos/branches/ros-branch-0_3_0/reactos/dll/wi… ============================================================================== --- branches/ros-branch-0_3_0/reactos/dll/win32/syssetup/install.c (original) +++ branches/ros-branch-0_3_0/reactos/dll/win32/syssetup/install.c Thu Aug 17 05:26:51 2006 @@ -425,8 +425,8 @@ CreateShortcut(CSIDL_PROGRAMS, sAccessories, _T("Calculator.lnk"), _T("calc.exe"), IDS_CMT_CALC); CreateShortcut(CSIDL_PROGRAMS, sAccessories, _T("Command Prompt.lnk"), _T("cmd.exe"), IDS_CMT_CMD); CreateShortcut(CSIDL_PROGRAMS, sAccessories, _T("Notepad.lnk"), _T("notepad.exe"), IDS_CMT_NOTEPAD); - CreateShortcut(CSIDL_PROGRAMS, sAccessories, _T("..\\ReactOS Explorer.lnk"), _T("explorer.exe"), IDS_CMT_EXPLORER); - CreateShortcut(CSIDL_PROGRAMS, sAccessories, _T("..\\Regedit.lnk"), _T("regedit.exe"), IDS_CMT_REGEDIT); + CreateShortcut(CSIDL_PROGRAMS, sAccessories, _T("ReactOS Explorer.lnk"), _T("..\\explorer.exe"), IDS_CMT_EXPLORER); + CreateShortcut(CSIDL_PROGRAMS, sAccessories, _T("Regedit.lnk"), _T("..\\regedit.exe"), IDS_CMT_REGEDIT); CreateShortcut(CSIDL_PROGRAMS, sAccessories, _T("WordPad.lnk"), _T("wordpad.exe"), IDS_CMT_WORDPAD); }

1 0

[ion] 23592: - Update status.
by ion＠svn.reactos.org 16 Aug '06

16 Aug '06

Author: ion Date: Thu Aug 17 03:33:24 2006 New Revision: 23592 URL: http://svn.reactos.org/svn/reactos?rev=23592&view=rev Log: - Update status. Modified: branches/alex-cm-branch/reactos/ntoskrnl/cm/cminfo.txt Modified: branches/alex-cm-branch/reactos/ntoskrnl/cm/cminfo.txt URL: http://svn.reactos.org/svn/reactos/branches/alex-cm-branch/reactos/ntoskrnl… ============================================================================== --- branches/alex-cm-branch/reactos/ntoskrnl/cm/cminfo.txt (original) +++ branches/alex-cm-branch/reactos/ntoskrnl/cm/cminfo.txt Thu Aug 17 03:33:24 2006 @@ -88,6 +88,10 @@ ~60% of the KCB/NCB code is complete. Blocking on cmlib being modified to use actual NT _HHIVE. +**As of 16/08/2006 + ~90% of the KCB/NCB code is complete. + Work about to resume on initialization code. + -= Structure =- cmapi.c - Contains the low-level Cmp APIs that correspond to the external Nt

1 0

[ion] 23591: - Add NCB lock macros. - Implement CmpDereferenceNcbWithLock, CmpFreeDelayItem.
by ion＠svn.reactos.org 16 Aug '06

16 Aug '06

Author: ion Date: Thu Aug 17 03:31:39 2006 New Revision: 23591 URL: http://svn.reactos.org/svn/reactos?rev=23591&view=rev Log: - Add NCB lock macros. - Implement CmpDereferenceNcbWithLock, CmpFreeDelayItem. Modified: branches/alex-cm-branch/reactos/ntoskrnl/cm/cm_x.h branches/alex-cm-branch/reactos/ntoskrnl/cm/cmkcbncb.c Modified: branches/alex-cm-branch/reactos/ntoskrnl/cm/cm_x.h URL: http://svn.reactos.org/svn/reactos/branches/alex-cm-branch/reactos/ntoskrnl… ============================================================================== --- branches/alex-cm-branch/reactos/ntoskrnl/cm/cm_x.h (original) +++ branches/alex-cm-branch/reactos/ntoskrnl/cm/cm_x.h Thu Aug 17 03:31:39 2006 @@ -80,3 +80,20 @@ (k)->ConvKey).Lock); \ } +// +// Exclusively acquires an NCB +// +#define CmpAcquireNcbLockExclusive(n) \ +{ \ + ExAcquirePushLockExclusive(GET_HASH_ENTRY(CmpNameCacheTable, \ + (n)->ConvKey).Lock); \ +} + +// +// Releases an exlusively or shared acquired NCB +// +#define CmpReleaseNcbLock(k) \ +{ \ + ExReleasePushLock(GET_HASH_ENTRY(CmpNameCacheTable, \ + (k)->ConvKey).Lock); \ +} Modified: branches/alex-cm-branch/reactos/ntoskrnl/cm/cmkcbncb.c URL: http://svn.reactos.org/svn/reactos/branches/alex-cm-branch/reactos/ntoskrnl… ============================================================================== --- branches/alex-cm-branch/reactos/ntoskrnl/cm/cmkcbncb.c (original) +++ branches/alex-cm-branch/reactos/ntoskrnl/cm/cmkcbncb.c Thu Aug 17 03:31:39 2006 @@ -290,6 +290,79 @@ } VOID +CmpDereferenceNcbWithLock(IN PCM_NAME_CONTROL_BLOCK Ncb) +{ + PCM_NAME_HASH Current, Next; + + /* Lock the NCB */ + CmpAcquireNcbLockExclusive(Ncb); + + /* Decrease the reference count */ + if (!(--Ncb->RefCount)) + { + /* Find the NCB in the table */ + Next = GET_HASH_ENTRY(CmpNameCacheTable, Ncb->ConvKey).Entry; + while (TRUE) + { + /* Check the current entry */ + Current = Next; + ASSERT(Current != NULL); + if (Current == &Ncb->NameHash) break; + + /* Get to the next one */ + Next = Current->NextHash; + } + + /* Found it, now unlink it and free it */ + Current->NextHash = Next->NextHash; + ExFreePool(Ncb); + } + + /* Release the lock */ + CmpReleaseNcbLock(Ncb); +} + +VOID +NTAPI +CmpFreeDelayItem(PVOID Entry) +{ + PCM_DELAYED_CLOSE_ENTRY AllocEntry = (PCM_DELAYED_CLOSE_ENTRY)Entry; + PCM_DELAYED_CLOSE_ENTRY *AllocTable; + PCM_ALLOC_PAGE AllocPage; + ULONG i; + PAGED_CODE(); + + /* Lock the table */ + KeAcquireGuardedMutex(&CmpDelayAllocBucketLock); + + /* Add the entry at the end */ + InsertTailList(&CmpFreeDelayItemsListHead, &AllocEntry->DelayedLRUList); + + /* Get the alloc page */ + AllocPage = (PCM_ALLOC_PAGE)((ULONG_PTR)Entry & 0xFFFFF000); + ASSERT(AllocPage->FreeCount != CM_DELAYS_PER_PAGE); + + /* Increase the number of free items */ + if (++AllocPage->FreeCount == CM_DELAYS_PER_PAGE) + { + /* Page is totally free now, loop each entry */ + AllocTable = (PCM_DELAYED_CLOSE_ENTRY*)&AllocPage->AllocPage; + for (i = CM_DELAYS_PER_PAGE; i; i--) + { + /* Get the entry and unlink it */ + AllocEntry = AllocTable[i]; + RemoveEntryList(&AllocEntry->DelayedLRUList); + } + + /* Now free the page */ + ExFreePool(AllocPage); + } + + /* Release the lock */ + KeReleaseGuardedMutex(&CmpDelayAllocBucketLock); +} + +VOID NTAPI CmpRemoveFromDelayedClose(IN PCM_KEY_CONTROL_BLOCK Kcb) {

1 0

[ion] 23590: - Add definitions for HCELL_NIL and HCELL_CACHED. - Add CM_DELAY_DEREF_KCB_ITEM. - Add CM_CACHED_VALUE_INDEX, CM_CACHED_VALUE. - Add macros for dealing with cached cells (CMP_GET_CACHED_CELL, CMP_GET_CACHED_DATA, _INDEX, _VALUE and CMP_IS_CELL_CACHED). - Implement CmpRemoveFromDelayedClose, CmpDelayDerefKCb, CmpCleanUpKcbValueCache, CmpCleanUpKcbCacheWithLock. - Fix return value of CmpAllocateDelayItem.
by ion＠svn.reactos.org 16 Aug '06

16 Aug '06

Author: ion Date: Wed Aug 16 22:38:09 2006 New Revision: 23590 URL: http://svn.reactos.org/svn/reactos?rev=23590&view=rev Log: - Add definitions for HCELL_NIL and HCELL_CACHED. - Add CM_DELAY_DEREF_KCB_ITEM. - Add CM_CACHED_VALUE_INDEX, CM_CACHED_VALUE. - Add macros for dealing with cached cells (CMP_GET_CACHED_CELL, CMP_GET_CACHED_DATA, _INDEX, _VALUE and CMP_IS_CELL_CACHED). - Implement CmpRemoveFromDelayedClose, CmpDelayDerefKCb, CmpCleanUpKcbValueCache, CmpCleanUpKcbCacheWithLock. - Fix return value of CmpAllocateDelayItem. Modified: branches/alex-cm-branch/reactos/ntoskrnl/cm/cm.h branches/alex-cm-branch/reactos/ntoskrnl/cm/cm_x.h branches/alex-cm-branch/reactos/ntoskrnl/cm/cmkcbncb.c Modified: branches/alex-cm-branch/reactos/ntoskrnl/cm/cm.h URL: http://svn.reactos.org/svn/reactos/branches/alex-cm-branch/reactos/ntoskrnl… ============================================================================== --- branches/alex-cm-branch/reactos/ntoskrnl/cm/cm.h (original) +++ branches/alex-cm-branch/reactos/ntoskrnl/cm/cm.h Wed Aug 16 22:38:09 2006 @@ -73,6 +73,12 @@ #define HBLOCK_SIZE 0x1000 #define HSECTOR_SIZE 0x200 #define HSECTOR_COUNT 8 + +// +// Cell Masks +// +#define HCELL_NIL 0 +#define HCELL_CACHED 1 // // CM_KEY_CONTROL_BLOCK Flags @@ -367,6 +373,15 @@ LIST_ENTRY DelayedLRUList; PCM_KEY_CONTROL_BLOCK KeyControlBlock; } CM_DELAYED_CLOSE_ENTRY, *PCM_DELAYED_CLOSE_ENTRY; + +// +// Delayed KCB Dereference Entry +// +typedef struct _CM_DELAY_DEREF_KCB_ITEM +{ + LIST_ENTRY ListEntry; + PCM_KEY_CONTROL_BLOCK Kcb; +} CM_DELAY_DEREF_KCB_ITEM, *PCM_DELAY_DEREF_KCB_ITEM; // // Use Count Log and Entry @@ -521,6 +536,29 @@ } CELL_DATA, *PCELL_DATA; // +// Cached Value Index +// +typedef struct _CM_CACHED_VALUE_INDEX +{ + HCELL_INDEX CellIndex; + union + { + CELL_DATA CellData; + ULONG_PTR List[ANYSIZE_ARRAY]; + } Data; +} CM_CACHED_VALUE_INDEX, *PCM_CACHED_VALUE_INDEX; + +// +// Cached Value +// +typedef struct _CM_CACHED_VALUE +{ + USHORT DataCacheType; + USHORT ValueKeySize; + CM_KEY_VALUE KeyValue; +} CM_CACHED_VALUE, *PCM_CACHED_VALUE; + +// // Registry Validation Functions // BOOLEAN @@ -531,7 +569,7 @@ ); // -// Registry Lock +// Registry Locking Functions // BOOLEAN NTAPI @@ -540,6 +578,16 @@ ); // +// KCB Functions +// +VOID +NTAPI +CmpDereferenceKcbWithLock( + IN PCM_KEY_CONTROL_BLOCK Kcb, + IN BOOLEAN LockHeldExclusively +); + +// // Global variables accessible from all of Cm // Modified: branches/alex-cm-branch/reactos/ntoskrnl/cm/cm_x.h URL: http://svn.reactos.org/svn/reactos/branches/alex-cm-branch/reactos/ntoskrnl… ============================================================================== --- branches/alex-cm-branch/reactos/ntoskrnl/cm/cm_x.h (original) +++ branches/alex-cm-branch/reactos/ntoskrnl/cm/cm_x.h Wed Aug 16 22:38:09 2006 @@ -19,6 +19,24 @@ GET_HASH_KEY(ConvKey) % CmpHashTableSize #define GET_HASH_ENTRY(Table, ConvKey) \ (*Table[GET_HASH_INDEX(ConvKey)]) + +// +// Returns whether or not the cell is cached +// +#define CMP_IS_CELL_CACHED(c) \ + (((c) & HCELL_CACHED) && ((c) != HCELL_NIL)) + +// +// Return data from a cached cell +// +#define CMP_GET_CACHED_CELL(c) \ + (ULONG_PTR)((c) & ~HCELL_CACHED) +#define CMP_GET_CACHED_DATA(c) \ + (&(((PCM_CACHED_VALUE_INDEX)(CMP_GET_CACHED_CELL(c)))->Data.CellData)) +#define CMP_GET_CACHED_INDEX(c) \ + (&(((PCM_CACHED_ENTRY)(CMP_GET_CACHED_CELL(c)))->CellIndex)) +#define CMP_GET_CACHED_VALUE(c) \ + (&(((PCM_CACHED_VALUE)(CMP_GET_CACHED_CELL(c)))->KeyValue)) // // Makes sure that the registry is locked Modified: branches/alex-cm-branch/reactos/ntoskrnl/cm/cmkcbncb.c URL: http://svn.reactos.org/svn/reactos/branches/alex-cm-branch/reactos/ntoskrnl… ============================================================================== --- branches/alex-cm-branch/reactos/ntoskrnl/cm/cmkcbncb.c (original) +++ branches/alex-cm-branch/reactos/ntoskrnl/cm/cmkcbncb.c Wed Aug 16 22:38:09 2006 @@ -29,6 +29,14 @@ ULONG CmpDelayCloseIntervalInSeconds = 5; KDPC CmpDelayCloseDpc; KTIMER CmpDelayCloseTimer; + +KGUARDED_MUTEX CmpDelayDerefKCBLock; +BOOLEAN CmpDelayDerefKCBWorkItemActive; +LIST_ENTRY CmpDelayDerefKCBListHead; +ULONG CmpDelayDerefKCBIntervalInSeconds = 5; +KDPC CmpDelayDerefKCBDpc; +KTIMER CmpDelayDerefKCBTimer; + BOOLEAN CmpHoldLazyFlush; /* FUNCTIONS *****************************************************************/ @@ -281,6 +289,56 @@ } } +VOID +NTAPI +CmpRemoveFromDelayedClose(IN PCM_KEY_CONTROL_BLOCK Kcb) +{ + PCM_DELAYED_CLOSE_ENTRY Entry; + ULONG NewRefCount, OldRefCount; + PAGED_CODE(); + + /* Sanity checks */ + ASSERT((CmpIsKcbLockedExclusive(Kcb) == TRUE) || + (CmpTestRegistryLockExclusive() == TRUE)); + if (Kcb->DelayedCloseIndex == CmpDelayedCloseSize) ASSERT(FALSE); + + /* Get the entry and lock the table */ + Entry = Kcb->DelayCloseEntry; + KeAcquireGuardedMutex(&CmpDelayedCloseTableLock); + + /* Remove the entry */ + RemoveEntryList(&Entry->DelayedLRUList); + + /* Release the lock */ + KeReleaseGuardedMutex(&CmpDelayedCloseTableLock); + + /* Free the entry */ + CmpFreeDelayItem(Entry); + + /* Reduce the number of elements */ + InterlockedDecrement(&CmpDelayedCloseElements); + + /* Sanity check */ + if (!Kcb->InDelayClose) ASSERT(FALSE); + + /* Get the old reference count */ + OldRefCount = Kcb->InDelayClose; + ASSERT(OldRefCount == 1); + + /* Set it to 0 */ + NewRefCount = InterlockedCompareExchange(&Kcb->InDelayClose, + 0, + OldRefCount); + if (NewRefCount != OldRefCount) ASSERT(FALSE); + + /* Remove the link to the entry */ + Kcb->DelayCloseEntry = NULL; + + /* Set new delay size and remove the delete flag */ + Kcb->DelayedCloseIndex = CmpDelayedCloseSize; + Kcb->Delete = FALSE; +} + BOOLEAN NTAPI CmpReferenceKcb(IN PCM_KEY_CONTROL_BLOCK Kcb) @@ -359,7 +417,7 @@ } // FIXME: THIS FUNCTION IS PARTIALLY FUCKED -PCM_DELAYED_CLOSE_ENTRY +PVOID NTAPI CmpAllocateDelayItem(VOID) { @@ -408,6 +466,131 @@ /* Release the lock */ KeReleaseGuardedMutex(&CmpDelayAllocBucketLock); return Entry; +} + +VOID +NTAPI +CmpDelayDerefKcb(IN PCM_KEY_CONTROL_BLOCK Kcb) +{ + USHORT OldRefCount, NewRefCount; + LARGE_INTEGER Timeout; + PCM_DELAY_DEREF_KCB_ITEM Entry; + PAGED_CODE(); + + /* Get the previous reference count */ + OldRefCount = Kcb->RefCount; + + /* Write the new one */ + NewRefCount = (USHORT)InterlockedCompareExchange((PLONG)&Kcb->RefCount, + OldRefCount - 1, + OldRefCount); + if (NewRefCount != OldRefCount) return; + + /* Allocate a delay item */ + Entry = CmpAllocateDelayItem(); + if (!Entry) return; + + /* Set the KCB */ + Entry->Kcb = Kcb; + + /* Acquire the delayed deref table lock */ + KeAcquireGuardedMutex(&CmpDelayDerefKCBLock); + + /* Insert the entry into the list */ + InsertHeadList(&CmpDelayDerefKCBListHead, &Entry->ListEntry); + + /* Check if we need to enable anything */ + if (CmpDelayDerefKCBWorkItemActive) + { + /* Yes, we have no work item, setup the interval */ + Timeout.QuadPart = CmpDelayDerefKCBIntervalInSeconds * -10000000; + KeSetTimer(&CmpDelayDerefKCBTimer, Timeout, &CmpDelayDerefKCBDpc); + } + + /* Release the table lock */ + KeReleaseGuardedMutex(&CmpDelayDerefKCBLock); +} + +VOID +NTAPI +CmpCleanUpKcbValueCache(IN PCM_KEY_CONTROL_BLOCK Kcb) +{ + PULONG_PTR CachedList; + ULONG i; + + /* Sanity check */ + ASSERT((CmpIsKcbLockedExclusive(Kcb) == TRUE) || + (CmpTestRegistryLockExclusive() == TRUE)); + + /* Check if the value list is cached */ + if (CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList)) + { + /* Get the cache list */ + CachedList = (PULONG_PTR)CMP_GET_CACHED_DATA(Kcb->ValueCache.ValueList); + for (i = 0; i < Kcb->ValueCache.Count; i++) + { + /* Check if this cell is cached */ + if (CMP_IS_CELL_CACHED(CachedList[i])) + { + /* Free it */ + ExFreePool((PVOID)CMP_GET_CACHED_CELL(CachedList[i])); + } + } + + /* Now free the list */ + ExFreePool((PVOID)CMP_GET_CACHED_CELL(Kcb->ValueCache.ValueList)); + Kcb->ValueCache.ValueList = HCELL_NIL; + } + else if (Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND) + { + /* This is a sym link, check if there's only one reference left */ + if ((Kcb->ValueCache.RealKcb->RefCount == 1) && + !(Kcb->ValueCache.RealKcb->Delete)) + { + /* Disable delay close for the KCB */ + Kcb->ValueCache.RealKcb->ExtFlags |= CM_KCB_NO_DELAY_CLOSE; + } + + /* Dereference the KCB */ + CmpDelayDerefKcb(Kcb->ValueCache.RealKcb); + Kcb->ExtFlags &= ~ CM_KCB_SYM_LINK_FOUND; + } +} + +VOID +NTAPI +CmpCleanUpKcbCacheWithLock(IN PCM_KEY_CONTROL_BLOCK Kcb, + IN BOOLEAN LockHeldExclusively) +{ + PCM_KEY_CONTROL_BLOCK Parent; + PAGED_CODE(); + + /* Sanity checks */ + ASSERT((CmpIsKcbLockedExclusive(Kcb) == TRUE) || + (CmpTestRegistryLockExclusive() == TRUE)); + ASSERT(Kcb->RefCount == 0); + + /* Cleanup the value cache */ + CmpCleanUpKcbValueCache(Kcb); + + /* Reference the NCB */ + CmpDereferenceNcbWithLock(Kcb->NameBlock); + + /* Check if we have an index hint block and free it */ + if (Kcb->ExtFlags & CM_KCB_SUBKEY_HINT) ExFreePool(Kcb->IndexHint); + + /* Check if we were already deleted */ + Parent = Kcb->ParentKcb; + if (!Kcb->Delete) CmpFreeKcb(Kcb); + + /* Check if we have a parent */ + if (Parent) + { + /* Dereference the parent */ + LockHeldExclusively ? CmpDereferenceKcbWithLock(Kcb, + LockHeldExclusively) : + CmpDelayDerefKcb(Kcb); + } } VOID

1 0

[janderwald] 23589: merge 23524 from trunk
by janderwald＠svn.reactos.org 16 Aug '06

16 Aug '06

Author: janderwald Date: Wed Aug 16 19:03:49 2006 New Revision: 23589 URL: http://svn.reactos.org/svn/reactos?rev=23589&view=rev Log: merge 23524 from trunk Modified: branches/ros-branch-0_3_0/reactos/tools/rbuild/backend/mingw/modulehandler.cpp Modified: branches/ros-branch-0_3_0/reactos/tools/rbuild/backend/mingw/modulehandler.cpp URL: http://svn.reactos.org/svn/reactos/branches/ros-branch-0_3_0/reactos/tools/… ============================================================================== --- branches/ros-branch-0_3_0/reactos/tools/rbuild/backend/mingw/modulehandler.cpp (original) +++ branches/ros-branch-0_3_0/reactos/tools/rbuild/backend/mingw/modulehandler.cpp Wed Aug 16 19:03:49 2006 @@ -1810,6 +1810,10 @@ globalCflags += " -pipe"; if ( !module.allowWarnings ) globalCflags += " -Werror"; + + // Always force disabling of sibling calls optimisation for GCC + // (TODO: Move to version-specific once this bug is fixed in GCC) + globalCflags += " -fno-optimize-sibling-calls"; fprintf ( fMakefile,

1 0

[ion] 23588: - Properly disable impersonation in PsDisableImpersonation if it was previously enabled, instead of not disabling it. (fix a wrong check). Thanks to Arty.
by ion＠svn.reactos.org 16 Aug '06

16 Aug '06

Author: ion Date: Wed Aug 16 07:17:21 2006 New Revision: 23588 URL: http://svn.reactos.org/svn/reactos?rev=23588&view=rev Log: - Properly disable impersonation in PsDisableImpersonation if it was previously enabled, instead of not disabling it. (fix a wrong check). Thanks to Arty. Modified: trunk/reactos/ntoskrnl/ps/security.c Modified: trunk/reactos/ntoskrnl/ps/security.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/ps/security.c?rev… ============================================================================== --- trunk/reactos/ntoskrnl/ps/security.c (original) +++ trunk/reactos/ntoskrnl/ps/security.c Wed Aug 16 07:17:21 2006 @@ -814,8 +814,8 @@ OldValue); } while (NewValue != OldValue); - /* Did someone disable behind our back? */ - if (!(NewValue & CT_ACTIVE_IMPERSONATION_INFO_BIT)) + /* Make sure nobody disabled it behind our back */ + if (NewValue & CT_ACTIVE_IMPERSONATION_INFO_BIT) { /* Copy the old state */ Impersonation = Thread->ImpersonationInfo;

1 0

[jimtabor] 23587: Only lower word is used with dwTypeData as bitmap handle.
by jimtabor＠svn.reactos.org 15 Aug '06

15 Aug '06

Author: jimtabor Date: Tue Aug 15 22:05:18 2006 New Revision: 23587 URL: http://svn.reactos.org/svn/reactos?rev=23587&view=rev Log: Only lower word is used with dwTypeData as bitmap handle. Modified: trunk/reactos/subsystems/win32/win32k/ntuser/menu.c Modified: trunk/reactos/subsystems/win32/win32k/ntuser/menu.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/win32k/nt… ============================================================================== --- trunk/reactos/subsystems/win32/win32k/ntuser/menu.c (original) +++ trunk/reactos/subsystems/win32/win32k/ntuser/menu.c Tue Aug 15 22:05:18 2006 @@ -788,12 +788,12 @@ } if(lpmii->fType & MFT_BITMAP) { -// if(lpmii->hbmpItem) + if(lpmii->hbmpItem) MenuItem->hbmpItem = lpmii->hbmpItem; -// else -// { /* Win 9x/Me stuff */ -// MenuItem->hbmpItem = (HBITMAP)lpmii->dwTypeData; -// } + else + { /* Win 9x/Me stuff */ + MenuItem->hbmpItem = (HBITMAP)((ULONG_PTR)(LOWORD(lpmii->dwTypeData))); + } } MenuItem->fType |= lpmii->fType; }

1 0

[ion] 23586: - Add CM_VIEW_OF_FILE, CM_DELAYED_CLOSE_ENTRY. - Fix CM_KEY_CONTROL_BLOCK definition. - Fix minor parameter definition in CmpInitializeHive - Add cmkcbncb.c with the current work for NCB/KCB management, as well as cache indexes and delayed allocation/free. Some of these routines will go into cmutil.c soon. File is incomplete (have not coded all the routines yet, just the general framework) and full of bugs.
by ion＠svn.reactos.org 15 Aug '06

15 Aug '06

Author: ion Date: Tue Aug 15 20:12:19 2006 New Revision: 23586 URL: http://svn.reactos.org/svn/reactos?rev=23586&view=rev Log: - Add CM_VIEW_OF_FILE, CM_DELAYED_CLOSE_ENTRY. - Fix CM_KEY_CONTROL_BLOCK definition. - Fix minor parameter definition in CmpInitializeHive - Add cmkcbncb.c with the current work for NCB/KCB management, as well as cache indexes and delayed allocation/free. Some of these routines will go into cmutil.c soon. File is incomplete (have not coded all the routines yet, just the general framework) and full of bugs. Added: branches/alex-cm-branch/reactos/ntoskrnl/cm/cmkcbncb.c Modified: branches/alex-cm-branch/reactos/ntoskrnl/cm/cm.h branches/alex-cm-branch/reactos/ntoskrnl/cm/cmhive.c Modified: branches/alex-cm-branch/reactos/ntoskrnl/cm/cm.h URL: http://svn.reactos.org/svn/reactos/branches/alex-cm-branch/reactos/ntoskrnl… ============================================================================== --- branches/alex-cm-branch/reactos/ntoskrnl/cm/cm.h (original) +++ branches/alex-cm-branch/reactos/ntoskrnl/cm/cm.h Tue Aug 15 20:12:19 2006 @@ -114,19 +114,37 @@ #define CMP_HASH_PRIME 1000000007 // +// CmpCreateKcb Flags +// +#define CMP_CREATE_FAKE_KCB 0x1 +#define CMP_LOCK_HASHES_FOR_KCB 0x2 + +// +// Number of items that can fit inside an Allocation Page +// +#define CM_KCBS_PER_PAGE \ + PAGE_SIZE / sizeof(CM_KEY_CONTROL_BLOCK) +#define CM_DELAYS_PER_PAGE \ + PAGE_SIZE / sizeof(CM_DELAYED_CLOSE_ENTRY) + +// // A Cell Index is just a ULONG // typedef ULONG HCELL_INDEX; // -// TEMPORARY HACK HACK -// -typedef struct _HHIVE -{ - ULONG I; - ULONG Love; - ULONG Filip; -} HHIVE, *PHHIVE; +// Mapped View of a Hive +// +typedef struct _CM_VIEW_OF_FILE +{ + LIST_ENTRY LRUViewList; + LIST_ENTRY PinViewList; + ULONG FileOffset; + ULONG Size; + PULONG ViewAddress; + PVOID Bcb; + ULONG UseCount; +} CM_VIEW_OF_FILE, *PCM_VIEW_OF_FILE; // // Key Hash @@ -270,7 +288,7 @@ typedef struct _CM_KEY_CONTROL_BLOCK { USHORT RefCount; - ULONG Flags; + USHORT Flags; ULONG ExtFlags:8; ULONG PrivateAlloc:1; ULONG Delete:1; @@ -294,8 +312,11 @@ PCM_INDEX_HINT_BLOCK IndexHint; ULONG HashKey; ULONG SubKeyCount; - LIST_ENTRY KeyBodyListHead; - LIST_ENTRY FreeListEntry; + union + { + LIST_ENTRY KeyBodyListHead; + LIST_ENTRY FreeListEntry; + }; PCM_KEY_BODY KeyBodyArray[4]; PVOID DelayCloseEntry; LARGE_INTEGER KcbLastWriteTime; @@ -337,6 +358,15 @@ ULONG Reserved; PVOID AllocPage; } CM_ALLOC_PAGE, *PCM_ALLOC_PAGE; + +// +// Delayed Close Entry +// +typedef struct _CM_DELAYED_CLOSE_ENTRY +{ + LIST_ENTRY DelayedLRUList; + PCM_KEY_CONTROL_BLOCK KeyControlBlock; +} CM_DELAYED_CLOSE_ENTRY, *PCM_DELAYED_CLOSE_ENTRY; // // Use Count Log and Entry @@ -501,6 +531,15 @@ ); // +// Registry Lock +// +BOOLEAN +NTAPI +CmpTestRegistryLockExclusive( + VOID +); + +// // Global variables accessible from all of Cm // Modified: branches/alex-cm-branch/reactos/ntoskrnl/cm/cmhive.c URL: http://svn.reactos.org/svn/reactos/branches/alex-cm-branch/reactos/ntoskrnl… ============================================================================== --- branches/alex-cm-branch/reactos/ntoskrnl/cm/cmhive.c (original) +++ branches/alex-cm-branch/reactos/ntoskrnl/cm/cmhive.c Tue Aug 15 20:12:19 2006 @@ -127,7 +127,7 @@ IN ULONG Operation, IN ULONG Flags, IN ULONG FileType, - IN PVOID Context, + IN PVOID HiveData, IN HANDLE Primary, IN HANDLE Alternate, IN HANDLE Log, @@ -146,7 +146,7 @@ * An external hive that is also internal. * An alternate hive or a log hive that's not a primary hive too. * A volatile hive that's linked to permanent storage. - * An in-memory initailization without context data. + * An in-memory initailization without hive data. * A log hive or alternative hive that's not linked to a correct file type. */ if ((Alternate && Log) || @@ -155,7 +155,7 @@ (Log && !Primary) || ((Flags & HIVE_VOLATILE) && (Alternate || Primary || External || Log)) || - ((Operation == HINIT_MEMORY) && (!Context)) || + ((Operation == HINIT_MEMORY) && (!HiveData)) || (Log && (FileType != HFILE_TYPE_LOG)) || (Alternate && (FileType != HFILE_TYPE_ALTERNATE))) { @@ -274,7 +274,7 @@ Operation, Flags, FileType, - Context, + (ULONG_PTR)HiveData, CmpAllocate, CmpFree, CmpFileRead, Added: branches/alex-cm-branch/reactos/ntoskrnl/cm/cmkcbncb.c URL: http://svn.reactos.org/svn/reactos/branches/alex-cm-branch/reactos/ntoskrnl… ============================================================================== --- branches/alex-cm-branch/reactos/ntoskrnl/cm/cmkcbncb.c (added) +++ branches/alex-cm-branch/reactos/ntoskrnl/cm/cmkcbncb.c Tue Aug 15 20:12:19 2006 @@ -1,0 +1,844 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL - See COPYING in the top level directory + * FILE: ntoskrnl/cm/cmkcbncb.c + * PURPOSE: Routines for handling KCBs, NCBs, as well as key hashes. + * PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org) + */ + +/* INCLUDES ******************************************************************/ + +#include <ntoskrnl.h> +#define NDEBUG +#include <debug.h> + +/* GLOBALS *******************************************************************/ + +ULONG CmpHashTableSize; +PCM_KEY_HASH_TABLE_ENTRY *CmpCacheTable; +PCM_NAME_HASH_TABLE_ENTRY *CmpNameCacheTable; +BOOLEAN CmpAllocInited; +KGUARDED_MUTEX CmpAllocBucketLock, CmpDelayAllocBucketLock; +LIST_ENTRY CmpFreeKCBListHead; +ULONG CmpDelayedCloseSize; +ULONG CmpDelayedCloseElements; +KGUARDED_MUTEX CmpDelayedCloseTableLock; +BOOLEAN CmpDelayCloseWorkItemActive; +LIST_ENTRY CmpDelayedLRUListHead; +LIST_ENTRY CmpFreeDelayItemsListHead; +ULONG CmpDelayCloseIntervalInSeconds = 5; +KDPC CmpDelayCloseDpc; +KTIMER CmpDelayCloseTimer; +BOOLEAN CmpHoldLazyFlush; + +/* FUNCTIONS *****************************************************************/ + +VOID +NTAPI +CmpRemoveKeyHash(IN PCM_KEY_HASH KeyHash) +{ + PCM_KEY_HASH *Prev; + PCM_KEY_HASH Current; + + /* Lookup all the keys in this index entry */ + Prev = &GET_HASH_ENTRY(CmpCacheTable, KeyHash->ConvKey).Entry; + while (TRUE) + { + /* Save the current one and make sure it's valid */ + Current = *Prev; + ASSERT(Current != NULL); + + /* Check if it matches */ + if (Current == KeyHash) + { + /* Then write the previous one */ + *Prev = Current->NextHash; + break; + } + + /* Otherwise, keep going */ + Prev = &Current->NextHash; + } +} + +PCM_KEY_CONTROL_BLOCK +NTAPI +CmpInsertKeyHash(IN PCM_KEY_HASH KeyHash, + IN BOOLEAN IsFake) +{ + ULONG i; + PCM_KEY_HASH Entry; + + /* Get the hash index */ + i = GET_HASH_INDEX(KeyHash->ConvKey); + + /* If this is a fake key, increase the key cell to use the parent data */ + if (IsFake) KeyHash->KeyCell++; + + /* Loop the hash table */ + Entry = CmpCacheTable[i]->Entry; + while (Entry) + { + /* Check if this matches */ + if ((KeyHash->ConvKey == Entry->ConvKey) && + (KeyHash->KeyCell == Entry->KeyCell) && + (KeyHash->KeyHive == Entry->KeyHive)) + { + /* Return it */ + return CONTAINING_RECORD(Entry, CM_KEY_CONTROL_BLOCK, KeyHash); + } + + /* Keep looping */ + Entry = Entry->NextHash; + } + + /* No entry found, add this one and return NULL since none existed */ + KeyHash->NextHash = CmpCacheTable[i]->Entry; + CmpCacheTable[i]->Entry = KeyHash; + return NULL; +} + +// FIXME: NEEDS COMPLETION +PCM_NAME_CONTROL_BLOCK +NTAPI +CmpGetNcb(IN PUNICODE_STRING NodeName) +{ + PCM_NAME_CONTROL_BLOCK Ncb; + ULONG ConvKey = 0; + PWCHAR p, pp; + ULONG i; + BOOLEAN IsCompressed = TRUE, Found; + PCM_NAME_HASH HashEntry; + ULONG Length; + + /* Loop the name */ + p = NodeName->Buffer; + for (i = 0; i < NodeName->Length; i += sizeof(WCHAR)) + { + /* Make sure it's not a slash */ + if (*p != OBJ_NAME_PATH_SEPARATOR) + { + /* Add it to the hash */ + ConvKey = 37 * ConvKey + RtlUpcaseUnicodeChar(*p); + } + + /* Next character */ + p++; + } + + /* Set assumed lengh and loop to check */ + Length = NodeName->Length / sizeof(WCHAR); + for (i = 0; i < (NodeName->Length / sizeof(WCHAR)); i++) + { + /* Check if this is a valid character */ + if (*NodeName->Buffer > (UCHAR)-1) + { + /* This is the actual size, and we know we're not compressed */ + Length = NodeName->Length; + IsCompressed = FALSE; + } + } + + /* Get the hash entry */ + HashEntry = GET_HASH_ENTRY(CmpNameCacheTable, ConvKey).Entry; + while (HashEntry) + { + /* Get the current NCB */ + Ncb = CONTAINING_RECORD(HashEntry, CM_NAME_CONTROL_BLOCK, NameHash); + + /* Check if the hash matches */ + if ((ConvKey = HashEntry->ConvKey) && (Length = Ncb->NameLength)) + { + /* Assume success */ + Found = TRUE; + + /* If the NCB is compressed, do a compressed name compare */ + if (Ncb->Compressed) + { + /* Compare names */ + if (CmpCompareCompressedName(NodeName, Ncb->Name, Length)) + { + /* We failed */ + Found = FALSE; + } + } + else + { + /* Do a manual compare */ + p = NodeName->Buffer; + pp = Ncb->Name; + for (i = 0; i < Ncb->NameLength; i += sizeof(WCHAR)) + { + /* Compare the character */ + if (RtlUpcaseUnicodeChar(*p) != RtlUpcaseUnicodeChar(*pp)) + { + /* Failed */ + Found = FALSE; + break; + } + + /* Next chars */ + *p++; + *pp++; + } + } + + /* Check if we found a name */ + if (Found) + { + + } + } + + /* Go to the next hash */ + HashEntry = HashEntry->NextHash; + } +} + +BOOLEAN +NTAPI +CmpTryToConvertKcbSharedToExclusive(IN PCM_KEY_CONTROL_BLOCK Kcb) +{ + /* Convert the lock */ + ASSERT(CmpIsKcbLockedExclusive(Kcb) == FALSE); + if (ExConvertPushLockSharedToExclusive(GET_HASH_ENTRY(CmpCacheTable, + Kcb->ConvKey).Lock)) + { + /* Set the lock owner */ + GET_HASH_ENTRY(CmpCacheTable, Kcb->ConvKey).Owner = KeGetCurrentThread(); + return TRUE; + } + + /* We failed */ + return FALSE; +} + +VOID +NTAPI +CmpRemoveKcb(IN PCM_KEY_CONTROL_BLOCK Kcb) +{ + /* Make sure that the registry and KCB are utterly locked */ + ASSERT((CmpIsKcbLockedExclusive(Kcb) == TRUE) || + (CmpTestRegistryLockExclusive() == TRUE)); + + /* Remove the key hash */ + CmpRemoveKeyHash(&Kcb->KeyHash); +} + +VOID +NTAPI +CmpFreeKcb(IN PCM_KEY_CONTROL_BLOCK Kcb) +{ + ULONG i; + PCM_ALLOC_PAGE AllocPage; + PAGED_CODE(); + + /* Sanity checks */ + ASSERT(IsListEmpty(&(Kcb->KeyBodyListHead)) == TRUE); + for (i = 0; i < 4; i++) ASSERT(Kcb->KeyBodyArray[i] == NULL); + + /* Check if it wasn't privately allocated */ + if (!Kcb->PrivateAlloc) + { + /* Free it from the pool */ + ExFreePool(Kcb); + } + else + { + /* Acquire the private allocation lock */ + KeAcquireGuardedMutex(&CmpAllocBucketLock); + + /* Sanity check on lock ownership */ + ASSERT((GET_HASH_ENTRY(CmpCacheTable, Kcb->ConvKey).Owner == + KeGetCurrentThread()) || + (CmpTestRegistryLockExclusive() == TRUE)); + + /* Remove us from the list */ + RemoveEntryList(&CmpFreeKCBListHead); + + /* Get the allocation page */ + AllocPage = (PCM_ALLOC_PAGE)((ULONG_PTR)Kcb & 0xFFFFF000); + + /* Sanity check */ + ASSERT(AllocPage->FreeCount != CM_KCBS_PER_PAGE); + + /* Increase free count */ + if (++AllocPage->FreeCount == CM_KCBS_PER_PAGE) + { + /* Loop all the entries */ + for (i = CM_KCBS_PER_PAGE; i; i--) + { + /* Remove the entry + RemoveEntryList(& */ + } + + /* Free the page */ + ExFreePool(AllocPage); + } + + /* Release the lock */ + KeReleaseGuardedMutex(&CmpAllocBucketLock); + } +} + +BOOLEAN +NTAPI +CmpReferenceKcb(IN PCM_KEY_CONTROL_BLOCK Kcb) +{ + /* Check if this is the KCB's first reference */ + if (Kcb->RefCount == 0) + { + /* Check if the KCB is locked in shared mode */ + if (!CmpIsKcbLockedExclusive(Kcb)) + { + /* Convert it to exclusive */ + if (!CmpTryToConvertKcbSharedToExclusive(Kcb)) + { + /* Set the delete flag */ + Kcb->Delete = TRUE; + + /* Increase the reference count while we release the lock */ + InterlockedIncrement((PLONG)&Kcb->RefCount); + + /* Sanity check, KCB should still be shared */ + ASSERT(CmpIsKcbLockedExclusive(Kcb) == FALSE); + + /* Release the current lock */ + CmpReleaseKcbLock(Kcb); + + /* Now acquire the lock in exclusive mode */ + CmpAcquireKcbLockExclusive(Kcb); + + /* Decrement the reference count; the lock is now held again */ + InterlockedDecrement((PLONG)&Kcb->RefCount); + + /* Sanity check */ + ASSERT((Kcb->DelayedCloseIndex == CmpDelayedCloseSize) || + (Kcb->DelayedCloseIndex == 0)); + + /* Remove the delete flag */ + Kcb->Delete = FALSE; + } + } + } + + /* Increase the reference count */ + if ((InterlockedIncrement((PLONG)&Kcb->RefCount) + 1) == 0) + { + /* We've overflown to 64K references, bail out */ + InterlockedDecrement((PLONG)&Kcb->RefCount); + return FALSE; + } + + /* Check if this was the last close index */ + if (!Kcb->DelayedCloseIndex) + { + /* Check if the KCB is locked in shared mode */ + if (!CmpIsKcbLockedExclusive(Kcb)) + { + /* Convert it to exclusive */ + if (!CmpTryToConvertKcbSharedToExclusive(Kcb)) + { + /* Sanity check, KCB should still be shared */ + ASSERT(CmpIsKcbLockedExclusive(Kcb) == FALSE); + + /* Release the current lock */ + CmpReleaseKcbLock(Kcb); + + /* Now acquire the lock in exclusive mode */ + CmpAcquireKcbLockExclusive(Kcb); + } + } + + /* If we're still the last entry, remove us */ + if (!Kcb->DelayedCloseIndex) CmpRemoveFromDelayedClose(Kcb); + } + + /* Return success */ + return TRUE; +} + +// FIXME: THIS FUNCTION IS PARTIALLY FUCKED +PCM_DELAYED_CLOSE_ENTRY +NTAPI +CmpAllocateDelayItem(VOID) +{ + PCM_DELAYED_CLOSE_ENTRY Entry; + PCM_ALLOC_PAGE AllocPage; + ULONG i; + PLIST_ENTRY NextEntry; + PAGED_CODE(); + + /* Lock the allocation buckets */ + KeAcquireGuardedMutex(&CmpDelayAllocBucketLock); + if (TRUE) + { + /* Allocate an allocation page */ + AllocPage = ExAllocatePoolWithTag(PagedPool, PAGE_SIZE, TAG_CM); + if (AllocPage) + { + /* Set default entries */ + AllocPage->FreeCount = CM_DELAYS_PER_PAGE; + + /* Loop each entry */ + for (i = 0; i < CM_DELAYS_PER_PAGE; i++) + { + /* Get this entry and link it */ + Entry = (PCM_DELAYED_CLOSE_ENTRY)(&AllocPage[i]); + InsertHeadList(&Entry->DelayedLRUList, + &CmpFreeDelayItemsListHead); + } + } + + /* Get the entry and the alloc page */ + Entry = CONTAINING_RECORD(NextEntry, + CM_DELAYED_CLOSE_ENTRY, + DelayedLRUList); + AllocPage = (PCM_ALLOC_PAGE)((ULONG_PTR)Entry & 0xFFFFF000); + + /* Decrease free entries */ + ASSERT(AllocPage->FreeCount != 0); + AllocPage->FreeCount--; + + /* Release the lock */ + KeReleaseGuardedMutex(&CmpDelayAllocBucketLock); + return Entry; + } + + /* Release the lock */ + KeReleaseGuardedMutex(&CmpDelayAllocBucketLock); + return Entry; +} + +VOID +NTAPI +CmpArmDelayedCloseTimer(VOID) +{ + LARGE_INTEGER Timeout; + PAGED_CODE(); + + /* Setup the interval */ + Timeout.QuadPart = CmpDelayCloseIntervalInSeconds * -10000000; + KeSetTimer(&CmpDelayCloseTimer, Timeout, &CmpDelayCloseDpc); +} + +VOID +NTAPI +CmpAddToDelayedClose(IN PCM_KEY_CONTROL_BLOCK Kcb, + IN BOOLEAN LockHeldExclusively) +{ + ULONG i; + ULONG OldRefCount, NewRefCount; + PCM_DELAYED_CLOSE_ENTRY Entry; + PAGED_CODE(); + + /* Sanity check */ + ASSERT((CmpIsKcbLockedExclusive(Kcb) == TRUE) || + (CmpTestRegistryLockExclusive() == TRUE)); + + /* Make sure it's valid */ + if (Kcb->DelayedCloseIndex != CmpDelayedCloseSize) ASSERT(FALSE); + + /* Sanity checks */ + ASSERT(Kcb->RefCount == 0); + ASSERT(IsListEmpty(&Kcb->KeyBodyListHead) == TRUE); + for (i = 0; i < 4; i++) ASSERT(Kcb->KeyBodyArray[i] == NULL); + + /* Allocate a delay item */ + Entry = CmpAllocateDelayItem(); + if (!Entry) + { + /* Cleanup immediately */ + CmpCleanUpKcbCacheWithLock(Kcb, LockHeldExclusively); + return; + } + + /* Sanity check */ + if (Kcb->InDelayClose) ASSERT(FALSE); + + /* Get the previous reference count */ + OldRefCount = Kcb->InDelayClose; + ASSERT(OldRefCount == 0); + + /* Write the new one */ + NewRefCount = InterlockedCompareExchange(&Kcb->InDelayClose, + 1, + OldRefCount); + if (NewRefCount != OldRefCount) ASSERT(FALSE); + + /* Remove the delete flag */ + Kcb->Delete = FALSE; + + /* Set up the close entry */ + Kcb->DelayCloseEntry = Entry; + Entry->KeyControlBlock = Kcb; + + /* Increase the number of elements */ + InterlockedIncrement(&CmpDelayedCloseElements); + + /* Acquire the delayed close table lock */ + KeAcquireGuardedMutex(&CmpDelayedCloseTableLock); + + /* Insert the entry into the list */ + InsertHeadList(&CmpDelayedLRUListHead, &Entry->DelayedLRUList); + + /* Check if we need to enable anything */ + if ((CmpDelayedCloseElements > CmpDelayedCloseSize) && + !(CmpDelayCloseWorkItemActive)) + { + /* Yes, we have too many elements to close, and no work item */ + CmpArmDelayedCloseTimer(); + } + + /* Release the table lock */ + KeReleaseGuardedMutex(&CmpDelayedCloseTableLock); +} + +PCM_KEY_CONTROL_BLOCK +NTAPI +CmpAllocateKcb(VOID) +{ + PLIST_ENTRY ListHead, NextEntry; + PCM_KEY_CONTROL_BLOCK CurrentKcb; + PCM_ALLOC_PAGE AllocPage; + ULONG i; + PAGED_CODE(); + + /* Check if private allocations are initialized */ + if (CmpAllocInited) + { + /* They are, acquire the bucket lock */ + KeAcquireGuardedMutex(&CmpAllocBucketLock); + + /* Loop the free KCB list */ + ListHead = &CmpFreeKCBListHead; + NextEntry = ListHead->Flink; + while (NextEntry != ListHead) + { + /* Remove the entry */ + RemoveEntryList(NextEntry); + + /* Get the KCB */ + CurrentKcb = CONTAINING_RECORD(NextEntry, + CM_KEY_CONTROL_BLOCK, + FreeListEntry); + + /* Get the allocation page */ + AllocPage = (PCM_ALLOC_PAGE)((ULONG_PTR)CurrentKcb & 0xFFFFF000); + + /* Decrease the free count */ + ASSERT(AllocPage->FreeCount != 0); + AllocPage->FreeCount--; + + /* Make sure this KCB is privately allocated */ + ASSERT(CurrentKcb->PrivateAlloc == 1); + + /* Release the allocation lock */ + KeReleaseGuardedMutex(&CmpAllocBucketLock); + + /* Return the KCB */ + return CurrentKcb; + } + + /* Allocate an allocation page */ + AllocPage = ExAllocatePoolWithTag(PagedPool, PAGE_SIZE, TAG_CM); + if (AllocPage) + { + /* Set default entries */ + AllocPage->FreeCount = CM_KCBS_PER_PAGE; + + /* Loop each entry */ + for (i = 0; i < CM_KCBS_PER_PAGE; i++) + { + /* Get this entry */ + CurrentKcb = (PCM_KEY_CONTROL_BLOCK)(AllocPage + 1); + + /* Set it up */ + CurrentKcb->PrivateAlloc = TRUE; + CurrentKcb->DelayCloseEntry = NULL; + InsertHeadList(&CurrentKcb->FreeListEntry, + &CmpFreeKCBListHead); + } + + /* Get the KCB */ + CurrentKcb = CONTAINING_RECORD(NextEntry, + CM_KEY_CONTROL_BLOCK, + FreeListEntry); + + /* Get the allocation page */ + AllocPage = (PCM_ALLOC_PAGE)((ULONG_PTR)CurrentKcb & 0xFFFFF000); + + /* Decrease the free count */ + ASSERT(AllocPage->FreeCount != 0); + AllocPage->FreeCount--; + + /* Make sure this KCB is privately allocated */ + ASSERT(CurrentKcb->PrivateAlloc == 1); + + /* Release the allocation lock */ + KeReleaseGuardedMutex(&CmpAllocBucketLock); + + /* Return the KCB */ + return CurrentKcb; + } + + /* Release the lock */ + KeReleaseGuardedMutex(&CmpAllocBucketLock); + } + + /* Allocate a KCB only */ + CurrentKcb = ExAllocatePoolWithTag(PagedPool, + sizeof(CM_KEY_CONTROL_BLOCK), + TAG_CM); + if (CurrentKcb) + { + /* Set it up */ + CurrentKcb->PrivateAlloc = 0; + CurrentKcb->DelayCloseEntry = NULL; + } + + /* Return it */ + return CurrentKcb; +} + +VOID +NTAPI +CmpDereferenceKcbWithLock(IN PCM_KEY_CONTROL_BLOCK Kcb, + IN BOOLEAN LockHeldExclusively) +{ + /* Sanity check */ + ASSERT((CmpIsKcbLockedExclusive(Kcb) == TRUE) || + (CmpTestRegistryLockExclusive() == TRUE)); + + /* Check if we should do a direct delete */ + if (((CmpHoldLazyFlush) && + !(Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND) && + !(Kcb->Flags & KEY_SYM_LINK)) || + (Kcb->ExtFlags & CM_KCB_NO_DELAY_CLOSE) || + (Kcb->PrivateAlloc)) + { + /* Clean up the KCB*/ + CmpCleanUpKcbCacheWithLock(Kcb, LockHeldExclusively); + } + else + { + /* Otherwise, use delayed close */ + CmpAddToDelayedClose(Kcb, LockHeldExclusively); + } +} + +VOID +NTAPI +CmpInitializeKcbKeyBodyList(IN PCM_KEY_CONTROL_BLOCK Kcb) +{ + /* Initialize the list */ + InitializeListHead(&Kcb->KeyBodyListHead); + + /* Clear the bodies */ + Kcb->KeyBodyArray[0] = + Kcb->KeyBodyArray[1] = + Kcb->KeyBodyArray[2] = + Kcb->KeyBodyArray[3] = NULL; +} + +PCM_KEY_CONTROL_BLOCK +NTAPI +CmpCreateKcb(IN PHHIVE Hive, + IN HCELL_INDEX Index, + IN PCM_KEY_NODE Node, + IN PCM_KEY_CONTROL_BLOCK Parent, + IN ULONG Flags, + IN PUNICODE_STRING KeyName) +{ + PCM_KEY_CONTROL_BLOCK Kcb, FoundKcb = NULL; + UNICODE_STRING NodeName; + ULONG ConvKey = 0, i; + BOOLEAN IsFake, HashLock; + PWCHAR p; + + /* Make sure we own this hive */ + if (((PCMHIVE)Hive)->CreatorOwner != KeGetCurrentThread()) return NULL; + + /* Check if this is a fake KCB */ + IsFake = (BOOLEAN)(Flags & CMP_CREATE_FAKE_KCB); + + /* If we have a parent, use its ConvKey */ + if (Parent) ConvKey = Parent->ConvKey; + + /* Make a copy of the name */ + NodeName = *KeyName; + + /* Remove leading slash */ + while ((NodeName.Length) && (*NodeName.Buffer == OBJ_NAME_PATH_SEPARATOR)) + { + /* Move the buffer by one */ + NodeName.Buffer++; + NodeName.Length -= sizeof(WCHAR); + } + + /* Make sure we didn't get just a slash or something */ + ASSERT(NodeName.Length > 0); + + /* Now setup the hash */ + p = NodeName.Buffer; + for (i = 0; i < NodeName.Length; i += sizeof(WCHAR)) + { + /* Make sure it's a valid character */ + if ((*p != OBJ_NAME_PATH_SEPARATOR) && (*p)) + { + /* Add this key to the hash */ + ConvKey = 37 * ConvKey + RtlUpcaseUnicodeChar(*p); + } + + /* Move on */ + p++; + } + + /* Allocate the KCB */ + Kcb = CmpAllocateKcb(); + if (!Kcb) return NULL; + + /* Initailize the key list */ + CmpInitializeKcbKeyBodyList(Kcb); + + /* Set it up */ + Kcb->Delete = FALSE; + Kcb->RefCount = 1; + Kcb->KeyHive = Hive; + Kcb->KeyCell = Index; + Kcb->ConvKey = ConvKey; + Kcb->DelayedCloseIndex = CmpDelayedCloseSize; + + /* Check if we have two hash entires */ + HashLock = (BOOLEAN)(Flags & CMP_LOCK_HASHES_FOR_KCB); + if (HashLock) + { + /* Not yet implemented */ + KeBugCheck(0); + } + + /* Check if we already have a KCB */ + FoundKcb = CmpInsertKeyHash(&Kcb->KeyHash, IsFake); + if (FoundKcb) + { + /* Sanity check */ + ASSERT(!FoundKcb->Delete); + + /* Free the one we allocated and reference this one */ + CmpFreeKcb(Kcb); + Kcb = FoundKcb; + if (!CmpReferenceKcb(Kcb)) + { + /* We got too many handles */ + ASSERT(Kcb->RefCount + 1 != 0); + Kcb = NULL; + } + else + { + /* Check if we're not creating a fake one, but it used to be fake */ + if ((Kcb->ExtFlags & CM_KCB_KEY_NON_EXIST) && !(IsFake)) + { + /* Set the hive and cell */ + Kcb->KeyHive = Hive; + Kcb->KeyCell = Index; + + /* This means that our current information is invalid */ + Kcb->ExtFlags = CM_KCB_INVALID_CACHED_INFO; + } + + /* Check if we didn't have any valid data */ + if (!(Kcb->ExtFlags & (CM_KCB_NO_SUBKEY | + CM_KCB_SUBKEY_ONE | + CM_KCB_SUBKEY_HINT))) + { + /* Calculate the index hint */ + Kcb->SubKeyCount = Node->SubKeyCounts[0] + + Node->SubKeyCounts[1]; + + /* Cached information is now valid */ + Kcb->ExtFlags &= ~CM_KCB_INVALID_CACHED_INFO; + } + + /* Setup the other data */ + Kcb->KcbLastWriteTime = Node->LastWriteTime; + Kcb->KcbMaxNameLen = (USHORT)Node->MaxNameLen; + Kcb->KcbMaxValueNameLen = (USHORT)Node->MaxValueNameLen; + Kcb->KcbMaxValueDataLen = Node->MaxValueDataLen; + } + } + else + { + /* No KCB, do we have a parent? */ + if (Parent) + { + /* Reference the parent */ + if (((Parent->TotalLevels + 1) < 512) && (CmpReferenceKcb(Parent))) + { + /* Link it */ + Kcb->ParentKcb = Parent; + Kcb->TotalLevels = Parent->TotalLevels + 1; + } + else + { + /* Remove the KCB and free it */ + CmpRemoveKcb(Kcb); + CmpFreeKcb(Kcb); + Kcb = NULL; + } + } + else + { + /* No parent, this is the root node */ + Kcb->ParentKcb = NULL; + Kcb->TotalLevels = 1; + } + + /* Check if we have a KCB */ + if (Kcb) + { + /* Get the NCB */ + Kcb->NameBlock = CmpGetNcb(&NodeName); + if (Kcb->NameBlock) + { + /* Fill it out */ + Kcb->ValueCache.Count = Node->ValueList.Count; + Kcb->ValueCache.ValueList = Node->ValueList.List; + Kcb->Flags = Node->Flags; + Kcb->ExtFlags = 0; + Kcb->DelayedCloseIndex = CmpDelayedCloseSize; + + /* Remember if this is a fake key */ + if (IsFake) Kcb->ExtFlags |= CM_KCB_KEY_NON_EXIST; + + /* Setup the other data */ + Kcb->SubKeyCount = Node->SubKeyCounts[0] + + Node->SubKeyCounts[1]; + Kcb->KcbLastWriteTime = Node->LastWriteTime; + Kcb->KcbMaxNameLen = (USHORT)Node->MaxNameLen; + Kcb->KcbMaxValueNameLen = (USHORT)Node->MaxValueNameLen; + Kcb->KcbMaxValueDataLen = (USHORT)Node->MaxValueDataLen; + } + else + { + /* Dereference the KCB */ + CmpDereferenceKcbWithLock(Parent, FALSE); + + /* Remove the KCB and free it */ + CmpRemoveKcb(Kcb); + CmpFreeKcb(Kcb); + Kcb = NULL; + } + } + } + + /* Check if we had locked the hashes */ + if (HashLock) + { + /* Not yet implemented: Unlock hashes */ + KeBugCheck(0); + } + + /* Return the KCB */ + return Kcb; +} +

1 0

[gedmurphy] 23585: [AUDIT] iprtprio unimplemented
by gedmurphy＠svn.reactos.org 14 Aug '06

14 Aug '06

Author: gedmurphy Date: Tue Aug 15 01:48:55 2006 New Revision: 23585 URL: http://svn.reactos.org/svn/reactos?rev=23585&view=rev Log: [AUDIT] iprtprio unimplemented Modified: trunk/reactos/dll/win32/iprtprio/iprtprio.c (props changed) trunk/reactos/dll/win32/iprtprio/iprtprio.def (props changed) trunk/reactos/dll/win32/iprtprio/iprtprio.rc (props changed) Propchange: trunk/reactos/dll/win32/iprtprio/iprtprio.c ------------------------------------------------------------------------------ --- svn:needs-lock (original) +++ svn:needs-lock (removed) @@ -1,1 +1,0 @@ -* Propchange: trunk/reactos/dll/win32/iprtprio/iprtprio.def ------------------------------------------------------------------------------ --- svn:needs-lock (original) +++ svn:needs-lock (removed) @@ -1,1 +1,0 @@ -* Propchange: trunk/reactos/dll/win32/iprtprio/iprtprio.rc ------------------------------------------------------------------------------ --- svn:needs-lock (original) +++ svn:needs-lock (removed) @@ -1,1 +1,0 @@ -*

1 0

[gedmurphy] 23584: Add debug print
by gedmurphy＠svn.reactos.org 14 Aug '06

14 Aug '06

Author: gedmurphy Date: Tue Aug 15 01:35:51 2006 New Revision: 23584 URL: http://svn.reactos.org/svn/reactos?rev=23584&view=rev Log: Add debug print Modified: trunk/reactos/base/system/services/rpcserver.c Modified: trunk/reactos/base/system/services/rpcserver.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/system/services/rpcse… ============================================================================== --- trunk/reactos/base/system/services/rpcserver.c (original) +++ trunk/reactos/base/system/services/rpcserver.c Tue Aug 15 01:35:51 2006 @@ -1792,7 +1792,10 @@ /* Start the service */ Status = ScmStartService(lpService); if (!NT_SUCCESS(Status)) + { + DPRINT("ScmStartService failed!\n"); return RtlNtStatusToDosError(Status); + } return dwError; }

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