dynmem.c File Reference

#include "mi.h"

Go to the source code of this file.

Defines
#define	PFN_REMOVED   ((PMMPTE)(INT_PTR)(int)0x99887766)
Functions
PFN_COUNT	MiRemovePhysicalPages (IN PFN_NUMBER StartPage, IN PFN_NUMBER EndPage)
NTSTATUS	MmAddPhysicalMemory (IN PPHYSICAL_ADDRESS StartAddress, IN OUT PLARGE_INTEGER NumberOfBytes)
NTSTATUS	MmRemovePhysicalMemory (IN PPHYSICAL_ADDRESS StartAddress, IN OUT PLARGE_INTEGER NumberOfBytes)
PPHYSICAL_MEMORY_RANGE	MmGetPhysicalMemoryRanges (VOID)
Variables
FAST_MUTEX	MmDynamicMemoryMutex
LOGICAL	MiTrimRemovalPagesOnly = FALSE

---

Define Documentation

#define PFN_REMOVED   ((PMMPTE)(INT_PTR)(int)0x99887766)

Definition at line 33 of file dynmem.c. Referenced by MmAddPhysicalMemory(), and MmRemovePhysicalMemory().

---

Function Documentation

PFN_COUNT MiRemovePhysicalPages (  IN PFN_NUMBER  StartPage, IN PFN_NUMBER  EndPage )

