pfnlist.c File Reference

#include "mi.h"

Go to the source code of this file.

Defines
#define	MM_LOW_LIMIT   2
#define	MM_HIGH_LIMIT   19
#define	MI_TALLY_TRANSITION_PAGE_ADDITION(Pfn)
#define	MI_TALLY_TRANSITION_PAGE_REMOVAL(Pfn)
Functions
VOID	MiRemovePageByColor (IN PFN_NUMBER Page, IN ULONG PageColor)
VOID FASTCALL	MiInsertPageInList (IN PMMPFNLIST ListHead, IN PFN_NUMBER PageFrameIndex)
VOID FASTCALL	MiInsertStandbyListAtFront (IN PFN_NUMBER PageFrameIndex)
PFN_NUMBER FASTCALL	MiRemovePageFromList (IN PMMPFNLIST ListHead)
VOID FASTCALL	MiUnlinkPageFromList (IN PMMPFN Pfn)
VOID	MiUnlinkFreeOrZeroedPage (IN PFN_NUMBER Page)
ULONG FASTCALL	MiEnsureAvailablePageOrWait (IN PEPROCESS Process, IN PVOID VirtualAddress)
PFN_NUMBER FASTCALL	MiRemoveZeroPage (IN ULONG PageColor)
PFN_NUMBER FASTCALL	MiRemoveAnyPage (IN ULONG PageColor)
VOID FASTCALL	MiInsertFrontModifiedNoWrite (IN PFN_NUMBER PageFrameIndex)
Variables
KEVENT	MmAvailablePagesEventHigh
ULONG	MmTransitionPrivatePages
ULONG	MmTransitionSharedPages

---

Define Documentation

#define MI_TALLY_TRANSITION_PAGE_ADDITION (  Pfn   )

Value: if (Pfn->u3.e1.PrototypePte) { \ MmTransitionSharedPages += 1; \ } \ else { \ MmTransitionPrivatePages += 1; \ } \ ASSERT (MmTransitionPrivatePages + MmTransitionSharedPages == MmStandbyPageListHead.Total + MmModifiedPageListHead.Total + MmModifiedNoWritePageListHead.Total); Definition at line 32 of file pfnlist.c. Referenced by MiInsertFrontModifiedNoWrite(), and MiInsertPageInList().

#define MI_TALLY_TRANSITION_PAGE_REMOVAL (  Pfn   )

Value: if (Pfn->u3.e1.PrototypePte) { \ MmTransitionSharedPages -= 1; \ } \ else { \ MmTransitionPrivatePages -= 1; \ } \ ASSERT (MmTransitionPrivatePages + MmTransitionSharedPages == MmStandbyPageListHead.Total + MmModifiedPageListHead.Total + MmModifiedNoWritePageListHead.Total); Definition at line 41 of file pfnlist.c. Referenced by MiRemovePageFromList(), and MiUnlinkPageFromList().

#define MM_HIGH_LIMIT   19

Definition at line 25 of file pfnlist.c. Referenced by MiEnsureAvailablePageOrWait(), MiInsertPageInList(), and MiInsertStandbyListAtFront().

#define MM_LOW_LIMIT   2

Definition at line 24 of file pfnlist.c. Referenced by MiEnsureAvailablePageOrWait(), MiInsertPageInList(), and MiInsertStandbyListAtFront().

---

Function Documentation

ULONG FASTCALL MiEnsureAvailablePageOrWait (  IN PEPROCESS  Process, IN PVOID  VirtualAddress )

