wslist.c File Reference

#include "mi.h"

Go to the source code of this file.

Defines
#define	MM_SYSTEM_CACHE_THRESHOLD   ((1024*1024) / PAGE_SIZE)
#define	MM_RETRY_COUNT   2
Functions
ULONG	MiDoReplacement (IN PMMSUPPORT WsInfo, IN BOOLEAN MustReplace)
VOID	MiReplaceWorkingSetEntryUsingFaultInfo (IN PMMSUPPORT WsInfo, IN BOOLEAN MustReplace)
VOID	MiCheckWsleHash (IN PMMWSL WorkingSetList)
VOID	MiEliminateWorkingSetEntry (IN ULONG WorkingSetIndex, IN PMMPTE PointerPte, IN PMMPFN Pfn, IN PMMWSLE Wsle)
ULONG	MiAddWorkingSetPage (IN PMMSUPPORT WsInfo)
VOID	MiRemoveWorkingSetPages (IN PMMWSL WorkingSetList, IN PMMSUPPORT WsInfo)
VOID	MiCheckNullIndex (IN PMMWSL WorkingSetList)
VOID	MiDumpWsleInCacheBlock (IN PMMPTE CachePte)
ULONG	MiDumpPteInCacheBlock (IN PMMPTE PointerPte)
WSLE_NUMBER	MiLocateAndReserveWsle (IN PMMSUPPORT WsInfo)
LOGICAL	MmEnforceWorkingSetLimit (IN PMMSUPPORT WsInfo, IN LOGICAL Enable)
ULONG	MiRemovePageFromWorkingSet (IN PMMPTE PointerPte, IN PMMPFN Pfn1, IN PMMSUPPORT WsInfo)
VOID	MiReleaseWsle (IN WSLE_NUMBER WorkingSetIndex, IN PMMSUPPORT WsInfo)
VOID	MiUpdateWsle (IN OUT PWSLE_NUMBER DesiredIndex, IN PVOID VirtualAddress, PMMWSL WorkingSetList, IN PMMPFN Pfn)
ULONG	MiFreeWsle (IN WSLE_NUMBER WorkingSetIndex, IN PMMSUPPORT WsInfo, IN PMMPTE PointerPte)
VOID	MiInitializeWorkingSetList (IN PEPROCESS CurrentProcess)
VOID	MiInitializeSessionWsSupport (VOID)
NTSTATUS	MiSessionInitializeWorkingSetList (VOID)
LOGICAL	MmAssignProcessToJob (IN PEPROCESS Process)
NTSTATUS	MmAdjustWorkingSetSize (IN SIZE_T WorkingSetMinimumInBytes, IN SIZE_T WorkingSetMaximumInBytes, IN ULONG SystemCache)
LOGICAL	MiAddWsleHash (IN PMMSUPPORT WsInfo, IN PMMPTE PointerPte)
VOID	MiGrowWsleHash (IN PMMSUPPORT WsInfo)
ULONG	MiTrimWorkingSet (ULONG Reduction, IN PMMSUPPORT WsInfo, IN ULONG ForcedReductionOrTrimAge)
NTSTATUS	MiEmptyWorkingSet (IN PMMSUPPORT WsInfo, IN LOGICAL WaitOk)
Variables
ULONG	MmMaximumWorkingSetSize
ULONG	MmFaultsTakenToGoAboveMaxWs = 100
ULONG	MmFaultsTakenToGoAboveMinWs = 16
ULONG	MmSystemCodePage
ULONG	MmSystemCachePage
ULONG	MmPagedPoolPage
ULONG	MmSystemDriverPage
ULONG	MmTransitionSharedPages
ULONG	MmTransitionSharedPagesPeak
LOGICAL	MiTrimRemovalPagesOnly

---

Define Documentation

#define MM_RETRY_COUNT   2

Definition at line 45 of file wslist.c. Referenced by MmAdjustWorkingSetSize().

#define MM_SYSTEM_CACHE_THRESHOLD   ((1024*1024) / PAGE_SIZE)

Definition at line 29 of file wslist.c. Referenced by MiDoReplacement().

---

Function Documentation

ULONG MiAddWorkingSetPage (  IN PMMSUPPORT  WsInfo  )