Definition at line 1109 of file dynmem.c. References ASSERT, BadPageList, _MMPFNLIST::Blink, _MMCOLOR_TABLES::Blink, FALSE, _MMPFNLIST::Flink, _MMCOLOR_TABLES::Flink, FreePageList, MI_MAGIC_AWE_PTEFRAME, MI_PFN_ELEMENT, MiInsertPageInList(), MiRestoreTransitionPte(), MiUnlinkFreeOrZeroedPage(), MiUnlinkPageFromList(), MM_EMPTY_LIST, MM_PFN_LOCK_ASSERT, MmFreePagesByColor, MMLISTS, MmPageLocationList, MmPfnDatabase, MmSecondaryColors, _MMPFN::OriginalPte, _MMPFN::PteFrame, StandbyPageList, TRUE, _MMPTE::u, _MMPFN::u1, _MMPFN::u2, _MMPFN::u3, and ZeroedPageList. Referenced by MmRemovePhysicalMemory(). 01116 : 01117 01118 This routine searches the PFN database for free, zeroed or standby pages 01119 that are marked for removal. 01120 01121 Arguments: 01122 01123 StartPage - Supplies the low physical frame number to remove. 01124 01125 EndPage - Supplies the last physical frame number to remove. 01126 01127 Return Value: 01128 01129 Returns the number of pages removed from the free, zeroed and standby lists. 01130 01131 Environment: 01132 01133 Kernel mode, PFN lock held. 01134 01135 --*/ 01136 01137 { 01138 PMMPFN Pfn1; 01139 PMMPFN Pfn2; 01140 PMMPFN PfnNextColored; 01141 PMMPFN PfnNextFlink; 01142 PMMPFN PfnLastColored; 01143 PFN_NUMBER Page; 01144 LOGICAL RemovePage; 01145 ULONG Color; 01146 PMMCOLOR_TABLES ColorHead; 01147 PFN_NUMBER MovedPage; 01148 MMLISTS MemoryList; 01149 PFN_NUMBER PageNextColored; 01150 PFN_NUMBER PageNextFlink; 01151 PFN_NUMBER PageLastColored; 01152 PFN_COUNT NumberOfPages; 01153 PMMPFNLIST ListHead; 01154 LOGICAL RescanNeeded; 01155 01156 MM_PFN_LOCK_ASSERT(); 01157 01158 NumberOfPages = 0; 01159 01160 rescan: 01161 01162 // 01163 // Grab all zeroed (and then free) pages first directly from the 01164 // colored lists to avoid multiple walks down these singly linked lists. 01165 // Handle transition pages last. 01166 // 01167 01168 for (MemoryList = ZeroedPageList; MemoryList <= FreePageList; MemoryList += 1) { 01169 01170 ListHead = MmPageLocationList[MemoryList]; 01171 01172 for (Color = 0; Color < MmSecondaryColors; Color += 1) { 01173 ColorHead = &MmFreePagesByColor[MemoryList][Color]; 01174 01175 MovedPage = MM_EMPTY_LIST; 01176 01177 while (ColorHead->Flink != MM_EMPTY_LIST) { 01178 01179 Page = ColorHead->Flink; 01180 01181 Pfn1 = MI_PFN_ELEMENT(Page); 01182 01183 ASSERT ((MMLISTS)Pfn1->u3.e1.PageLocation == MemoryList); 01184 01185 // 01186 // The Flink and Blink must be nonzero here for the page 01187 // to be on the listhead. Only code that scans the 01188 // MmPhysicalMemoryBlock has to check for the zero case. 01189 // 01190 01191 ASSERT (Pfn1->u1.Flink != 0); 01192 ASSERT (Pfn1->u2.Blink != 0); 01193 01194 // 01195 // See if the page is desired by the caller. 01196 // 01197 01198 if (Pfn1->u3.e1.RemovalRequested == 1) { 01199 01200 ASSERT (Pfn1->u3.e1.ReadInProgress == 0); 01201 01202 MiUnlinkFreeOrZeroedPage (Page); 01203 01204 MiInsertPageInList (MmPageLocationList[BadPageList], 01205 Page); 01206 01207 NumberOfPages += 1; 01208 } 01209 else { 01210 01211 // 01212 // Unwanted so put the page on the end of list. 01213 // If first time, save pfn. 01214 // 01215 01216 if (MovedPage == MM_EMPTY_LIST) { 01217 MovedPage = Page; 01218 } 01219 else if (Page == MovedPage) { 01220 01221 // 01222 // No more pages available in this colored chain. 01223 // 01224 01225 break; 01226 } 01227 01228 // 01229 // If the colored chain has more than one entry then 01230 // put this page on the end. 01231 // 01232 01233 PageNextColored = (PFN_NUMBER)Pfn1->OriginalPte.u.Long; 01234 01235 if (PageNextColored == MM_EMPTY_LIST) { 01236 01237 // 01238 // No more pages available in this colored chain. 01239 // 01240 01241 break; 01242 } 01243 01244 ASSERT (Pfn1->u1.Flink != 0); 01245 ASSERT (Pfn1->u1.Flink != MM_EMPTY_LIST); 01246 ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01247 01248 PfnNextColored = MI_PFN_ELEMENT(PageNextColored); 01249 ASSERT ((MMLISTS)PfnNextColored->u3.e1.PageLocation == MemoryList); 01250 ASSERT (PfnNextColored->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01251 01252 // 01253 // Adjust the free page list so Page 01254 // follows PageNextFlink. 01255 // 01256 01257 PageNextFlink = Pfn1->u1.Flink; 01258 PfnNextFlink = MI_PFN_ELEMENT(PageNextFlink); 01259 01260 ASSERT ((MMLISTS)PfnNextFlink->u3.e1.PageLocation == MemoryList); 01261 ASSERT (PfnNextFlink->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01262 01263 PfnLastColored = ColorHead->Blink; 01264 ASSERT (PfnLastColored != (PMMPFN)MM_EMPTY_LIST); 01265 ASSERT (PfnLastColored->OriginalPte.u.Long == MM_EMPTY_LIST); 01266 ASSERT (PfnLastColored->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01267 ASSERT (PfnLastColored->u2.Blink != MM_EMPTY_LIST); 01268 01269 ASSERT ((MMLISTS)PfnLastColored->u3.e1.PageLocation == MemoryList); 01270 PageLastColored = PfnLastColored - MmPfnDatabase; 01271 01272 if (ListHead->Flink == Page) { 01273 01274 ASSERT (Pfn1->u2.Blink == MM_EMPTY_LIST); 01275 ASSERT (ListHead->Blink != Page); 01276 01277 ListHead->Flink = PageNextFlink; 01278 01279 PfnNextFlink->u2.Blink = MM_EMPTY_LIST; 01280 } 01281 else { 01282 01283 ASSERT (Pfn1->u2.Blink != MM_EMPTY_LIST); 01284 ASSERT ((MMLISTS)(MI_PFN_ELEMENT((MI_PFN_ELEMENT(Pfn1->u2.Blink)->u1.Flink)))->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01285 ASSERT ((MMLISTS)(MI_PFN_ELEMENT((MI_PFN_ELEMENT(Pfn1->u2.Blink)->u1.Flink)))->u3.e1.PageLocation == MemoryList); 01286 01287 MI_PFN_ELEMENT(Pfn1->u2.Blink)->u1.Flink = PageNextFlink; 01288 PfnNextFlink->u2.Blink = Pfn1->u2.Blink; 01289 } 01290 01291 #if DBG 01292 if (PfnLastColored->u1.Flink == MM_EMPTY_LIST) { 01293 ASSERT (ListHead->Blink == PageLastColored); 01294 } 01295 #endif 01296 01297 Pfn1->u1.Flink = PfnLastColored->u1.Flink; 01298 Pfn1->u2.Blink = PageLastColored; 01299 01300 if (ListHead->Blink == PageLastColored) { 01301 ListHead->Blink = Page; 01302 } 01303 01304 // 01305 // Adjust the colored chains. 01306 // 01307 01308 if (PfnLastColored->u1.Flink != MM_EMPTY_LIST) { 01309 ASSERT (MI_PFN_ELEMENT(PfnLastColored->u1.Flink)->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01310 ASSERT ((MMLISTS)(MI_PFN_ELEMENT(PfnLastColored->u1.Flink)->u3.e1.PageLocation) == MemoryList); 01311 MI_PFN_ELEMENT(PfnLastColored->u1.Flink)->u2.Blink = Page; 01312 } 01313 01314 PfnLastColored->u1.Flink = Page; 01315 01316 ColorHead->Flink = PageNextColored; 01317 Pfn1->OriginalPte.u.Long = MM_EMPTY_LIST; 01318 01319 ASSERT (PfnLastColored->OriginalPte.u.Long == MM_EMPTY_LIST); 01320 PfnLastColored->OriginalPte.u.Long = Page; 01321 ColorHead->Blink = Pfn1; 01322 } 01323 } 01324 } 01325 } 01326 01327 RescanNeeded = FALSE; 01328 Pfn1 = MI_PFN_ELEMENT (StartPage); 01329 01330 do { 01331 01332 if ((Pfn1->u3.e1.PageLocation == StandbyPageList) && 01333 (Pfn1->u1.Flink != 0) && 01334 (Pfn1->u2.Blink != 0) && 01335 (Pfn1->u3.e2.ReferenceCount == 0)) { 01336 01337 ASSERT (Pfn1->u3.e1.ReadInProgress == 0); 01338 01339 RemovePage = TRUE; 01340 01341 if (Pfn1->u3.e1.RemovalRequested == 0) { 01342 01343 // 01344 // This page is not directly needed for a hot remove - but if 01345 // it contains a chunk of prototype PTEs (and this chunk is 01346 // in a page that needs to be removed), then any pages 01347 // referenced by transition prototype PTEs must also be removed 01348 // before the desired page can be removed. 01349 // 01350 // The same analogy holds for page parent, directory and table 01351 // pages. 01352 // 01353 01354 Pfn2 = MI_PFN_ELEMENT (Pfn1->PteFrame); 01355 if (Pfn2->u3.e1.RemovalRequested == 0) { 01356 #if defined (_WIN64) 01357 Pfn2 = MI_PFN_ELEMENT (Pfn2->PteFrame); 01358 if (Pfn2->u3.e1.RemovalRequested == 0) { 01359 RemovePage = FALSE; 01360 } 01361 else if (Pfn2->u2.ShareCount == 1) { 01362 RescanNeeded = TRUE; 01363 } 01364 #else 01365 RemovePage = FALSE; 01366 #endif 01367 } 01368 else if (Pfn2->u2.ShareCount == 1) { 01369 RescanNeeded = TRUE; 01370 } 01371 } 01372 01373 if (RemovePage == TRUE) { 01374 01375 // 01376 // This page is in the desired range - grab it. 01377 // 01378 01379 MiUnlinkPageFromList (Pfn1); 01380 MiRestoreTransitionPte (StartPage); 01381 MiInsertPageInList (MmPageLocationList[BadPageList], 01382 StartPage); 01383 NumberOfPages += 1; 01384 } 01385 } 01386 01387 StartPage += 1; 01388 Pfn1 += 1; 01389 01390 } while (StartPage < EndPage); 01391 01392 if (RescanNeeded == TRUE) { 01393 01394 // 01395 // A page table, directory or parent was freed by removing a transition 01396 // page from the cache. Rescan from the top to pick it up. 01397 // 01398 01399 #if DBG 01400 MiDynmemData[7] += 1; 01401 #endif 01402 01403 goto rescan; 01404 } 01405 #if DBG 01406 else { 01407 MiDynmemData[8] += 1; 01408 } 01409 #endif 01410 01411 return NumberOfPages; 01412 } }

NTSTATUS MmAddPhysicalMemory (  IN PPHYSICAL_ADDRESS  StartAddress, IN OUT PLARGE_INTEGER  NumberOfBytes )

Definition at line 43 of file dynmem.c. References ASSERT, ASSERT64, _PHYSICAL_MEMORY_RUN::BasePage, BYTE_OFFSET, ExAllocatePoolWithTag, ExFreePool(), FALSE, FreePageList, LOCK_PFN, MI_GET_PAGE_COLOR_FROM_PTE, MI_IS_PHYSICAL_ADDRESS, MI_PFN_ELEMENT, MiGetPteAddress, MiInitializePfn(), MiInsertPageInList(), MiRemoveZeroPage(), MmAvailablePages, MmChargeCommitmentLock, MmDynamicMemoryMutex, MmDynamicPfn, MmHighestPhysicalPage, MmHighestPossiblePhysicalPage, MmNumberOfPhysicalPages, MmPageLocationList, MmPfnDatabase, MmPhysicalMemoryBlock, MmResidentAvailablePages, MmTotalCommitLimit, MmTotalCommitLimitMaximum, MmTotalCommittedPages, NonPagedPool, NULL, _PHYSICAL_MEMORY_DESCRIPTOR::NumberOfPages, _PHYSICAL_MEMORY_DESCRIPTOR::NumberOfRuns, _MMPFN::OriginalPte, PAGE_SHIFT, PAGE_SIZE, _PHYSICAL_MEMORY_RUN::PageCount, PASSIVE_LEVEL, PFN_REMOVED, PMMPTE, PTE_SHIFT, _MMPFN::PteAddress, _MMPFN::PteFrame, _PHYSICAL_MEMORY_DESCRIPTOR::Run, TRUE, _MMPTE::u, _MMPFN::u2, _MMPFN::u3, UNLOCK_PFN, ValidKernelPte, and ZeroKernelPte. : This routine adds the specified physical address range to the system. This includes initializing PFN database entries and adding it to the freelists. Arguments: StartAddress - Supplies the starting physical address. NumberOfBytes - Supplies a pointer to the number of bytes being added. If any bytes were added (ie: STATUS_SUCCESS is being returned), the actual amount is returned here. Return Value: NTSTATUS. Environment: Kernel mode. PASSIVE level. No locks held. --*/ { ULONG i; PMMPFN Pfn1; KIRQL OldIrql; LOGICAL Inserted; LOGICAL Updated; MMPTE TempPte; PMMPTE PointerPte; PMMPTE LastPte; PFN_NUMBER NumberOfPages; PFN_NUMBER start; PFN_NUMBER count; PFN_NUMBER StartPage; PFN_NUMBER EndPage; PFN_NUMBER PageFrameIndex; PFN_NUMBER Page; PFN_NUMBER LastPage; PFN_COUNT PagesNeeded; PPHYSICAL_MEMORY_DESCRIPTOR OldPhysicalMemoryBlock; PPHYSICAL_MEMORY_DESCRIPTOR NewPhysicalMemoryBlock; PPHYSICAL_MEMORY_RUN NewRun; LOGICAL PfnDatabaseIsPhysical; ASSERT (KeGetCurrentIrql() == PASSIVE_LEVEL); ASSERT (BYTE_OFFSET(NumberOfBytes->LowPart) == 0); ASSERT (BYTE_OFFSET(StartAddress->LowPart) == 0); if (MI_IS_PHYSICAL_ADDRESS(MmPfnDatabase)) { // // The system must be configured for dynamic memory addition. This is // critical as only then is the database guaranteed to be non-sparse. // if (MmDynamicPfn == FALSE) { return STATUS_NOT_SUPPORTED; } PfnDatabaseIsPhysical = TRUE; } else { PfnDatabaseIsPhysical = FALSE; } StartPage = (PFN_NUMBER)(StartAddress->QuadPart >> PAGE_SHIFT); NumberOfPages = (PFN_NUMBER)(NumberOfBytes->QuadPart >> PAGE_SHIFT); EndPage = StartPage + NumberOfPages; if (EndPage - 1 > MmHighestPossiblePhysicalPage) { // // Truncate the request into something that can be mapped by the PFN // database. // EndPage = MmHighestPossiblePhysicalPage + 1; NumberOfPages = EndPage - StartPage; } // // The range cannot wrap. // if (StartPage >= EndPage) { return STATUS_INVALID_PARAMETER_1; } ExAcquireFastMutex (&MmDynamicMemoryMutex); i = (sizeof(PHYSICAL_MEMORY_DESCRIPTOR) + (sizeof(PHYSICAL_MEMORY_RUN) * (MmPhysicalMemoryBlock->NumberOfRuns + 1))); NewPhysicalMemoryBlock = ExAllocatePoolWithTag (NonPagedPool, i, ' mM'); if (NewPhysicalMemoryBlock == NULL) { ExReleaseFastMutex (&MmDynamicMemoryMutex); return STATUS_INSUFFICIENT_RESOURCES; } // // The range cannot overlap any ranges that are already present. // start = 0; LOCK_PFN (OldIrql); do { count = MmPhysicalMemoryBlock->Run[start].PageCount; Page = MmPhysicalMemoryBlock->Run[start].BasePage; if (count != 0) { LastPage = Page + count; if ((StartPage < Page) && (EndPage > Page)) { UNLOCK_PFN (OldIrql); ExReleaseFastMutex (&MmDynamicMemoryMutex); ExFreePool (NewPhysicalMemoryBlock); return STATUS_CONFLICTING_ADDRESSES; } if ((StartPage >= Page) && (StartPage < LastPage)) { UNLOCK_PFN (OldIrql); ExReleaseFastMutex (&MmDynamicMemoryMutex); ExFreePool (NewPhysicalMemoryBlock); return STATUS_CONFLICTING_ADDRESSES; } } start += 1; } while (start != MmPhysicalMemoryBlock->NumberOfRuns); // // Fill any gaps in the (sparse) PFN database needed for these pages, // unless the PFN database was physically allocated and completely // committed up front. // PagesNeeded = 0; if (PfnDatabaseIsPhysical == FALSE) { PointerPte = MiGetPteAddress (MI_PFN_ELEMENT(StartPage)); LastPte = MiGetPteAddress ((PCHAR)(MI_PFN_ELEMENT(EndPage)) - 1); while (PointerPte <= LastPte) { if (PointerPte->u.Hard.Valid == 0) { PagesNeeded += 1; } PointerPte += 1; } if (MmAvailablePages < PagesNeeded) { UNLOCK_PFN (OldIrql); ExReleaseFastMutex (&MmDynamicMemoryMutex); ExFreePool (NewPhysicalMemoryBlock); return STATUS_INSUFFICIENT_RESOURCES; } TempPte = ValidKernelPte; PointerPte = MiGetPteAddress (MI_PFN_ELEMENT(StartPage)); while (PointerPte <= LastPte) { if (PointerPte->u.Hard.Valid == 0) { PageFrameIndex = MiRemoveZeroPage(MI_GET_PAGE_COLOR_FROM_PTE (PointerPte)); MiInitializePfn (PageFrameIndex, PointerPte, 0); TempPte.u.Hard.PageFrameNumber = PageFrameIndex; *PointerPte = TempPte; } PointerPte += 1; } MmResidentAvailablePages -= PagesNeeded; } // // If the new range is adjacent to an existing range, just merge it into // the old block. Otherwise use the new block as a new entry will have to // be used. // NewPhysicalMemoryBlock->NumberOfRuns = MmPhysicalMemoryBlock->NumberOfRuns + 1; NewPhysicalMemoryBlock->NumberOfPages = MmPhysicalMemoryBlock->NumberOfPages + NumberOfPages; NewRun = &NewPhysicalMemoryBlock->Run[0]; start = 0; Inserted = FALSE; Updated = FALSE; do { Page = MmPhysicalMemoryBlock->Run[start].BasePage; count = MmPhysicalMemoryBlock->Run[start].PageCount; if (Inserted == FALSE) { // // Note overlaps into adjacent ranges were already checked above. // if (StartPage == Page + count) { MmPhysicalMemoryBlock->Run[start].PageCount += NumberOfPages; OldPhysicalMemoryBlock = NewPhysicalMemoryBlock; MmPhysicalMemoryBlock->NumberOfPages += NumberOfPages; // // Coalesce below and above to avoid leaving zero length gaps // as these gaps would prevent callers from removing ranges // the span them. // if (start + 1 < MmPhysicalMemoryBlock->NumberOfRuns) { start += 1; Page = MmPhysicalMemoryBlock->Run[start].BasePage; count = MmPhysicalMemoryBlock->Run[start].PageCount; if (StartPage + NumberOfPages == Page) { MmPhysicalMemoryBlock->Run[start - 1].PageCount += count; MmPhysicalMemoryBlock->NumberOfRuns -= 1; // // Copy any remaining entries. // if (start != MmPhysicalMemoryBlock->NumberOfRuns) { RtlMoveMemory (&MmPhysicalMemoryBlock->Run[start], &MmPhysicalMemoryBlock->Run[start + 1], (MmPhysicalMemoryBlock->NumberOfRuns - start) * sizeof (PHYSICAL_MEMORY_RUN)); } } } Updated = TRUE; break; } if (StartPage + NumberOfPages == Page) { MmPhysicalMemoryBlock->Run[start].BasePage = StartPage; MmPhysicalMemoryBlock->Run[start].PageCount += NumberOfPages; OldPhysicalMemoryBlock = NewPhysicalMemoryBlock; MmPhysicalMemoryBlock->NumberOfPages += NumberOfPages; Updated = TRUE; break; } if (StartPage + NumberOfPages <= Page) { if (start + 1 < MmPhysicalMemoryBlock->NumberOfRuns) { if (StartPage + NumberOfPages <= MmPhysicalMemoryBlock->Run[start + 1].BasePage) { // // Don't insert here - the new entry really belongs // (at least) one entry further down. // continue; } } NewRun->BasePage = StartPage; NewRun->PageCount = NumberOfPages; NewRun += 1; Inserted = TRUE; Updated = TRUE; } } *NewRun = MmPhysicalMemoryBlock->Run[start]; NewRun += 1; start += 1; } while (start != MmPhysicalMemoryBlock->NumberOfRuns); // // If the memory block has not been updated, then the new entry must // be added at the very end. // if (Updated == FALSE) { ASSERT (Inserted == FALSE); NewRun->BasePage = StartPage; NewRun->PageCount = NumberOfPages; Inserted = TRUE; } // // Repoint the MmPhysicalMemoryBlock at the new chunk, free the old after // releasing the PFN lock. // if (Inserted == TRUE) { OldPhysicalMemoryBlock = MmPhysicalMemoryBlock; MmPhysicalMemoryBlock = NewPhysicalMemoryBlock; } // // Note that the page directory (page parent entries on Win64) must be // filled in at system boot so that already-created processes do not fault // when referencing the new PFNs. // // // Walk through the memory descriptors and add pages to the // free list in the PFN database. // PageFrameIndex = StartPage; Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); if (EndPage - 1 > MmHighestPhysicalPage) { MmHighestPhysicalPage = EndPage - 1; } while (PageFrameIndex < EndPage) { ASSERT (Pfn1->u2.ShareCount == 0); ASSERT (Pfn1->u3.e2.ShortFlags == 0); ASSERT (Pfn1->u3.e2.ReferenceCount == 0); ASSERT64 (Pfn1->UsedPageTableEntries == 0); ASSERT (Pfn1->OriginalPte.u.Long == ZeroKernelPte.u.Long); ASSERT (Pfn1->PteFrame == 0); ASSERT ((Pfn1->PteAddress == PFN_REMOVED) || (Pfn1->PteAddress == (PMMPTE)(UINT_PTR)0)); // // Set the PTE address to the physical page for // virtual address alignment checking. // Pfn1->PteAddress = (PMMPTE)(PageFrameIndex << PTE_SHIFT); MiInsertPageInList (MmPageLocationList[FreePageList], PageFrameIndex); PageFrameIndex += 1; Pfn1 += 1; } MmResidentAvailablePages += NumberOfPages; MmNumberOfPhysicalPages += (PFN_COUNT)NumberOfPages; UNLOCK_PFN (OldIrql); // // Increase all commit limits to reflect the additional memory. // ExAcquireSpinLock (&MmChargeCommitmentLock, &OldIrql); MmTotalCommitLimit += NumberOfPages; MmTotalCommitLimitMaximum += NumberOfPages; MmTotalCommittedPages += PagesNeeded; ExReleaseSpinLock (&MmChargeCommitmentLock, OldIrql); ExReleaseFastMutex (&MmDynamicMemoryMutex); ExFreePool (OldPhysicalMemoryBlock); // // Indicate number of bytes actually added to our caller. // NumberOfBytes->QuadPart = (ULONGLONG)NumberOfPages * PAGE_SIZE; return STATUS_SUCCESS; }

PPHYSICAL_MEMORY_RANGE MmGetPhysicalMemoryRanges (  VOID   )

Definition at line 1032 of file dynmem.c. References ASSERT, _PHYSICAL_MEMORY_RANGE::BaseAddress, _PHYSICAL_MEMORY_RUN::BasePage, ExAllocatePoolWithTag, LOCK_PFN, MmDynamicMemoryMutex, MmPhysicalMemoryBlock, NonPagedPool, NULL, _PHYSICAL_MEMORY_RANGE::NumberOfBytes, _PHYSICAL_MEMORY_DESCRIPTOR::NumberOfRuns, PAGE_SIZE, _PHYSICAL_MEMORY_RUN::PageCount, PASSIVE_LEVEL, PHYSICAL_MEMORY_RANGE, _PHYSICAL_MEMORY_DESCRIPTOR::Run, and UNLOCK_PFN. 01038 : 01039 01040 This routine returns the virtual address of a nonpaged pool block which 01041 contains the physical memory ranges in the system. 01042 01043 The returned block contains physical address and page count pairs. 01044 The last entry contains zero for both. 01045 01046 The caller must understand that this block can change at any point before 01047 or after this snapshot. 01048 01049 It is the caller's responsibility to free this block. 01050 01051 Arguments: 01052 01053 None. 01054 01055 Return Value: 01056 01057 NULL on failure. 01058 01059 Environment: 01060 01061 Kernel mode. PASSIVE level. No locks held. 01062 01063 --*/ 01064 01065 { 01066 ULONG i; 01067 KIRQL OldIrql; 01068 PPHYSICAL_MEMORY_RANGE p; 01069 PPHYSICAL_MEMORY_RANGE PhysicalMemoryBlock; 01070 01071 ASSERT (KeGetCurrentIrql() == PASSIVE_LEVEL); 01072 01073 ExAcquireFastMutex (&MmDynamicMemoryMutex); 01074 01075 i = sizeof(PHYSICAL_MEMORY_RANGE) * (MmPhysicalMemoryBlock->NumberOfRuns + 1); 01076 01077 PhysicalMemoryBlock = ExAllocatePoolWithTag (NonPagedPool, 01078 i, 01079 'hPmM'); 01080 01081 if (PhysicalMemoryBlock == NULL) { 01082 ExReleaseFastMutex (&MmDynamicMemoryMutex); 01083 return NULL; 01084 } 01085 01086 p = PhysicalMemoryBlock; 01087 01088 LOCK_PFN (OldIrql); 01089 01090 ASSERT (i == (sizeof(PHYSICAL_MEMORY_RANGE) * (MmPhysicalMemoryBlock->NumberOfRuns + 1))); 01091 01092 for (i = 0; i < MmPhysicalMemoryBlock->NumberOfRuns; i += 1) { 01093 p->BaseAddress.QuadPart = (LONGLONG)MmPhysicalMemoryBlock->Run[i].BasePage * PAGE_SIZE; 01094 p->NumberOfBytes.QuadPart = (LONGLONG)MmPhysicalMemoryBlock->Run[i].PageCount * PAGE_SIZE; 01095 p += 1; 01096 } 01097 01098 p->BaseAddress.QuadPart = 0; 01099 p->NumberOfBytes.QuadPart = 0; 01100 01101 UNLOCK_PFN (OldIrql); 01102 01103 ExReleaseFastMutex (&MmDynamicMemoryMutex); 01104 01105 return PhysicalMemoryBlock; 01106 }

NTSTATUS MmRemovePhysicalMemory (  IN PPHYSICAL_ADDRESS  StartAddress, IN OUT PLARGE_INTEGER  NumberOfBytes )

Definition at line 437 of file dynmem.c. References ASSERT, ASSERT64, BadPageList, _PHYSICAL_MEMORY_RUN::BasePage, BYTE_OFFSET, DbgPrint, ExAllocatePoolWithTag, ExFreePool(), FALSE, FreePageList, KeDelayExecutionThread(), KeFlushSingleTb(), KernelMode, LOCK_PFN, MI_GET_PAGE_FRAME_FROM_PTE, MI_IS_PHYSICAL_ADDRESS, MI_NONPAGABLE_MEMORY_AVAILABLE, MI_PFN_ELEMENT, MI_SET_PFN_DELETED, MiDecrementReferenceCount(), MiDelayPageFaults, MiEmptyAllWorkingSets(), MiFlushAllPages(), MiGetPteAddress, MiInsertPageInList(), MiRemovePhysicalPages(), MiReturnCommitment(), MiTrimRemovalPagesOnly, MiUnlinkPageFromList(), MmChargeCommitmentLock, MmDynamicMemoryMutex, MmDynamicPfn, MmHalfSecond, MmHighestPhysicalPage, MmHighestPossiblePhysicalPage, MmNumberOfPhysicalPages, MmPageLocationList, MmPfnDatabase, MmPhysicalMemoryBlock, MmResidentAvailablePages, MmTotalCommitLimit, MmTotalCommitLimitMaximum, MmTotalCommittedPages, NonPagedPool, NTSTATUS(), NULL, _PHYSICAL_MEMORY_DESCRIPTOR::NumberOfPages, _PHYSICAL_MEMORY_DESCRIPTOR::NumberOfRuns, _MMPFN::OriginalPte, PAGE_ALIGN, PAGE_SHIFT, PAGE_SIZE, _PHYSICAL_MEMORY_RUN::PageCount, PASSIVE_LEVEL, PFN_REMOVED, _MMPFN::PteAddress, _MMPFN::PteFrame, ROUND_TO_PAGES, _PHYSICAL_MEMORY_DESCRIPTOR::Run, StandbyPageList, Status, TRUE, _MMPTE::u, _MMPFN::u1, _MMPFN::u2, _MMPFN::u3, UNLOCK_PFN, and ZeroKernelPte. : This routine attempts to remove the specified physical address range from the system. Arguments: StartAddress - Supplies the starting physical address. NumberOfBytes - Supplies a pointer to the number of bytes being removed. Return Value: NTSTATUS. Environment: Kernel mode. PASSIVE level. No locks held. --*/ { ULONG i; ULONG Additional; PFN_NUMBER Page; PFN_NUMBER LastPage; PFN_NUMBER OriginalLastPage; PFN_NUMBER start; PFN_NUMBER PagesReleased; PMMPFN Pfn1; PMMPFN StartPfn; PMMPFN EndPfn; KIRQL OldIrql; PFN_NUMBER StartPage; PFN_NUMBER EndPage; PFN_COUNT NumberOfPages; SPFN_NUMBER MaxPages; PFN_NUMBER PageFrameIndex; PFN_NUMBER RemovedPages; LOGICAL Inserted; NTSTATUS Status; PMMPTE PointerPte; PMMPTE EndPte; PVOID VirtualAddress; PPHYSICAL_MEMORY_DESCRIPTOR OldPhysicalMemoryBlock; PPHYSICAL_MEMORY_DESCRIPTOR NewPhysicalMemoryBlock; PPHYSICAL_MEMORY_RUN NewRun; LOGICAL PfnDatabaseIsPhysical; ASSERT (KeGetCurrentIrql() == PASSIVE_LEVEL); ASSERT (BYTE_OFFSET(NumberOfBytes->LowPart) == 0); ASSERT (BYTE_OFFSET(StartAddress->LowPart) == 0); if (MI_IS_PHYSICAL_ADDRESS(MmPfnDatabase)) { // // The system must be configured for dynamic memory addition. This is // not strictly required to remove the memory, but it's better to check // for it now under the assumption that the administrator is probably // going to want to add this range of memory back in - better to give // the error now and refuse the removal than to refuse the addition // later. // if (MmDynamicPfn == FALSE) { return STATUS_NOT_SUPPORTED; } PfnDatabaseIsPhysical = TRUE; } else { PfnDatabaseIsPhysical = FALSE; } StartPage = (PFN_NUMBER)(StartAddress->QuadPart >> PAGE_SHIFT); NumberOfPages = (PFN_COUNT)(NumberOfBytes->QuadPart >> PAGE_SHIFT); EndPage = StartPage + NumberOfPages; if (EndPage - 1 > MmHighestPossiblePhysicalPage) { // // Truncate the request into something that can be mapped by the PFN // database. // EndPage = MmHighestPossiblePhysicalPage + 1; NumberOfPages = (PFN_COUNT)(EndPage - StartPage); } // // The range cannot wrap. // if (StartPage >= EndPage) { return STATUS_INVALID_PARAMETER_1; } StartPfn = MI_PFN_ELEMENT (StartPage); EndPfn = MI_PFN_ELEMENT (EndPage); ExAcquireFastMutex (&MmDynamicMemoryMutex); #if DBG MiDynmemData[0] += 1; #endif // // Decrease all commit limits to reflect the removed memory. // ExAcquireSpinLock (&MmChargeCommitmentLock, &OldIrql); ASSERT (MmTotalCommitLimit <= MmTotalCommitLimitMaximum); if ((NumberOfPages + 100 > MmTotalCommitLimit - MmTotalCommittedPages) || (MmTotalCommittedPages > MmTotalCommitLimit)) { #if DBG MiDynmemData[1] += 1; #endif ExReleaseSpinLock (&MmChargeCommitmentLock, OldIrql); ExReleaseFastMutex (&MmDynamicMemoryMutex); return STATUS_INSUFFICIENT_RESOURCES; } MmTotalCommitLimit -= NumberOfPages; MmTotalCommitLimitMaximum -= NumberOfPages; ExReleaseSpinLock (&MmChargeCommitmentLock, OldIrql); // // Check for outstanding promises that cannot be broken. // LOCK_PFN (OldIrql); MaxPages = MI_NONPAGABLE_MEMORY_AVAILABLE() - 100; if ((SPFN_NUMBER)NumberOfPages > MaxPages) { #if DBG MiDynmemData[2] += 1; #endif UNLOCK_PFN (OldIrql); Status = STATUS_INSUFFICIENT_RESOURCES; goto giveup2; } MmResidentAvailablePages -= NumberOfPages; MmNumberOfPhysicalPages -= NumberOfPages; // // The range must be contained in a single entry. It is permissible for // it to be part of a single entry, but it must not cross multiple entries. // Additional = (ULONG)-2; start = 0; do { Page = MmPhysicalMemoryBlock->Run[start].BasePage; LastPage = Page + MmPhysicalMemoryBlock->Run[start].PageCount; if ((StartPage >= Page) && (EndPage <= LastPage)) { if ((StartPage == Page) && (EndPage == LastPage)) { Additional = (ULONG)-1; } else if ((StartPage == Page) || (EndPage == LastPage)) { Additional = 0; } else { Additional = 1; } break; } start += 1; } while (start != MmPhysicalMemoryBlock->NumberOfRuns); if (Additional == (ULONG)-2) { #if DBG MiDynmemData[3] += 1; #endif MmResidentAvailablePages += NumberOfPages; MmNumberOfPhysicalPages += NumberOfPages; UNLOCK_PFN (OldIrql); Status = STATUS_CONFLICTING_ADDRESSES; goto giveup2; } for (Pfn1 = StartPfn; Pfn1 < EndPfn; Pfn1 += 1) { Pfn1->u3.e1.RemovalRequested = 1; } // // The free and zero lists must be pruned now before releasing the PFN // lock otherwise if another thread allocates the page from these lists, // the allocation will clear the RemovalRequested flag forever. // RemovedPages = MiRemovePhysicalPages (StartPage, EndPage); if (RemovedPages != NumberOfPages) { #if DBG retry: #endif Pfn1 = StartPfn; InterlockedIncrement (&MiDelayPageFaults); for (i = 0; i < 5; i += 1) { UNLOCK_PFN (OldIrql); // // Attempt to move pages to the standby list. Note that only the // pages with RemovalRequested set are moved. // MiTrimRemovalPagesOnly = TRUE; MiEmptyAllWorkingSets (); MiTrimRemovalPagesOnly = FALSE; MiFlushAllPages (); KeDelayExecutionThread (KernelMode, FALSE, &MmHalfSecond); LOCK_PFN (OldIrql); RemovedPages += MiRemovePhysicalPages (StartPage, EndPage); if (RemovedPages == NumberOfPages) { break; } // // RemovedPages doesn't include pages that were freed directly to // the bad page list via MiDecrementReferenceCount. So use the above // check purely as an optimization - and walk here when necessary. // for ( ; Pfn1 < EndPfn; Pfn1 += 1) { if (Pfn1->u3.e1.PageLocation != BadPageList) { break; } } if (Pfn1 == EndPfn) { RemovedPages = NumberOfPages; break; } } InterlockedDecrement (&MiDelayPageFaults); } if (RemovedPages != NumberOfPages) { #if DBG MiDynmemData[4] += 1; if (MiShowStuckPages != 0) { RemovedPages = 0; for (Pfn1 = StartPfn; Pfn1 < EndPfn; Pfn1 += 1) { if (Pfn1->u3.e1.PageLocation != BadPageList) { RemovedPages += 1; } } ASSERT (RemovedPages != 0); DbgPrint("MmRemovePhysicalMemory : could not get %d of %d pages\n", RemovedPages, NumberOfPages); if (MiShowStuckPages & 0x2) { ULONG PfnsPrinted; ULONG EnoughShown; PMMPFN FirstPfn; PFN_COUNT PfnCount; PfnCount = 0; PfnsPrinted = 0; EnoughShown = 100; if (MiShowStuckPages & 0x4) { EnoughShown = (ULONG)-1; } DbgPrint("Stuck PFN list: "); for (Pfn1 = StartPfn; Pfn1 < EndPfn; Pfn1 += 1) { if (Pfn1->u3.e1.PageLocation != BadPageList) { if (PfnCount == 0) { FirstPfn = Pfn1; } PfnCount += 1; } else { if (PfnCount != 0) { DbgPrint("%x -> %x ; ", FirstPfn - MmPfnDatabase, (FirstPfn - MmPfnDatabase) + PfnCount - 1); PfnsPrinted += 1; if (PfnsPrinted == EnoughShown) { break; } PfnCount = 0; } } } if (PfnCount != 0) { DbgPrint("%x -> %x ; ", FirstPfn - MmPfnDatabase, (FirstPfn - MmPfnDatabase) + PfnCount - 1); } DbgPrint("\n"); } if (MiShowStuckPages & 0x8) { DbgBreakPoint (); } if (MiShowStuckPages & 0x10) { goto retry; } } #endif UNLOCK_PFN (OldIrql); Status = STATUS_NO_MEMORY; goto giveup; } #if DBG for (Pfn1 = StartPfn; Pfn1 < EndPfn; Pfn1 += 1) { ASSERT (Pfn1->u3.e1.PageLocation == BadPageList); } #endif // // All the pages in the range have been removed. Update the physical // memory blocks and other associated housekeeping. // if (Additional == 0) { // // The range can be split off from an end of an existing chunk so no // pool growth or shrinkage is required. // NewPhysicalMemoryBlock = MmPhysicalMemoryBlock; OldPhysicalMemoryBlock = NULL; } else { // // The range cannot be split off from an end of an existing chunk so // pool growth or shrinkage is required. // UNLOCK_PFN (OldIrql); i = (sizeof(PHYSICAL_MEMORY_DESCRIPTOR) + (sizeof(PHYSICAL_MEMORY_RUN) * (MmPhysicalMemoryBlock->NumberOfRuns + Additional))); NewPhysicalMemoryBlock = ExAllocatePoolWithTag (NonPagedPool, i, ' mM'); if (NewPhysicalMemoryBlock == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; #if DBG MiDynmemData[5] += 1; #endif goto giveup; } OldPhysicalMemoryBlock = MmPhysicalMemoryBlock; RtlZeroMemory (NewPhysicalMemoryBlock, i); LOCK_PFN (OldIrql); } // // Remove or split the requested range from the existing memory block. // NewPhysicalMemoryBlock->NumberOfRuns = MmPhysicalMemoryBlock->NumberOfRuns + Additional; NewPhysicalMemoryBlock->NumberOfPages = MmPhysicalMemoryBlock->NumberOfPages - NumberOfPages; NewRun = &NewPhysicalMemoryBlock->Run[0]; start = 0; Inserted = FALSE; do { Page = MmPhysicalMemoryBlock->Run[start].BasePage; LastPage = Page + MmPhysicalMemoryBlock->Run[start].PageCount; if (Inserted == FALSE) { if ((StartPage >= Page) && (EndPage <= LastPage)) { if ((StartPage == Page) && (EndPage == LastPage)) { ASSERT (Additional == -1); start += 1; continue; } else if ((StartPage == Page) || (EndPage == LastPage)) { ASSERT (Additional == 0); if (StartPage == Page) { MmPhysicalMemoryBlock->Run[start].BasePage += NumberOfPages; } MmPhysicalMemoryBlock->Run[start].PageCount -= NumberOfPages; } else { ASSERT (Additional == 1); OriginalLastPage = LastPage; MmPhysicalMemoryBlock->Run[start].PageCount = StartPage - MmPhysicalMemoryBlock->Run[start].BasePage; *NewRun = MmPhysicalMemoryBlock->Run[start]; NewRun += 1; NewRun->BasePage = EndPage; NewRun->PageCount = OriginalLastPage - EndPage; NewRun += 1; start += 1; continue; } Inserted = TRUE; } } *NewRun = MmPhysicalMemoryBlock->Run[start]; NewRun += 1; start += 1; } while (start != MmPhysicalMemoryBlock->NumberOfRuns); // // Repoint the MmPhysicalMemoryBlock at the new chunk. // Free the old block after releasing the PFN lock. // MmPhysicalMemoryBlock = NewPhysicalMemoryBlock; if (EndPage - 1 == MmHighestPhysicalPage) { MmHighestPhysicalPage = StartPage - 1; } // // Throw away all the removed pages that are currently enqueued. // for (Pfn1 = StartPfn; Pfn1 < EndPfn; Pfn1 += 1) { ASSERT (Pfn1->u3.e1.PageLocation == BadPageList); ASSERT (Pfn1->u3.e1.RemovalRequested == 1); MiUnlinkPageFromList (Pfn1); ASSERT (Pfn1->u1.Flink == 0); ASSERT (Pfn1->u2.Blink == 0); ASSERT (Pfn1->u3.e2.ReferenceCount == 0); ASSERT64 (Pfn1->UsedPageTableEntries == 0); Pfn1->PteAddress = PFN_REMOVED; Pfn1->u3.e2.ShortFlags = 0; Pfn1->OriginalPte.u.Long = ZeroKernelPte.u.Long; Pfn1->PteFrame = 0; } // // Now that the removed pages have been discarded, eliminate the PFN // entries that mapped them. Straddling entries left over from an // adjacent earlier removal are not collapsed at this point. // // PagesReleased = 0; if (PfnDatabaseIsPhysical == FALSE) { VirtualAddress = (PVOID)ROUND_TO_PAGES(MI_PFN_ELEMENT(StartPage)); PointerPte = MiGetPteAddress (VirtualAddress); EndPte = MiGetPteAddress (PAGE_ALIGN(MI_PFN_ELEMENT(EndPage))); while (PointerPte < EndPte) { PageFrameIndex = MI_GET_PAGE_FRAME_FROM_PTE (PointerPte); Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); ASSERT (Pfn1->u2.ShareCount == 1); ASSERT (Pfn1->u3.e2.ReferenceCount == 1); Pfn1->u2.ShareCount = 0; MI_SET_PFN_DELETED (Pfn1); #if DBG Pfn1->u3.e1.PageLocation = StandbyPageList; #endif //DBG MiDecrementReferenceCount (PageFrameIndex); KeFlushSingleTb (VirtualAddress, TRUE, TRUE, (PHARDWARE_PTE)PointerPte, ZeroKernelPte.u.Flush); PagesReleased += 1; PointerPte += 1; VirtualAddress = (PVOID)((PCHAR)VirtualAddress + PAGE_SIZE); } MmResidentAvailablePages += PagesReleased; } #if DBG MiDynmemData[6] += 1; #endif UNLOCK_PFN (OldIrql); if (PagesReleased != 0) { MiReturnCommitment (PagesReleased); } ExReleaseFastMutex (&MmDynamicMemoryMutex); if (OldPhysicalMemoryBlock != NULL) { ExFreePool (OldPhysicalMemoryBlock); } NumberOfBytes->QuadPart = (ULONGLONG)NumberOfPages * PAGE_SIZE; return STATUS_SUCCESS; giveup: // // All the pages in the range were not obtained. Back everything out. // PageFrameIndex = StartPage; Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); LOCK_PFN (OldIrql); while (PageFrameIndex < EndPage) { ASSERT (Pfn1->u3.e1.RemovalRequested == 1); Pfn1->u3.e1.RemovalRequested = 0; if ((Pfn1->u3.e1.PageLocation == BadPageList) && (Pfn1->u3.e1.ParityError == 0)) { MiUnlinkPageFromList (Pfn1); MiInsertPageInList (MmPageLocationList[FreePageList], PageFrameIndex); } Pfn1 += 1; PageFrameIndex += 1; } MmResidentAvailablePages += NumberOfPages; MmNumberOfPhysicalPages += NumberOfPages; UNLOCK_PFN (OldIrql); giveup2: ExAcquireSpinLock (&MmChargeCommitmentLock, &OldIrql); MmTotalCommitLimit += NumberOfPages; MmTotalCommitLimitMaximum += NumberOfPages; ExReleaseSpinLock (&MmChargeCommitmentLock, OldIrql); ExReleaseFastMutex (&MmDynamicMemoryMutex); return Status; }

---

Variable Documentation

LOGICAL MiTrimRemovalPagesOnly = FALSE

Definition at line 26 of file dynmem.c. Referenced by MiEmptyWorkingSet(), and MmRemovePhysicalMemory().

FAST_MUTEX MmDynamicMemoryMutex

Definition at line 24 of file dynmem.c. Referenced by MiCheckForCrashDump(), MiFindContiguousMemory(), MmAddPhysicalMemory(), MmAllocatePagesForMdl(), MmGetPhysicalMemoryRanges(), MmInitSystem(), and MmRemovePhysicalMemory().

---