Definition at line 941 of file pfnlist.c. References APC_LEVEL, _PHYSICAL_MEMORY_RUN::BasePage, DbgPrint, Event(), FALSE, FASTCALL, HYDRA_PROCESS, HYPER_SPACE, KdDebuggerNotPresent, KeBugCheckEx(), KeClearEvent, KernelMode, KeWaitForSingleObject(), LOCK_PFN, LOCK_SESSION_SPACE_WS, LOCK_SYSTEM_WS, LOCK_WS_REGARDLESS, MI_IS_HYPER_SPACE_ADDRESS, MI_IS_SYSTEM_ADDRESS, MI_PFN_ELEMENT, MiGetPteAddress, MM_HIGH_LIMIT, MM_LOW_LIMIT, MM_PFN_LOCK_ASSERT, MmAllocatedNonPagedPool, MmAvailablePages, MmAvailablePagesEvent, MmAvailablePagesEventHigh, MmMaximumNonPagedPoolInBytes, MmModifiedPageListHead, MmPhysicalMemoryBlock, MmSevenMinutes, MmSystemLockOwner, MmTotalPagesForPagingFile, NTSTATUS(), NULL, _PHYSICAL_MEMORY_DESCRIPTOR::NumberOfRuns, PAGE_SHIFT, _PHYSICAL_MEMORY_RUN::PageCount, PsGetCurrentThread, _PHYSICAL_MEMORY_DESCRIPTOR::Run, Status, _MMPFNLIST::Total, TransitionPage, TRUE, _MMPFN::u3, UNLOCK_PFN, UNLOCK_SESSION_SPACE_WS, UNLOCK_SYSTEM_WS, UNLOCK_WS_REGARDLESS, and WrFreePage. Referenced by MiCopyOnWrite(), MiDoneWithThisPageGetAnother(), MiFillSystemPageDirectory(), MiGetPageForHeader(), MiInitializeSessionPool(), MiInitializeWorkingSetList(), MiLoadImageSection(), MiMakeOutswappedPageResident(), MiReloadBootLoadedDrivers(), MiResolveDemandZeroFault(), MiResolveMappedFileFault(), MiResolvePageFileFault(), MiSessionCommitImagePages(), MiSessionCommitPageTables(), MiSessionCopyOnWrite(), MiSessionCreateInternal(), MiSessionInitializeWorkingSetList(), MmAccessFault(), MmAllocateIndependentPages(), MmAllocateNonCachedMemory(), MmCopyToCachedPage(), MmCreateKernelStack(), MmCreateProcessAddressSpace(), and MmGrowKernelStack(). : This procedure ensures that a physical page is available on the zeroed, free or standby list such that the next call the remove a page absolutely will not block. This is necessary as blocking would require a wait which could cause a deadlock condition. If a page is available the function returns immediately with a value of FALSE indicating no wait operation was performed. If no physical page is available, the thread enters a wait state and the function returns the value TRUE when the wait operation completes. Arguments: Process - Supplies a pointer to the current process if, and only if, the working set mutex is held currently held and should be released if a wait operation is issued. Supplies the value NULL otherwise. VirtualAddress - Supplies the virtual address for the faulting page. If the value is NULL, the page is treated as a user mode address. Return Value: FALSE - if a page was immediately available. TRUE - if a wait operation occurred before a page became available. Environment: Must be holding the PFN database mutex with APCs disabled. --*/ { PVOID Event; NTSTATUS Status; KIRQL OldIrql; KIRQL Ignore; ULONG Limit; ULONG Relock; PFN_NUMBER StrandedPages; LOGICAL WsHeldSafe; PMMPFN Pfn1; PMMPFN EndPfn; LARGE_INTEGER WaitBegin; LARGE_INTEGER WaitEnd; MM_PFN_LOCK_ASSERT(); if (MmAvailablePages >= MM_HIGH_LIMIT) { // // Pages are available. // return FALSE; } // // If this fault is for paged pool (or pagable kernel space, // including page table pages), let it use the last page. // #if defined(_IA64_) if (MI_IS_SYSTEM_ADDRESS(VirtualAddress) || (MI_IS_HYPER_SPACE_ADDRESS(VirtualAddress))) { #else if (((PMMPTE)VirtualAddress > MiGetPteAddress(HYPER_SPACE)) || ((VirtualAddress > MM_HIGHEST_USER_ADDRESS) && (VirtualAddress < (PVOID)PTE_BASE))) { #endif // // This fault is in the system, use 1 page as the limit. // if (MmAvailablePages >= MM_LOW_LIMIT) { // // Pages are available. // return FALSE; } Limit = MM_LOW_LIMIT; Event = (PVOID)&MmAvailablePagesEvent; } else { Limit = MM_HIGH_LIMIT; Event = (PVOID)&MmAvailablePagesEventHigh; } while (MmAvailablePages < Limit) { KeClearEvent ((PKEVENT)Event); UNLOCK_PFN (APC_LEVEL); if (Process == HYDRA_PROCESS) { UNLOCK_SESSION_SPACE_WS (APC_LEVEL); } else if (Process != NULL) { // // The working set lock may have been acquired safely or unsafely // by our caller. Handle both cases here and below. // UNLOCK_WS_REGARDLESS (Process, WsHeldSafe); } else { Relock = FALSE; if (MmSystemLockOwner == PsGetCurrentThread()) { UNLOCK_SYSTEM_WS (APC_LEVEL); Relock = TRUE; } } KiQueryInterruptTime(&WaitBegin); // // Wait 7 minutes for pages to become available. // Status = KeWaitForSingleObject(Event, WrFreePage, KernelMode, FALSE, (PLARGE_INTEGER)&MmSevenMinutes); if (Status == STATUS_TIMEOUT) { KiQueryInterruptTime(&WaitEnd); // // See how many transition pages have nonzero reference counts as // these indicate drivers that aren't unlocking the pages in their // MDLs. // Limit = 0; StrandedPages = 0; do { Pfn1 = MI_PFN_ELEMENT (MmPhysicalMemoryBlock->Run[Limit].BasePage); EndPfn = Pfn1 + MmPhysicalMemoryBlock->Run[Limit].PageCount; while (Pfn1 < EndPfn) { if ((Pfn1->u3.e1.PageLocation == TransitionPage) && (Pfn1->u3.e2.ReferenceCount != 0)) { StrandedPages += 1; } Pfn1 += 1; } Limit += 1; } while (Limit != MmPhysicalMemoryBlock->NumberOfRuns); // // This bugcheck can occur for the following reasons: // // A driver has blocked, deadlocking the modified or mapped // page writers. Examples of this include mutex deadlocks or // accesses to paged out memory in filesystem drivers, filter // drivers, etc. This indicates a driver bug. // // The storage driver(s) are not processing requests. Examples // of this are stranded queues, non-responding drives, etc. This // indicates a driver bug. // // Not enough pool is available for the storage stack to write out // modified pages. This indicates a driver bug. // // A high priority realtime thread has starved the balance set // manager from trimming pages and/or starved the modified writer // from writing them out. This indicates a bug in the component // that created this thread. // // All the processes have been trimmed to their minimums and all // modified pages written, but still no memory is available. The // freed memory must be stuck in transition pages with non-zero // reference counts - thus they cannot be put on the freelist. // A driver is neglecting to unlock the pages preventing the // reference counts from going to zero which would free the pages. // This may be due to transfers that never finish and the driver // never aborts or other driver bugs. // KeBugCheckEx (NO_PAGES_AVAILABLE, MmModifiedPageListHead.Total, MmTotalPagesForPagingFile, (MmMaximumNonPagedPoolInBytes >> PAGE_SHIFT) - MmAllocatedNonPagedPool, StrandedPages); if (!KdDebuggerNotPresent) { DbgPrint ("MmEnsureAvailablePageOrWait: 7 min timeout %x %x %x %x\n", WaitEnd.HighPart, WaitEnd.LowPart, WaitBegin.HighPart, WaitBegin.LowPart); DbgBreakPoint (); } } if (Process == HYDRA_PROCESS) { LOCK_SESSION_SPACE_WS (Ignore); } else if (Process != NULL) { // // The working set lock may have been acquired safely or unsafely // by our caller. Reacquire it in the same manner our caller did. // LOCK_WS_REGARDLESS (Process, WsHeldSafe); } else { if (Relock) { LOCK_SYSTEM_WS (Ignore); } } LOCK_PFN (OldIrql); } return TRUE; }

VOID FASTCALL MiInsertFrontModifiedNoWrite (  IN PFN_NUMBER  PageFrameIndex  )

Definition at line 1683 of file pfnlist.c. References ASSERT, _MMPFNLIST::Blink, _MMPFNLIST::Flink, MI_PFN_ELEMENT, MI_TALLY_TRANSITION_PAGE_ADDITION, MM_EMPTY_LIST, MM_PFN_LOCK_ASSERT, MmHighestPhysicalPage, MmLowestPhysicalPage, MmModifiedNoWritePageListHead, ModifiedNoWritePageList, _MMPFNLIST::Total, _MMPFN::u1, _MMPFN::u2, and _MMPFN::u3. Referenced by MiGatherMappedPages(). 01689 : 01690 01691 This procedure inserts a page at the FRONT of the modified no 01692 write list. 01693 01694 Arguments: 01695 01696 PageFrameIndex - Supplies the physical page number to insert in the 01697 list. 01698 01699 Return Value: 01700 01701 none. 01702 01703 Environment: 01704 01705 Must be holding the PFN database mutex with APCs disabled. 01706 01707 --*/ 01708 01709 { 01710 PFN_NUMBER first; 01711 PMMPFN Pfn1; 01712 PMMPFN Pfn2; 01713 01714 MM_PFN_LOCK_ASSERT(); 01715 ASSERT ((PageFrameIndex != 0) && (PageFrameIndex <= MmHighestPhysicalPage) && 01716 (PageFrameIndex >= MmLowestPhysicalPage)); 01717 01718 // 01719 // Check to ensure the reference count for the page 01720 // is zero. 01721 // 01722 01723 Pfn1 = MI_PFN_ELEMENT(PageFrameIndex); 01724 01725 ASSERT (Pfn1->u3.e2.ReferenceCount == 0); 01726 01727 MmModifiedNoWritePageListHead.Total += 1; // One more page on the list. 01728 01729 MI_TALLY_TRANSITION_PAGE_ADDITION (Pfn1); 01730 01731 first = MmModifiedNoWritePageListHead.Flink; 01732 if (first == MM_EMPTY_LIST) { 01733 01734 // 01735 // List is empty add the page to the ListHead. 01736 // 01737 01738 MmModifiedNoWritePageListHead.Blink = PageFrameIndex; 01739 } else { 01740 Pfn2 = MI_PFN_ELEMENT (first); 01741 Pfn2->u2.Blink = PageFrameIndex; 01742 } 01743 01744 MmModifiedNoWritePageListHead.Flink = PageFrameIndex; 01745 Pfn1->u1.Flink = first; 01746 Pfn1->u2.Blink = MM_EMPTY_LIST; 01747 Pfn1->u3.e1.PageLocation = ModifiedNoWritePageList; 01748 return; 01749 } }

VOID FASTCALL MiInsertPageInList (  IN PMMPFNLIST  ListHead, IN PFN_NUMBER  PageFrameIndex )

Definition at line 59 of file pfnlist.c. References ASSERT, BadPageList, _MMCOLOR_TABLES::Blink, FALSE, _MMCOLOR_TABLES::Flink, FreePageList, KeBugCheckEx(), KeSetEvent(), KeSetTimerEx(), MI_BARRIER_STAMP_ZEROED_PAGE, MI_GET_COLOR_FROM_SECONDARY, MI_GET_PAGE_FRAME_FROM_PTE, MI_GET_PAGE_FRAME_FROM_TRANSITION_PTE, MI_GET_SECONDARY_COLOR, MI_PFN_ELEMENT, MI_TALLY_TRANSITION_PAGE_ADDITION, MiGetByteOffset, MiMapPageInHyperSpace(), MiModifiedPageLife, MiModifiedPageWriterTimer, MiModifiedPageWriterTimerDpc, MiRestoreTransitionPte(), MiTimerPending, MiUnmapPageInHyperSpace, MM_DBG_PAGE_REF_COUNT, MM_EMPTY_LIST, MM_HIGH_LIMIT, MM_LOW_LIMIT, MM_PFN_LOCK_ASSERT, MmAvailablePages, MmAvailablePagesEvent, MmAvailablePagesEventHigh, MmFreePageListHead, MmFreePagesByColor, MmHighestPhysicalPage, MmIsAddressValid(), MmLowestPhysicalPage, MmMinimumFreePagesToZero, MmModifiedPageListByColor, MmModifiedPageListHead, MmModifiedPageMaximum, MmModifiedPageWriterEvent, MmPageLocationList, MmTotalPagesForPagingFile, MmZeroedPageListHead, MmZeroingPageEvent, MmZeroingPageThreadActive, ModifiedNoWritePageList, ModifiedPageList, _MMPFN::OriginalPte, PERFINFO_INSERTINLIST, PsGetCurrentProcess, _MMPFN::PteAddress, _MMPFN::PteFrame, StandbyPageList, _MMPFNLIST::Total, TRUE, _MMPTE::u, _MMPFN::u1, _MMPFN::u2, _MMPFN::u3, VOID(), and ZeroedPageList. Referenced by MiCleanSection(), MiDecommitPages(), MiDecrementCloneBlockReference(), MiDecrementReferenceCount(), MiDeletePte(), MiDeleteSystemPagableVm(), MiDispatchFault(), MiFreeInitializationCode(), MiGatherMappedPages(), MiInitMachineDependent(), MiModifiedPageWriterWorker(), MiPurgeImageSection(), MiRemovePhysicalPages(), MiResetVirtualMemory(), MiResolveTransitionFault(), MiSegmentDelete(), MmAddPhysicalMemory(), MmDeleteProcessAddressSpace(), MmFreeLoaderBlock(), MmPurgeSection(), MmRemovePhysicalMemory(), and MmZeroPageThread(). : This procedure inserts a page at the end of the specified list (free, standby, bad, zeroed, modified). Arguments: ListHead - Supplies the list of the list in which to insert the specified physical page. PageFrameIndex - Supplies the physical page number to insert in the list. Return Value: none. Environment: Must be holding the PFN database mutex with APCs disabled. --*/ { PFN_NUMBER last; PMMPFN Pfn1; PMMPFN Pfn2; ULONG Color; MM_PFN_LOCK_ASSERT(); ASSERT ((PageFrameIndex != 0) && (PageFrameIndex <= MmHighestPhysicalPage) && (PageFrameIndex >= MmLowestPhysicalPage)); // // Check to ensure the reference count for the page is zero. // Pfn1 = MI_PFN_ELEMENT(PageFrameIndex); ASSERT (Pfn1->u3.e1.LockCharged == 0); PERFINFO_INSERTINLIST(PageFrameIndex, ListHead); #if DBG if (MmDebug & MM_DBG_PAGE_REF_COUNT) { PMMPTE PointerPte; KIRQL OldIrql = 99; if ((ListHead->ListName == StandbyPageList) || (ListHead->ListName == ModifiedPageList)) { if ((Pfn1->u3.e1.PrototypePte == 1) && (MmIsAddressValid (Pfn1->PteAddress))) { PointerPte = Pfn1->PteAddress; } else { // // The page containing the prototype PTE is not valid, // map the page into hyperspace and reference it that way. // PointerPte = MiMapPageInHyperSpace (Pfn1->PteFrame, &OldIrql); PointerPte = (PMMPTE)((PCHAR)PointerPte + MiGetByteOffset(Pfn1->PteAddress)); } ASSERT ((MI_GET_PAGE_FRAME_FROM_TRANSITION_PTE (PointerPte) == PageFrameIndex) || (MI_GET_PAGE_FRAME_FROM_PTE (PointerPte) == PageFrameIndex)); ASSERT (PointerPte->u.Soft.Transition == 1); ASSERT (PointerPte->u.Soft.Prototype == 0); if (OldIrql != 99) { MiUnmapPageInHyperSpace (OldIrql) } } } #endif #if PFN_CONSISTENCY if (ListHead == &MmFreePageListHead) { if (Pfn1->u2.ShareCount != 0) { KeBugCheckEx (PFN_LIST_CORRUPT, 0x91, PageFrameIndex, Pfn1->u2.ShareCount, Pfn1->u3.e2.ReferenceCount); } } else if (ListHead == &MmZeroedPageListHead) { if (Pfn1->u2.ShareCount != 0) { KeBugCheckEx (PFN_LIST_CORRUPT, 0x92, PageFrameIndex, Pfn1->u2.ShareCount, Pfn1->u3.e2.ReferenceCount); } } #endif #if DBG if ((ListHead->ListName == StandbyPageList) || (ListHead->ListName == ModifiedPageList)) { if ((Pfn1->OriginalPte.u.Soft.Prototype == 0) && (Pfn1->OriginalPte.u.Soft.Transition == 1)) { KeBugCheckEx (MEMORY_MANAGEMENT, 0x8888, 0,0,0); } } #endif ASSERT (Pfn1->u3.e2.ReferenceCount == 0); ListHead->Total += 1; // One more page on the list. // // On MIPS R4000 modified pages destined for the paging file are // kept on separate lists which group pages of the same color // together // if (ListHead == &MmModifiedPageListHead) { #if PFN_CONSISTENCY if (Pfn1->u2.ShareCount != 0) { KeBugCheckEx (PFN_LIST_CORRUPT, 0x90, PageFrameIndex, Pfn1->u2.ShareCount, Pfn1->u3.e2.ReferenceCount); } #endif if (Pfn1->OriginalPte.u.Soft.Prototype == 0) { // // This page is destined for the paging file (not // a mapped file). Change the list head to the // appropriate colored list head. // ListHead = &MmModifiedPageListByColor [Pfn1->u3.e1.PageColor]; ListHead->Total += 1; MmTotalPagesForPagingFile += 1; } else { // // This page is destined for a mapped file (not // the paging file). If there are no other pages currently // destined for the mapped file, start our timer so that we can // ensure that these pages make it to disk even if we don't pile // up enough of them to trigger the modified page writer or need // the memory. If we don't do this here, then for this scenario, // only an orderly system shutdown will write them out (days, // weeks, months or years later) and any power out in between // means we'll have lost the data. // if (ListHead->Total - MmTotalPagesForPagingFile == 1) { // // Start the DPC timer because we're the first on the list. // if (MiTimerPending == FALSE) { MiTimerPending = TRUE; (VOID) KeSetTimerEx( &MiModifiedPageWriterTimer, MiModifiedPageLife, 0, &MiModifiedPageWriterTimerDpc ); } } } } else if ((Pfn1->u3.e1.RemovalRequested == 1) && (ListHead->ListName <= StandbyPageList)) { ListHead->Total -= 1; // Undo previous increment if (ListHead->ListName == StandbyPageList) { Pfn1->u3.e1.PageLocation = StandbyPageList; MiRestoreTransitionPte (PageFrameIndex); } ListHead = MmPageLocationList[BadPageList]; ListHead->Total += 1; // One more page on the list. } last = ListHead->Blink; if (last == MM_EMPTY_LIST) { // // List is empty add the page to the ListHead. // ListHead->Flink = PageFrameIndex; } else { Pfn2 = MI_PFN_ELEMENT (last); Pfn2->u1.Flink = PageFrameIndex; } ListHead->Blink = PageFrameIndex; Pfn1->u1.Flink = MM_EMPTY_LIST; Pfn1->u2.Blink = last; Pfn1->u3.e1.PageLocation = ListHead->ListName; // // If the page was placed on the free, standby or zeroed list, // update the count of usable pages in the system. If the count // transitions from 0 to 1, the event associated with available // pages should become true. // if (ListHead->ListName <= StandbyPageList) { MmAvailablePages += 1; // // A page has just become available, check to see if the // page wait events should be signalled. // if (MmAvailablePages == MM_LOW_LIMIT) { KeSetEvent (&MmAvailablePagesEvent, 0, FALSE); } else if (MmAvailablePages == MM_HIGH_LIMIT) { KeSetEvent (&MmAvailablePagesEventHigh, 0, FALSE); } if (ListHead->ListName <= FreePageList) { ASSERT (Pfn1->u3.e1.InPageError == 0); // // We are adding a page to the free or zeroed page list. // Add the page to the end of the correct colored page list. // Color = MI_GET_SECONDARY_COLOR (PageFrameIndex, Pfn1); ASSERT (Pfn1->u3.e1.PageColor == MI_GET_COLOR_FROM_SECONDARY(Color)); if (MmFreePagesByColor[ListHead->ListName][Color].Flink == MM_EMPTY_LIST) { // // This list is empty, add this as the first and last // entry. // MmFreePagesByColor[ListHead->ListName][Color].Flink = PageFrameIndex; MmFreePagesByColor[ListHead->ListName][Color].Blink = (PVOID)Pfn1; } else { Pfn2 = (PMMPFN)MmFreePagesByColor[ListHead->ListName][Color].Blink; Pfn2->OriginalPte.u.Long = PageFrameIndex; MmFreePagesByColor[ListHead->ListName][Color].Blink = (PVOID)Pfn1; } Pfn1->OriginalPte.u.Long = MM_EMPTY_LIST; if (ListHead->ListName == ZeroedPageList) { MI_BARRIER_STAMP_ZEROED_PAGE (&Pfn1->PteFrame); } } else { // // Transition page list so tally it appropriately. // MI_TALLY_TRANSITION_PAGE_ADDITION (Pfn1); } if ((ListHead->ListName == FreePageList) && (MmFreePageListHead.Total >= MmMinimumFreePagesToZero) && (MmZeroingPageThreadActive == FALSE)) { // // There are enough pages on the free list, start // the zeroing page thread. // MmZeroingPageThreadActive = TRUE; KeSetEvent (&MmZeroingPageEvent, 0, FALSE); } return; } // // Check to see if there are too many modified pages. // if (ListHead->ListName == ModifiedPageList) { // // Transition page list so tally it appropriately. // MI_TALLY_TRANSITION_PAGE_ADDITION (Pfn1); if (Pfn1->OriginalPte.u.Soft.Prototype == 0) { ASSERT (Pfn1->OriginalPte.u.Soft.PageFileHigh == 0); } PsGetCurrentProcess()->ModifiedPageCount += 1; if (MmModifiedPageListHead.Total >= MmModifiedPageMaximum ) { // // Start the modified page writer. // KeSetEvent (&MmModifiedPageWriterEvent, 0, FALSE); } } else if (ListHead->ListName == ModifiedNoWritePageList) { MI_TALLY_TRANSITION_PAGE_ADDITION (Pfn1); } return; }

VOID FASTCALL MiInsertStandbyListAtFront (  IN PFN_NUMBER  PageFrameIndex  )

Definition at line 388 of file pfnlist.c. References ASSERT, FALSE, _MMPFNLIST::Flink, KeBugCheckEx(), KeSetEvent(), MI_GET_PAGE_FRAME_FROM_PTE, MI_GET_PAGE_FRAME_FROM_TRANSITION_PTE, MI_PFN_ELEMENT, MiGetByteOffset, MiMapPageInHyperSpace(), MiUnmapPageInHyperSpace, MM_DBG_PAGE_REF_COUNT, MM_EMPTY_LIST, MM_HIGH_LIMIT, MM_LOW_LIMIT, MM_PFN_LOCK_ASSERT, MmAvailablePages, MmAvailablePagesEvent, MmAvailablePagesEventHigh, MmHighestPhysicalPage, MmIsAddressValid(), MmLowestPhysicalPage, MmModifiedNoWritePageListHead, MmModifiedPageListHead, MmStandbyPageListHead, MmTransitionPrivatePages, MmTransitionSharedPages, _MMPFN::OriginalPte, PERFINFO_INSERT_FRONT_STANDBY, _MMPFN::PteAddress, _MMPFN::PteFrame, StandbyPageList, _MMPFNLIST::Total, _MMPTE::u, _MMPFN::u1, _MMPFN::u2, and _MMPFN::u3. Referenced by MiDecrementReferenceCount(). 00394 : 00395 00396 This procedure inserts a page at the front of the standby list. 00397 00398 Arguments: 00399 00400 PageFrameIndex - Supplies the physical page number to insert in the 00401 list. 00402 00403 Return Value: 00404 00405 none. 00406 00407 Environment: 00408 00409 Must be holding the PFN database mutex with APCs disabled. 00410 00411 --*/ 00412 00413 { 00414 PFN_NUMBER first; 00415 IN PMMPFNLIST ListHead; 00416 PMMPFN Pfn1; 00417 PMMPFN Pfn2; 00418 00419 MM_PFN_LOCK_ASSERT(); 00420 ASSERT ((PageFrameIndex != 0) && (PageFrameIndex <= MmHighestPhysicalPage) && 00421 (PageFrameIndex >= MmLowestPhysicalPage)); 00422 00423 // 00424 // Check to ensure the reference count for the page 00425 // is zero. 00426 // 00427 00428 Pfn1 = MI_PFN_ELEMENT(PageFrameIndex); 00429 00430 PERFINFO_INSERT_FRONT_STANDBY(PageFrameIndex); 00431 00432 #if DBG 00433 if (MmDebug & MM_DBG_PAGE_REF_COUNT) { 00434 00435 PMMPTE PointerPte; 00436 KIRQL OldIrql = 99; 00437 00438 if ((Pfn1->u3.e1.PrototypePte == 1) && 00439 (MmIsAddressValid (Pfn1->PteAddress))) { 00440 PointerPte = Pfn1->PteAddress; 00441 } else { 00442 00443 // 00444 // The page containing the prototype PTE is not valid, 00445 // map the page into hyperspace and reference it that way. 00446 // 00447 00448 PointerPte = MiMapPageInHyperSpace (Pfn1->PteFrame, &OldIrql); 00449 PointerPte = (PMMPTE)((PCHAR)PointerPte + 00450 MiGetByteOffset(Pfn1->PteAddress)); 00451 } 00452 00453 ASSERT ((MI_GET_PAGE_FRAME_FROM_TRANSITION_PTE (PointerPte) == PageFrameIndex) || 00454 (MI_GET_PAGE_FRAME_FROM_PTE (PointerPte) == PageFrameIndex)); 00455 ASSERT (PointerPte->u.Soft.Transition == 1); 00456 ASSERT (PointerPte->u.Soft.Prototype == 0); 00457 if (OldIrql != 99) { 00458 MiUnmapPageInHyperSpace (OldIrql) 00459 } 00460 } 00461 00462 if ((Pfn1->OriginalPte.u.Soft.Prototype == 0) && 00463 (Pfn1->OriginalPte.u.Soft.Transition == 1)) { 00464 KeBugCheckEx (MEMORY_MANAGEMENT, 0x8889, 0,0,0); 00465 } 00466 #endif 00467 00468 ASSERT (Pfn1->u3.e2.ReferenceCount == 0); 00469 ASSERT (Pfn1->u3.e1.PrototypePte == 1); 00470 MmTransitionSharedPages += 1; 00471 00472 MmStandbyPageListHead.Total += 1; // One more page on the list. 00473 00474 ASSERT (MmTransitionPrivatePages + MmTransitionSharedPages == MmStandbyPageListHead.Total + MmModifiedPageListHead.Total + MmModifiedNoWritePageListHead.Total); 00475 00476 ListHead = &MmStandbyPageListHead; 00477 00478 first = ListHead->Flink; 00479 if (first == MM_EMPTY_LIST) { 00480 00481 // 00482 // List is empty add the page to the ListHead. 00483 // 00484 00485 ListHead->Blink = PageFrameIndex; 00486 } else { 00487 Pfn2 = MI_PFN_ELEMENT (first); 00488 Pfn2->u2.Blink = PageFrameIndex; 00489 } 00490 00491 ListHead->Flink = PageFrameIndex; 00492 Pfn1->u2.Blink = MM_EMPTY_LIST; 00493 Pfn1->u1.Flink = first; 00494 Pfn1->u3.e1.PageLocation = StandbyPageList; 00495 00496 // 00497 // If the page was placed on the free, standby or zeroed list, 00498 // update the count of usable pages in the system. If the count 00499 // transitions from 0 to 1, the event associated with available 00500 // pages should become true. 00501 // 00502 00503 MmAvailablePages += 1; 00504 00505 // 00506 // A page has just become available, check to see if the 00507 // page wait events should be signalled. 00508 // 00509 00510 if (MmAvailablePages == MM_LOW_LIMIT) { 00511 KeSetEvent (&MmAvailablePagesEvent, 0, FALSE); 00512 } else if (MmAvailablePages == MM_HIGH_LIMIT) { 00513 KeSetEvent (&MmAvailablePagesEventHigh, 0, FALSE); 00514 } 00515 00516 return; 00517 }

PFN_NUMBER FASTCALL MiRemoveAnyPage (  IN ULONG  PageColor  )

Definition at line 1395 of file pfnlist.c. References ASSERT, _MMPFNLIST::Flink, _MMCOLOR_TABLES::Flink, FreePageList, MI_CHECK_PAGE_ALIGNMENT, MI_GET_SECONDARY_COLOR, MI_MAGIC_AWE_PTEFRAME, MI_PFN_ELEMENT, MiRemovePageByColor(), MiRemovePageFromList(), MM_COLOR_MASK, MM_EMPTY_LIST, MM_PFN_LOCK_ASSERT, MmAvailablePages, MmFreePageListHead, MmFreePagesByColor, MmStandbyPageListHead, MmZeroedPageListHead, _MMPFN::PteFrame, _MMPFNLIST::Total, _MMPFN::u2, _MMPFN::u3, and ZeroedPageList. Referenced by ExAllocatePool(), MiAllocatePoolPages(), MiAllocateSpecialPool(), MiBuildPagedPool(), MiCopyOnWrite(), MiFillSystemPageDirectory(), MiGetPageForHeader(), MiInitializeSessionPool(), MiInitMachineDependent(), MiLoadImageSection(), MiMakeOutswappedPageResident(), MiReloadBootLoadedDrivers(), MiResolveDemandZeroFault(), MiResolveMappedFileFault(), MiResolvePageFileFault(), MiSessionCommitImagePages(), MiSessionCommitPageTables(), MiSessionCopyOnWrite(), MiSessionCreateInternal(), MiSessionInitializeWorkingSetList(), MmAccessFault(), MmAllocateIndependentPages(), MmAllocateNonCachedMemory(), MmCopyToCachedPage(), MmCreateKernelStack(), MmCreateProcessAddressSpace(), MmGatherMemoryForHibernate(), MmGrowKernelStack(), MmInitSystem(), and MmZeroPageThread(). : This procedure removes a page from either the free, zeroed, or standby lists (in that order). If no pages exist on the zeroed or free list a transition page is removed from the standby list and the PTE (may be a prototype PTE) which refers to this page is changed from transition back to its original contents. Note pages MUST exist to satisfy this request. The caller ensures this by first calling MiEnsureAvailablePageOrWait. Arguments: PageColor - Supplies the page color for which this page is destined. This is used for checking virtual address alignments to determine if the D cache needs flushing before the page can be reused. Return Value: The physical page number removed from the specified list. Environment: Must be holding the PFN database mutex with APCs disabled. --*/ { PFN_NUMBER Page; PMMPFN Pfn1; ULONG Color; MM_PFN_LOCK_ASSERT(); ASSERT(MmAvailablePages != 0); // // Check the free page list, and if a page is available // remove it and return its value. // if (MmFreePagesByColor[FreePageList][PageColor].Flink != MM_EMPTY_LIST) { // // Remove the first entry on the free by color list. // Page = MmFreePagesByColor[FreePageList][PageColor].Flink; #if DBG Pfn1 = MI_PFN_ELEMENT(Page); ASSERT (Pfn1->u3.e1.PageLocation == FreePageList); ASSERT (Pfn1->u3.e1.PageColor == (PageColor & MM_COLOR_MASK)); ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); #endif MiRemovePageByColor (Page, PageColor); #if DBG ASSERT (Pfn1->u3.e1.PageColor == (PageColor & MM_COLOR_MASK)); ASSERT (Pfn1->u3.e2.ReferenceCount == 0); ASSERT (Pfn1->u2.ShareCount == 0); ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); #endif return Page; } if (MmFreePagesByColor[ZeroedPageList][PageColor].Flink != MM_EMPTY_LIST) { // // Remove the first entry on the zeroed by color list. // Page = MmFreePagesByColor[ZeroedPageList][PageColor].Flink; #if DBG Pfn1 = MI_PFN_ELEMENT(Page); ASSERT (Pfn1->u3.e1.PageColor == (PageColor & MM_COLOR_MASK)); ASSERT (Pfn1->u3.e1.PageLocation == ZeroedPageList); ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); #endif MiRemovePageByColor (Page, PageColor); ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); return Page; } // // Try the free page list by primary color. // if (MmFreePageListHead.Flink != MM_EMPTY_LIST) { Page = MmFreePageListHead.Flink; Color = MI_GET_SECONDARY_COLOR (Page, MI_PFN_ELEMENT(Page)); #if DBG Pfn1 = MI_PFN_ELEMENT(Page); ASSERT (Pfn1->u3.e1.PageColor == (PageColor & MM_COLOR_MASK)); ASSERT (Pfn1->u3.e1.PageLocation == FreePageList); ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); #endif MiRemovePageByColor (Page, Color); #if DBG ASSERT (Pfn1->u3.e1.PageColor == (PageColor & MM_COLOR_MASK)); ASSERT (Pfn1->u3.e2.ReferenceCount == 0); ASSERT (Pfn1->u2.ShareCount == 0); ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); #endif return Page; } if (MmZeroedPageListHead.Flink != MM_EMPTY_LIST) { Page = MmZeroedPageListHead.Flink; Color = MI_GET_SECONDARY_COLOR (Page, MI_PFN_ELEMENT(Page)); MiRemovePageByColor (Page, Color); #if DBG Pfn1 = MI_PFN_ELEMENT(Page); ASSERT (Pfn1->u3.e1.PageColor == (PageColor & MM_COLOR_MASK)); ASSERT (Pfn1->u3.e2.ReferenceCount == 0); ASSERT (Pfn1->u2.ShareCount == 0); ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); #endif return Page; } if (MmFreePageListHead.Total != 0) { Page = MiRemovePageFromList(&MmFreePageListHead); ASSERT ((MI_PFN_ELEMENT(Page))->PteFrame != MI_MAGIC_AWE_PTEFRAME); } else { // // Check the zeroed page list, and if a page is available // remove it and return its value. // if (MmZeroedPageListHead.Total != 0) { Page = MiRemovePageFromList(&MmZeroedPageListHead); ASSERT ((MI_PFN_ELEMENT(Page))->PteFrame != MI_MAGIC_AWE_PTEFRAME); } else { // // No pages exist on the free or zeroed list, use the // standby list. // ASSERT(MmStandbyPageListHead.Total != 0); Page = MiRemovePageFromList(&MmStandbyPageListHead); ASSERT ((MI_PFN_ELEMENT(Page))->PteFrame != MI_MAGIC_AWE_PTEFRAME); } } MI_CHECK_PAGE_ALIGNMENT(Page, PageColor & MM_COLOR_MASK); #if DBG Pfn1 = MI_PFN_ELEMENT (Page); ASSERT (Pfn1->u3.e2.ReferenceCount == 0); ASSERT (Pfn1->u2.ShareCount == 0); #endif return Page; }

VOID MiRemovePageByColor (  IN PFN_NUMBER  Page, IN ULONG  PageColor )

Definition at line 1567 of file pfnlist.c. References ASSERT, _MMPFNLIST::Blink, _MMPFNLIST::Flink, _MMCOLOR_TABLES::Flink, KeBugCheckEx(), _MMPFNLIST::ListName, MI_PFN_ELEMENT, MiObtainFreePages(), MM_EMPTY_LIST, MM_PFN_LOCK_ASSERT, MmAvailablePages, MmFreePagesByColor, MmMinimumFreePages, MmPageLocationList, _MMPFN::OriginalPte, PERFINFO_REMOVEPAGE, _MMPFNLIST::Total, _MMPTE::u, _MMPFN::u1, _MMPFN::u2, and _MMPFN::u3. Referenced by MiRemoveAnyPage(), and MiRemoveZeroPage(). : This procedure removes a page from the middle of the free or zeroed page list. Arguments: PageFrameIndex - Supplies the physical page number to unlink from the list. Return Value: none. Environment: Must be holding the PFN database mutex with APCs disabled. --*/ { PMMPFNLIST ListHead; PMMPFNLIST PrimaryListHead; PFN_NUMBER Previous; PFN_NUMBER Next; PMMPFN Pfn1; PMMPFN Pfn2; ULONG PrimaryColor; MM_PFN_LOCK_ASSERT(); Pfn1 = MI_PFN_ELEMENT (Page); PrimaryColor = Pfn1->u3.e1.PageColor; PERFINFO_REMOVEPAGE(Page, PERFINFO_LOG_TYPE_REMOVEPAGEBYCOLOR); ListHead = MmPageLocationList[Pfn1->u3.e1.PageLocation]; ListHead->Total -= 1; PrimaryListHead = ListHead; #if PFN_CONSISTENCY if (MmFreePagesByColor[PrimaryListHead->ListName][Color].Flink != Page) { KeBugCheckEx (PFN_LIST_CORRUPT, 0x9A, Page, Color, (PFN_NUMBER)&MmFreePagesByColor[PrimaryListHead->ListName][Color].Flink); } #endif Next = Pfn1->u1.Flink; Pfn1->u1.Flink = 0; // Assumes Flink width is >= WsIndex width Previous = Pfn1->u2.Blink; Pfn1->u2.Blink = 0; if (Next == MM_EMPTY_LIST) { PrimaryListHead->Blink = Previous; } else { Pfn2 = MI_PFN_ELEMENT(Next); Pfn2->u2.Blink = Previous; } if (Previous == MM_EMPTY_LIST) { PrimaryListHead->Flink = Next; } else { Pfn2 = MI_PFN_ELEMENT(Previous); Pfn2->u1.Flink = Next; } // // Zero the flags longword, but keep the color information. // ASSERT (Pfn1->u3.e1.RemovalRequested == 0); Pfn1->u3.e2.ShortFlags = 0; Pfn1->u3.e1.PageColor = PrimaryColor; // // Update the color lists. // MmFreePagesByColor[ListHead->ListName][Color].Flink = (PFN_NUMBER) Pfn1->OriginalPte.u.Long; // // Note that we now have one less page available. // MmAvailablePages -= 1; if (MmAvailablePages < MmMinimumFreePages) { // // Obtain free pages. // MiObtainFreePages(); } return; }

PFN_NUMBER FASTCALL MiRemovePageFromList (  IN PMMPFNLIST  ListHead  )

Definition at line 521 of file pfnlist.c. References ASSERT, _MMCOLOR_TABLES::Flink, FreePageList, KeBugCheckEx(), MI_GET_SECONDARY_COLOR, MI_PFN_ELEMENT, MI_TALLY_TRANSITION_PAGE_REMOVAL, MiObtainFreePages(), MiRestoreTransitionPte(), MM_EMPTY_LIST, MM_PFN_LOCK_ASSERT, MmAvailablePages, MmFreePagesByColor, MmHighestPhysicalPage, MmLowestPhysicalPage, MmMinimumFreePages, ModifiedPageList, _MMPFN::OriginalPte, PERFINFO_REMOVEPAGE, StandbyPageList, _MMPTE::u, _MMPFN::u1, _MMPFN::u2, and _MMPFN::u3. Referenced by MiRemoveAnyPage(), MiRemoveZeroPage(), and MmTrimAllSystemPagableMemory(). 00527 : 00528 00529 This procedure removes a page from the head of the specified list (free, 00530 standby, zeroed, modified). 00531 00532 This routine clears the flags word in the PFN database, hence the 00533 PFN information for this page must be initialized. 00534 00535 Arguments: 00536 00537 ListHead - Supplies the list of the list in which to remove the 00538 specified physical page. 00539 00540 Return Value: 00541 00542 The physical page number removed from the specified list. 00543 00544 Environment: 00545 00546 Must be holding the PFN database mutex with APCs disabled. 00547 00548 --*/ 00549 00550 { 00551 PFN_NUMBER PageFrameIndex; 00552 PMMPFN Pfn1; 00553 PMMPFN Pfn2; 00554 ULONG Color; 00555 00556 MM_PFN_LOCK_ASSERT(); 00557 00558 // 00559 // If the specified list is empty return MM_EMPTY_LIST. 00560 // 00561 00562 if (ListHead->Total == 0) { 00563 00564 KdPrint(("MM:Attempting to remove page from empty list\n")); 00565 KeBugCheckEx (PFN_LIST_CORRUPT, 1, (ULONG_PTR)ListHead, MmAvailablePages, 0); 00566 return 0; 00567 } 00568 00569 ASSERT (ListHead->ListName != ModifiedPageList); 00570 00571 // 00572 // Decrement the count of pages on the list and remove the first 00573 // page from the list. 00574 // 00575 00576 ListHead->Total -= 1; 00577 PageFrameIndex = ListHead->Flink; 00578 Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); 00579 00580 PERFINFO_REMOVEPAGE(PageFrameIndex, PERFINFO_LOG_TYPE_REMOVEPAGEFROMLIST); 00581 00582 ListHead->Flink = Pfn1->u1.Flink; 00583 00584 // 00585 // Zero the flink and blink in the pfn database element. 00586 // 00587 00588 Pfn1->u1.Flink = 0; // Assumes Flink width is >= WsIndex width 00589 Pfn1->u2.Blink = 0; 00590 00591 // 00592 // If the last page was removed (the ListHead->Flink is now 00593 // MM_EMPTY_LIST) make the listhead->Blink MM_EMPTY_LIST as well. 00594 // 00595 00596 if (ListHead->Flink == MM_EMPTY_LIST) { 00597 ListHead->Blink = MM_EMPTY_LIST; 00598 } else { 00599 00600 // 00601 // Make the PFN element point to MM_EMPTY_LIST signifying this 00602 // is the last page in the list. 00603 // 00604 00605 Pfn2 = MI_PFN_ELEMENT (ListHead->Flink); 00606 Pfn2->u2.Blink = MM_EMPTY_LIST; 00607 } 00608 00609 // 00610 // Check to see if we now have one less page available. 00611 // 00612 00613 if (ListHead->ListName <= StandbyPageList) { 00614 MmAvailablePages -= 1; 00615 00616 if (ListHead->ListName == StandbyPageList) { 00617 00618 // 00619 // This page is currently in transition, restore the PTE to 00620 // its original contents so this page can be reused. 00621 // 00622 00623 MI_TALLY_TRANSITION_PAGE_REMOVAL (Pfn1); 00624 MiRestoreTransitionPte (PageFrameIndex); 00625 } 00626 00627 if (MmAvailablePages < MmMinimumFreePages) { 00628 00629 // 00630 // Obtain free pages. 00631 // 00632 00633 MiObtainFreePages(); 00634 } 00635 } 00636 00637 ASSERT ((PageFrameIndex != 0) && 00638 (PageFrameIndex <= MmHighestPhysicalPage) && 00639 (PageFrameIndex >= MmLowestPhysicalPage)); 00640 00641 // 00642 // Zero the PFN flags longword. 00643 // 00644 00645 Color = Pfn1->u3.e1.PageColor; 00646 ASSERT (Pfn1->u3.e1.RemovalRequested == 0); 00647 Pfn1->u3.e2.ShortFlags = 0; 00648 Pfn1->u3.e1.PageColor = Color; 00649 Color = MI_GET_SECONDARY_COLOR (PageFrameIndex, Pfn1); 00650 00651 if (ListHead->ListName <= FreePageList) { 00652 00653 // 00654 // Update the color lists. 00655 // 00656 00657 ASSERT (MmFreePagesByColor[ListHead->ListName][Color].Flink == PageFrameIndex); 00658 MmFreePagesByColor[ListHead->ListName][Color].Flink = 00659 (PFN_NUMBER) Pfn1->OriginalPte.u.Long; 00660 } 00661 00662 return PageFrameIndex; 00663 }

PFN_NUMBER FASTCALL MiRemoveZeroPage (  IN ULONG  PageColor  )

Definition at line 1177 of file pfnlist.c. References ASSERT, _MMPFNLIST::Flink, _MMCOLOR_TABLES::Flink, FreePageList, MI_BARRIER_STAMP_ZEROED_PAGE, MI_CHECK_PAGE_ALIGNMENT, MI_GET_SECONDARY_COLOR, MI_MAGIC_AWE_PTEFRAME, MI_PFN_ELEMENT, MiRemovePageByColor(), MiRemovePageFromList(), MiZeroPhysicalPage(), MM_COLOR_MASK, MM_EMPTY_LIST, MM_PFN_LOCK_ASSERT, MmAvailablePages, MmFreePageListHead, MmFreePagesByColor, MmStandbyPageListHead, MmZeroedPageListHead, PAGE_SHIFT, _MMPFN::PteFrame, _MMPFNLIST::Total, _MMPFN::u2, _MMPFN::u3, and ZeroedPageList. Referenced by MiAddWorkingSetPage(), MiAddWsleHash(), MiDoneWithThisPageGetAnother(), MiInitializeSystemCache(), MiInitializeWorkingSetList(), MiResolveDemandZeroFault(), MiResolveMappedFileFault(), MiSessionInitializeWorkingSetList(), MmAddPhysicalMemory(), MmCheckCachedPageState(), MmInitSystem(), and MmShutdownSystem(). 01183 : 01184 01185 This procedure removes a zero page from either the zeroed, free 01186 or standby lists (in that order). If no pages exist on the zeroed 01187 or free list a transition page is removed from the standby list 01188 and the PTE (may be a prototype PTE) which refers to this page is 01189 changed from transition back to its original contents. 01190 01191 If the page is not obtained from the zeroed list, it is zeroed. 01192 01193 Arguments: 01194 01195 PageColor - Supplies the page color for which this page is destined. 01196 This is used for checking virtual address alignments to 01197 determine if the D cache needs flushing before the page 01198 can be reused. 01199 01200 Return Value: 01201 01202 The physical page number removed from the specified list. 01203 01204 Environment: 01205 01206 Must be holding the PFN database mutex with APCs disabled. 01207 01208 --*/ 01209 01210 { 01211 PFN_NUMBER Page; 01212 PMMPFN Pfn1; 01213 ULONG Color; 01214 01215 MM_PFN_LOCK_ASSERT(); 01216 ASSERT(MmAvailablePages != 0); 01217 01218 // 01219 // Attempt to remove a page from the zeroed page list. If a page 01220 // is available, then remove it and return its page frame index. 01221 // Otherwise, attempt to remove a page from the free page list or 01222 // the standby list. 01223 // 01224 // N.B. It is not necessary to change page colors even if the old 01225 // color is not equal to the new color. The zero page thread 01226 // ensures that all zeroed pages are removed from all caches. 01227 // 01228 01229 if (MmFreePagesByColor[ZeroedPageList][PageColor].Flink != MM_EMPTY_LIST) { 01230 01231 // 01232 // Remove the first entry on the zeroed by color list. 01233 // 01234 01235 Page = MmFreePagesByColor[ZeroedPageList][PageColor].Flink; 01236 01237 #if DBG 01238 Pfn1 = MI_PFN_ELEMENT(Page); 01239 ASSERT (Pfn1->u3.e1.PageLocation == ZeroedPageList); 01240 ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01241 #endif 01242 01243 MiRemovePageByColor (Page, PageColor); 01244 01245 #if DBG 01246 ASSERT (Pfn1->u3.e1.PageColor == (PageColor & MM_COLOR_MASK)); 01247 ASSERT (Pfn1->u3.e2.ReferenceCount == 0); 01248 ASSERT (Pfn1->u2.ShareCount == 0); 01249 ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01250 #endif 01251 return Page; 01252 01253 } 01254 01255 // 01256 // No previously zeroed page with the specified secondary color exists. 01257 // Try a zeroed page of the primary color. 01258 // 01259 01260 if (MmZeroedPageListHead.Flink != MM_EMPTY_LIST) { 01261 Page = MmZeroedPageListHead.Flink; 01262 #if DBG 01263 Pfn1 = MI_PFN_ELEMENT(Page); 01264 ASSERT (Pfn1->u3.e1.PageLocation == ZeroedPageList); 01265 ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01266 #endif 01267 Color = MI_GET_SECONDARY_COLOR (Page, MI_PFN_ELEMENT(Page)); 01268 MiRemovePageByColor (Page, Color); 01269 #if DBG 01270 Pfn1 = MI_PFN_ELEMENT(Page); 01271 ASSERT (Pfn1->u3.e1.PageColor == (PageColor & MM_COLOR_MASK)); 01272 ASSERT (Pfn1->u3.e2.ReferenceCount == 0); 01273 ASSERT (Pfn1->u2.ShareCount == 0); 01274 ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01275 #endif 01276 return Page; 01277 } 01278 01279 // 01280 // No zeroed page of the primary color exists, try a free page of the 01281 // secondary color. 01282 // 01283 01284 if (MmFreePagesByColor[FreePageList][PageColor].Flink != MM_EMPTY_LIST) { 01285 01286 // 01287 // Remove the first entry on the free list by color. 01288 // 01289 01290 Page = MmFreePagesByColor[FreePageList][PageColor].Flink; 01291 01292 #if DBG 01293 Pfn1 = MI_PFN_ELEMENT(Page); 01294 ASSERT (Pfn1->u3.e1.PageLocation == FreePageList); 01295 ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01296 #endif 01297 01298 MiRemovePageByColor (Page, PageColor); 01299 #if DBG 01300 Pfn1 = MI_PFN_ELEMENT(Page); 01301 ASSERT (Pfn1->u3.e1.PageColor == (PageColor & MM_COLOR_MASK)); 01302 ASSERT (Pfn1->u3.e2.ReferenceCount == 0); 01303 ASSERT (Pfn1->u2.ShareCount == 0); 01304 ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01305 #endif 01306 goto ZeroPage; 01307 } 01308 01309 if (MmFreePageListHead.Flink != MM_EMPTY_LIST) { 01310 Page = MmFreePageListHead.Flink; 01311 01312 Color = MI_GET_SECONDARY_COLOR (Page, MI_PFN_ELEMENT(Page)); 01313 MiRemovePageByColor (Page, Color); 01314 #if DBG 01315 Pfn1 = MI_PFN_ELEMENT(Page); 01316 ASSERT (Pfn1->u3.e1.PageColor == (PageColor & MM_COLOR_MASK)); 01317 ASSERT (Pfn1->u3.e2.ReferenceCount == 0); 01318 ASSERT (Pfn1->u2.ShareCount == 0); 01319 ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01320 #endif 01321 goto ZeroPage; 01322 } 01323 01324 ASSERT (MmZeroedPageListHead.Total == 0); 01325 ASSERT (MmFreePageListHead.Total == 0); 01326 01327 if (MmZeroedPageListHead.Total != 0) { 01328 01329 Page = MiRemovePageFromList(&MmZeroedPageListHead); 01330 MI_CHECK_PAGE_ALIGNMENT(Page, PageColor & MM_COLOR_MASK); 01331 01332 } else { 01333 01334 // 01335 // Attempt to remove a page from the free list. If a page is 01336 // available, then remove it. Otherwise, attempt to remove a 01337 // page from the standby list. 01338 // 01339 01340 if (MmFreePageListHead.Total != 0) { 01341 Page = MiRemovePageFromList(&MmFreePageListHead); 01342 ASSERT ((MI_PFN_ELEMENT(Page))->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01343 } else { 01344 01345 // 01346 // Remove a page from the standby list and restore the original 01347 // contents of the PTE to free the last reference to the physical 01348 // page. 01349 // 01350 01351 ASSERT (MmStandbyPageListHead.Total != 0); 01352 01353 Page = MiRemovePageFromList(&MmStandbyPageListHead); 01354 ASSERT ((MI_PFN_ELEMENT(Page))->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01355 } 01356 01357 // 01358 // Zero the page removed from the free or standby list. 01359 // 01360 01361 ZeroPage: 01362 01363 Pfn1 = MI_PFN_ELEMENT(Page); 01364 01365 #if defined(_ALPHA_) 01366 HalZeroPage((PVOID)ULongToPtr((PageColor & MM_COLOR_MASK) << PAGE_SHIFT), 01367 (PVOID)ULongToPtr((Pfn1->u3.e1.PageColor) << PAGE_SHIFT), 01368 Page); 01369 #else 01370 MiZeroPhysicalPage (Page, 0); 01371 #endif 01372 01373 // 01374 // Note the stamping must occur after the page is zeroed. 01375 // 01376 01377 MI_BARRIER_STAMP_ZEROED_PAGE (&Pfn1->PteFrame); 01378 01379 Pfn1->u3.e1.PageColor = PageColor & MM_COLOR_MASK; 01380 01381 } 01382 01383 #if DBG 01384 Pfn1 = MI_PFN_ELEMENT (Page); 01385 ASSERT (Pfn1->u3.e2.ReferenceCount == 0); 01386 ASSERT (Pfn1->u2.ShareCount == 0); 01387 ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01388 #endif 01389 01390 return Page; 01391 }

VOID MiUnlinkFreeOrZeroedPage (  IN PFN_NUMBER  Page  )

Definition at line 821 of file pfnlist.c. References ASSERT, _MMCOLOR_TABLES::Blink, _MMPFNLIST::Blink, _MMCOLOR_TABLES::Flink, _MMPFNLIST::Flink, FreePageList, _MMPFNLIST::ListName, MI_GET_COLOR_FROM_SECONDARY, MI_GET_SECONDARY_COLOR, MI_PFN_ELEMENT, MiObtainFreePages(), MM_EMPTY_LIST, MM_PFN_LOCK_ASSERT, MmAvailablePages, MmFreePagesByColor, MmMinimumFreePages, MmPageLocationList, MmPfnDatabase, _MMPFN::OriginalPte, PERFINFO_UNLINKFREEPAGE, _MMPFNLIST::Total, _MMPTE::u, _MMPFN::u1, _MMPFN::u2, and _MMPFN::u3. Referenced by MiFindContiguousMemory(), MiInitMachineDependent(), MiRemovePhysicalPages(), and MmAllocatePagesForMdl(). : This procedure removes a page from the middle of a list. This is designed for the removing of free or zeroed pages from the middle of their lists. Arguments: Pfn - Supplies a pointer to the PFN database element for the physical page to remove from the list. Return Value: None. Environment: Must be holding the PFN database mutex with APCs disabled. --*/ { PMMPFNLIST ListHead; PFN_NUMBER Previous; PFN_NUMBER Next; PMMPFN Pfn2; PMMPFN Pfn; ULONG Color; Pfn = MI_PFN_ELEMENT (Page); MM_PFN_LOCK_ASSERT(); ListHead = MmPageLocationList[Pfn->u3.e1.PageLocation]; ASSERT (ListHead->Total != 0); ListHead->Total -= 1; ASSERT (ListHead->ListName <= FreePageList); ASSERT (Pfn->u3.e1.WriteInProgress == 0); ASSERT (Pfn->u3.e1.ReadInProgress == 0); PERFINFO_UNLINKFREEPAGE((ULONG_PTR)(Pfn - MmPfnDatabase), Pfn->u3.e1.PageLocation); Next = Pfn->u1.Flink; Pfn->u1.Flink = 0; // Assumes Flink width is >= WsIndex width Previous = Pfn->u2.Blink; Pfn->u2.Blink = 0; if (Next == MM_EMPTY_LIST) { ListHead->Blink = Previous; } else { Pfn2 = MI_PFN_ELEMENT(Next); Pfn2->u2.Blink = Previous; } if (Previous == MM_EMPTY_LIST) { ListHead->Flink = Next; } else { Pfn2 = MI_PFN_ELEMENT(Previous); Pfn2->u1.Flink = Next; } // // We are removing a page from the middle of the free or zeroed page list. // The secondary color tables must be updated at this time. // Color = MI_GET_SECONDARY_COLOR (Page, Pfn); ASSERT (Pfn->u3.e1.PageColor == MI_GET_COLOR_FROM_SECONDARY(Color)); // // Walk down the list and remove the page. // Next = MmFreePagesByColor[ListHead->ListName][Color].Flink; if (Next == Page) { MmFreePagesByColor[ListHead->ListName][Color].Flink = (PFN_NUMBER) Pfn->OriginalPte.u.Long; } else { // // Walk the list to find the parent. // for (; ; ) { Pfn2 = MI_PFN_ELEMENT (Next); Next = (PFN_NUMBER) Pfn2->OriginalPte.u.Long; if (Page == Next) { Pfn2->OriginalPte.u.Long = Pfn->OriginalPte.u.Long; if ((PFN_NUMBER) Pfn->OriginalPte.u.Long == MM_EMPTY_LIST) { MmFreePagesByColor[ListHead->ListName][Color].Blink = Pfn2; } break; } } } MmAvailablePages -= 1; if (MmAvailablePages < MmMinimumFreePages) { // // Obtain free pages. // MiObtainFreePages(); } return; }

VOID FASTCALL MiUnlinkPageFromList (  IN PMMPFN  Pfn  )

Definition at line 667 of file pfnlist.c. References ASSERT, _MMPFNLIST::Blink, DbgPrint, _MMPFNLIST::Flink, KeBugCheckEx(), _MMPFNLIST::ListName, MI_PFN_ELEMENT, MI_TALLY_TRANSITION_PAGE_REMOVAL, MiFormatPfn(), MiObtainFreePages(), MM_DBG_PAGE_IN_LIST, MM_EMPTY_LIST, MM_PFN_LOCK_ASSERT, MmAvailablePages, MmHighestPhysicalPage, MmMinimumFreePages, MmModifiedPageListByColor, MmModifiedPageListHead, MmPageLocationList, MmPfnDatabase, MmTotalPagesForPagingFile, ModifiedNoWritePageList, ModifiedPageList, PERFINFO_UNLINKPAGE, StandbyPageList, _MMPFNLIST::Total, _MMPFN::u1, and _MMPFN::u2. Referenced by MiCleanSection(), MiDecommitPages(), MiDecrementCloneBlockReference(), MiDeletePte(), MiDeleteSystemPagableVm(), MiDispatchFault(), MiFindContiguousMemory(), MiFlushSectionInternal(), MiGatherMappedPages(), MiGatherPagefilePages(), MiLockCode(), MiMakeOutswappedPageResident(), MiModifiedPageWriterWorker(), MiPurgeImageSection(), MiRemovePhysicalPages(), MiResetVirtualMemory(), MiResolveTransitionFault(), MiSegmentDelete(), MmAllocatePagesForMdl(), MmCheckCachedPageState(), MmCopyToCachedPage(), MmPurgeSection(), MmRemovePhysicalMemory(), and MmShutdownSystem(). 00673 : 00674 00675 This procedure removes a page from the middle of a list. This is 00676 designed for the faulting of transition pages from the standby and 00677 modified list and making them active and valid again. 00678 00679 Arguments: 00680 00681 Pfn - Supplies a pointer to the PFN database element for the physical 00682 page to remove from the list. 00683 00684 Return Value: 00685 00686 none. 00687 00688 Environment: 00689 00690 Must be holding the PFN database mutex with APCs disabled. 00691 00692 --*/ 00693 00694 { 00695 PMMPFNLIST ListHead; 00696 PFN_NUMBER Previous; 00697 PFN_NUMBER Next; 00698 PMMPFN Pfn2; 00699 00700 MM_PFN_LOCK_ASSERT(); 00701 00702 PERFINFO_UNLINKPAGE((ULONG_PTR)(Pfn - MmPfnDatabase), Pfn->u3.e1.PageLocation); 00703 00704 // 00705 // Page not on standby or modified list, check to see if the 00706 // page is currently being written by the modified page 00707 // writer, if so, just return this page. The reference 00708 // count for the page will be incremented, so when the modified 00709 // page write completes, the page will not be put back on 00710 // the list, rather, it will remain active and valid. 00711 // 00712 00713 if (Pfn->u3.e2.ReferenceCount > 0) { 00714 00715 // 00716 // The page was not on any "transition lists", check to see 00717 // if this has I/O in progress. 00718 // 00719 00720 if (Pfn->u2.ShareCount == 0) { 00721 #if DBG 00722 if (MmDebug & MM_DBG_PAGE_IN_LIST) { 00723 DbgPrint("unlinking page not in list...\n"); 00724 MiFormatPfn(Pfn); 00725 } 00726 #endif 00727 return; 00728 } 00729 KdPrint(("MM:attempt to remove page from wrong page list\n")); 00730 KeBugCheckEx (PFN_LIST_CORRUPT, 00731 2, 00732 Pfn - MmPfnDatabase, 00733 MmHighestPhysicalPage, 00734 Pfn->u3.e2.ReferenceCount); 00735 return; 00736 } 00737 00738 ListHead = MmPageLocationList[Pfn->u3.e1.PageLocation]; 00739 00740 // 00741 // Must not remove pages from free or zeroed without updating 00742 // the colored lists. 00743 // 00744 00745 ASSERT (ListHead->ListName >= StandbyPageList); 00746 00747 // 00748 // On MIPS R4000 modified pages destined for the paging file are 00749 // kept on separate lists which group pages of the same color 00750 // together 00751 // 00752 00753 if ((ListHead == &MmModifiedPageListHead) && 00754 (Pfn->OriginalPte.u.Soft.Prototype == 0)) { 00755 00756 // 00757 // This page is destined for the paging file (not 00758 // a mapped file). Change the list head to the 00759 // appropriate colored list head. 00760 // 00761 00762 ListHead->Total -= 1; 00763 MmTotalPagesForPagingFile -= 1; 00764 ListHead = &MmModifiedPageListByColor [Pfn->u3.e1.PageColor]; 00765 } 00766 00767 ASSERT (Pfn->u3.e1.WriteInProgress == 0); 00768 ASSERT (Pfn->u3.e1.ReadInProgress == 0); 00769 ASSERT (ListHead->Total != 0); 00770 00771 Next = Pfn->u1.Flink; 00772 Pfn->u1.Flink = 0; // Assumes Flink width is >= WsIndex width 00773 Previous = Pfn->u2.Blink; 00774 Pfn->u2.Blink = 0; 00775 00776 if (Next == MM_EMPTY_LIST) { 00777 ListHead->Blink = Previous; 00778 } else { 00779 Pfn2 = MI_PFN_ELEMENT(Next); 00780 Pfn2->u2.Blink = Previous; 00781 } 00782 00783 if (Previous == MM_EMPTY_LIST) { 00784 ListHead->Flink = Next; 00785 } else { 00786 Pfn2 = MI_PFN_ELEMENT(Previous); 00787 Pfn2->u1.Flink = Next; 00788 } 00789 00790 ListHead->Total -= 1; 00791 00792 // 00793 // Check to see if we now have one less page available. 00794 // 00795 00796 if (ListHead->ListName <= StandbyPageList) { 00797 MmAvailablePages -= 1; 00798 00799 if (ListHead->ListName == StandbyPageList) { 00800 MI_TALLY_TRANSITION_PAGE_REMOVAL (Pfn); 00801 } 00802 00803 if (MmAvailablePages < MmMinimumFreePages) { 00804 00805 // 00806 // Obtain free pages. 00807 // 00808 00809 MiObtainFreePages(); 00810 00811 } 00812 } 00813 else if (ListHead->ListName == ModifiedPageList || ListHead->ListName == ModifiedNoWritePageList) { 00814 MI_TALLY_TRANSITION_PAGE_REMOVAL (Pfn); 00815 } 00816 00817 return; 00818 }

---

Variable Documentation

KEVENT MmAvailablePagesEventHigh

Definition at line 27 of file pfnlist.c. Referenced by MiEnsureAvailablePageOrWait(), MiInsertPageInList(), MiInsertStandbyListAtFront(), and MmInitSystem().

ULONG MmTransitionPrivatePages

Definition at line 29 of file pfnlist.c. Referenced by MiInsertStandbyListAtFront().

ULONG MmTransitionSharedPages

Definition at line 30 of file pfnlist.c.

---