Definition at line 2824 of file wslist.c. References ASSERT, _MM_SESSION_SPACE::CommittedPages, CONSISTENCY_LOCK_PFN, CONSISTENCY_UNLOCK_PFN, FALSE, _MMWSL::FirstDynamic, _MMWSL::FirstFree, _MMWSL::HashTable, _MMWSL::HashTableStart, _MMWSL::LastEntry, _MMWSL::LastInitializedWsle, LOCK_EXPANSION_IF_ALPHA, LOCK_PFN, MI_GET_PAGE_COLOR_FROM_PTE, MI_MAKE_VALID_PTE, MI_PFN_ELEMENT, MI_SET_PTE_DIRTY, MI_SET_PTE_IN_WORKING_SET, MI_WRITE_VALID_PTE, MiChargeCommitmentCantExpand(), MiGetPteAddress, MiGetVirtualAddressMappedByPte, MiInitializePfn(), MiRemoveZeroPage(), MiSwapWslEntries(), MiUpdateWsle(), MM_BUMP_COUNTER, MM_BUMP_SESS_COUNTER, MM_DBG_COMMIT_SESSION_ADDITIONAL_WS_PAGES, MM_DBG_SESSION_WS_PAGE_ALLOC_GROWTH, MM_DEMAND_ZERO_WRITE_PTE, MM_FREE_WSLE_SHIFT, MM_GROW_WSLE_HASH, MM_READWRITE, MM_SYSTEM_WS_LOCK_ASSERT, MM_TRACK_COMMIT, MmAvailablePages, MmPagesAboveWsMinimum, MmResidentAvailablePages, MmSessionSpace, MmSystemCacheWs, _MM_SESSION_SPACE::NonPagablePages, NULL, PAGE_SIZE, PsGetCurrentThread, _MMWSL::Quota, TRUE, _MMPTE::u, _MMPFN::u1, _MMWSLE::u1, UNLOCK_EXPANSION_IF_ALPHA, UNLOCK_PFN, _MMWSL::Wsle, WSLE_NULL_INDEX, and WSLE_NUMBER. Referenced by MiLocateAndReserveWsle(), and MmAdjustWorkingSetSize(). : This function grows the working set list above working set maximum during working set adjustment. At most one page can be added at a time. Arguments: None. Return Value: Returns FALSE if no working set page could be added. Environment: Kernel mode, APCs disabled, working set mutexes held. --*/ { ULONG SwapEntry; ULONG CurrentEntry; PMMWSLE WslEntry; ULONG i; PMMPTE PointerPte; PMMPTE PointerPde; PMMPTE Va; MMPTE TempPte; WSLE_NUMBER NumberOfEntriesMapped; PFN_NUMBER WorkingSetPage; WSLE_NUMBER WorkingSetIndex; PMMWSL WorkingSetList; PMMWSLE Wsle; PMMPFN Pfn1; KIRQL OldIrql; LOGICAL PageTablePageAllocated; WorkingSetList = WsInfo->VmWorkingSetList; Wsle = WorkingSetList->Wsle; #if DBG if (WsInfo == &MmSystemCacheWs) { MM_SYSTEM_WS_LOCK_ASSERT(); } #endif //DBG // // The maximum size of the working set is being increased, check // to ensure the proper number of pages are mapped to cover // the complete working set list. // PointerPte = MiGetPteAddress (&Wsle[WorkingSetList->LastInitializedWsle]); ASSERT (PointerPte->u.Hard.Valid == 1); PointerPte += 1; Va = (PMMPTE)MiGetVirtualAddressMappedByPte (PointerPte); if ((PVOID)Va >= WorkingSetList->HashTableStart) { // // Adding this entry would overrun the hash table. The caller // must replace instead. // WorkingSetList->Quota = WorkingSetList->LastInitializedWsle; return FALSE; } PageTablePageAllocated = FALSE; #if defined (_WIN64) PointerPde = MiGetPteAddress (PointerPte); if (PointerPde->u.Hard.Valid == 0) { ASSERT (WsInfo->u.Flags.SessionSpace == 0); // // Map in a new working set page. // LOCK_PFN (OldIrql); if (MmAvailablePages < 21) { // // No pages are available, set the quota to the last // initialized WSLE and return. // WorkingSetList->Quota = WorkingSetList->LastInitializedWsle; UNLOCK_PFN (OldIrql); return FALSE; } PageTablePageAllocated = TRUE; WorkingSetPage = MiRemoveZeroPage (MI_GET_PAGE_COLOR_FROM_PTE (PointerPde)); PointerPde->u.Long = MM_DEMAND_ZERO_WRITE_PTE; MiInitializePfn (WorkingSetPage, PointerPde, 1); UNLOCK_PFN (OldIrql); MI_MAKE_VALID_PTE (TempPte, WorkingSetPage, MM_READWRITE, PointerPde); MI_SET_PTE_DIRTY (TempPte); MI_WRITE_VALID_PTE (PointerPde, TempPte); // // Further down in this routine (once an actual working set page // has been allocated) the quota will be increased by 1 to reflect // the working set size entry for the new page table page. // The page table page will be put in a working set entry which will // be locked into the working set. // } #endif ASSERT (PointerPte->u.Hard.Valid == 0); NumberOfEntriesMapped = (WSLE_NUMBER)(((PMMWSLE)((PCHAR)Va + PAGE_SIZE)) - Wsle); // // Map in a new working set page. // LOCK_PFN (OldIrql); if ((PageTablePageAllocated == FALSE) && (MmAvailablePages < 20)) { // // No pages are available, set the quota to the last // initialized WSLE and return. // WorkingSetList->Quota = WorkingSetList->LastInitializedWsle; UNLOCK_PFN (OldIrql); return FALSE; } WorkingSetPage = MiRemoveZeroPage (MI_GET_PAGE_COLOR_FROM_PTE (PointerPte)); PointerPte->u.Long = MM_DEMAND_ZERO_WRITE_PTE; MiInitializePfn (WorkingSetPage, PointerPte, 1); UNLOCK_PFN (OldIrql); MI_MAKE_VALID_PTE (TempPte, WorkingSetPage, MM_READWRITE, PointerPte); MI_SET_PTE_DIRTY (TempPte); MI_WRITE_VALID_PTE (PointerPte, TempPte); if (WsInfo->u.Flags.SessionSpace == 1) { MM_BUMP_SESS_COUNTER (MM_DBG_SESSION_WS_PAGE_ALLOC_GROWTH, 1); MmSessionSpace->NonPagablePages += 1; MmSessionSpace->CommittedPages += 1; MiChargeCommitmentCantExpand (1, TRUE); LOCK_PFN (OldIrql); MM_BUMP_COUNTER (48, 1); MmResidentAvailablePages -= 1; UNLOCK_PFN (OldIrql); MM_TRACK_COMMIT (MM_DBG_COMMIT_SESSION_ADDITIONAL_WS_PAGES, 1); } CurrentEntry = WorkingSetList->LastInitializedWsle + 1; ASSERT (NumberOfEntriesMapped > CurrentEntry); WslEntry = &Wsle[CurrentEntry - 1]; for (i = CurrentEntry; i < NumberOfEntriesMapped; i += 1) { // // Build the free list, note that the first working // set entries (CurrentEntry) are not on the free list. // These entries are reserved for the pages which // map the working set and the page which contains the PDE. // WslEntry += 1; WslEntry->u1.Long = (i + 1) << MM_FREE_WSLE_SHIFT; } WslEntry->u1.Long = WorkingSetList->FirstFree << MM_FREE_WSLE_SHIFT; ASSERT (CurrentEntry >= WorkingSetList->FirstDynamic); WorkingSetList->FirstFree = CurrentEntry; WorkingSetList->LastInitializedWsle = (NumberOfEntriesMapped - 1); ASSERT ((WorkingSetList->FirstFree <= WorkingSetList->LastInitializedWsle) || (WorkingSetList->FirstFree == WSLE_NULL_INDEX)); // // As we are growing the working set, make sure the quota is // above the working set size by adding 1 to the quota. // WorkingSetList->Quota += 1; Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); CONSISTENCY_LOCK_PFN (OldIrql); Pfn1->u1.Event = (PVOID)PsGetCurrentThread(); CONSISTENCY_UNLOCK_PFN (OldIrql); // // Get a working set entry. // WsInfo->WorkingSetSize += 1; ASSERT (WorkingSetList->FirstFree != WSLE_NULL_INDEX); ASSERT (WorkingSetList->FirstFree >= WorkingSetList->FirstDynamic); WorkingSetIndex = WorkingSetList->FirstFree; WorkingSetList->FirstFree = (WSLE_NUMBER)(Wsle[WorkingSetIndex].u1.Long >> MM_FREE_WSLE_SHIFT); ASSERT ((WorkingSetList->FirstFree <= WorkingSetList->LastInitializedWsle) || (WorkingSetList->FirstFree == WSLE_NULL_INDEX)); if (WsInfo->WorkingSetSize > WsInfo->MinimumWorkingSetSize) { MmPagesAboveWsMinimum += 1; } if (WorkingSetIndex > WorkingSetList->LastEntry) { WorkingSetList->LastEntry = WorkingSetIndex; } MiUpdateWsle (&WorkingSetIndex, Va, WorkingSetList, Pfn1); MI_SET_PTE_IN_WORKING_SET (PointerPte, WorkingSetIndex); // // Lock any created page table pages into the working set. // if (WorkingSetIndex >= WorkingSetList->FirstDynamic) { SwapEntry = WorkingSetList->FirstDynamic; if (WorkingSetIndex != WorkingSetList->FirstDynamic) { // // Swap this entry with the one at first dynamic. // MiSwapWslEntries (WorkingSetIndex, SwapEntry, WsInfo); } WorkingSetList->FirstDynamic += 1; Wsle[SwapEntry].u1.e1.LockedInWs = 1; ASSERT (Wsle[SwapEntry].u1.e1.Valid == 1); } #if defined (_WIN64) if (PageTablePageAllocated == TRUE) { // // As we are growing the working set, make sure the quota is // above the working set size by adding 1 to the quota. // WorkingSetList->Quota += 1; Pfn1 = MI_PFN_ELEMENT (PointerPde->u.Hard.PageFrameNumber); CONSISTENCY_LOCK_PFN (OldIrql); Pfn1->u1.Event = (PVOID)PsGetCurrentThread(); CONSISTENCY_UNLOCK_PFN (OldIrql); // // Get a working set entry. // WsInfo->WorkingSetSize += 1; ASSERT (WorkingSetList->FirstFree != WSLE_NULL_INDEX); ASSERT (WorkingSetList->FirstFree >= WorkingSetList->FirstDynamic); WorkingSetIndex = WorkingSetList->FirstFree; WorkingSetList->FirstFree = (WSLE_NUMBER)(Wsle[WorkingSetIndex].u1.Long >> MM_FREE_WSLE_SHIFT); ASSERT ((WorkingSetList->FirstFree <= WorkingSetList->LastInitializedWsle) || (WorkingSetList->FirstFree == WSLE_NULL_INDEX)); if (WsInfo->WorkingSetSize > WsInfo->MinimumWorkingSetSize) { MmPagesAboveWsMinimum += 1; } if (WorkingSetIndex > WorkingSetList->LastEntry) { WorkingSetList->LastEntry = WorkingSetIndex; } MiUpdateWsle (&WorkingSetIndex, PointerPte, WorkingSetList, Pfn1); MI_SET_PTE_IN_WORKING_SET (PointerPde, WorkingSetIndex); // // Lock the created page table page into the working set. // if (WorkingSetIndex >= WorkingSetList->FirstDynamic) { SwapEntry = WorkingSetList->FirstDynamic; if (WorkingSetIndex != WorkingSetList->FirstDynamic) { // // Swap this entry with the one at first dynamic. // MiSwapWslEntries (WorkingSetIndex, SwapEntry, WsInfo); } WorkingSetList->FirstDynamic += 1; Wsle[SwapEntry].u1.e1.LockedInWs = 1; ASSERT (Wsle[SwapEntry].u1.e1.Valid == 1); } } #endif ASSERT ((MiGetPteAddress(&Wsle[WorkingSetList->LastInitializedWsle]))->u.Hard.Valid == 1); if ((WorkingSetList->HashTable == NULL) && (MmAvailablePages > 20)) { // // Add a hash table to support shared pages in the working set to // eliminate costly lookups. // LOCK_EXPANSION_IF_ALPHA (OldIrql); ASSERT (WsInfo->AllowWorkingSetAdjustment != FALSE); WsInfo->AllowWorkingSetAdjustment = MM_GROW_WSLE_HASH; UNLOCK_EXPANSION_IF_ALPHA (OldIrql); } ASSERT (WsInfo->WorkingSetSize <= WorkingSetList->Quota); return TRUE; }

LOGICAL MiAddWsleHash (  IN PMMSUPPORT  WsInfo, IN PMMPTE  PointerPte )

Definition at line 3179 of file wslist.c. References ASSERT, _MM_SESSION_SPACE::CommittedPages, CONSISTENCY_LOCK_PFN, CONSISTENCY_UNLOCK_PFN, _MMWSLE::e1, FALSE, _MMWSL::FirstDynamic, LOCK_PFN, MI_GET_PAGE_COLOR_FROM_PTE, MI_MAKE_VALID_PTE, MI_PFN_ELEMENT, MI_SET_PTE_DIRTY, MI_SET_PTE_IN_WORKING_SET, MI_WRITE_VALID_PTE, MiChargeCommitmentCantExpand(), MiGetVirtualAddressMappedByPte, MiInitializePfn(), MiLocateAndReserveWsle(), MiRemoveZeroPage(), MiSwapWslEntries(), MiUpdateWsle(), MM_BUMP_SESS_COUNTER, MM_DBG_COMMIT_SESSION_ADDITIONAL_WS_HASHPAGES, MM_DBG_SESSION_WS_HASHPAGE_ALLOC, MM_DEMAND_ZERO_WRITE_PTE, MM_READWRITE, MM_TRACK_COMMIT, MmAvailablePages, MmSessionSpace, _MM_SESSION_SPACE::NonPagablePages, PsGetCurrentThread, TRUE, _MMWSLE::u1, _MMPFN::u1, UNLOCK_PFN, _MMWSLENTRY::Valid, _MMWSL::Wsle, and WSLE_NUMBER. Referenced by MiGrowWsleHash(). : This function adds a page directory, page table or actual mapping page for hash table creation (or expansion) for the current process. Arguments: WsInfo - Supplies a pointer to the working set info block for the process (or system cache). PointerPte - Supplies a pointer to the PTE to be filled. Return Value: None. Environment: Kernel mode, APCs disabled, working set lock held. --*/ { KIRQL OldIrql; PMMPFN Pfn1; ULONG SwapEntry; MMPTE TempPte; PVOID Va; PMMWSLE Wsle; PFN_NUMBER WorkingSetPage; WSLE_NUMBER WorkingSetIndex; PMMWSL WorkingSetList; WorkingSetList = WsInfo->VmWorkingSetList; Wsle = WorkingSetList->Wsle; ASSERT (PointerPte->u.Hard.Valid == 0); LOCK_PFN (OldIrql); if (MmAvailablePages < 10) { UNLOCK_PFN (OldIrql); return FALSE; } WorkingSetPage = MiRemoveZeroPage ( MI_GET_PAGE_COLOR_FROM_PTE (PointerPte)); PointerPte->u.Long = MM_DEMAND_ZERO_WRITE_PTE; MiInitializePfn (WorkingSetPage, PointerPte, 1); MI_MAKE_VALID_PTE (TempPte, WorkingSetPage, MM_READWRITE, PointerPte ); MI_SET_PTE_DIRTY (TempPte); MI_WRITE_VALID_PTE (PointerPte, TempPte); UNLOCK_PFN (OldIrql); // // As we are growing the working set, we know that quota // is above the current working set size. Just take the // next free WSLE from the list and use it. // Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); CONSISTENCY_LOCK_PFN (OldIrql); Pfn1->u1.Event = (PVOID)PsGetCurrentThread(); CONSISTENCY_UNLOCK_PFN (OldIrql); Va = (PMMPTE)MiGetVirtualAddressMappedByPte (PointerPte); WorkingSetIndex = MiLocateAndReserveWsle (WsInfo); MiUpdateWsle (&WorkingSetIndex, Va, WorkingSetList, Pfn1); MI_SET_PTE_IN_WORKING_SET (PointerPte, WorkingSetIndex); // // Lock any created page table pages into the working set. // if (WorkingSetIndex >= WorkingSetList->FirstDynamic) { SwapEntry = WorkingSetList->FirstDynamic; if (WorkingSetIndex != WorkingSetList->FirstDynamic) { // // Swap this entry with the one at first dynamic. // MiSwapWslEntries (WorkingSetIndex, SwapEntry, WsInfo); } WorkingSetList->FirstDynamic += 1; Wsle[SwapEntry].u1.e1.LockedInWs = 1; ASSERT (Wsle[SwapEntry].u1.e1.Valid == 1); } if (WsInfo->u.Flags.SessionSpace == 1) { MM_BUMP_SESS_COUNTER (MM_DBG_SESSION_WS_HASHPAGE_ALLOC, 1); MmSessionSpace->NonPagablePages += 1; MmSessionSpace->CommittedPages += 1; MiChargeCommitmentCantExpand (1, TRUE); MM_TRACK_COMMIT (MM_DBG_COMMIT_SESSION_ADDITIONAL_WS_HASHPAGES, 1); } return TRUE; }

VOID MiCheckNullIndex (  IN PMMWSL  WorkingSetList  )

Referenced by MiRemoveWorkingSetPages().

VOID MiCheckWsleHash (  IN PMMWSL  WorkingSetList  )

ULONG MiDoReplacement (  IN PMMSUPPORT  WsInfo, IN BOOLEAN  MustReplace )

Definition at line 254 of file wslist.c. References ASSERT, FALSE, KeQuerySystemTime(), LOCK_EXPANSION_IF_ALPHA, MEMORY_PRIORITY_FOREGROUND, MI_BACKGROUND_CLAIM_AVAILABLE_SHIFT, MI_FOREGROUND_CLAIM_AVAILABLE_SHIFT, MI_PASS0_TRIM_AGE, MI_PASS4_TRIM_AGE, MI_SESSION_MAXIMUM_WORKING_SET, MI_WS_GROWING_TOO_FAST, MiReplaceWorkingSetEntryUsingFaultInfo(), MiTrimWorkingSet(), MM_FORCE_TRIM, MM_MAXIMUM_WORKING_SET, MM_NO_WS_EXPANSION, MM_SYSTEM_CACHE_THRESHOLD, MM_SYSTEM_WS_LOCK_ASSERT, MmAvailablePages, MmFaultsTakenToGoAboveMinWs, MmMoreThanEnoughFreePages, MmSystemCacheWs, MmWorkingSetSizeExpansion, MmWorkingSetSizeIncrement, MmWsAdjustThreshold, MmWsExpandThreshold, NULL, _MMWSL::Quota, TRUE, and UNLOCK_EXPANSION_IF_ALPHA. Referenced by MiLocateAndReserveWsle(). : This function determines whether the working set should be grown or if a page should be replaced. Replacement is done here if deemed necessary. Arguments: WsInfo - Supplies the working set information structure to replace within. MustReplace - Supplies TRUE if replacement must succeed. Return Value: Quota increment if growth is necessary. Environment: Kernel mode, APCs disabled, working set lock. PFN lock NOT held. --*/ { PMMWSL WorkingSetList; ULONG CurrentSize; LARGE_INTEGER CurrentTime; #if defined(_ALPHA_) && !defined(_AXP64_) KIRQL OldIrql; #endif ULONG QuotaIncrement; PFN_NUMBER AvailablePageThreshold; #ifdef _MI_USE_CLAIMS_ PEPROCESS ProcessToTrim; ULONG Dummy1; ULONG Dummy2; ULONG Trim; ULONG TrimAge; #endif WorkingSetList = WsInfo->VmWorkingSetList; if (WsInfo == &MmSystemCacheWs) { MM_SYSTEM_WS_LOCK_ASSERT(); AvailablePageThreshold = MM_SYSTEM_CACHE_THRESHOLD; } // // Determine the number of pages that need to be available to // grow the working set and how much the quota should be // boosted if the working set grows over it. // // If below the Minimum use the defaults. // recheck: AvailablePageThreshold = 0; QuotaIncrement = 1; if (WsInfo->WorkingSetSize >= WsInfo->MinimumWorkingSetSize) { if (WsInfo->AllowWorkingSetAdjustment == MM_FORCE_TRIM) { // // The working set manager cannot attach to this process // to trim it. Force a trim now and update the working // set manager's fields properly to indicate a trim occurred. // #ifdef _MI_USE_CLAIMS_ Trim = WsInfo->Claim >> ((WsInfo->MemoryPriority == MEMORY_PRIORITY_FOREGROUND) ? MI_FOREGROUND_CLAIM_AVAILABLE_SHIFT : MI_BACKGROUND_CLAIM_AVAILABLE_SHIFT); if (WsInfo == &MmSystemCacheWs) { ProcessToTrim = NULL; } else if (WsInfo->u.Flags.SessionSpace == 0) { ProcessToTrim = CONTAINING_RECORD(WsInfo, EPROCESS, Vm); } else { ProcessToTrim = NULL; // Hydra session. } if (MmAvailablePages < 100) { if (WsInfo->WorkingSetSize > WsInfo->MinimumWorkingSetSize) { Trim = (WsInfo->WorkingSetSize - WsInfo->MinimumWorkingSetSize) >> 2; } TrimAge = MI_PASS4_TRIM_AGE; } else { TrimAge = MI_PASS0_TRIM_AGE; } MiTrimWorkingSet (Trim, WsInfo, TrimAge); MiAgeAndEstimateAvailableInWorkingSet (WsInfo, TRUE, &Dummy1, &Dummy2 ); #else MiTrimWorkingSet(20, WsInfo, FALSE); #endif KeQuerySystemTime (&CurrentTime); WsInfo->LastTrimTime = CurrentTime; WsInfo->LastTrimFaultCount = WsInfo->PageFaultCount; #if defined(_ALPHA_) && !defined(_AXP64_) LOCK_EXPANSION_IF_ALPHA (OldIrql); #endif WsInfo->AllowWorkingSetAdjustment = TRUE; #if defined(_ALPHA_) && !defined(_AXP64_) UNLOCK_EXPANSION_IF_ALPHA (OldIrql); #endif // // Set the quota to the current size. // WorkingSetList->Quota = WsInfo->WorkingSetSize; if (WorkingSetList->Quota < WsInfo->MinimumWorkingSetSize) { WorkingSetList->Quota = WsInfo->MinimumWorkingSetSize; } goto recheck; } CurrentSize = WsInfo->WorkingSetSize; ASSERT (CurrentSize <= (WorkingSetList->LastInitializedWsle + 1)); if ((WsInfo->u.Flags.WorkingSetHard) && (CurrentSize >= WsInfo->MaximumWorkingSetSize)) { // // This is an enforced working set maximum triggering a replace. // #ifdef _MI_USE_CLAIMS_ MiReplaceWorkingSetEntryUsingClaim (WsInfo, MustReplace); #else MiReplaceWorkingSetEntryUsingFaultInfo (WsInfo, MustReplace); #endif return 0; } #ifdef _MI_USE_CLAIMS_ // // If using claims, don't grow if // - we're over the max // - there aren't any pages to take // - or if we are growing too much in this // time interval and there isn't much // memory available // if (CurrentSize > MM_MAXIMUM_WORKING_SET || MmAvailablePages == 0 || MustReplace == TRUE) { // // Can't grow this one. // AvailablePageThreshold = 0xffffffff; MiReplacing = TRUE; } #if defined (_X86PAE_) else if ((WsInfo->u.Flags.SessionSpace == 1) && (CurrentSize > MI_SESSION_MAXIMUM_WORKING_SET)) { // // Can't grow this one. // AvailablePageThreshold = 0xffffffff; MiReplacing = TRUE; } #endif else if (MmAvailablePages < 10000 && MI_WS_GROWING_TOO_FAST(WsInfo)) { // // Can't grow this one either. // AvailablePageThreshold = 0xffffffff; MiReplacing = TRUE; } #else // // Not using claims, base the growth on how much faulting // the process is doing. // if (MustReplace == TRUE) { AvailablePageThreshold = 0xffffffff; } if (CurrentSize < WorkingSetList->Quota) { // // Working set is below quota, allow it to grow with few pages // available. // AvailablePageThreshold = 10; QuotaIncrement = 1; } else if (CurrentSize < WsInfo->MaximumWorkingSetSize) { // // Working set is between min and max. Allow it to grow if enough // faults have been taken since last adjustment. // if ((WsInfo->PageFaultCount - WsInfo->LastTrimFaultCount) < MmFaultsTakenToGoAboveMinWs) { AvailablePageThreshold = MmMoreThanEnoughFreePages + 200; if (WsInfo->MemoryPriority == MEMORY_PRIORITY_FOREGROUND) { AvailablePageThreshold -= 250; } } else { AvailablePageThreshold = MmWsAdjustThreshold; } QuotaIncrement = (ULONG)MmWorkingSetSizeIncrement; } else { // // Working set is above max. // if ((WsInfo->PageFaultCount - WsInfo->LastTrimFaultCount) < (CurrentSize >> 3)) { AvailablePageThreshold = MmMoreThanEnoughFreePages + 200; if (WsInfo->MemoryPriority == MEMORY_PRIORITY_FOREGROUND) { AvailablePageThreshold -= 250; } } else { AvailablePageThreshold += MmWsExpandThreshold; } QuotaIncrement = (ULONG)MmWorkingSetSizeExpansion; if (CurrentSize > MM_MAXIMUM_WORKING_SET) { AvailablePageThreshold = 0xffffffff; QuotaIncrement = 1; } #if defined (_X86PAE_) else if ((WsInfo->u.Flags.SessionSpace == 1) && (CurrentSize > MI_SESSION_MAXIMUM_WORKING_SET)) { AvailablePageThreshold = 0xffffffff; QuotaIncrement = 1; } #endif } #endif } // // If there isn't enough memory to allow growth, find a good page // to remove and remove it. // if (WsInfo->AddressSpaceBeingDeleted == 0 && AvailablePageThreshold != 0) { if ((MmAvailablePages <= AvailablePageThreshold) || (WsInfo->WorkingSetExpansionLinks.Flink == MM_NO_WS_EXPANSION)) { #ifdef _MI_USE_CLAIMS_ MiReplaceWorkingSetEntryUsingClaim (WsInfo, MustReplace); #else MiReplaceWorkingSetEntryUsingFaultInfo (WsInfo, MustReplace); #endif } else { WsInfo->GrowthSinceLastEstimate += 1; } } else { WsInfo->GrowthSinceLastEstimate += 1; } return QuotaIncrement; }

ULONG MiDumpPteInCacheBlock (  IN PMMPTE  PointerPte  )

VOID MiDumpWsleInCacheBlock (  IN PMMPTE  CachePte  )

Referenced by MiFreeWsle().

VOID MiEliminateWorkingSetEntry (  IN ULONG  WorkingSetIndex, IN PMMPTE  PointerPte, IN PMMPFN  Pfn, IN PMMWSLE  Wsle )

Definition at line 3974 of file wslist.c. References ASSERT, FALSE, KeBugCheckEx(), KeFlushSingleTb(), MI_CAPTURE_DIRTY_BIT_TO_PFN, MI_FLUSH_SINGLE_SESSION_TB, MI_GET_PAGE_FRAME_FROM_PTE, MI_GET_PROTECTION_FROM_WSLE, MI_IS_PTE_DIRTY, MI_IS_SESSION_IMAGE_ADDRESS, MI_MAKE_VALID_PTE_TRANSITION, MI_MAKING_VALID_PTE_INVALID, MI_PTE_LOOKUP_NEEDED, MI_ZERO_WSINDEX, MiActiveWriteWatch, MiCaptureWriteWatchDirtyBit(), MiCheckPdeForPagedPool(), MiDecrementShareAndValidCount, MiDecrementShareCount(), MiGetPteAddress, MiGetVirtualAddressMappedByPte, MiProtoAddressForPte, MM_PFN_LOCK_ASSERT, MmSystemCacheWsle, MmWsle, NT_SUCCESS, PsGetCurrentProcess, TRUE, _MMSUPPORT::u, _MMPTE::u, and _EPROCESS::Vm. Referenced by MiFreeWsle(), and MiRemovePageFromWorkingSet(). 03983 : 03984 03985 This routine removes the specified working set list entry 03986 from the working set, flushes the TB for the page, decrements 03987 the share count for the physical page, and, if necessary turns 03988 the PTE into a transition PTE. 03989 03990 Arguments: 03991 03992 WorkingSetIndex - Supplies the working set index to remove. 03993 03994 PointerPte - Supplies a pointer to the PTE corresponding to the virtual 03995 address in the working set. 03996 03997 Pfn - Supplies a pointer to the PFN element corresponding to the PTE. 03998 03999 Wsle - Supplies a pointer to the first working set list entry for this 04000 working set. 04001 04002 Return Value: 04003 04004 None. 04005 04006 Environment: 04007 04008 Kernel mode, Working set lock and PFN lock held, APCs disabled. 04009 04010 --*/ 04011 04012 { 04013 PMMPTE ContainingPageTablePage; 04014 MMPTE TempPte; 04015 MMPTE PreviousPte; 04016 PFN_NUMBER PageFrameIndex; 04017 PEPROCESS Process; 04018 PVOID VirtualAddress; 04019 04020 // 04021 // Remove the page from the working set. 04022 // 04023 04024 MM_PFN_LOCK_ASSERT (); 04025 04026 TempPte = *PointerPte; 04027 PageFrameIndex = MI_GET_PAGE_FRAME_FROM_PTE (&TempPte); 04028 04029 #ifdef _X86_ 04030 #if DBG 04031 #if !defined(NT_UP) 04032 if (TempPte.u.Hard.Writable == 1) { 04033 ASSERT (TempPte.u.Hard.Dirty == 1); 04034 } 04035 ASSERT (TempPte.u.Hard.Accessed == 1); 04036 #endif //NTUP 04037 #endif //DBG 04038 #endif //X86 04039 04040 MI_MAKING_VALID_PTE_INVALID (FALSE); 04041 04042 if (Pfn->u3.e1.PrototypePte) { 04043 04044 // 04045 // This is a prototype PTE. The PFN database does not contain 04046 // the contents of this PTE it contains the contents of the 04047 // prototype PTE. This PTE must be reconstructed to contain 04048 // a pointer to the prototype PTE. 04049 // 04050 // The working set list entry contains information about 04051 // how to reconstruct the PTE. 04052 // 04053 04054 if (Wsle[WorkingSetIndex].u1.e1.SameProtectAsProto == 0) { 04055 04056 // 04057 // The protection for the prototype PTE is in the 04058 // WSLE. 04059 // 04060 04061 ASSERT (Wsle[WorkingSetIndex].u1.e1.Protection != 0); 04062 04063 if (!MI_IS_SESSION_IMAGE_ADDRESS (MiGetVirtualAddressMappedByPte(PointerPte))) { 04064 TempPte.u.Long = 0; 04065 TempPte.u.Soft.Protection = 04066 MI_GET_PROTECTION_FROM_WSLE (&Wsle[WorkingSetIndex]); 04067 TempPte.u.Soft.PageFileHigh = MI_PTE_LOOKUP_NEEDED; 04068 } 04069 else { 04070 04071 // 04072 // The session PTE protection must be carefully preserved. 04073 // 04074 04075 TempPte.u.Long = MiProtoAddressForPte (Pfn->PteAddress); 04076 } 04077 } else { 04078 04079 // 04080 // The protection is in the prototype PTE. 04081 // 04082 04083 TempPte.u.Long = MiProtoAddressForPte (Pfn->PteAddress); 04084 04085 if (MI_IS_SESSION_IMAGE_ADDRESS (MiGetVirtualAddressMappedByPte(PointerPte))) { 04086 04087 // 04088 // The session PTE protection must be carefully preserved. 04089 // 04090 04091 TempPte.u.Proto.ReadOnly = 1; 04092 } 04093 } 04094 04095 TempPte.u.Proto.Prototype = 1; 04096 04097 // 04098 // Decrement the share count of the containing page table 04099 // page as the PTE for the removed page is no longer valid 04100 // or in transition 04101 // 04102 04103 ContainingPageTablePage = MiGetPteAddress (PointerPte); 04104 #if defined (_WIN64) 04105 ASSERT (ContainingPageTablePage->u.Hard.Valid == 1); 04106 #else 04107 if (ContainingPageTablePage->u.Hard.Valid == 0) { 04108 if (!NT_SUCCESS(MiCheckPdeForPagedPool (PointerPte))) { 04109 KeBugCheckEx (MEMORY_MANAGEMENT, 04110 0x61940, 04111 (ULONG_PTR)PointerPte, 04112 (ULONG_PTR)ContainingPageTablePage->u.Long, 04113 (ULONG_PTR)MiGetVirtualAddressMappedByPte(PointerPte)); 04114 } 04115 } 04116 #endif 04117 MiDecrementShareAndValidCount (MI_GET_PAGE_FRAME_FROM_PTE (ContainingPageTablePage)); 04118 04119 } else { 04120 04121 // 04122 // This is a private page, make it transition. 04123 // 04124 04125 // 04126 // Assert that the share count is 1 for all user mode pages. 04127 // 04128 04129 ASSERT ((Pfn->u2.ShareCount == 1) || 04130 (Wsle[WorkingSetIndex].u1.VirtualAddress > 04131 (PVOID)MM_HIGHEST_USER_ADDRESS)); 04132 04133 // 04134 // Set the working set index to zero. This allows page table 04135 // pages to be brought back in with the proper WSINDEX. 04136 // 04137 04138 ASSERT (Pfn->u1.WsIndex != 0); 04139 MI_ZERO_WSINDEX (Pfn); 04140 MI_MAKE_VALID_PTE_TRANSITION (TempPte, 04141 Pfn->OriginalPte.u.Soft.Protection); 04142 } 04143 04144 if (Wsle == MmWsle) { 04145 PreviousPte.u.Flush = KeFlushSingleTb ( 04146 Wsle[WorkingSetIndex].u1.VirtualAddress, 04147 TRUE, 04148 FALSE, 04149 (PHARDWARE_PTE)PointerPte, 04150 TempPte.u.Flush); 04151 } 04152 else if (Wsle == MmSystemCacheWsle) { 04153 04154 // 04155 // Must be the system cache. 04156 // 04157 04158 PreviousPte.u.Flush = KeFlushSingleTb ( 04159 Wsle[WorkingSetIndex].u1.VirtualAddress, 04160 TRUE, 04161 TRUE, 04162 (PHARDWARE_PTE)PointerPte, 04163 TempPte.u.Flush); 04164 } 04165 else { 04166 04167 // 04168 // Must be a session space. 04169 // 04170 04171 MI_FLUSH_SINGLE_SESSION_TB (Wsle[WorkingSetIndex].u1.VirtualAddress, 04172 TRUE, 04173 FALSE, 04174 (PHARDWARE_PTE)PointerPte, 04175 TempPte.u.Flush, 04176 PreviousPte); 04177 } 04178 04179 ASSERT (PreviousPte.u.Hard.Valid == 1); 04180 04181 // 04182 // A page is being removed from the working set, on certain 04183 // hardware the dirty bit should be ORed into the modify bit in 04184 // the PFN element. 04185 // 04186 04187 MI_CAPTURE_DIRTY_BIT_TO_PFN (&PreviousPte, Pfn); 04188 04189 // 04190 // If the PTE indicates the page has been modified (this is different 04191 // from the PFN indicating this), then ripple it back to the write watch 04192 // bitmap now since we are still in the correct process context. 04193 // 04194 04195 if (MiActiveWriteWatch != 0) { 04196 if ((Pfn->u3.e1.PrototypePte == 0) && 04197 (MI_IS_PTE_DIRTY(PreviousPte))) { 04198 04199 Process = PsGetCurrentProcess(); 04200 04201 if (Process->Vm.u.Flags.WriteWatch == 1) { 04202 04203 // 04204 // This process has (or had) write watch VADs. Search now 04205 // for a write watch region encapsulating the PTE being 04206 // invalidated. 04207 // 04208 04209 VirtualAddress = MiGetVirtualAddressMappedByPte (PointerPte); 04210 MiCaptureWriteWatchDirtyBit (Process, VirtualAddress); 04211 } 04212 } 04213 } 04214 04215 // 04216 // Flush the translation buffer and decrement the number of valid 04217 // PTEs within the containing page table page. Note that for a 04218 // private page, the page table page is still needed because the 04219 // page is in transition. 04220 // 04221 04222 MiDecrementShareCount (PageFrameIndex); 04223 04224 return; 04225 }

NTSTATUS MiEmptyWorkingSet (  IN PMMSUPPORT  WsInfo, IN LOGICAL  WaitOk )

Definition at line 4726 of file wslist.c. References _EPROCESS::AddressSpaceDeleted, APC_LEVEL, ASSERT, Count, ExTryToAcquireResourceExclusiveLite(), FALSE, _MMWSL::FirstDynamic, _MMWSL::FirstFree, KeDelayExecutionThread(), KeLowerIrql(), KeRaiseIrql(), KernelMode, _MMWSL::LastEntry, _MMWSL::LastInitializedWsle, LOCK_SESSION_SPACE_WS, LOCK_SYSTEM_WS, LOCK_WS, MI_GET_PAGE_FRAME_FROM_PTE, MI_PFN_ELEMENT, MiFreeWsle(), MiGetPteAddress, MiHydra, MiRemoveWorkingSetPages(), MiTrimRemovalPagesOnly, MM_FREE_WSLE_SHIFT, MM_SET_SESSION_RESOURCE_OWNER, MmShortTime, MmSystemCacheWs, MmSystemLockOwner, MmSystemWsLock, _MMWSL::NextSlot, NTSTATUS(), PERFINFO_GET_PAGE_INFO, PERFINFO_LOG_WS_REMOVAL, PERFINFO_PAGE_INFO_DECL, PsGetCurrentProcess, PsGetCurrentThread, _MMPFN::PteFrame, _MMWSL::Quota, Status, TRUE, _MMSUPPORT::u, _MMWSLE::u1, _MMPFN::u3, UNLOCK_SESSION_SPACE_WS, UNLOCK_SYSTEM_WS, UNLOCK_WS, _MMWSLE::VirtualAddress, _EPROCESS::WorkingSetLock, _MMWSL::Wsle, WSLE_NULL_INDEX, and _MM_SESSION_SPACE::WsLock. Referenced by MiEmptyAllWorkingSetsWorker(), MmAdjustWorkingSetSize(), and MmTrimAllSystemPagableMemory(). 04733 : 04734 04735 This routine frees all pages from the working set. 04736 04737 Arguments: 04738 04739 WsInfo - Supplies the working set information entry to trim. 04740 04741 WaitOk - Supplies TRUE if the caller can wait, FALSE if not. 04742 04743 Return Value: 04744 04745 Status of operation. 04746 04747 Environment: 04748 04749 Kernel mode. No locks. For session operations, the caller is responsible 04750 for attaching into the proper session. 04751 04752 --*/ 04753 04754 { 04755 PEPROCESS Process; 04756 KIRQL OldIrql; 04757 PMMPTE PointerPte; 04758 ULONG Entry; 04759 ULONG Count; 04760 ULONG LastFreed; 04761 PMMWSL WorkingSetList; 04762 PMMWSLE Wsle; 04763 PMMPFN Pfn1; 04764 PFN_NUMBER PageFrameIndex; 04765 ULONG Last; 04766 NTSTATUS Status; 04767 PMM_SESSION_SPACE SessionSpace; 04768 04769 if (WsInfo == &MmSystemCacheWs) { 04770 if (WaitOk == TRUE) { 04771 LOCK_SYSTEM_WS (OldIrql); 04772 } 04773 else { 04774 KeRaiseIrql (APC_LEVEL, &OldIrql); 04775 if (!ExTryToAcquireResourceExclusiveLite (&MmSystemWsLock)) { 04776 04777 // 04778 // System working set lock was not granted, don't trim 04779 // the system cache. 04780 // 04781 04782 KeLowerIrql (OldIrql); 04783 return STATUS_SUCCESS; 04784 } 04785 04786 MmSystemLockOwner = PsGetCurrentThread(); 04787 } 04788 } 04789 else if (WsInfo->u.Flags.SessionSpace == 0) { 04790 Process = PsGetCurrentProcess (); 04791 if (WaitOk == TRUE) { 04792 LOCK_WS (Process); 04793 } 04794 else { 04795 Count = 0; 04796 do { 04797 if (ExTryToAcquireFastMutex(&Process->WorkingSetLock) != FALSE) { 04798 break; 04799 } 04800 KeDelayExecutionThread (KernelMode, FALSE, &MmShortTime); 04801 Count += 1; 04802 if (Count == 5) { 04803 04804 // 04805 // Could not get the lock, don't trim this process. 04806 // 04807 04808 return STATUS_SUCCESS; 04809 } 04810 } while (TRUE); 04811 } 04812 if (Process->AddressSpaceDeleted != 0) { 04813 Status = STATUS_PROCESS_IS_TERMINATING; 04814 goto Deleted; 04815 } 04816 } 04817 else { 04818 if (WaitOk == TRUE) { 04819 LOCK_SESSION_SPACE_WS (OldIrql); 04820 } 04821 else { 04822 ASSERT (MiHydra == TRUE); 04823 SessionSpace = CONTAINING_RECORD(WsInfo, 04824 MM_SESSION_SPACE, 04825 Vm); 04826 04827 KeRaiseIrql (APC_LEVEL, &OldIrql); 04828 04829 if (!ExTryToAcquireResourceExclusiveLite (&SessionSpace->WsLock)) { 04830 04831 // 04832 // This session space's working set lock was not 04833 // granted, don't trim it. 04834 // 04835 04836 KeLowerIrql (OldIrql); 04837 return STATUS_SUCCESS; 04838 } 04839 04840 MM_SET_SESSION_RESOURCE_OWNER(); 04841 } 04842 } 04843 04844 WorkingSetList = WsInfo->VmWorkingSetList; 04845 Wsle = WorkingSetList->Wsle; 04846 04847 // 04848 // Attempt to remove the pages starting at the bottom. 04849 // 04850 04851 LastFreed = WorkingSetList->LastEntry; 04852 for (Entry = WorkingSetList->FirstDynamic; Entry <= LastFreed; Entry += 1) { 04853 04854 if (Wsle[Entry].u1.e1.Valid != 0) { 04855 PERFINFO_PAGE_INFO_DECL(); 04856 04857 PointerPte = MiGetPteAddress (Wsle[Entry].u1.VirtualAddress); 04858 04859 PERFINFO_GET_PAGE_INFO(PointerPte); 04860 04861 if (MiTrimRemovalPagesOnly == TRUE) { 04862 PageFrameIndex = MI_GET_PAGE_FRAME_FROM_PTE (PointerPte); 04863 Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); 04864 if (Pfn1->u3.e1.RemovalRequested == 0) { 04865 Pfn1 = MI_PFN_ELEMENT (Pfn1->PteFrame); 04866 if (Pfn1->u3.e1.RemovalRequested == 0) { 04867 #if defined (_WIN64) 04868 Pfn1 = MI_PFN_ELEMENT (Pfn1->PteFrame); 04869 if (Pfn1->u3.e1.RemovalRequested == 0) { 04870 continue; 04871 } 04872 #else 04873 continue; 04874 #endif 04875 } 04876 } 04877 } 04878 04879 if (MiFreeWsle (Entry, WsInfo, PointerPte)) { 04880 PERFINFO_LOG_WS_REMOVAL(PERFINFO_LOG_TYPE_OUTWS_EMPTYQ, WsInfo); 04881 } 04882 } 04883 } 04884 04885 if (WsInfo != &MmSystemCacheWs && WsInfo->u.Flags.SessionSpace == 0) { 04886 MiRemoveWorkingSetPages (WorkingSetList,WsInfo); 04887 } 04888 WorkingSetList->Quota = WsInfo->WorkingSetSize; 04889 WorkingSetList->NextSlot = WorkingSetList->FirstDynamic; 04890 04891 // 04892 // Attempt to remove the pages from the front to the end. 04893 // 04894 04895 // 04896 // Reorder the free list. 04897 // 04898 04899 Last = 0; 04900 Entry = WorkingSetList->FirstDynamic; 04901 LastFreed = WorkingSetList->LastInitializedWsle; 04902 while (Entry <= LastFreed) { 04903 if (Wsle[Entry].u1.e1.Valid == 0) { 04904 if (Last == 0) { 04905 WorkingSetList->FirstFree = Entry; 04906 } else { 04907 Wsle[Last].u1.Long = Entry << MM_FREE_WSLE_SHIFT; 04908 } 04909 Last = Entry; 04910 } 04911 Entry += 1; 04912 } 04913 if (Last != 0) { 04914 Wsle[Last].u1.Long = WSLE_NULL_INDEX << MM_FREE_WSLE_SHIFT; // End of list. 04915 } 04916 Status = STATUS_SUCCESS; 04917 Deleted: 04918 04919 if (WsInfo == &MmSystemCacheWs) { 04920 UNLOCK_SYSTEM_WS (OldIrql); 04921 } 04922 else if (WsInfo->u.Flags.SessionSpace == 0) { 04923 UNLOCK_WS (Process); 04924 } 04925 else { 04926 UNLOCK_SESSION_SPACE_WS (OldIrql); 04927 } 04928 04929 return Status; 04930 }

ULONG MiFreeWsle (  IN WSLE_NUMBER  WorkingSetIndex, IN PMMSUPPORT  WsInfo, IN PMMPTE  PointerPte )

Definition at line 1326 of file wslist.c. References ASSERT, _MMWSLE::e1, FALSE, _MMWSL::FirstDynamic, _MMWSL::FirstFree, _MMWSL::LastInitializedWsle, LOCK_PFN, MI_IS_SESSION_ADDRESS, MI_PFN_ELEMENT, MiDumpWsleInCacheBlock(), MiEliminateWorkingSetEntry(), MiRemoveWsle(), MM_FREE_WSLE_SHIFT, MM_SYSTEM_WS_LOCK_ASSERT, MmPagesAboveWsMinimum, MmSystemCacheWs, PDE_TOP, TRUE, _MMWSLE::u1, _MMPFN::u2, _MMPFN::u3, UNLOCK_PFN, _MMWSLENTRY::Valid, _MMWSLE::VirtualAddress, _MMWSL::Wsle, and WSLE_NULL_INDEX. Referenced by MiEmptyWorkingSet(), MiInsertWsle(), MiReplaceWorkingSetEntryUsingFaultInfo(), MiTrimWorkingSet(), MmAdjustWorkingSetSize(), and NtUnlockVirtualMemory(). 01334 : 01335 01336 This routine frees the specified WSLE and decrements the share 01337 count for the corresponding page, putting the PTE into a transition 01338 state if the share count goes to 0. 01339 01340 Arguments: 01341 01342 WorkingSetIndex - Supplies the index of the working set entry to free. 01343 01344 WsInfo - Supplies a pointer to the working set structure (process or 01345 system cache). 01346 01347 PointerPte - Supplies a pointer to the PTE for the working set entry. 01348 01349 Return Value: 01350 01351 Returns TRUE if the WSLE was removed, FALSE if it was not removed. 01352 Pages with valid PTEs are not removed (i.e. page table pages 01353 that contain valid or transition PTEs). 01354 01355 Environment: 01356 01357 Kernel mode, APCs disabled, working set lock. PFN lock NOT held. 01358 01359 --*/ 01360 01361 { 01362 PMMPFN Pfn1; 01363 PMMWSL WorkingSetList; 01364 PMMWSLE Wsle; 01365 KIRQL OldIrql; 01366 01367 WorkingSetList = WsInfo->VmWorkingSetList; 01368 Wsle = WorkingSetList->Wsle; 01369 01370 #if DBG 01371 if (WsInfo == &MmSystemCacheWs) { 01372 MM_SYSTEM_WS_LOCK_ASSERT(); 01373 } 01374 #endif //DBG 01375 01376 ASSERT (Wsle[WorkingSetIndex].u1.e1.Valid == 1); 01377 01378 // 01379 // Check to see if the located entry is eligible for removal. 01380 // 01381 01382 ASSERT (PointerPte->u.Hard.Valid == 1); 01383 01384 ASSERT (WorkingSetIndex >= WorkingSetList->FirstDynamic); 01385 01386 // 01387 // Check to see if this is a page table with valid PTEs. 01388 // 01389 // Note, don't clear the access bit for page table pages 01390 // with valid PTEs as this could cause an access trap fault which 01391 // would not be handled (it is only handled for PTEs not PDEs). 01392 // 01393 01394 Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); 01395 01396 LOCK_PFN (OldIrql); 01397 01398 // 01399 // If the PTE is a page table page with non-zero share count or 01400 // within the system cache with its reference count greater 01401 // than 0, don't remove it. 01402 // 01403 01404 if (WsInfo == &MmSystemCacheWs) { 01405 if (Pfn1->u3.e2.ReferenceCount > 1) { 01406 UNLOCK_PFN (OldIrql); 01407 return FALSE; 01408 } 01409 } else { 01410 if ((Pfn1->u2.ShareCount > 1) && 01411 (Pfn1->u3.e1.PrototypePte == 0)) { 01412 01413 #if DBG 01414 if (WsInfo->u.Flags.SessionSpace == 1) { 01415 ASSERT (MI_IS_SESSION_ADDRESS (Wsle[WorkingSetIndex].u1.VirtualAddress)); 01416 } 01417 else { 01418 ASSERT ((Wsle[WorkingSetIndex].u1.VirtualAddress >= (PVOID)PTE_BASE) && 01419 (Wsle[WorkingSetIndex].u1.VirtualAddress<= (PVOID)PDE_TOP)); 01420 } 01421 #endif 01422 01423 // 01424 // Don't remove page table pages from the working set until 01425 // all transition pages have exited. 01426 // 01427 01428 UNLOCK_PFN (OldIrql); 01429 return FALSE; 01430 } 01431 } 01432 01433 // 01434 // Found a candidate, remove the page from the working set. 01435 // 01436 01437 MiEliminateWorkingSetEntry (WorkingSetIndex, 01438 PointerPte, 01439 Pfn1, 01440 Wsle); 01441 01442 UNLOCK_PFN (OldIrql); 01443 01444 // 01445 // Remove the working set entry from the working set. 01446 // 01447 01448 MiRemoveWsle (WorkingSetIndex, WorkingSetList); 01449 01450 ASSERT (WorkingSetList->FirstFree >= WorkingSetList->FirstDynamic); 01451 01452 ASSERT (WorkingSetIndex >= WorkingSetList->FirstDynamic); 01453 01454 // 01455 // Put the entry on the free list and decrement the current 01456 // size. 01457 // 01458 01459 ASSERT ((WorkingSetList->FirstFree <= WorkingSetList->LastInitializedWsle) || 01460 (WorkingSetList->FirstFree == WSLE_NULL_INDEX)); 01461 Wsle[WorkingSetIndex].u1.Long = WorkingSetList->FirstFree << MM_FREE_WSLE_SHIFT; 01462 WorkingSetList->FirstFree = WorkingSetIndex; 01463 ASSERT ((WorkingSetList->FirstFree <= WorkingSetList->LastInitializedWsle) || 01464 (WorkingSetList->FirstFree == WSLE_NULL_INDEX)); 01465 01466 if (WsInfo->WorkingSetSize > WsInfo->MinimumWorkingSetSize) { 01467 MmPagesAboveWsMinimum -= 1; 01468 } 01469 WsInfo->WorkingSetSize -= 1; 01470 01471 #if 0 01472 if ((WsInfo == &MmSystemCacheWs) && 01473 (Pfn1->u3.e1.Modified == 1)) { 01474 MiDumpWsleInCacheBlock (PointerPte); 01475 } 01476 #endif //0 01477 return TRUE; 01478 }

VOID MiGrowWsleHash (  IN PMMSUPPORT  WsInfo  )

Definition at line 3300 of file wslist.c. References ASSERT, ASSERT32, ASSERT64, Count, FALSE, _MMWSL::HashTable, _MMWSL::HashTableSize, _MMWSL::HashTableStart, _MMWSL::HighestPermittedHashAddress, _MMWSL::LastInitializedWsle, LOCK_PFN, _MMWSLE::Long, MI_WSLE_HASH, MiAddWsleHash(), MiCheckWsleHash(), MiDeletePte(), MiGetPdeAddress, MiGetPpeAddress, MiGetPteAddress, MiGetVirtualAddressMappedByPte, MiIsPteOnPdeBoundary, MmSystemCacheWs, MMWSLE_HASH, _MMWSL::NonDirectCount, NULL, _EPROCESS::NumberOfPrivatePages, PAGE_ALIGN, PAGE_SHIFT, PAGE_SIZE, PsGetCurrentProcess, Size, TRUE, _MMSUPPORT::u, _MMPTE::u, _MMWSLE::u1, UNLOCK_PFN, _MMWSLE::VirtualAddress, and _MMWSL::Wsle. Referenced by MiInitializeSystemCache(), MiInitializeWorkingSetList(), MiMakeSpecialPoolPagable(), MiSessionInitializeWorkingSetList(), MmAccessFault(), and MmAdjustWorkingSetSize(). : This function grows (or adds) a hash table to the working set list to allow direct indexing for WSLEs than cannot be located via the PFN database WSINDEX field. The hash table is located AFTER the WSLE array and the pages are locked into the working set just like standard WSLEs. Note that the hash table is expanded by setting the hash table field in the working set to NULL, but leaving the size as non-zero. This indicates that the hash should be expanded and the initial portion of the table zeroed. Arguments: WsInfo - Supplies a pointer to the working set info block for the process (or system cache). Return Value: None. Environment: Kernel mode, APCs disabled, working set lock held. --*/ { LONG Size; PMMWSLE Wsle; PMMPTE StartPte; PMMPTE EndPte; PMMPTE PointerPte; PMMPTE PointerPde; PMMPTE PointerPpe; PMMPTE AllocatedPde; PMMPTE AllocatedPpe; ULONG First; ULONG Hash; ULONG NewSize; PMMWSLE_HASH Table; PMMWSLE_HASH OriginalTable; ULONG j; PMMWSL WorkingSetList; KIRQL OldIrql; ULONG Count; LOGICAL LoopStart; PVOID EntryHashTableEnd; PVOID TempVa; PEPROCESS CurrentProcess; WorkingSetList = WsInfo->VmWorkingSetList; Wsle = WorkingSetList->Wsle; Table = WorkingSetList->HashTable; OriginalTable = WorkingSetList->HashTable; First = WorkingSetList->HashTableSize; if (Table == NULL) { NewSize = PtrToUlong(PAGE_ALIGN (((1 + WorkingSetList->NonDirectCount) * 2 * sizeof(MMWSLE_HASH)) + PAGE_SIZE - 1)); // // Note that the Table may be NULL and the HashTableSize/PTEs nonzero // in the case where the hash has been contracted. // j = First * sizeof(MMWSLE_HASH); // // Don't try for additional hash pages if we already have // the right amount (or too many). // if ((j + PAGE_SIZE > NewSize) && (j != 0)) { return; } Table = (PMMWSLE_HASH)(WorkingSetList->HashTableStart); EntryHashTableEnd = &Table[WorkingSetList->HashTableSize]; WorkingSetList->HashTableSize = 0; } else { // // Attempt to add 4 pages, make sure the working set list has // 4 free entries. // if ((WorkingSetList->LastInitializedWsle + 5) > WsInfo->WorkingSetSize) { NewSize = PAGE_SIZE * 4; } else { NewSize = PAGE_SIZE; } EntryHashTableEnd = &Table[WorkingSetList->HashTableSize]; } if ((PCHAR)EntryHashTableEnd + NewSize > (PCHAR)WorkingSetList->HighestPermittedHashAddress) { NewSize = (ULONG)((PCHAR)(WorkingSetList->HighestPermittedHashAddress) - ((PCHAR)EntryHashTableEnd)); if (NewSize == 0) { if (OriginalTable == NULL) { WorkingSetList->HashTableSize = First; } return; } } ASSERT64 ((MiGetPpeAddress(EntryHashTableEnd)->u.Hard.Valid == 0) || (MiGetPdeAddress(EntryHashTableEnd)->u.Hard.Valid == 0) || (MiGetPteAddress(EntryHashTableEnd)->u.Hard.Valid == 0)); ASSERT32 (MiGetPteAddress(EntryHashTableEnd)->u.Hard.Valid == 0); Size = NewSize; PointerPte = MiGetPteAddress (EntryHashTableEnd); StartPte = PointerPte; EndPte = PointerPte + (NewSize >> PAGE_SHIFT); #if defined (_WIN64) LoopStart = TRUE; AllocatedPde = NULL; AllocatedPpe = NULL; #endif do { #if defined (_WIN64) if (LoopStart == TRUE || MiIsPteOnPdeBoundary(PointerPte)) { PointerPpe = MiGetPdeAddress(PointerPte); PointerPde = MiGetPteAddress(PointerPte); if (PointerPpe->u.Hard.Valid == 0) { if (MiAddWsleHash (WsInfo, PointerPpe) == FALSE) { break; } AllocatedPpe = PointerPpe; } if (PointerPde->u.Hard.Valid == 0) { if (MiAddWsleHash (WsInfo, PointerPde) == FALSE) { break; } AllocatedPde = PointerPde; } LoopStart = FALSE; } else { AllocatedPde = NULL; AllocatedPpe = NULL; } #endif if (PointerPte->u.Hard.Valid == 0) { if (MiAddWsleHash (WsInfo, PointerPte) == FALSE) { break; } } PointerPte += 1; Size -= PAGE_SIZE; } while (Size > 0); // // If MiAddWsleHash was unable to allocate memory above, then roll back // any extra PPEs & PDEs that may have been created. Note NewSize must // be recalculated to handle the fact that memory may have run out. // #if !defined (_WIN64) if (PointerPte == StartPte) { if (OriginalTable == NULL) { WorkingSetList->HashTableSize = First; } return; } #else if (PointerPte != EndPte) { // // Clean up the last allocated PPE/PDE as they are not needed. // Note that the system cache and the session space working sets // have no current process (which MiDeletePte requires) which is // needed for WSLE and PrivatePages adjustments. // if (WsInfo != &MmSystemCacheWs && WsInfo->u.Flags.SessionSpace == 0) { CurrentProcess = PsGetCurrentProcess(); if (AllocatedPde != NULL) { ASSERT (AllocatedPde->u.Hard.Valid == 1); TempVa = MiGetVirtualAddressMappedByPte(AllocatedPde); LOCK_PFN (OldIrql); MiDeletePte (AllocatedPde, TempVa, FALSE, CurrentProcess, NULL, NULL); // // Add back in the private page MiDeletePte subtracted. // CurrentProcess->NumberOfPrivatePages += 1; UNLOCK_PFN (OldIrql); } if (AllocatedPpe != NULL) { ASSERT (AllocatedPpe->u.Hard.Valid == 1); TempVa = MiGetVirtualAddressMappedByPte(AllocatedPpe); LOCK_PFN (OldIrql); MiDeletePte (AllocatedPpe, TempVa, FALSE, CurrentProcess, NULL, NULL); // // Add back in the private page MiDeletePte subtracted. // CurrentProcess->NumberOfPrivatePages += 1; UNLOCK_PFN (OldIrql); } } if (PointerPte == StartPte) { if (OriginalTable == NULL) { WorkingSetList->HashTableSize = First; } } return; } #endif NewSize = (ULONG)((PointerPte - StartPte) << PAGE_SHIFT); ASSERT ((MiGetVirtualAddressMappedByPte(PointerPte) == WorkingSetList->HighestPermittedHashAddress) || (PointerPte->u.Hard.Valid == 0)); WorkingSetList->HashTableSize = First + NewSize / sizeof (MMWSLE_HASH); WorkingSetList->HashTable = Table; ASSERT ((&Table[WorkingSetList->HashTableSize] == WorkingSetList->HighestPermittedHashAddress) || (MiGetPteAddress(&Table[WorkingSetList->HashTableSize])->u.Hard.Valid == 0)); if (First != 0) { RtlZeroMemory (Table, First * sizeof(MMWSLE_HASH)); } // // Fill hash table // j = 0; Count = WorkingSetList->NonDirectCount; Size = WorkingSetList->HashTableSize; do { if ((Wsle[j].u1.e1.Valid == 1) && (Wsle[j].u1.e1.Direct == 0)) { // // Hash this. // Count -= 1; Hash = MI_WSLE_HASH(Wsle[j].u1.Long, WorkingSetList); while (Table[Hash].Key != 0) { Hash += 1; if (Hash >= (ULONG)Size) { Hash = 0; } } Table[Hash].Key = Wsle[j].u1.Long & ~(PAGE_SIZE - 1); Table[Hash].Index = j; #if DBG PointerPte = MiGetPteAddress(Wsle[j].u1.VirtualAddress); ASSERT (PointerPte->u.Hard.Valid); #endif //DBG } ASSERT (j <= WorkingSetList->LastEntry); j += 1; } while (Count); #if DBG MiCheckWsleHash (WorkingSetList); #endif //DBG return; }

VOID MiInitializeSessionWsSupport (  VOID   )

Definition at line 1847 of file wslist.c. References MiSessionWsList. Referenced by MmInitSystem(). : This routine initializes the session space working set support. Arguments: None. Return Value: None. Environment: Kernel mode, APC_LEVEL or below, no mutexes held. --*/ { // // This is the list of all session spaces ordered in a working set list. // InitializeListHead (&MiSessionWsList); }

VOID MiInitializeWorkingSetList (  IN PEPROCESS  CurrentProcess  )

Definition at line 1481 of file wslist.c. References ASSERT, CONSISTENCY_LOCK_PFN, CONSISTENCY_UNLOCK_PFN, _MMWSL::FirstDynamic, _MMWSL::FirstFree, _MMWSL::HashTable, _MMWSL::HashTableSize, _MMWSL::HashTableStart, _MMWSL::HighestPermittedHashAddress, HYPER_SPACE, HYPER_SPACE_END, _MMWSL::LastEntry, _MMWSL::LastInitializedWsle, LOCK_PFN, MI_MAKE_VALID_PTE, MI_PAGE_COLOR_PTE_PROCESS, MI_PFN_ELEMENT, MI_SET_PTE_DIRTY, MI_SET_PTE_IN_WORKING_SET, MI_WRITE_VALID_PTE, MiEnsureAvailablePageOrWait(), MiGetPdeAddress, MiGetPpeAddress, MiGetPteAddress, MiGrowWsleHash(), MiInitializePfn(), MiRemoveZeroPage(), MM_DEMAND_ZERO_WRITE_PTE, MM_FREE_WSLE_SHIFT, MM_MAXIMUM_WORKING_SET, MM_READWRITE, MM_SESSION_SPACE_DEFAULT, MmWorkingSetList, MmWsle, _MMWSL::NextSlot, NULL, PAGE_ALIGN, PAGE_SHIFT, PAGE_SIZE, _MMWSL::Quota, _MMPTE::u, _MMPFN::u1, _MMWSLE::u1, UNLOCK_PFN, _MMWSL::WaitingForImageMapping, WORKING_SET_LIST, _MMWSL::Wsle, WSLE_NULL_INDEX, and WSLE_NUMBER. Referenced by MmInitializeProcessAddressSpace(). : This routine initializes a process's working set to the empty state. Arguments: CurrentProcess - Supplies a pointer to the process to initialize. Return Value: None. Environment: Kernel mode, APCs disabled. --*/ { ULONG i; PMMWSLE WslEntry; ULONG CurrentEntry; PMMPTE PointerPte; PMMPFN Pfn1; WSLE_NUMBER NumberOfEntriesMapped; ULONG_PTR CurrentVa; PFN_NUMBER WorkingSetPage; MMPTE TempPte; KIRQL OldIrql; WslEntry = MmWsle; // // Initialize the temporary double mapping portion of hyperspace, if // it has not already been done. // // Initialize the working set list control cells. // MmWorkingSetList->LastEntry = CurrentProcess->Vm.MinimumWorkingSetSize; MmWorkingSetList->Quota = MmWorkingSetList->LastEntry; MmWorkingSetList->WaitingForImageMapping = (PKEVENT)NULL; MmWorkingSetList->HashTable = NULL; MmWorkingSetList->HashTableSize = 0; MmWorkingSetList->Wsle = MmWsle; MmWorkingSetList->HashTableStart = (PVOID)((PCHAR)PAGE_ALIGN (&MmWsle[MM_MAXIMUM_WORKING_SET]) + PAGE_SIZE); MmWorkingSetList->HighestPermittedHashAddress = (PVOID)(HYPER_SPACE_END + 1); // // Fill in the reserved slots. Start with the page directory page. // #if !defined (_X86PAE_) WslEntry->u1.Long = PDE_BASE; WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; PointerPte = MiGetPteAddress (WslEntry->u1.VirtualAddress); Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); CONSISTENCY_LOCK_PFN (OldIrql); #if !defined (_WIN64) Pfn1->u1.Event = (PVOID)CurrentProcess; #endif CONSISTENCY_UNLOCK_PFN (OldIrql); #else // // Fill in all the page directory entries. // for (i = 0; i < PD_PER_SYSTEM; i += 1) { WslEntry->u1.VirtualAddress = (PVOID)(PDE_BASE + i * PAGE_SIZE); WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; PointerPte = MiGetPteAddress (WslEntry->u1.VirtualAddress); Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); ASSERT (Pfn1->u1.WsIndex == 0); CONSISTENCY_LOCK_PFN (OldIrql); Pfn1->u1.WsIndex = (WSLE_NUMBER)(WslEntry - MmWsle); CONSISTENCY_UNLOCK_PFN (OldIrql); WslEntry += 1; } WslEntry -= 1; #endif #if defined (_WIN64) // // Fill in the entry for the page directory parent page. // WslEntry += 1; WslEntry->u1.Long = PDE_TBASE; WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; PointerPte = MiGetPteAddress (WslEntry->u1.VirtualAddress); Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); ASSERT (Pfn1->u1.WsIndex == 0); CONSISTENCY_LOCK_PFN (OldIrql); Pfn1->u1.WsIndex = (WSLE_NUMBER)(WslEntry - MmWsle); CONSISTENCY_UNLOCK_PFN (OldIrql); // // Fill in the entry for the hyper space page directory page. // WslEntry += 1; WslEntry->u1.VirtualAddress = (PVOID)MiGetPdeAddress (HYPER_SPACE); WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; PointerPte = MiGetPteAddress (WslEntry->u1.VirtualAddress); Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); ASSERT (Pfn1->u1.WsIndex == 0); CONSISTENCY_LOCK_PFN (OldIrql); Pfn1->u1.WsIndex = (WSLE_NUMBER)(WslEntry - MmWsle); CONSISTENCY_UNLOCK_PFN (OldIrql); #if defined (_IA64_) // // Fill in the entry for the session space page directory parent page. // WslEntry += 1; WslEntry->u1.VirtualAddress = (PVOID)MiGetPpeAddress (MM_SESSION_SPACE_DEFAULT); WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; PointerPte = MiGetPteAddress (WslEntry->u1.VirtualAddress); Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); ASSERT (Pfn1->u1.WsIndex == 0); CONSISTENCY_LOCK_PFN (OldIrql); Pfn1->u1.WsIndex = (WSLE_NUMBER)(WslEntry - MmWsle); CONSISTENCY_UNLOCK_PFN (OldIrql); #endif #endif // // Fill in the entry for the page table page which maps hyper space. // WslEntry += 1; WslEntry->u1.VirtualAddress = (PVOID)MiGetPteAddress (HYPER_SPACE); WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; PointerPte = MiGetPteAddress (WslEntry->u1.VirtualAddress); Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); ASSERT (Pfn1->u1.WsIndex == 0); CONSISTENCY_LOCK_PFN (OldIrql); Pfn1->u1.WsIndex = (WSLE_NUMBER)(WslEntry - MmWsle); CONSISTENCY_UNLOCK_PFN (OldIrql); #if defined (_X86PAE_) // // Fill in the entry for the second page table page which maps hyper space. // WslEntry += 1; WslEntry->u1.VirtualAddress = (PVOID)MiGetPteAddress (HYPER_SPACE2); WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; PointerPte = MiGetPteAddress (WslEntry->u1.VirtualAddress); Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); ASSERT (Pfn1->u1.WsIndex == 0); CONSISTENCY_LOCK_PFN (OldIrql); Pfn1->u1.WsIndex = (WSLE_NUMBER)(WslEntry - MmWsle); CONSISTENCY_UNLOCK_PFN (OldIrql); #endif // // Fill in the entry for the page which contains the working set list. // WslEntry += 1; WslEntry->u1.VirtualAddress = (PVOID)MmWorkingSetList; WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; PointerPte = MiGetPteAddress (WslEntry->u1.VirtualAddress); Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); ASSERT (Pfn1->u1.WsIndex == 0); CONSISTENCY_LOCK_PFN (OldIrql); Pfn1->u1.WsIndex = (WSLE_NUMBER)(WslEntry - MmWsle); CONSISTENCY_UNLOCK_PFN (OldIrql); CurrentEntry = (WSLE_NUMBER)((WslEntry - MmWsle) + 1); // // Check to see if more pages are required in the working set list // to map the current maximum working set size. // NumberOfEntriesMapped = (WSLE_NUMBER)(((PMMWSLE)((PCHAR)WORKING_SET_LIST + PAGE_SIZE)) - MmWsle); if (CurrentProcess->Vm.MaximumWorkingSetSize >= NumberOfEntriesMapped) { PointerPte = MiGetPteAddress (&MmWsle[0]); CurrentVa = (ULONG_PTR)MmWorkingSetList + PAGE_SIZE; // // The working set requires more than a single page. // LOCK_PFN (OldIrql); do { MiEnsureAvailablePageOrWait (NULL, NULL); PointerPte += 1; WorkingSetPage = MiRemoveZeroPage ( MI_PAGE_COLOR_PTE_PROCESS (PointerPte, &CurrentProcess->NextPageColor)); PointerPte->u.Long = MM_DEMAND_ZERO_WRITE_PTE; MiInitializePfn (WorkingSetPage, PointerPte, 1); MI_MAKE_VALID_PTE (TempPte, WorkingSetPage, MM_READWRITE, PointerPte ); MI_SET_PTE_DIRTY (TempPte); MI_SET_PTE_IN_WORKING_SET (&TempPte, CurrentEntry); MI_WRITE_VALID_PTE (PointerPte, TempPte); WslEntry += 1; WslEntry->u1.Long = CurrentVa; WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); ASSERT (Pfn1->u1.WsIndex == 0); Pfn1->u1.WsIndex = CurrentEntry; // MiInsertWsle(CurrentEntry, MmWorkingSetList); CurrentEntry += 1; CurrentVa += PAGE_SIZE; NumberOfEntriesMapped += PAGE_SIZE / sizeof(MMWSLE); } while (CurrentProcess->Vm.MaximumWorkingSetSize >= NumberOfEntriesMapped); UNLOCK_PFN (OldIrql); } CurrentProcess->Vm.WorkingSetSize = CurrentEntry; MmWorkingSetList->FirstFree = CurrentEntry; MmWorkingSetList->FirstDynamic = CurrentEntry; MmWorkingSetList->NextSlot = CurrentEntry; // // Initialize the following slots as free. // i = CurrentEntry + 1; do { // // Build the free list, note that the first working // set entries (CurrentEntry) are not on the free list. // These entries are reserved for the pages which // map the working set and the page which contains the PDE. // WslEntry += 1; WslEntry->u1.Long = i << MM_FREE_WSLE_SHIFT; i += 1; } while (i <= NumberOfEntriesMapped); WslEntry->u1.Long = WSLE_NULL_INDEX << MM_FREE_WSLE_SHIFT; // End of list. MmWorkingSetList->LastInitializedWsle = NumberOfEntriesMapped - 1; if (CurrentProcess->Vm.MaximumWorkingSetSize > ((1536*1024) >> PAGE_SHIFT)) { // // The working set list consists of more than a single page. // MiGrowWsleHash (&CurrentProcess->Vm); } return; }

WSLE_NUMBER MiLocateAndReserveWsle (  IN PMMSUPPORT  WsInfo  )

Definition at line 117 of file wslist.c. References ASSERT, _MMWSLE::e1, FALSE, _MMWSL::FirstDynamic, _MMWSL::FirstFree, _MMWSL::LastEntry, _MMWSL::LastInitializedWsle, MiAddWorkingSetPage(), MiDoReplacement(), MM_FREE_WSLE_SHIFT, MmInfoCounters, MmPagesAboveWsMinimum, MmSystemCacheWs, MmTransitionSharedPages, MmTransitionSharedPagesPeak, _MMINFO_COUNTERS::PageFaultCount, _MMWSL::Quota, TRUE, _MMWSLE::u1, _MMWSLENTRY::Valid, _MMWSL::Wsle, WSLE_NULL_INDEX, and WSLE_NUMBER. Referenced by MiAddValidPageToWorkingSet(), MiAddWsleHash(), MiLockCode(), MmAccessFault(), MmCheckCachedPageState(), and MmCopyToCachedPage(). : This function examines the Working Set List for the current process and locates an entry to contain a new page. If the working set is not currently at its quota, the new page is added without removing a page, if the working set is at its quota a page is removed from the working set and the new page added in its place. Arguments: None. Return Value: Returns the working set index which is now reserved for the next page to be added. Environment: Kernel mode, APCs disabled, working set lock. PFN lock NOT held. --*/ { WSLE_NUMBER WorkingSetIndex; PMMWSL WorkingSetList; PMMWSLE Wsle; ULONG QuotaIncrement; BOOLEAN MustReplace; MustReplace = FALSE; WorkingSetList = WsInfo->VmWorkingSetList; Wsle = WorkingSetList->Wsle; // // Update page fault counts. // WsInfo->PageFaultCount += 1; MmInfoCounters.PageFaultCount += 1; // // Determine if a page should be removed from the working set to make // room for the new page. If so, remove it. In addition, determine // the size of the QuotaIncrement if the size needs to be boosted. // retry_replacement: QuotaIncrement = MiDoReplacement(WsInfo, MustReplace); ASSERT (WsInfo->WorkingSetSize <= WorkingSetList->Quota); WsInfo->WorkingSetSize += 1; if (WsInfo->WorkingSetSize > WorkingSetList->Quota) { // // Increment the quota and check boundary conditions. // WorkingSetList->Quota += QuotaIncrement; WsInfo->LastTrimFaultCount = WsInfo->PageFaultCount; if (WorkingSetList->Quota > WorkingSetList->LastInitializedWsle) { // // Add more pages to the working set list structure. // if (MiAddWorkingSetPage (WsInfo) == TRUE) { ASSERT (WsInfo->WorkingSetSize <= WorkingSetList->Quota); } else { // // No page was added to the working set list structure. // We must replace a page within this working set. // WsInfo->WorkingSetSize -= 1; MustReplace = TRUE; goto retry_replacement; } } } // // Get the working set entry from the free list. // ASSERT (WorkingSetList->FirstFree <= WorkingSetList->LastInitializedWsle); ASSERT (WorkingSetList->FirstFree >= WorkingSetList->FirstDynamic); WorkingSetIndex = WorkingSetList->FirstFree; WorkingSetList->FirstFree = (WSLE_NUMBER)(Wsle[WorkingSetIndex].u1.Long >> MM_FREE_WSLE_SHIFT); ASSERT ((WorkingSetList->FirstFree <= WorkingSetList->LastInitializedWsle) || (WorkingSetList->FirstFree == WSLE_NULL_INDEX)); if (WsInfo->WorkingSetSize > WsInfo->MinimumWorkingSetSize) { MmPagesAboveWsMinimum += 1; } if (WsInfo->WorkingSetSize > WsInfo->PeakWorkingSetSize) { WsInfo->PeakWorkingSetSize = WsInfo->WorkingSetSize; } if (WsInfo == &MmSystemCacheWs) { if (WsInfo->WorkingSetSize + MmTransitionSharedPages > MmTransitionSharedPagesPeak) { MmTransitionSharedPagesPeak = WsInfo->WorkingSetSize + MmTransitionSharedPages; } } if (WorkingSetIndex > WorkingSetList->LastEntry) { WorkingSetList->LastEntry = WorkingSetIndex; } // // The returned entry is guaranteed to be available at this point. // ASSERT (Wsle[WorkingSetIndex].u1.e1.Valid == 0); return WorkingSetIndex; }

VOID MiReleaseWsle (  IN WSLE_NUMBER  WorkingSetIndex, IN PMMSUPPORT  WsInfo )

Definition at line 1016 of file wslist.c. References ASSERT, _MMWSL::FirstFree, _MMWSL::LastInitializedWsle, MM_FREE_WSLE_SHIFT, MM_SYSTEM_WS_LOCK_ASSERT, MmPagesAboveWsMinimum, MmSystemCacheWs, _MMWSLE::u1, _MMWSL::Wsle, and WSLE_NULL_INDEX. Referenced by MiDecommitPages(), MiDeleteAddressesInWorkingSet(), MiDeletePte(), MiDeleteSystemPagableVm(), MiLockCode(), MiRemoveMappedPtes(), MiRemovePageFromWorkingSet(), and MmUnmapViewInSystemCache(). 01023 : 01024 01025 This function releases a previously reserved working set entry to 01026 be reused. A release occurs when a page fault is retried due to 01027 changes in PTEs and working sets during an I/O operation. 01028 01029 Arguments: 01030 01031 WorkingSetIndex - Supplies the index of the working set entry to 01032 release. 01033 01034 Return Value: 01035 01036 None. 01037 01038 Environment: 01039 01040 Kernel mode, APCs disabled, working set lock held and PFN lock held. 01041 01042 --*/ 01043 01044 { 01045 PMMWSL WorkingSetList; 01046 PMMWSLE Wsle; 01047 01048 WorkingSetList = WsInfo->VmWorkingSetList; 01049 Wsle = WorkingSetList->Wsle; 01050 #if DBG 01051 if (WsInfo == &MmSystemCacheWs) { 01052 MM_SYSTEM_WS_LOCK_ASSERT(); 01053 } 01054 #endif //DBG 01055 01056 ASSERT (WorkingSetIndex <= WorkingSetList->LastInitializedWsle); 01057 01058 // 01059 // Put the entry on the free list and decrement the current 01060 // size. 01061 // 01062 01063 ASSERT ((WorkingSetList->FirstFree <= WorkingSetList->LastInitializedWsle) || 01064 (WorkingSetList->FirstFree == WSLE_NULL_INDEX)); 01065 Wsle[WorkingSetIndex].u1.Long = WorkingSetList->FirstFree << MM_FREE_WSLE_SHIFT; 01066 WorkingSetList->FirstFree = WorkingSetIndex; 01067 ASSERT ((WorkingSetList->FirstFree <= WorkingSetList->LastInitializedWsle) || 01068 (WorkingSetList->FirstFree == WSLE_NULL_INDEX)); 01069 if (WsInfo->WorkingSetSize > WsInfo->MinimumWorkingSetSize) { 01070 MmPagesAboveWsMinimum -= 1; 01071 } 01072 WsInfo->WorkingSetSize -= 1; 01073 return; 01074 01075 }

ULONG MiRemovePageFromWorkingSet (  IN PMMPTE  PointerPte, IN PMMPFN  Pfn1, IN PMMSUPPORT  WsInfo )

Definition at line 899 of file wslist.c. References ASSERT, FALSE, _MMWSL::FirstDynamic, LOCK_PFN, _MMWSLENTRY::LockedInMemory, _MMWSLENTRY::LockedInWs, MI_PFN_ELEMENT, MiEliminateWorkingSetEntry(), MiGetPteAddress, MiGetVirtualAddressMappedByPte, MiLocateWsle(), MiReleaseWsle(), MiRemoveWsle(), MiSwapWslEntries(), PAGE_ALIGN, TRUE, _MMWSLE::u1, UNLOCK_PFN, _MMWSL::Wsle, WSLE_NULL_INDEX, and WSLE_NUMBER. Referenced by MiProtectSpecialPool(), MiProtectVirtualMemory(), and MiSetProtectionOnSection(). : This function removes the page mapped by the specified PTE from the process's working set list. Arguments: PointerPte - Supplies a pointer to the PTE mapping the page to be removed from the working set list. Pfn1 - Supplies a pointer to the PFN database element referred to by the PointerPte. Return Value: Returns TRUE if the specified page was locked in the working set, FALSE otherwise. Environment: Kernel mode, APCs disabled, working set mutex held. --*/ { WSLE_NUMBER WorkingSetIndex; PVOID VirtualAddress; WSLE_NUMBER Entry; PVOID SwapVa; MMWSLENTRY Locked; PMMWSL WorkingSetList; PMMWSLE Wsle; KIRQL OldIrql; WorkingSetList = WsInfo->VmWorkingSetList; Wsle = WorkingSetList->Wsle; VirtualAddress = MiGetVirtualAddressMappedByPte (PointerPte); WorkingSetIndex = MiLocateWsle (VirtualAddress, WorkingSetList, Pfn1->u1.WsIndex); ASSERT (WorkingSetIndex != WSLE_NULL_INDEX); LOCK_PFN (OldIrql); MiEliminateWorkingSetEntry (WorkingSetIndex, PointerPte, Pfn1, Wsle); UNLOCK_PFN (OldIrql); // // Check to see if this entry is locked in the working set // or locked in memory. // Locked = Wsle[WorkingSetIndex].u1.e1; MiRemoveWsle (WorkingSetIndex, WorkingSetList); // // Add this entry to the list of free working set entries // and adjust the working set count. // MiReleaseWsle ((WSLE_NUMBER)WorkingSetIndex, WsInfo); if ((Locked.LockedInWs == 1) || (Locked.LockedInMemory == 1)) { // // This entry is locked. // WorkingSetList->FirstDynamic -= 1; if (WorkingSetIndex != WorkingSetList->FirstDynamic) { SwapVa = Wsle[WorkingSetList->FirstDynamic].u1.VirtualAddress; SwapVa = PAGE_ALIGN (SwapVa); PointerPte = MiGetPteAddress (SwapVa); Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); #if 0 Entry = MiLocateWsleAndParent (SwapVa, &Parent, WorkingSetList, Pfn1->u1.WsIndex); // // Swap the removed entry with the last locked entry // which is located at first dynamic. // MiSwapWslEntries (Entry, Parent, WorkingSetIndex, WorkingSetList); #endif //0 Entry = MiLocateWsle (SwapVa, WorkingSetList, Pfn1->u1.WsIndex); MiSwapWslEntries (Entry, WorkingSetIndex, WsInfo); } return TRUE; } else { ASSERT (WorkingSetIndex >= WorkingSetList->FirstDynamic); } return FALSE; }

VOID MiRemoveWorkingSetPages (  IN PMMWSL  WorkingSetList, IN PMMSUPPORT  WsInfo )

Referenced by MiEmptyWorkingSet(), and MiTrimWorkingSet().

VOID MiReplaceWorkingSetEntryUsingFaultInfo (  IN PMMSUPPORT  WsInfo, IN BOOLEAN  MustReplace )

Definition at line 790 of file wslist.c. References _MMWSL::FirstDynamic, _MMWSL::LastEntry, MI_GET_ACCESSED_IN_PTE, MI_SET_ACCESSED_IN_PTE, MiFreeWsle(), MiGetPteAddress, MM_WORKING_SET_LIST_SEARCH, _MMWSL::NextSlot, PERFINFO_GET_PAGE_INFO_REPLACEMENT, PERFINFO_LOG_WS_REPLACEMENT, PERFINFO_PAGE_INFO_REPLACEMENT_DECL, TRUE, _MMWSLE::u1, _MMWSLE::VirtualAddress, and _MMWSL::Wsle. Referenced by MiDoReplacement(). 00797 : 00798 00799 This function tries to find a reasonable working set entry to replace. 00800 00801 Arguments: 00802 00803 WsInfo - Supplies the working set info pointer. 00804 00805 MustReplace - Supplies TRUE if replacement must succeed. 00806 00807 Return Value: 00808 00809 None 00810 00811 Environment: 00812 00813 Kernel mode, APCs disabled, working set lock. PFN lock NOT held. 00814 00815 --*/ 00816 00817 { 00818 ULONG WorkingSetIndex; 00819 ULONG FirstDynamic; 00820 ULONG LastEntry; 00821 PMMWSL WorkingSetList; 00822 PMMWSLE Wsle; 00823 ULONG NumberOfCandidates; 00824 PMMPTE PointerPte; 00825 ULONG TheNextSlot; 00826 00827 WorkingSetList = WsInfo->VmWorkingSetList; 00828 Wsle = WorkingSetList->Wsle; 00829 00830 // 00831 // Toss a page out of the working set. 00832 // 00833 00834 LastEntry = WorkingSetList->LastEntry; 00835 FirstDynamic = WorkingSetList->FirstDynamic; 00836 WorkingSetIndex = WorkingSetList->NextSlot; 00837 00838 if ((WorkingSetIndex > LastEntry) || (WorkingSetIndex < FirstDynamic)) { 00839 WorkingSetIndex = FirstDynamic; 00840 } 00841 00842 TheNextSlot = WorkingSetIndex; 00843 NumberOfCandidates = 0; 00844 00845 do { 00846 00847 // 00848 // Find a valid entry within the set. 00849 // 00850 00851 if (Wsle[WorkingSetIndex].u1.e1.Valid != 0) { 00852 00853 PointerPte = MiGetPteAddress ( 00854 Wsle[WorkingSetIndex].u1.VirtualAddress); 00855 00856 if ((MI_GET_ACCESSED_IN_PTE(PointerPte) == 0) || 00857 (NumberOfCandidates > MM_WORKING_SET_LIST_SEARCH)) { 00858 00859 PERFINFO_PAGE_INFO_REPLACEMENT_DECL(); 00860 PERFINFO_GET_PAGE_INFO_REPLACEMENT(PointerPte); 00861 00862 // 00863 // Don't pick the same entry we replaced the last time 00864 // unless we're under extreme pressure. 00865 // 00866 00867 if ((WorkingSetIndex != TheNextSlot || MustReplace == TRUE) && 00868 MiFreeWsle (WorkingSetIndex, WsInfo, PointerPte)) { 00869 00870 PERFINFO_LOG_WS_REPLACEMENT(WsInfo); 00871 00872 // 00873 // This entry was removed. 00874 // 00875 00876 WorkingSetList->NextSlot = WorkingSetIndex + 1; 00877 break; 00878 } 00879 } 00880 MI_SET_ACCESSED_IN_PTE (PointerPte, 0); 00881 NumberOfCandidates += 1; 00882 } 00883 00884 WorkingSetIndex += 1; 00885 if (WorkingSetIndex > LastEntry) { 00886 WorkingSetIndex = FirstDynamic; 00887 } 00888 00889 } while (WorkingSetIndex != TheNextSlot || MustReplace == TRUE); 00890 00891 // 00892 // Entire working set list has been searched. If an entry wasn't 00893 // removed, our caller can increase the working set size. 00894 // 00895 } #endif

NTSTATUS MiSessionInitializeWorkingSetList (  VOID   )

Definition at line 1881 of file wslist.c. References _MMSUPPORT::AllowWorkingSetAdjustment, ASSERT, BYTES_TO_PAGES, _MM_SESSION_SPACE::CommittedPages, CONSISTENCY_LOCK_PFN, CONSISTENCY_UNLOCK_PFN, DbgPrint, ExDeleteResource, ExInitializeResource, FALSE, _MMWSL::FirstDynamic, _MMWSL::FirstFree, _MMWSL::HashTable, _MMWSL::HashTableSize, _MMWSL::HashTableStart, _MMWSL::HighestPermittedHashAddress, Index, _MMWSL::LastEntry, _MMWSL::LastInitializedWsle, LOCK_EXPANSION, LOCK_PFN, _MMSUPPORT::MaximumWorkingSetSize, MI_GET_PAGE_COLOR_FROM_VA, MI_NONPAGABLE_MEMORY_AVAILABLE, MI_PFN_ELEMENT, MI_SESSION_MAXIMUM_WORKING_SET, MI_SESSION_SPACE_WORKING_SET_MAXIMUM, MI_SESSION_SPACE_WORKING_SET_MINIMUM, MI_SESSION_SPACE_WS, MI_SESSION_VIEW_START, MI_SET_PTE_DIRTY, MI_SET_PTE_IN_WORKING_SET, MI_WRITE_VALID_PTE, MiChargeCommitment(), MiEnsureAvailablePageOrWait(), MiFillMemoryPte, MiGetPdeAddress, MiGetPdeSessionIndex, MiGetPteAddress, MiGetVirtualAddressMappedByPte, MiGrowWsleHash(), MiInitializePfn(), MiInitializePfnForOtherProcess(), _MMSUPPORT::MinimumWorkingSetSize, MiRemoveAnyPage(), MiRemoveZeroPage(), MiRemoveZeroPageIfAny, MiReturnCommitment(), MiSessionWsList, MiZeroPhysicalPage(), MM_BUMP_COUNTER, MM_BUMP_SESS_COUNTER, MM_BUMP_SESSION_FAILURES, MM_DBG_COMMIT_RETURN_SESSION_WSL_FAILURE, MM_DBG_COMMIT_SESSION_WS_INIT, MM_DBG_SESSION_WS_PAGE_ALLOC, MM_DBG_SESSION_WS_PAGETABLE_ALLOC, MM_DEMAND_ZERO_WRITE_PTE, MM_FREE_WSLE_SHIFT, MM_SESSION_FAILURE_NO_COMMIT, MM_SESSION_FAILURE_NO_RESIDENT, MM_TRACK_COMMIT, MM_VA_MAPPED_BY_PDE, MmResidentAvailablePages, MmSessionSpace, _MMWSL::NextSlot, _MM_SESSION_SPACE::NonPagablePages, NULL, PAGE_ALIGN, PAGE_SHIFT, PAGE_SIZE, _MM_SESSION_SPACE::PagedPoolStart, _MM_SESSION_SPACE::PageTables, _MMWSL::Quota, SESSION_GLOBAL, _MM_SESSION_SPACE::SessionPageDirectoryIndex, TRUE, _MM_SESSION_SPACE::u, _MMSUPPORT::u, _MMPTE::u, _MMWSLE::u1, _MMPFN::u1, UNLOCK_EXPANSION, UNLOCK_PFN, _MMWSL::UsedPageTableEntries, ValidKernelPdeLocal, ValidKernelPteLocal, _MM_SESSION_SPACE::Vm, _MMSUPPORT::VmWorkingSetList, _MM_SESSION_SPACE::WorkingSetLockOwner, _MMSUPPORT::WorkingSetSize, _MMWSL::Wsle, _MM_SESSION_SPACE::Wsle, WSLE_NULL_INDEX, WSLE_NUMBER, _MM_SESSION_SPACE::WsListEntry, _MM_SESSION_SPACE::WsLock, and ZeroKernelPte. Referenced by MmSessionCreate(). : This function initializes the working set for the session space and adds it to the list of session space working sets. Arguments: None. Return Value: NT_SUCCESS if success or STATUS_NO_MEMORY on failure. Environment: Kernel mode, APC_LEVEL or below, no mutexes held. --*/ { ULONG i; KIRQL OldIrql; PMMPTE PointerPte; PMMPTE PointerPde; MMPTE TempPte; PMMWSLE WslEntry; PMMPFN Pfn1; ULONG PageColor; PFN_NUMBER ResidentPages; ULONG Index; PFN_NUMBER PageFrameIndex; ULONG CurrentEntry; ULONG NumberOfEntriesMapped; ULONG_PTR AdditionalBytes; ULONG NumberOfEntriesMappedByFirstPage; ULONG WorkingSetMaximum; PMM_SESSION_SPACE SessionGlobal; LOGICAL AllocatedPageTable; // // Use the global address for pointer references by // MmWorkingSetManager before it attaches to the address space. // SessionGlobal = SESSION_GLOBAL (MmSessionSpace); // // Set up the working set variables. // WorkingSetMaximum = MI_SESSION_SPACE_WORKING_SET_MAXIMUM; MmSessionSpace->Vm.VmWorkingSetList = (PMMWSL)MI_SESSION_SPACE_WS; #if defined (_WIN64) MmSessionSpace->Wsle = (PMMWSLE)(MmSessionSpace->Vm.VmWorkingSetList + 1); #else MmSessionSpace->Wsle = (PMMWSLE)(&MmSessionSpace->Vm.VmWorkingSetList->UsedPageTableEntries[0]); #endif ASSERT (MmSessionSpace->WorkingSetLockOwner == NULL); ASSERT (MmSessionSpace->WorkingSetLockOwnerCount == 0); // // Build the PDE entry for the working set - note that the global bit // must be turned off. // PointerPde = MiGetPdeAddress (MmSessionSpace->Vm.VmWorkingSetList); // // The page table page for the working set and its first data page // are charged against MmResidentAvailablePages and for commitment. // if (PointerPde->u.Hard.Valid == 1) { // // The page directory entry for the working set is the same // as for another range in the session space. Share the PDE. // #ifndef _IA64_ ASSERT (PointerPde->u.Hard.Global == 0); #endif AllocatedPageTable = FALSE; ResidentPages = 1; } else { AllocatedPageTable = TRUE; ResidentPages = 2; } PointerPte = MiGetPteAddress (MmSessionSpace->Vm.VmWorkingSetList); // // The data pages needed to map up to maximum working set size are also // charged against MmResidentAvailablePages and for commitment. // NumberOfEntriesMappedByFirstPage = (WSLE_NUMBER)( ((PMMWSLE)((ULONG_PTR)MmSessionSpace->Vm.VmWorkingSetList + PAGE_SIZE)) - MmSessionSpace->Wsle); if (WorkingSetMaximum > NumberOfEntriesMappedByFirstPage) { AdditionalBytes = (WorkingSetMaximum - NumberOfEntriesMappedByFirstPage) * sizeof (MMWSLE); ResidentPages += BYTES_TO_PAGES (AdditionalBytes); } if (MiChargeCommitment (ResidentPages, NULL) == FALSE) { #if DBG DbgPrint("MiSessionInitializeWorkingSetList: No commit for %d pages\n", ResidentPages); #endif MM_BUMP_SESSION_FAILURES (MM_SESSION_FAILURE_NO_COMMIT); return STATUS_NO_MEMORY; } MM_TRACK_COMMIT (MM_DBG_COMMIT_SESSION_WS_INIT, ResidentPages); // // Use the global address for resources since they are linked // into the global system wide resource list. // ExInitializeResource (&SessionGlobal->WsLock); LOCK_PFN (OldIrql); // // Check to make sure the physical pages are available. // if ((SPFN_NUMBER)ResidentPages > MI_NONPAGABLE_MEMORY_AVAILABLE() - 20) { #if DBG DbgPrint("MiSessionInitializeWorkingSetList: No Resident Pages %d, Need %d\n", MmResidentAvailablePages, ResidentPages); #endif UNLOCK_PFN (OldIrql); MiReturnCommitment (ResidentPages); MM_TRACK_COMMIT (MM_DBG_COMMIT_RETURN_SESSION_WSL_FAILURE, ResidentPages); ExDeleteResource (&SessionGlobal->WsLock); MM_BUMP_SESSION_FAILURES (MM_SESSION_FAILURE_NO_RESIDENT); return STATUS_NO_MEMORY; } MmResidentAvailablePages -= ResidentPages; MM_BUMP_COUNTER(50, ResidentPages); if (AllocatedPageTable == TRUE) { MM_BUMP_SESS_COUNTER (MM_DBG_SESSION_WS_PAGETABLE_ALLOC, 1); MiEnsureAvailablePageOrWait (NULL, NULL); PageColor = MI_GET_PAGE_COLOR_FROM_VA (NULL); PageFrameIndex = MiRemoveZeroPageIfAny (PageColor); if (PageFrameIndex == 0) { PageFrameIndex = MiRemoveAnyPage (PageColor); UNLOCK_PFN (OldIrql); MiZeroPhysicalPage (PageFrameIndex, PageColor); LOCK_PFN (OldIrql); } // // The global bit is masked off since we need to make sure the TB entry // is flushed when we switch to a process in a different session space. // TempPte.u.Long = ValidKernelPdeLocal.u.Long; TempPte.u.Hard.PageFrameNumber = PageFrameIndex; MI_WRITE_VALID_PTE (PointerPde, TempPte); #if !defined (_WIN64) // // Add this to the session structure so other processes can fault it in. // Index = MiGetPdeSessionIndex (MmSessionSpace->Vm.VmWorkingSetList); MmSessionSpace->PageTables[Index] = TempPte; #endif // // This page frame references the session space page table page. // MiInitializePfnForOtherProcess (PageFrameIndex, PointerPde, MmSessionSpace->SessionPageDirectoryIndex); MiFillMemoryPte (PointerPte, PAGE_SIZE, ZeroKernelPte.u.Long); Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); // // This page is never paged, ensure that its WsIndex stays clear so the // release of the page will be handled correctly. // ASSERT (Pfn1->u1.WsIndex == 0); KeFillEntryTb ((PHARDWARE_PTE) PointerPde, PointerPte, FALSE); } MiEnsureAvailablePageOrWait (NULL, NULL); PageColor = MI_GET_PAGE_COLOR_FROM_VA (NULL); PageFrameIndex = MiRemoveZeroPageIfAny (PageColor); if (PageFrameIndex == 0) { PageFrameIndex = MiRemoveAnyPage (PageColor); UNLOCK_PFN (OldIrql); MiZeroPhysicalPage (PageFrameIndex, PageColor); LOCK_PFN (OldIrql); } MM_BUMP_SESS_COUNTER (MM_DBG_SESSION_WS_PAGE_ALLOC, ResidentPages - 1); #if DBG Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); ASSERT (Pfn1->u1.WsIndex == 0); #endif // // The global bit is masked off since we need to make sure the TB entry // is flushed when we switch to a process in a different session space. // TempPte.u.Long = ValidKernelPteLocal.u.Long; MI_SET_PTE_DIRTY (TempPte); TempPte.u.Hard.PageFrameNumber = PageFrameIndex; MI_WRITE_VALID_PTE (PointerPte, TempPte); MiInitializePfn (PageFrameIndex, PointerPte, 1); #if DBG Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); ASSERT (Pfn1->u1.WsIndex == 0); #endif UNLOCK_PFN (OldIrql); KeFillEntryTb ((PHARDWARE_PTE) PointerPte, (PMMPTE)MmSessionSpace->Vm.VmWorkingSetList, FALSE); // // Fill in the reserved slots starting with the session data page. // WslEntry = MmSessionSpace->Wsle; WslEntry->u1.VirtualAddress = (PVOID)MmSessionSpace; WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; Pfn1 = MI_PFN_ELEMENT (MiGetPteAddress (WslEntry->u1.VirtualAddress)->u.Hard.PageFrameNumber); ASSERT (Pfn1->u1.WsIndex == 0); // // The next reserved slot is for the page table page mapping // the session data page. // WslEntry += 1; WslEntry->u1.VirtualAddress = MiGetPteAddress (MmSessionSpace); WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; Pfn1 = MI_PFN_ELEMENT (MiGetPteAddress (WslEntry->u1.VirtualAddress)->u.Hard.PageFrameNumber); ASSERT (Pfn1->u1.WsIndex == 0); CONSISTENCY_LOCK_PFN (OldIrql); Pfn1->u1.WsIndex = (WSLE_NUMBER)(WslEntry - MmSessionSpace->Wsle); CONSISTENCY_UNLOCK_PFN (OldIrql); // // The next reserved slot is for the working set page. // WslEntry += 1; WslEntry->u1.VirtualAddress = MmSessionSpace->Vm.VmWorkingSetList; WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); ASSERT (Pfn1->u1.WsIndex == 0); CONSISTENCY_LOCK_PFN (OldIrql); Pfn1->u1.WsIndex = (WSLE_NUMBER)(WslEntry - MmSessionSpace->Wsle); CONSISTENCY_UNLOCK_PFN (OldIrql); if (AllocatedPageTable == TRUE) { // // The next reserved slot is for the page table page // mapping the working set page. // WslEntry += 1; WslEntry->u1.VirtualAddress = (PVOID)PointerPte; WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; Pfn1 = MI_PFN_ELEMENT (MiGetPteAddress (WslEntry->u1.VirtualAddress)->u.Hard.PageFrameNumber); ASSERT (Pfn1->u1.WsIndex == 0); CONSISTENCY_LOCK_PFN (OldIrql); Pfn1->u1.WsIndex = (WSLE_NUMBER)(WslEntry - MmSessionSpace->Wsle); CONSISTENCY_UNLOCK_PFN (OldIrql); } // // The next reserved slot is for the page table page // mapping the first session paged pool page. // WslEntry += 1; WslEntry->u1.VirtualAddress = (PVOID)MiGetPteAddress (MmSessionSpace->PagedPoolStart); WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; Pfn1 = MI_PFN_ELEMENT (MiGetPteAddress (WslEntry->u1.VirtualAddress)->u.Hard.PageFrameNumber); ASSERT (Pfn1->u1.WsIndex == 0); CONSISTENCY_LOCK_PFN (OldIrql); Pfn1->u1.WsIndex = (WSLE_NUMBER)(WslEntry - MmSessionSpace->Wsle); CONSISTENCY_UNLOCK_PFN (OldIrql); CurrentEntry = (WSLE_NUMBER)(WslEntry + 1 - MmSessionSpace->Wsle); MmSessionSpace->Vm.u.Flags.SessionSpace = 1; MmSessionSpace->Vm.MinimumWorkingSetSize = MI_SESSION_SPACE_WORKING_SET_MINIMUM; MmSessionSpace->Vm.MaximumWorkingSetSize = WorkingSetMaximum; // // Don't trim from this session till we're finished setting up and // it's got some pages in it... // MmSessionSpace->Vm.AllowWorkingSetAdjustment = FALSE; MmSessionSpace->Vm.VmWorkingSetList->LastEntry = MI_SESSION_SPACE_WORKING_SET_MINIMUM; MmSessionSpace->Vm.VmWorkingSetList->Quota = MmSessionSpace->Vm.VmWorkingSetList->LastEntry; MmSessionSpace->Vm.VmWorkingSetList->HashTable = NULL; MmSessionSpace->Vm.VmWorkingSetList->HashTableSize = 0; MmSessionSpace->Vm.VmWorkingSetList->Wsle = MmSessionSpace->Wsle; MmSessionSpace->Vm.VmWorkingSetList->HashTableStart = (PVOID)((PCHAR)PAGE_ALIGN (&MmSessionSpace->Wsle[MI_SESSION_MAXIMUM_WORKING_SET]) + PAGE_SIZE); #if defined (_X86PAE_) // // One less page table page is needed on PAE systems. // MmSessionSpace->Vm.VmWorkingSetList->HighestPermittedHashAddress = (PVOID)(MI_SESSION_VIEW_START - MM_VA_MAPPED_BY_PDE); #else MmSessionSpace->Vm.VmWorkingSetList->HighestPermittedHashAddress = (PVOID)MI_SESSION_VIEW_START; #endif NumberOfEntriesMapped = (WSLE_NUMBER)(((PMMWSLE)((ULONG_PTR)MmSessionSpace->Vm.VmWorkingSetList + PAGE_SIZE)) - MmSessionSpace->Wsle); LOCK_PFN (OldIrql); while (NumberOfEntriesMapped < WorkingSetMaximum) { PointerPte += 1; MiEnsureAvailablePageOrWait (NULL, NULL); PageFrameIndex = MiRemoveZeroPage(MI_GET_PAGE_COLOR_FROM_VA (NULL)); PointerPte->u.Long = MM_DEMAND_ZERO_WRITE_PTE; MiInitializePfn (PageFrameIndex, PointerPte, 1); TempPte.u.Hard.PageFrameNumber = PageFrameIndex; MI_SET_PTE_IN_WORKING_SET (&TempPte, CurrentEntry); MI_WRITE_VALID_PTE (PointerPte, TempPte); WslEntry += 1; WslEntry->u1.VirtualAddress = MiGetVirtualAddressMappedByPte (PointerPte); WslEntry->u1.e1.Valid = 1; WslEntry->u1.e1.LockedInWs = 1; WslEntry->u1.e1.Direct = 1; Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); ASSERT (Pfn1->u1.WsIndex == 0); Pfn1->u1.WsIndex = CurrentEntry; // MiInsertWsle(CurrentEntry, MmWorkingSetList); CurrentEntry += 1; NumberOfEntriesMapped += PAGE_SIZE / sizeof(MMWSLE); } UNLOCK_PFN (OldIrql); MmSessionSpace->Vm.WorkingSetSize = CurrentEntry; MmSessionSpace->Vm.VmWorkingSetList->FirstFree = CurrentEntry; MmSessionSpace->Vm.VmWorkingSetList->FirstDynamic = CurrentEntry; MmSessionSpace->Vm.VmWorkingSetList->NextSlot = CurrentEntry; MmSessionSpace->NonPagablePages += ResidentPages; MmSessionSpace->CommittedPages += ResidentPages; // // Initialize the following slots as free. // WslEntry = MmSessionSpace->Wsle + CurrentEntry; for (i = CurrentEntry + 1; i < NumberOfEntriesMapped; i += 1) { // // Build the free list, note that the first working // set entries (CurrentEntry) are not on the free list. // These entries are reserved for the pages which // map the working set and the page which contains the PDE. // WslEntry->u1.Long = i << MM_FREE_WSLE_SHIFT; WslEntry += 1; } WslEntry->u1.Long = WSLE_NULL_INDEX << MM_FREE_WSLE_SHIFT; // End of list. MmSessionSpace->Vm.VmWorkingSetList->LastInitializedWsle = NumberOfEntriesMapped - 1; if (WorkingSetMaximum > ((1536*1024) >> PAGE_SHIFT)) { // // The working set list consists of more than a single page. // MiGrowWsleHash (&MmSessionSpace->Vm); } // // Put this session's working set in lists using its global address. // LOCK_EXPANSION (OldIrql); InsertTailList (&MiSessionWsList, &SessionGlobal->WsListEntry); MmSessionSpace->u.Flags.HasWsLock = 1; MmSessionSpace->u.Flags.SessionListInserted = 1; UNLOCK_EXPANSION (OldIrql); return STATUS_SUCCESS; }

ULONG MiTrimWorkingSet (  ULONG  Reduction, IN PMMSUPPORT  WsInfo, IN ULONG  ForcedReductionOrTrimAge )

Definition at line 3612 of file wslist.c. References FALSE, _MMWSL::FirstDynamic, _MMWSL::LastEntry, MI_GET_ACCESSED_IN_PTE, MI_GET_WSLE_AGE, MI_SET_ACCESSED_IN_PTE, MiFreeWsle(), MiGetPteAddress, MiRemoveWorkingSetPages(), MM_SYSTEM_WS_LOCK_ASSERT, MmSystemCacheWs, _MMWSL::NextSlot, PAGE_SIZE, PERFINFO_GET_PAGE_INFO_WITH_DECL, PERFINFO_LOG_WS_REMOVAL, _MMWSL::Quota, TRUE, _MMSUPPORT::u, _MMWSLE::u1, _MMWSLE::VirtualAddress, and _MMWSL::Wsle. Referenced by MiDoReplacement(), MmSetMemoryPriorityProcess(), and MmWorkingSetManager(). 03620 : 03621 03622 This function reduces the working set by the specified amount. 03623 03624 Arguments: 03625 03626 Reduction - Supplies the number of pages to remove from the working 03627 set. 03628 03629 WsInfo - Supplies a pointer to the working set information for the 03630 process (or system cache) to trim. 03631 03632 ForcedReductionOrTrimAge - If using fault-based trimming, this is set to 03633 TRUE if the reduction is being done to free up 03634 pages in which case we should try to reduce 03635 working set pages as well. Set to FALSE when 03636 the reduction is trying to increase the fault 03637 rates in which case the policy should be more 03638 like locate and reserve. 03639 03640 If using claim-based trimming, this is the age 03641 value to use - ie: pages of this age or older 03642 will be removed. 03643 03644 Return Value: 03645 03646 Returns the actual number of pages removed. 03647 03648 Environment: 03649 03650 Kernel mode, APCs disabled, working set lock. PFN lock NOT held. 03651 03652 --*/ 03653 03654 { 03655 ULONG TryToFree; 03656 ULONG StartEntry; 03657 ULONG LastEntry; 03658 PMMWSL WorkingSetList; 03659 PMMWSLE Wsle; 03660 PMMPTE PointerPte; 03661 ULONG NumberLeftToRemove; 03662 ULONG LoopCount; 03663 ULONG EndCount; 03664 BOOLEAN StartFromZero; 03665 03666 NumberLeftToRemove = Reduction; 03667 WorkingSetList = WsInfo->VmWorkingSetList; 03668 Wsle = WorkingSetList->Wsle; 03669 03670 #if DBG 03671 if (WsInfo == &MmSystemCacheWs) { 03672 MM_SYSTEM_WS_LOCK_ASSERT(); 03673 } 03674 #endif //DBG 03675 03676 LastEntry = WorkingSetList->LastEntry; 03677 03678 TryToFree = WorkingSetList->NextSlot; 03679 if (TryToFree > LastEntry || TryToFree < WorkingSetList->FirstDynamic) { 03680 TryToFree = WorkingSetList->FirstDynamic; 03681 } 03682 03683 StartEntry = TryToFree; 03684 03685 #ifdef _MI_USE_CLAIMS_ 03686 03687 while (NumberLeftToRemove != 0) { 03688 if (Wsle[TryToFree].u1.e1.Valid == 1) { 03689 PointerPte = MiGetPteAddress (Wsle[TryToFree].u1.VirtualAddress); 03690 03691 if ((ForcedReductionOrTrimAge == 0) || 03692 ((MI_GET_ACCESSED_IN_PTE (PointerPte) == 0) && 03693 (MI_GET_WSLE_AGE(PointerPte, &Wsle[TryToFree]) >= ForcedReductionOrTrimAge))) { 03694 03695 PERFINFO_GET_PAGE_INFO_WITH_DECL(PointerPte); 03696 03697 if (MiFreeWsle (TryToFree, WsInfo, PointerPte)) { 03698 PERFINFO_LOG_WS_REMOVAL(PERFINFO_LOG_TYPE_OUTWS_VOLUNTRIM, WsInfo); 03699 NumberLeftToRemove -= 1; 03700 } 03701 } 03702 } 03703 TryToFree += 1; 03704 03705 if (TryToFree > LastEntry) { 03706 TryToFree = WorkingSetList->FirstDynamic; 03707 } 03708 03709 if (TryToFree == StartEntry) { 03710 break; 03711 } 03712 } 03713 03714 #else 03715 03716 LoopCount = 0; 03717 03718 if (ForcedReductionOrTrimAge) { 03719 EndCount = 4; 03720 } else { 03721 EndCount = 1; 03722 } 03723 03724 StartFromZero = FALSE; 03725 03726 while (NumberLeftToRemove != 0 && LoopCount != EndCount) { 03727 while ((NumberLeftToRemove != 0) && (TryToFree <= LastEntry)) { 03728 03729 if (Wsle[TryToFree].u1.e1.Valid == 1) { 03730 PointerPte = MiGetPteAddress (Wsle[TryToFree].u1.VirtualAddress); 03731 if (MI_GET_ACCESSED_IN_PTE (PointerPte)) { 03732 03733 // 03734 // If accessed bit is set, clear it. If accessed 03735 // bit is clear, remove from working set. 03736 // 03737 03738 MI_SET_ACCESSED_IN_PTE (PointerPte, 0); 03739 } else { 03740 PERFINFO_GET_PAGE_INFO_WITH_DECL(PointerPte); 03741 if (MiFreeWsle (TryToFree, WsInfo, PointerPte)) { 03742 PERFINFO_LOG_WS_REMOVAL(PERFINFO_LOG_TYPE_OUTWS_VOLUNTRIM, WsInfo); 03743 NumberLeftToRemove -= 1; 03744 } 03745 } 03746 } 03747 TryToFree += 1; 03748 03749 if (StartFromZero == TRUE && EndCount == 1 && TryToFree >= StartEntry) { 03750 LoopCount = EndCount; 03751 if (TryToFree > LastEntry) { 03752 TryToFree = WorkingSetList->FirstDynamic; 03753 } 03754 break; 03755 } 03756 } 03757 03758 if (TryToFree > LastEntry) { 03759 TryToFree = WorkingSetList->FirstDynamic; 03760 if (StartFromZero == TRUE) { 03761 03762 // 03763 // We've already wrapped once but didn't get back to 03764 // the StartEntry. Use the first dynamic as our base now. 03765 // 03766 03767 StartEntry = TryToFree; 03768 } 03769 else { 03770 StartFromZero = TRUE; 03771 } 03772 03773 if (TryToFree >= StartEntry) { 03774 03775 // 03776 // We've wrapped. If this is not a forced trim, then bail 03777 // now so we don't cannibalize entries we just cleared the 03778 // access bit for because they haven't had a fair chance to 03779 // be re-accessed yet. 03780 // 03781 03782 LoopCount += 1; 03783 StartFromZero = FALSE; 03784 } 03785 } 03786 } 03787 03788 #endif 03789 03790 WorkingSetList->NextSlot = TryToFree; 03791 03792 // 03793 // If this is not the system cache or a session working set, see if the 03794 // working set list can be contracted. 03795 // 03796 03797 if (WsInfo != &MmSystemCacheWs && WsInfo->u.Flags.SessionSpace == 0) { 03798 03799 // 03800 // Make sure we are at least a page above the working set maximum. 03801 // 03802 03803 if (WorkingSetList->FirstDynamic == WsInfo->WorkingSetSize) { 03804 MiRemoveWorkingSetPages (WorkingSetList, WsInfo); 03805 } else { 03806 03807 if ((WorkingSetList->Quota + 15 + (PAGE_SIZE / sizeof(MMWSLE))) < 03808 WorkingSetList->LastEntry) { 03809 if ((WsInfo->MaximumWorkingSetSize + 15 + (PAGE_SIZE / sizeof(MMWSLE))) < 03810 WorkingSetList->LastEntry ) { 03811 MiRemoveWorkingSetPages (WorkingSetList, WsInfo); 03812 } 03813 } 03814 } 03815 } 03816 return Reduction - NumberLeftToRemove; 03817 }

VOID MiUpdateWsle (  IN OUT PWSLE_NUMBER  DesiredIndex, IN PVOID  VirtualAddress, PMMWSL  WorkingSetList, IN PMMPFN  Pfn )

Definition at line 1078 of file wslist.c. References ASSERT, ASSERT32, CONSISTENCY_LOCK_PFN, CONSISTENCY_UNLOCK_PFN, _MMWSL::FirstDynamic, _MMWSL::FirstFree, _MMWSL::HashTable, Index, _MMWSL::LastEntry, _MMWSL::LastInitializedWsle, MI_IS_SESSION_ADDRESS, MI_IS_SYSTEM_CACHE_ADDRESS, MI_ZERO_WSINDEX, MiInsertWsle(), MiSwapWslEntries(), MM_FREE_WSLE_SHIFT, MM_PAGED_POOL_START, MM_SYSTEM_SPACE_START, MM_SYSTEM_WS_LOCK_ASSERT, MmNonPagedSystemStart, MmPagedPoolPage, MmSessionSpace, MmSystemCachePage, MmSystemCacheStart, MmSystemCacheWorkingSetList, MmSystemCacheWs, MmSystemCacheWsle, MmSystemCodePage, MmSystemDriverPage, MmWsle, NULL, PAGE_ALIGN, PAGE_SIZE, PsGetCurrentProcess, PsGetCurrentThread, PWSLE_NUMBER, _MMWSLE::u1, _MM_SESSION_SPACE::Vm, _MMWSL::Wsle, WSLE_NULL_INDEX, and WSLE_NUMBER. Referenced by MiAddValidPageToWorkingSet(), MiAddWorkingSetPage(), MiAddWsleHash(), MiLockCode(), MmAccessFault(), MmCheckCachedPageState(), and MmCopyToCachedPage(). : This routine updates a reserved working set entry to place it into the valid state. Arguments: DesiredIndex - Supplies the index of the working set entry to update. VirtualAddress - Supplies the virtual address which the working set entry maps. WsInfo - Supplies a pointer to the working set info block for the process (or system cache). Pfn - Supplies a pointer to the PFN element for the page. Return Value: None. Environment: Kernel mode, APCs disabled, working set lock held and PFN lock held. --*/ { PMMWSLE Wsle; WSLE_NUMBER Index; WSLE_NUMBER WorkingSetIndex; #if PFN_CONSISTENCY KIRQL OldIrql; #endif WorkingSetIndex = *DesiredIndex; Wsle = WorkingSetList->Wsle; if (WorkingSetList == MmSystemCacheWorkingSetList) { // // This assert doesn't hold for NT64 as we can be adding page // directories and page tables for the system cache WSLE hash tables. // ASSERT32 ((VirtualAddress < (PVOID)PTE_BASE) || (VirtualAddress >= (PVOID)MM_SYSTEM_SPACE_START)); } else { ASSERT ((VirtualAddress < (PVOID)MM_SYSTEM_SPACE_START) || (MI_IS_SESSION_ADDRESS (VirtualAddress))); } ASSERT (WorkingSetIndex >= WorkingSetList->FirstDynamic); if (WorkingSetList == MmSystemCacheWorkingSetList) { MM_SYSTEM_WS_LOCK_ASSERT(); // // count system space inserts and removals. // #if defined(_X86_) if (MI_IS_SYSTEM_CACHE_ADDRESS(VirtualAddress)) { MmSystemCachePage += 1; } else #endif if (VirtualAddress < MmSystemCacheStart) { MmSystemCodePage += 1; } else if (VirtualAddress < MM_PAGED_POOL_START) { MmSystemCachePage += 1; } else if (VirtualAddress < MmNonPagedSystemStart) { MmPagedPoolPage += 1; } else { MmSystemDriverPage += 1; } } // // Make the wsle valid, referring to the corresponding virtual // page number. // // // The value 0 is invalid. This is due to the fact that the working // set lock is a process wide lock and two threads in different // processes could be adding the same physical page to their working // sets. Each one could see the WsIndex field in the PFN as 0, and // set the direct bit. To solve this, the WsIndex field is set to // the current thread pointer. // ASSERT (Pfn->u1.WsIndex != 0); #if DBG if (Pfn->u1.WsIndex <= WorkingSetList->LastInitializedWsle) { ASSERT ((PAGE_ALIGN(VirtualAddress) != PAGE_ALIGN(Wsle[Pfn->u1.WsIndex].u1.VirtualAddress)) || (Wsle[Pfn->u1.WsIndex].u1.e1.Valid == 0)); } #endif //DBG Wsle[WorkingSetIndex].u1.VirtualAddress = VirtualAddress; Wsle[WorkingSetIndex].u1.Long &= ~(PAGE_SIZE - 1); Wsle[WorkingSetIndex].u1.e1.Valid = 1; if ((ULONG_PTR)Pfn->u1.Event == (ULONG_PTR)PsGetCurrentThread()) { // // Directly index into the WSL for this entry via the PFN database // element. // CONSISTENCY_LOCK_PFN (OldIrql); #if defined(_WIN64) // // The entire working set index union must be zeroed on Win64 systems. // MI_ZERO_WSINDEX (Pfn); #endif Pfn->u1.WsIndex = WorkingSetIndex; CONSISTENCY_UNLOCK_PFN (OldIrql); Wsle[WorkingSetIndex].u1.e1.Direct = 1; return; } else if (WorkingSetList->HashTable == NULL) { // // Try to insert at WsIndex. // Index = Pfn->u1.WsIndex; if ((Index < WorkingSetList->LastInitializedWsle) && (Index > WorkingSetList->FirstDynamic) && (Index != WorkingSetIndex)) { if (Wsle[Index].u1.e1.Valid) { if (Wsle[Index].u1.e1.Direct) { // // Only move direct indexed entries. // PMMSUPPORT WsInfo; if (Wsle == MmWsle) { WsInfo = &PsGetCurrentProcess()->Vm; } else if (Wsle == MmSystemCacheWsle) { WsInfo = &MmSystemCacheWs; } else { WsInfo = &MmSessionSpace->Vm; } MiSwapWslEntries (Index, WorkingSetIndex, WsInfo); WorkingSetIndex = Index; } } else { // // On free list, try to remove quickly without walking // all the free pages. // ULONG FreeIndex; MMWSLE Temp; FreeIndex = 0; ASSERT (WorkingSetList->FirstFree >= WorkingSetList->FirstDynamic); ASSERT (WorkingSetIndex >= WorkingSetList->FirstDynamic); if (WorkingSetList->FirstFree == Index) { WorkingSetList->FirstFree = WorkingSetIndex; Temp = Wsle[WorkingSetIndex]; Wsle[WorkingSetIndex] = Wsle[Index]; Wsle[Index] = Temp; WorkingSetIndex = Index; ASSERT (((Wsle[WorkingSetList->FirstFree].u1.Long >> MM_FREE_WSLE_SHIFT) <= WorkingSetList->LastInitializedWsle) || ((Wsle[WorkingSetList->FirstFree].u1.Long >> MM_FREE_WSLE_SHIFT) == WSLE_NULL_INDEX)); } else if (Wsle[Index - 1].u1.e1.Valid == 0) { if ((Wsle[Index - 1].u1.Long >> MM_FREE_WSLE_SHIFT) == Index) { FreeIndex = Index - 1; } } else if (Wsle[Index + 1].u1.e1.Valid == 0) { if ((Wsle[Index + 1].u1.Long >> MM_FREE_WSLE_SHIFT) == Index) { FreeIndex = Index + 1; } } if (FreeIndex != 0) { // // Link the Wsle into the free list. // Temp = Wsle[WorkingSetIndex]; Wsle[FreeIndex].u1.Long = WorkingSetIndex << MM_FREE_WSLE_SHIFT; Wsle[WorkingSetIndex] = Wsle[Index]; Wsle[Index] = Temp; WorkingSetIndex = Index; ASSERT (((Wsle[FreeIndex].u1.Long >> MM_FREE_WSLE_SHIFT) <= WorkingSetList->LastInitializedWsle) || ((Wsle[FreeIndex].u1.Long >> MM_FREE_WSLE_SHIFT) == WSLE_NULL_INDEX)); } } *DesiredIndex = WorkingSetIndex; if (WorkingSetIndex > WorkingSetList->LastEntry) { WorkingSetList->LastEntry = WorkingSetIndex; } } } // // Insert the valid WSLE into the working set list. // MiInsertWsle (WorkingSetIndex, WorkingSetList); return; }

NTSTATUS MmAdjustWorkingSetSize (  IN SIZE_T  WorkingSetMinimumInBytes, IN SIZE_T  WorkingSetMaximumInBytes, IN ULONG  SystemCache )

Definition at line 2450 of file wslist.c. References _EPROCESS::AddressSpaceDeleted, _MMSUPPORT::AllowWorkingSetAdjustment, ASSERT, ExPageLockHandle, FALSE, _MMWSL::FirstDynamic, _MMWSL::FirstFree, _MMWSL::HashTable, _MMWSL::LastEntry, _MMWSL::LastInitializedWsle, LOCK_PFN, LOCK_SYSTEM_WS, LOCK_WS, _MMSUPPORT::MaximumWorkingSetSize, MI_NONPAGABLE_MEMORY_AVAILABLE, MiAddWorkingSetPage(), MiEmptyWorkingSet(), MiFreeWsle(), MiGetPteAddress, MiGrowWsleHash(), _MMSUPPORT::MinimumWorkingSetSize, MM_BUMP_COUNTER, MM_FLUID_WORKING_SET, MM_RETRY_COUNT, MmAllowWorkingSetExpansion(), MmAvailablePages, MmLockPagableSectionByHandle(), MmMaximumWorkingSetSize, MmMinimumWorkingSetSize, MmPagesAboveWsMinimum, MmResidentAvailablePages, MmSystemCacheWs, MmUnlockPagableImageSection(), NTSTATUS(), NULL, PAGE_SHIFT, PAGE_SIZE, PERFINFO_GET_PAGE_INFO, PERFINFO_LOG_WS_REMOVAL, PERFINFO_PAGE_INFO_DECL, PsGetCurrentProcess, _MMWSL::Quota, TRUE, _MMWSLE::u1, UNLOCK_PFN, UNLOCK_SYSTEM_WS, UNLOCK_WS, _MMWSLE::VirtualAddress, _EPROCESS::Vm, _MMSUPPORT::VmWorkingSetList, _MMSUPPORT::WorkingSetSize, _MMWSL::Wsle, WSLE_NULL_INDEX, and WSLE_NUMBER. Referenced by NtSetInformationJobObject(), NtSetSystemInformation(), PspAddProcessToJob(), PspSetQuotaLimits(), and xxxMinMaximize(). 02458 : 02459 02460 This routine adjusts the current size of a process's working set 02461 list. If the maximum value is above the current maximum, pages 02462 are removed from the working set list. 02463 02464 An exception is raised if the limit cannot be granted. This 02465 could occur if too many pages were locked in the process's 02466 working set. 02467 02468 Note: if the minimum and maximum are both (SIZE_T)-1, the working set 02469 is purged, but the default sizes are not changed. 02470 02471 Arguments: 02472 02473 WorkingSetMinimumInBytes - Supplies the new minimum working set size in 02474 bytes. 02475 02476 WorkingSetMaximumInBytes - Supplies the new maximum working set size in 02477 bytes. 02478 02479 SystemCache - Supplies TRUE if the system cache working set is being 02480 adjusted, FALSE for all other working sets. 02481 02482 Return Value: 02483 02484 NTSTATUS. 02485 02486 Environment: 02487 02488 Kernel mode, IRQL APC_LEVEL or below. 02489 02490 --*/ 02491 02492 02493 { 02494 PEPROCESS CurrentProcess; 02495 ULONG Entry; 02496 ULONG LastFreed; 02497 PMMWSLE Wsle; 02498 KIRQL OldIrql; 02499 KIRQL OldIrql2; 02500 SPFN_NUMBER i; 02501 PMMPTE PointerPte; 02502 NTSTATUS ReturnStatus; 02503 LONG PagesAbove; 02504 LONG NewPagesAbove; 02505 ULONG FreeTryCount; 02506 PMMSUPPORT WsInfo; 02507 PMMWSL WorkingSetList; 02508 WSLE_NUMBER WorkingSetMinimum; 02509 WSLE_NUMBER WorkingSetMaximum; 02510 02511 PERFINFO_PAGE_INFO_DECL(); 02512 02513 FreeTryCount = 0; 02514 02515 if (SystemCache) { 02516 WsInfo = &MmSystemCacheWs; 02517 } else { 02518 CurrentProcess = PsGetCurrentProcess (); 02519 WsInfo = &CurrentProcess->Vm; 02520 } 02521 02522 if ((WorkingSetMinimumInBytes == (SIZE_T)-1) && 02523 (WorkingSetMaximumInBytes == (SIZE_T)-1)) { 02524 return MiEmptyWorkingSet (WsInfo, TRUE); 02525 } 02526 02527 if (WorkingSetMinimumInBytes == 0) { 02528 WorkingSetMinimum = WsInfo->MinimumWorkingSetSize; 02529 } 02530 else { 02531 WorkingSetMinimum = (WSLE_NUMBER)(WorkingSetMinimumInBytes >> PAGE_SHIFT); 02532 } 02533 02534 if (WorkingSetMaximumInBytes == 0) { 02535 WorkingSetMaximum = WsInfo->MaximumWorkingSetSize; 02536 } 02537 else { 02538 WorkingSetMaximum = (WSLE_NUMBER)(WorkingSetMaximumInBytes >> PAGE_SHIFT); 02539 } 02540 02541 if (WorkingSetMinimum > WorkingSetMaximum) { 02542 return STATUS_BAD_WORKING_SET_LIMIT; 02543 } 02544 02545 MmLockPagableSectionByHandle(ExPageLockHandle); 02546 02547 ReturnStatus = STATUS_SUCCESS; 02548 02549 // 02550 // Get the working set lock and disable APCs. 02551 // 02552 02553 if (SystemCache) { 02554 LOCK_SYSTEM_WS (OldIrql2); 02555 } else { 02556 LOCK_WS (CurrentProcess); 02557 02558 if (CurrentProcess->AddressSpaceDeleted != 0) { 02559 ReturnStatus = STATUS_PROCESS_IS_TERMINATING; 02560 goto Returns; 02561 } 02562 } 02563 02564 if (WorkingSetMaximum > MmMaximumWorkingSetSize) { 02565 WorkingSetMaximum = MmMaximumWorkingSetSize; 02566 ReturnStatus = STATUS_WORKING_SET_LIMIT_RANGE; 02567 } 02568 02569 if (WorkingSetMinimum > MmMaximumWorkingSetSize) { 02570 WorkingSetMinimum = MmMaximumWorkingSetSize; 02571 ReturnStatus = STATUS_WORKING_SET_LIMIT_RANGE; 02572 } 02573 02574 if (WorkingSetMinimum < MmMinimumWorkingSetSize) { 02575 WorkingSetMinimum = (ULONG)MmMinimumWorkingSetSize; 02576 ReturnStatus = STATUS_WORKING_SET_LIMIT_RANGE; 02577 } 02578 02579 // 02580 // Make sure that the number of locked pages will not 02581 // make the working set not fluid. 02582 // 02583 02584 if ((WsInfo->VmWorkingSetList->FirstDynamic + MM_FLUID_WORKING_SET) >= 02585 WorkingSetMaximum) { 02586 ReturnStatus = STATUS_BAD_WORKING_SET_LIMIT; 02587 goto Returns; 02588 } 02589 02590 WorkingSetList = WsInfo->VmWorkingSetList; 02591 Wsle = WorkingSetList->Wsle; 02592 02593 // 02594 // Check to make sure ample resident physical pages exist for 02595 // this operation. 02596 // 02597 02598 LOCK_PFN (OldIrql); 02599 02600 i = WorkingSetMinimum - WsInfo->MinimumWorkingSetSize; 02601 02602 if (i > 0) { 02603 02604 // 02605 // New minimum working set is greater than the old one. Ensure that 02606 // we don't allow this process' working set minimum to increase to 02607 // a point where subsequent nonpaged pool allocations could cause 02608 // us to run out of pages. Additionally, leave 100 extra pages around 02609 // so the user can later bring up tlist and kill processes if necessary. 02610 // 02611 02612 if (MmAvailablePages < (20 + (i / (PAGE_SIZE / sizeof (MMWSLE))))) { 02613 UNLOCK_PFN (OldIrql); 02614 ReturnStatus = STATUS_INSUFFICIENT_RESOURCES; 02615 goto Returns; 02616 } 02617 02618 if (MI_NONPAGABLE_MEMORY_AVAILABLE() - 100 < i) { 02619 UNLOCK_PFN (OldIrql); 02620 ReturnStatus = STATUS_INSUFFICIENT_RESOURCES; 02621 goto Returns; 02622 } 02623 } 02624 02625 // 02626 // Adjust the number of resident pages up or down dependent on 02627 // the size of the new minimum working set size versus the previous 02628 // minimum size. 02629 // 02630 02631 MmResidentAvailablePages -= i; 02632 MM_BUMP_COUNTER(27, i); 02633 02634 UNLOCK_PFN (OldIrql); 02635 02636 if (WsInfo->AllowWorkingSetAdjustment == FALSE) { 02637 MmAllowWorkingSetExpansion (); 02638 } 02639 02640 if (WorkingSetMaximum > WorkingSetList->LastInitializedWsle) { 02641 02642 do { 02643 02644 // 02645 // The maximum size of the working set is being increased, check 02646 // to ensure the proper number of pages are mapped to cover 02647 // the complete working set list. 02648 // 02649 02650 if (!MiAddWorkingSetPage (WsInfo)) { 02651 WorkingSetMaximum = WorkingSetList->LastInitializedWsle - 1; 02652 break; 02653 } 02654 } while (WorkingSetMaximum > WorkingSetList->LastInitializedWsle); 02655 02656 } else { 02657 02658 // 02659 // The new working set maximum is less than the current working set 02660 // maximum. 02661 // 02662 02663 if (WsInfo->WorkingSetSize > WorkingSetMaximum) { 02664 02665 // 02666 // Remove some pages from the working set. 02667 // 02668 02669 // 02670 // Make sure that the number of locked pages will not 02671 // make the working set not fluid. 02672 // 02673 02674 if ((WorkingSetList->FirstDynamic + MM_FLUID_WORKING_SET) >= 02675 WorkingSetMaximum) { 02676 02677 ReturnStatus = STATUS_BAD_WORKING_SET_LIMIT; 02678 02679 LOCK_PFN (OldIrql); 02680 02681 MmResidentAvailablePages += i; 02682 MM_BUMP_COUNTER(54, i); 02683 02684 UNLOCK_PFN (OldIrql); 02685 02686 goto Returns; 02687 } 02688 02689 // 02690 // Attempt to remove the pages from the Maximum downward. 02691 // 02692 02693 LastFreed = WorkingSetList->LastEntry; 02694 if (WorkingSetList->LastEntry > WorkingSetMaximum) { 02695 02696 while (LastFreed >= WorkingSetMaximum) { 02697 02698 PointerPte = MiGetPteAddress( 02699 Wsle[LastFreed].u1.VirtualAddress); 02700 02701 PERFINFO_GET_PAGE_INFO(PointerPte); 02702 02703 if ((Wsle[LastFreed].u1.e1.Valid != 0) && 02704 (!MiFreeWsle (LastFreed, 02705 WsInfo, 02706 PointerPte))) { 02707 02708 // 02709 // This LastFreed could not be removed. 02710 // 02711 02712 break; 02713 } 02714 PERFINFO_LOG_WS_REMOVAL(PERFINFO_LOG_TYPE_OUTWS_ADJUSTWS, WsInfo); 02715 LastFreed -= 1; 02716 } 02717 WorkingSetList->LastEntry = LastFreed; 02718 } 02719 02720 // 02721 // Remove pages. 02722 // 02723 02724 Entry = WorkingSetList->FirstDynamic; 02725 02726 while (WsInfo->WorkingSetSize > WorkingSetMaximum) { 02727 if (Wsle[Entry].u1.e1.Valid != 0) { 02728 PointerPte = MiGetPteAddress ( 02729 Wsle[Entry].u1.VirtualAddress); 02730 PERFINFO_GET_PAGE_INFO(PointerPte); 02731 02732 if (MiFreeWsle(Entry, WsInfo, PointerPte)) { 02733 PERFINFO_LOG_WS_REMOVAL(PERFINFO_LOG_TYPE_OUTWS_ADJUSTWS, 02734 WsInfo); 02735 } 02736 } 02737 Entry += 1; 02738 if (Entry > LastFreed) { 02739 FreeTryCount += 1; 02740 if (FreeTryCount > MM_RETRY_COUNT) { 02741 02742 // 02743 // Page table pages are not becoming free, give up 02744 // and return an error. 02745 // 02746 02747 ReturnStatus = STATUS_BAD_WORKING_SET_LIMIT; 02748 02749 break; 02750 } 02751 Entry = WorkingSetList->FirstDynamic; 02752 } 02753 } 02754 02755 if (FreeTryCount <= MM_RETRY_COUNT) { 02756 WorkingSetList->Quota = WorkingSetMaximum; 02757 } 02758 } 02759 } 02760 02761 // 02762 // Adjust the number of pages above the working set minimum. 02763 // 02764 02765 PagesAbove = (LONG)WsInfo->WorkingSetSize - 02766 (LONG)WsInfo->MinimumWorkingSetSize; 02767 NewPagesAbove = (LONG)WsInfo->WorkingSetSize - 02768 (LONG)WorkingSetMinimum; 02769 02770 LOCK_PFN (OldIrql); 02771 if (PagesAbove > 0) { 02772 MmPagesAboveWsMinimum -= (ULONG)PagesAbove; 02773 } 02774 if (NewPagesAbove > 0) { 02775 MmPagesAboveWsMinimum += (ULONG)NewPagesAbove; 02776 } 02777 UNLOCK_PFN (OldIrql); 02778 02779 if (FreeTryCount <= MM_RETRY_COUNT) { 02780 WsInfo->MaximumWorkingSetSize = WorkingSetMaximum; 02781 WsInfo->MinimumWorkingSetSize = WorkingSetMinimum; 02782 02783 if (WorkingSetMinimum >= WorkingSetList->Quota) { 02784 WorkingSetList->Quota = WorkingSetMinimum; 02785 } 02786 } 02787 else { 02788 LOCK_PFN (OldIrql); 02789 02790 MmResidentAvailablePages += i; 02791 MM_BUMP_COUNTER(55, i); 02792 02793 UNLOCK_PFN (OldIrql); 02794 } 02795 02796 02797 ASSERT ((WorkingSetList->FirstFree <= WorkingSetList->LastInitializedWsle) || 02798 (WorkingSetList->FirstFree == WSLE_NULL_INDEX)); 02799 02800 if ((WorkingSetList->HashTable == NULL) && 02801 (WsInfo->MaximumWorkingSetSize > ((1536*1024) >> PAGE_SHIFT))) { 02802 02803 // 02804 // The working set list consists of more than a single page. 02805 // 02806 02807 MiGrowWsleHash (WsInfo); 02808 } 02809 02810 Returns: 02811 02812 if (SystemCache) { 02813 UNLOCK_SYSTEM_WS (OldIrql2); 02814 } else { 02815 UNLOCK_WS (CurrentProcess); 02816 } 02817 02818 MmUnlockPagableImageSection(ExPageLockHandle); 02819 02820 return ReturnStatus; 02821 }

LOGICAL MmAssignProcessToJob (  IN PEPROCESS  Process  )

Definition at line 2386 of file wslist.c. References FALSE, KeAttachProcess(), KeDetachProcess(), LOCK_WS_AND_ADDRESS_SPACE, PAGED_CODE, PS_JOB_STATUS_REPORT_COMMIT_CHANGES, PsChangeJobMemoryUsage(), PsGetCurrentProcess, Status, TRUE, and UNLOCK_WS_AND_ADDRESS_SPACE. Referenced by PspAddProcessToJob(). : This routine acquires the working set lock so a consistent snapshot of the argument process' commit charges and working set size can be used when adding this process to a job. Arguments: Process - Supplies a pointer to the process to operate upon. Return Value: TRUE if the process is allowed to join the job, FALSE otherwise. Note that FALSE cannot be returned without changing the code in ps. Environment: Kernel mode, IRQL APC_LEVEL or below. The caller provides protection from the target process going away. --*/ { LOGICAL Attached; LOGICAL Status; PAGED_CODE (); Attached = FALSE; if (PsGetCurrentProcess() != Process) { KeAttachProcess (&Process->Pcb); Attached = TRUE; } LOCK_WS_AND_ADDRESS_SPACE (Process); Status = PsChangeJobMemoryUsage (Process->CommitCharge); // // Join the job unconditionally. If the process is over any limits, it // will be caught on its next request. // Process->JobStatus |= PS_JOB_STATUS_REPORT_COMMIT_CHANGES; UNLOCK_WS_AND_ADDRESS_SPACE (Process); if (Attached) { KeDetachProcess(); } return TRUE; }

LOGICAL MmEnforceWorkingSetLimit (  IN PMMSUPPORT  WsInfo, IN LOGICAL  Enable )

Definition at line 543 of file wslist.c. References LOCK_EXPANSION, LOCK_SYSTEM_WS, LOCK_WS, MmSystemCacheWs, PsGetCurrentProcess, UNLOCK_EXPANSION, UNLOCK_SYSTEM_WS, and UNLOCK_WS. Referenced by NtSetInformationJobObject(), PspAddProcessToJob(), and PspApplyJobLimitsToProcess(). : This function enables hard enforcement of the working set maximum for the specified WsInfo. Arguments: WsInfo - Supplies the working set info pointer. Enable - Supplies TRUE if enabling hard enforcement, FALSE if not. Return Value: The previous state of the working set enforcement. Environment: Kernel mode, APCs disabled. The working set lock must NOT be held. The caller guarantees that the target WsInfo cannot go away. --*/ { KIRQL OldIrql; LOGICAL PreviousWorkingSetEnforcement; LOCK_EXPANSION (OldIrql); PreviousWorkingSetEnforcement = WsInfo->u.Flags.WorkingSetHard; WsInfo->u.Flags.WorkingSetHard = Enable; UNLOCK_EXPANSION (OldIrql); #if 0 PEPROCESS CurrentProcess; // // Get the working set lock and disable APCs. // The working set could be trimmed at this point if it is excessive. // // The working set lock cannot be acquired at this point without updating // ps in order to avoid deadlock. // if (WsInfo == &MmSystemCacheWs) { LOCK_SYSTEM_WS (OldIrql2); UNLOCK_SYSTEM_WS (OldIrql2); } else if (WsInfo->u.Flags.SessionSpace == 0) { CurrentProcess = PsGetCurrentProcess (); LOCK_WS (CurrentProcess); UNLOCK_WS (CurrentProcess); } #endif return PreviousWorkingSetEnforcement; }

---

Variable Documentation

LOGICAL MiTrimRemovalPagesOnly

Definition at line 50 of file wslist.c. Referenced by MiEmptyWorkingSet(), and MmRemovePhysicalMemory().

ULONG MmFaultsTakenToGoAboveMaxWs = 100

Definition at line 33 of file wslist.c.

ULONG MmFaultsTakenToGoAboveMinWs = 16

Definition at line 34 of file wslist.c. Referenced by MiDoReplacement().

ULONG MmMaximumWorkingSetSize

Definition at line 31 of file wslist.c. Referenced by MmAdjustWorkingSetSize(), and MmInitSystem().

ULONG MmPagedPoolPage

Definition at line 38 of file wslist.c.

ULONG MmSystemCachePage

Definition at line 37 of file wslist.c.

ULONG MmSystemCodePage

Definition at line 36 of file wslist.c.

ULONG MmSystemDriverPage

Definition at line 39 of file wslist.c.

ULONG MmTransitionSharedPages

Definition at line 47 of file wslist.c.

ULONG MmTransitionSharedPagesPeak

Definition at line 48 of file wslist.c. Referenced by MiLocateAndReserveWsle(), and NtQuerySystemInformation().

---