mminit.c File Reference

#include "mi.h"

Go to the source code of this file.

Defines
#define	MM_MAX_LOADER_BLOCKS   30
#define	MM_SMALL_SYSTEM   ((13*1024*1024) / 4096)
#define	MM_MEDIUM_SYSTEM   ((19*1024*1024) / 4096)
#define	MM_MIN_INITIAL_PAGED_POOL   ((32*1024*1024) >> PAGE_SHIFT)
#define	MM_DEFAULT_IO_LOCK_LIMIT   (2 * 1024 * 1024)
Functions
VOID	MiMapBBTMemory (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
VOID	MiInitializeSpecialPool (VOID)
VOID	MiEnablePagingTheExecutive (VOID)
VOID	MiEnablePagingOfDriverAtInit (IN PMMPTE PointerPte, IN PMMPTE LastPte)
VOID	MiBuildPagedPool ()
VOID	MiMergeMemoryLimit (IN OUT PPHYSICAL_MEMORY_DESCRIPTOR Memory, IN PFN_NUMBER StartPage, IN PFN_NUMBER NumberOfPages)
VOID	MiWriteProtectSystemImage (IN PVOID DllBase)
VOID	MiInitializeSpecialPoolCriteria (IN VOID)
BOOLEAN	MmInitSystem (IN ULONG Phase, IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN PPHYSICAL_MEMORY_DESCRIPTOR PhysicalMemoryBlock)
VOID	MmInitializeMemoryLimits (IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN PBOOLEAN IncludeType, OUT PPHYSICAL_MEMORY_DESCRIPTOR Memory)
VOID	MmFreeLoaderBlock (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
VOID	MiBuildPagedPool (VOID)
VOID	MiFindInitializationCode (OUT PVOID *StartVa, OUT PVOID *EndVa)
VOID	MiFreeInitializationCode (IN PVOID StartVa, IN PVOID EndVa)
MM_SYSTEMSIZE	MmQuerySystemSize (VOID)
NTKERNELAPI BOOLEAN	MmIsThisAnNtAsSystem (VOID)
NTKERNELAPI VOID FASTCALL	MmSetPageFaultNotifyRoutine (PPAGE_FAULT_NOTIFY_ROUTINE NotifyRoutine)
NTKERNELAPI VOID FASTCALL	MmSetHardFaultNotifyRoutine (PHARD_FAULT_NOTIFY_ROUTINE NotifyRoutine)
Variables
MMPTE	MmSharedUserDataPte
MMINPAGE_SUPPORT_LIST	MmInPageSupportList
MMEVENT_COUNT_LIST	MmEventCountList
KMUTANT	MmSystemLoadLock
ULONG_PTR	MmSystemPtesStart [MaximumPtePoolTypes]
ULONG	MiSpecialPoolPtes
ULONG	MmPagedPoolCommit
PVOID	BBTBuffer
ULONG	BBTPagesToReserve
ULONG_PTR	MmSubsectionBase
ULONG_PTR	MmSubsectionTopPage
ULONG	MmDataClusterSize
ULONG	MmCodeClusterSize
PFN_NUMBER	MmResidentAvailableAtInit
KEVENT	MmImageMappingPteEvent
PPHYSICAL_MEMORY_DESCRIPTOR	MmPhysicalMemoryBlock
LIST_ENTRY	MmLockConflictList
LOGICAL	MmPagedPoolMaximumDesired = FALSE
	PERFINFO_MMINIT_DECL
ULONG	MmModifiedPageLifeInSeconds = 300
LARGE_INTEGER	MiModifiedPageLife
BOOLEAN	MiTimerPending = FALSE
KEVENT	MiMappedPagesTooOldEvent
KDPC	MiModifiedPageWriterTimerDpc
KTIMER	MiModifiedPageWriterTimer
ULONG	MmMaximumWorkingSetSize
ULONG	MmEnforceWriteProtection
CHAR	MiPteStr []
LONG	MiTrimInProgressCount
PFN_NUMBER	MmSystemPageDirectory
PMMPTE	MmSystemPagePtes
ULONG	MmTotalSystemCodePages
MM_SYSTEMSIZE	MmSystemSize
ULONG	MmLargeSystemCache
ULONG	MmProductType
LIST_ENTRY	MmLoadedUserImageList
PPAGE_FAULT_NOTIFY_ROUTINE	MmPageFaultNotifyRoutine
PHARD_FAULT_NOTIFY_ROUTINE	MmHardFaultNotifyRoutine

---

Define Documentation

#define MM_DEFAULT_IO_LOCK_LIMIT   (2 * 1024 * 1024)

Definition at line 149 of file mminit.c.

#define MM_MAX_LOADER_BLOCKS   30

Definition at line 118 of file mminit.c. Referenced by MmFreeLoaderBlock().

#define MM_MEDIUM_SYSTEM   ((19*1024*1024) / 4096)

Definition at line 145 of file mminit.c. Referenced by MmInitSystem().

#define MM_MIN_INITIAL_PAGED_POOL   ((32*1024*1024) >> PAGE_SHIFT)

Definition at line 147 of file mminit.c. Referenced by MiBuildPagedPool().

#define MM_SMALL_SYSTEM   ((13*1024*1024) / 4096)

Definition at line 143 of file mminit.c. Referenced by MmInitSystem().

---

Function Documentation

VOID MiBuildPagedPool (  VOID   )

Definition at line 2184 of file mminit.c. References ActiveAndValid, ASSERT, BYTES_TO_PAGES, InitializePool(), L, LOCK_PFN, MI_GET_PAGE_COLOR_FROM_PTE, MI_GET_PAGE_FRAME_FROM_PTE, MI_IS_PHYSICAL_ADDRESS, MI_PFN_ELEMENT, MI_WRITE_VALID_PTE, MiCreateBitMap, MiFillMemoryPte, MiGetPdeAddress, MiGetPpeAddress, MiGetPteAddress, MiGetVirtualAddressMappedByPte, MiInitializeSpecialPool(), MiInitializeSystemSpaceMap(), MiMapPageInHyperSpace(), MiRemoveAnyPage(), MiReserveSystemPtes(), MiUnmapPageInHyperSpace, MM_COLOR_ALIGNMENT, MM_COLOR_MASK_VIRTUAL, MM_DEMAND_ZERO_WRITE_PTE, MM_KERNEL_NOACCESS_PTE, MM_MAX_PAGED_POOL, MM_MIN_INITIAL_PAGED_POOL, MM_MINIMUM_PAGED_POOL_NTAS, MmIsThisAnNtAsSystem(), MmMaximumNonPagedPoolInBytes, MmNonPagedSystemStart, MmNumberOfPhysicalPages, MmPageAlignedPoolBase, MmPagedPoolBasePde, MmPagedPoolEnd, MmPagedPoolInfo, MmPagedPoolMaximumDesired, MmPagedPoolStart, MmSizeOfPagedPoolInBytes, MmSystemPageDirectory, MmSystemPagePtes, MmVerifyDriverBufferLength, NonPagedPool, _MMPFN::OriginalPte, PAGE_SHIFT, PAGE_SIZE, PagedPool, PDE_KTBASE, PDE_PER_PAGE, PTE_PER_PAGE, _MMPFN::PteAddress, _MMPFN::PteFrame, RtlClearAllBits(), RtlClearBits(), RtlSetAllBits(), Size, SystemPteSpace, TRUE, _MMPTE::u, _MMPFN::u2, _MMPFN::u3, UNLOCK_PFN, ValidKernelPde, and VerifierLargePagedPoolMap. : This function is called to build the structures required for paged pool and initialize the pool. Once this routine is called, paged pool may be allocated. Arguments: None. Return Value: None. Environment: Kernel Mode Only. System initialization. --*/ { SIZE_T Size; PMMPTE PointerPte; PMMPTE PointerPde; PMMPTE PointerPpe; PMMPTE PointerPpeEnd; MMPTE TempPte; PMMPFN Pfn1; PFN_NUMBER PageFrameIndex; KIRQL OldIrql; ULONG i; #if !defined (_WIN64) // // Double map system page directory page. // #if defined (_X86PAE_) PointerPte = MiGetPteAddress(PDE_BASE); for (i = 0 ; i < PD_PER_SYSTEM; i += 1) { MmSystemPageDirectory[i] = MI_GET_PAGE_FRAME_FROM_PTE (PointerPte); Pfn1 = MI_PFN_ELEMENT(MmSystemPageDirectory[i]); Pfn1->OriginalPte.u.Long = MM_DEMAND_ZERO_WRITE_PTE; PointerPte += 1; } // // Was not mapped physically, map it virtually in system space. // PointerPte = MiReserveSystemPtes ( PD_PER_SYSTEM, SystemPteSpace, MM_COLOR_ALIGNMENT, ((ULONG_PTR)PDE_BASE & MM_COLOR_MASK_VIRTUAL), TRUE); MmSystemPagePtes = (PMMPTE)MiGetVirtualAddressMappedByPte (PointerPte); TempPte = ValidKernelPde; for (i = 0 ; i < PD_PER_SYSTEM; i += 1) { TempPte.u.Hard.PageFrameNumber = MmSystemPageDirectory[i]; MI_WRITE_VALID_PTE (PointerPte, TempPte); PointerPte += 1; } #else MmSystemPageDirectory = MI_GET_PAGE_FRAME_FROM_PTE (MiGetPteAddress(PDE_BASE)); Pfn1 = MI_PFN_ELEMENT(MmSystemPageDirectory); Pfn1->OriginalPte.u.Long = MM_DEMAND_ZERO_WRITE_PTE; MmSystemPagePtes = (PMMPTE)MiMapPageInHyperSpace (MmSystemPageDirectory, &OldIrql); MiUnmapPageInHyperSpace (OldIrql); if (!MI_IS_PHYSICAL_ADDRESS(MmSystemPagePtes)) { // // Was not mapped physically, map it virtually in system space. // PointerPte = MiReserveSystemPtes ( 1, SystemPteSpace, MM_COLOR_ALIGNMENT, ((ULONG_PTR)PDE_BASE & MM_COLOR_MASK_VIRTUAL), TRUE); TempPte = ValidKernelPde; TempPte.u.Hard.PageFrameNumber = MmSystemPageDirectory; MI_WRITE_VALID_PTE (PointerPte, TempPte); MmSystemPagePtes = (PMMPTE)MiGetVirtualAddressMappedByPte (PointerPte); } #endif #endif if (MmPagedPoolMaximumDesired == TRUE) { MmSizeOfPagedPoolInBytes = ((PCHAR)MmNonPagedSystemStart - (PCHAR)MmPagedPoolStart); } // // A size of 0 means size the pool based on physical memory. // if (MmSizeOfPagedPoolInBytes == 0) { MmSizeOfPagedPoolInBytes = 2 * MmMaximumNonPagedPoolInBytes; } if (MmIsThisAnNtAsSystem()) { if ((MmNumberOfPhysicalPages > ((24*1024*1024) >> PAGE_SHIFT)) && (MmSizeOfPagedPoolInBytes < MM_MINIMUM_PAGED_POOL_NTAS)) { MmSizeOfPagedPoolInBytes = MM_MINIMUM_PAGED_POOL_NTAS; } } if (MmSizeOfPagedPoolInBytes > (ULONG_PTR)((PCHAR)MmNonPagedSystemStart - (PCHAR)MmPagedPoolStart)) { MmSizeOfPagedPoolInBytes = ((PCHAR)MmNonPagedSystemStart - (PCHAR)MmPagedPoolStart); } Size = BYTES_TO_PAGES(MmSizeOfPagedPoolInBytes); if (Size < MM_MIN_INITIAL_PAGED_POOL) { Size = MM_MIN_INITIAL_PAGED_POOL; } if (Size > (MM_MAX_PAGED_POOL >> PAGE_SHIFT)) { Size = MM_MAX_PAGED_POOL >> PAGE_SHIFT; } Size = (Size + (PTE_PER_PAGE - 1)) / PTE_PER_PAGE; MmSizeOfPagedPoolInBytes = (ULONG_PTR)Size * PAGE_SIZE * PTE_PER_PAGE; ASSERT ((MmSizeOfPagedPoolInBytes + (PCHAR)MmPagedPoolStart) <= (PCHAR)MmNonPagedSystemStart); // // Set size to the number of pages in the pool. // Size = Size * PTE_PER_PAGE; MmPagedPoolEnd = (PVOID)(((PUCHAR)MmPagedPoolStart + MmSizeOfPagedPoolInBytes) - 1); MmPageAlignedPoolBase[PagedPool] = MmPagedPoolStart; // // Build page table page for paged pool. // PointerPde = MiGetPdeAddress (MmPagedPoolStart); MmPagedPoolBasePde = PointerPde; TempPte = ValidKernelPde; #if defined (_WIN64) // // Map in all the page directory pages to span all of paged pool. // This removes the need for a system lookup directory. // PointerPpe = MiGetPpeAddress (MmPagedPoolStart); PointerPpeEnd = MiGetPpeAddress (MmPagedPoolEnd); while (PointerPpe <= PointerPpeEnd) { if (PointerPpe->u.Hard.Valid == 0) { PageFrameIndex = MiRemoveAnyPage( MI_GET_PAGE_COLOR_FROM_PTE (PointerPpe)); TempPte.u.Hard.PageFrameNumber = PageFrameIndex; *PointerPpe = TempPte; Pfn1 = MI_PFN_ELEMENT(PageFrameIndex); Pfn1->PteFrame = MI_GET_PAGE_FRAME_FROM_PTE ( MiGetPteAddress(PDE_KTBASE)); Pfn1->PteAddress = PointerPpe; Pfn1->u2.ShareCount = 1; Pfn1->u3.e2.ReferenceCount = 1; Pfn1->u3.e1.PageLocation = ActiveAndValid; Pfn1->OriginalPte.u.Long = MM_DEMAND_ZERO_WRITE_PTE; } PointerPpe += 1; } #endif PointerPte = MiGetPteAddress (MmPagedPoolStart); MmPagedPoolInfo.FirstPteForPagedPool = PointerPte; MmPagedPoolInfo.LastPteForPagedPool = MiGetPteAddress (MmPagedPoolEnd); MiFillMemoryPte (PointerPde, sizeof(MMPTE) * (1 + MiGetPdeAddress (MmPagedPoolEnd) - PointerPde), MM_KERNEL_NOACCESS_PTE); LOCK_PFN (OldIrql); // // Map in a page table page. // PageFrameIndex = MiRemoveAnyPage( MI_GET_PAGE_COLOR_FROM_PTE (PointerPde)); TempPte.u.Hard.PageFrameNumber = PageFrameIndex; MI_WRITE_VALID_PTE (PointerPde, TempPte); Pfn1 = MI_PFN_ELEMENT(PageFrameIndex); #if defined (_WIN64) Pfn1->PteFrame = MI_GET_PAGE_FRAME_FROM_PTE(MiGetPpeAddress (MmPagedPoolStart)); #else #if !defined (_X86PAE_) Pfn1->PteFrame = MmSystemPageDirectory; #else Pfn1->PteFrame = MmSystemPageDirectory[(PointerPde - MiGetPdeAddress(0)) / PDE_PER_PAGE]; #endif #endif Pfn1->PteAddress = PointerPde; Pfn1->u2.ShareCount = 1; Pfn1->u3.e2.ReferenceCount = 1; Pfn1->u3.e1.PageLocation = ActiveAndValid; Pfn1->OriginalPte.u.Long = MM_DEMAND_ZERO_WRITE_PTE; MiFillMemoryPte (PointerPte, PAGE_SIZE, MM_KERNEL_NOACCESS_PTE); UNLOCK_PFN (OldIrql); MmPagedPoolInfo.NextPdeForPagedPoolExpansion = PointerPde + 1; // // Build bitmaps for paged pool. // MiCreateBitMap (&MmPagedPoolInfo.PagedPoolAllocationMap, Size, NonPagedPool); RtlSetAllBits (MmPagedPoolInfo.PagedPoolAllocationMap); // // Indicate first page worth of PTEs are available. // RtlClearBits (MmPagedPoolInfo.PagedPoolAllocationMap, 0, PTE_PER_PAGE); MiCreateBitMap (&MmPagedPoolInfo.EndOfPagedPoolBitmap, Size, NonPagedPool); RtlClearAllBits (MmPagedPoolInfo.EndOfPagedPoolBitmap); // // If verifier is present then build the verifier paged pool bitmap. // if (MmVerifyDriverBufferLength != (ULONG)-1) { MiCreateBitMap (&VerifierLargePagedPoolMap, Size, NonPagedPool); RtlClearAllBits (VerifierLargePagedPoolMap); } // // Initialize paged pool. // InitializePool (PagedPool, 0L); MiInitializeSpecialPool(); // // Allow mapping of views into system space. // MiInitializeSystemSpaceMap ((PVOID)0); return; }

VOID MiBuildPagedPool (   )

Referenced by MmInitSystem().

VOID MiEnablePagingOfDriverAtInit (  IN PMMPTE  PointerPte, IN PMMPTE  LastPte )

Definition at line 2944 of file mminit.c. References ASSERT, KeFlushSingleTb(), LOCK_PFN, LOCK_SYSTEM_WS, MI_FLUSH_ENTIRE_SESSION_TB, MI_GET_PAGE_FRAME_FROM_PTE, MI_IS_SESSION_PTE, MI_MAKE_VALID_PTE_TRANSITION, MI_PFN_ELEMENT, MI_ZERO_WSINDEX, MiDecrementShareCount(), MiGetVirtualAddressMappedByPte, MM_EXECUTE, MM_KERNEL_DEMAND_ZERO_PTE, MmResidentAvailablePages, MmTotalSystemCodePages, _MMPFN::OriginalPte, PAGE_SIZE, TRUE, _MMPTE::u, _MMPFN::u1, _MMPFN::u2, _MMPFN::u3, UNLOCK_PFN, and UNLOCK_SYSTEM_WS. Referenced by MiEnablePagingTheExecutive(). : This routine marks the specified range of PTEs as pagable. Arguments: PointerPte - Supplies the starting PTE. LastPte - Supplies the ending PTE. Return Value: None. --*/ { PVOID Base; PFN_NUMBER PageFrameIndex; PMMPFN Pfn; MMPTE TempPte; KIRQL OldIrql; KIRQL OldIrqlWs; LOGICAL SessionAddress; Base = MiGetVirtualAddressMappedByPte (PointerPte); SessionAddress = MI_IS_SESSION_PTE (PointerPte); LOCK_SYSTEM_WS (OldIrqlWs); LOCK_PFN (OldIrql); while (PointerPte <= LastPte) { // // The PTE must be carefully checked as drivers may call MmPageEntire // during their DriverEntry yet faults may occur prior to this routine // running which cause pages to already be resident and in the working // set at this point. So checks for validity and wsindex must be // applied. // if (PointerPte->u.Hard.Valid == 1) { PageFrameIndex = MI_GET_PAGE_FRAME_FROM_PTE (PointerPte); Pfn = MI_PFN_ELEMENT (PageFrameIndex); ASSERT (Pfn->u2.ShareCount == 1); if (Pfn->u1.WsIndex == 0) { // // Set the working set index to zero. This allows page table // pages to be brought back in with the proper WSINDEX. // MI_ZERO_WSINDEX (Pfn); // // Original PTE may need to be set for drivers loaded via // ntldr. // if (Pfn->OriginalPte.u.Long == 0) { Pfn->OriginalPte.u.Long = MM_KERNEL_DEMAND_ZERO_PTE; #if defined(_IA64_) Pfn->OriginalPte.u.Soft.Protection |= MM_EXECUTE; #endif } Pfn->u3.e1.Modified = 1; TempPte = *PointerPte; MI_MAKE_VALID_PTE_TRANSITION (TempPte, Pfn->OriginalPte.u.Soft.Protection); KeFlushSingleTb (Base, TRUE, TRUE, (PHARDWARE_PTE)PointerPte, TempPte.u.Flush); // // Flush the translation buffer and decrement the number of valid // PTEs within the containing page table page. Note that for a // private page, the page table page is still needed because the // page is in transition. // MiDecrementShareCount (PageFrameIndex); MmResidentAvailablePages += 1; MmTotalSystemCodePages += 1; } else { // // This would need to be taken out of the WSLEs so skip it for // now and let the normal paging algorithms remove it if we // run into memory pressure. // } } Base = (PVOID)((PCHAR)Base + PAGE_SIZE); PointerPte += 1; } UNLOCK_PFN (OldIrql); UNLOCK_SYSTEM_WS (OldIrqlWs); if (SessionAddress == TRUE) { // // Session space has no ASN - flush the entire TB. // MI_FLUSH_ENTIRE_SESSION_TB (TRUE, TRUE); } return; }

VOID MiEnablePagingTheExecutive (  VOID   )

Definition at line 2735 of file mminit.c. References ExAcquireResourceExclusive, ExReleaseResource, FALSE, IoRemoteBootClient, KdPitchDebugger, KeEnterCriticalRegion, KeLeaveCriticalRegion, MI_IS_PHYSICAL_ADDRESS, MiEnablePagingOfDriverAtInit(), MiGetPteAddress, MiHydra, MiSpecialPoolPtes, MmDisablePagingExecutive, MmVerifyDriverBufferLength, NULL, PAGE_SIZE, PsLoadedModuleList, PsLoadedModuleResource, ROUND_TO_PAGES, RtlImageNtHeader(), SECTION_BASE_ADDRESS, and TRUE. Referenced by MmInitSystem(). : This function locates the start and end of the kernel initialization code. This code resides in the "init" section of the kernel image. Arguments: StartVa - Returns the starting address of the init section. EndVa - Returns the ending address of the init section. Return Value: None. Environment: Kernel Mode Only. End of system initialization. --*/ { PLDR_DATA_TABLE_ENTRY LdrDataTableEntry; PVOID CurrentBase; PLIST_ENTRY Next; PIMAGE_NT_HEADERS NtHeader; PIMAGE_SECTION_HEADER SectionTableEntry; LONG i; PMMPTE PointerPte; PMMPTE LastPte; BOOLEAN PageSection; PVOID SectionBaseAddress; // // Don't page kernel mode code if customer does not want it paged or if // this is a diskless remote boot client. // if (MmDisablePagingExecutive #if defined(REMOTE_BOOT) || (IoRemoteBootClient && IoCscInitializationFailed) #endif ) { return; } // // Walk through the loader blocks looking for the base which // contains this routine. // KeEnterCriticalRegion(); ExAcquireResourceExclusive (&PsLoadedModuleResource, TRUE); Next = PsLoadedModuleList.Flink; while ( Next != &PsLoadedModuleList ) { LdrDataTableEntry = CONTAINING_RECORD( Next, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks ); if (LdrDataTableEntry->SectionPointer != NULL) { // // This entry was loaded by MmLoadSystemImage so it's already paged. // Next = Next->Flink; continue; } CurrentBase = (PVOID)LdrDataTableEntry->DllBase; NtHeader = RtlImageNtHeader(CurrentBase); SectionTableEntry = (PIMAGE_SECTION_HEADER)((PCHAR)NtHeader + sizeof(ULONG) + sizeof(IMAGE_FILE_HEADER) + NtHeader->FileHeader.SizeOfOptionalHeader); // // From the image header, locate the section named 'PAGE' or // '.edata'. // i = NtHeader->FileHeader.NumberOfSections; PointerPte = NULL; while (i > 0) { if (MI_IS_PHYSICAL_ADDRESS (CurrentBase)) { // // Mapped physically, can't be paged. // break; } SectionBaseAddress = SECTION_BASE_ADDRESS(SectionTableEntry); PageSection = ((*(PULONG)SectionTableEntry->Name == 'EGAP') || (*(PULONG)SectionTableEntry->Name == 'ade.')) && (SectionBaseAddress != ((PUCHAR)CurrentBase + SectionTableEntry->VirtualAddress)); if (*(PULONG)SectionTableEntry->Name == 'EGAP' && SectionTableEntry->Name[4] == 'K' && SectionTableEntry->Name[5] == 'D') { // // Only pageout PAGEKD if KdPitchDebugger is TRUE. // PageSection = KdPitchDebugger; } if ((*(PULONG)SectionTableEntry->Name == 'EGAP') && (*(PULONG)&SectionTableEntry->Name[4] == 'RDYH')) { // // Pageout PAGEHYDRA on non Hydra systems. // if (MiHydra == TRUE) { PageSection = FALSE; } } if ((*(PULONG)SectionTableEntry->Name == 'EGAP') && (*(PULONG)&SectionTableEntry->Name[4] == 'YFRV')) { // // Pageout PAGEVRFY if no drivers are being instrumented. // if (MmVerifyDriverBufferLength != (ULONG)-1) { PageSection = FALSE; } } if ((*(PULONG)SectionTableEntry->Name == 'EGAP') && (*(PULONG)&SectionTableEntry->Name[4] == 'CEPS')) { // // Pageout PAGESPEC special pool code if it's not enabled. // if (MiSpecialPoolPtes != 0) { PageSection = FALSE; } } if (PageSection) { // // This section is pagable, save away the start and end. // if (PointerPte == NULL) { // // Previous section was NOT pagable, get the start address. // PointerPte = MiGetPteAddress (ROUND_TO_PAGES ( (ULONG_PTR)CurrentBase + SectionTableEntry->VirtualAddress)); } LastPte = MiGetPteAddress ((ULONG_PTR)CurrentBase + SectionTableEntry->VirtualAddress + (NtHeader->OptionalHeader.SectionAlignment - 1) + SectionTableEntry->SizeOfRawData - PAGE_SIZE); } else { // // This section is not pagable, if the previous section was // pagable, enable it. // if (PointerPte != NULL) { MiEnablePagingOfDriverAtInit (PointerPte, LastPte); PointerPte = NULL; } } i -= 1; SectionTableEntry += 1; } //end while if (PointerPte != NULL) { MiEnablePagingOfDriverAtInit (PointerPte, LastPte); } Next = Next->Flink; } //end while ExReleaseResource (&PsLoadedModuleResource); KeLeaveCriticalRegion(); return; }

VOID MiFindInitializationCode (  OUT PVOID *  StartVa, OUT PVOID *  EndVa )

Definition at line 2474 of file mminit.c. References DbgPrint, ExAcquireResourceExclusive, ExReleaseResource, KeEnterCriticalRegion, KeLeaveCriticalRegion, MiFindInitializationCode(), MiFreeInitializationCode(), NULL, PAGE_ALIGN, PAGE_SIZE, PsLoadedModuleList, PsLoadedModuleResource, ROUND_TO_PAGES, RtlImageNtHeader(), and TRUE. Referenced by MiFindInitializationCode(), and MmZeroPageThread(). 02481 : 02482 02483 This function locates the start and end of the kernel initialization 02484 code. This code resides in the "init" section of the kernel image. 02485 02486 Arguments: 02487 02488 StartVa - Returns the starting address of the init section. 02489 02490 EndVa - Returns the ending address of the init section. 02491 02492 Return Value: 02493 02494 None. 02495 02496 Environment: 02497 02498 Kernel Mode Only. End of system initialization. 02499 02500 --*/ 02501 02502 { 02503 PLDR_DATA_TABLE_ENTRY LdrDataTableEntry; 02504 PVOID CurrentBase; 02505 PVOID InitStart; 02506 PVOID InitEnd; 02507 PLIST_ENTRY Next; 02508 PIMAGE_NT_HEADERS NtHeader; 02509 PIMAGE_SECTION_HEADER SectionTableEntry; 02510 PIMAGE_SECTION_HEADER LastDiscard; 02511 LONG i; 02512 PVOID MiFindInitializationCodeAddress; 02513 02514 MiFindInitializationCodeAddress = MmGetProcedureAddress((PVOID)&MiFindInitializationCode); 02515 02516 *StartVa = NULL; 02517 02518 // 02519 // Walk through the loader blocks looking for the base which 02520 // contains this routine. 02521 // 02522 02523 KeEnterCriticalRegion(); 02524 ExAcquireResourceExclusive (&PsLoadedModuleResource, TRUE); 02525 Next = PsLoadedModuleList.Flink; 02526 02527 while ( Next != &PsLoadedModuleList ) { 02528 LdrDataTableEntry = CONTAINING_RECORD( Next, 02529 LDR_DATA_TABLE_ENTRY, 02530 InLoadOrderLinks 02531 ); 02532 if (LdrDataTableEntry->SectionPointer != NULL) { 02533 02534 // 02535 // This entry was loaded by MmLoadSystemImage so it's already 02536 // had its init section removed. 02537 // 02538 02539 Next = Next->Flink; 02540 continue; 02541 } 02542 02543 CurrentBase = (PVOID)LdrDataTableEntry->DllBase; 02544 NtHeader = RtlImageNtHeader(CurrentBase); 02545 02546 SectionTableEntry = (PIMAGE_SECTION_HEADER)((PCHAR)NtHeader + 02547 sizeof(ULONG) + 02548 sizeof(IMAGE_FILE_HEADER) + 02549 NtHeader->FileHeader.SizeOfOptionalHeader); 02550 02551 // 02552 // From the image header, locate the section named 'INIT'. 02553 // 02554 02555 i = NtHeader->FileHeader.NumberOfSections; 02556 02557 InitStart = NULL; 02558 while (i > 0) { 02559 02560 #if DBG 02561 if ((*(PULONG)SectionTableEntry->Name == 'tini') || 02562 (*(PULONG)SectionTableEntry->Name == 'egap')) { 02563 DbgPrint("driver %wZ has lower case sections (init or pagexxx)\n", 02564 &LdrDataTableEntry->FullDllName); 02565 } 02566 #endif //DBG 02567 02568 // 02569 // Free any INIT sections (or relocation sections that haven't 02570 // been already). Note a driver may have a relocation section 02571 // but not have any INIT code. 02572 // 02573 02574 if ((*(PULONG)SectionTableEntry->Name == 'TINI') || 02575 ((SectionTableEntry->Characteristics & IMAGE_SCN_MEM_DISCARDABLE) != 0)) { 02576 02577 02578 InitStart = (PVOID)((PCHAR)CurrentBase + SectionTableEntry->VirtualAddress); 02579 InitEnd = (PVOID)((PCHAR)InitStart + SectionTableEntry->SizeOfRawData - 1); 02580 InitEnd = (PVOID)((PCHAR)PAGE_ALIGN ((PCHAR)InitEnd + 02581 (NtHeader->OptionalHeader.SectionAlignment - 1)) - 1); 02582 InitStart = (PVOID)ROUND_TO_PAGES (InitStart); 02583 02584 // 02585 // Check if more sections are discardable after this one so 02586 // even small INIT sections can be discarded. 02587 // 02588 02589 if (i == 1) { 02590 LastDiscard = SectionTableEntry; 02591 } 02592 else { 02593 LastDiscard = NULL; 02594 do { 02595 i -= 1; 02596 SectionTableEntry += 1; 02597 02598 if ((SectionTableEntry->Characteristics & 02599 IMAGE_SCN_MEM_DISCARDABLE) != 0) { 02600 02601 // 02602 // Discard this too. 02603 // 02604 02605 LastDiscard = SectionTableEntry; 02606 } else { 02607 break; 02608 } 02609 } while (i > 1); 02610 } 02611 02612 if (LastDiscard) { 02613 InitEnd = (PVOID)(((PCHAR)CurrentBase + 02614 LastDiscard->VirtualAddress) + 02615 (LastDiscard->SizeOfRawData - 1)); 02616 02617 // 02618 // If this isn't the last section in the driver then the 02619 // the next section is not discardable. So the last 02620 // section is not rounded down, but all others must be. 02621 // 02622 02623 if (i != 1) { 02624 InitEnd = (PVOID)((PCHAR)PAGE_ALIGN ((PCHAR)InitEnd + 02625 (NtHeader->OptionalHeader.SectionAlignment - 1)) - 1); 02626 } 02627 } 02628 02629 if (InitEnd > (PVOID)((PCHAR)CurrentBase + 02630 LdrDataTableEntry->SizeOfImage)) { 02631 InitEnd = (PVOID)(((ULONG_PTR)CurrentBase + 02632 (LdrDataTableEntry->SizeOfImage - 1)) | 02633 (PAGE_SIZE - 1)); 02634 } 02635 02636 if (InitStart <= InitEnd) { 02637 if ((MiFindInitializationCodeAddress >= InitStart) && 02638 (MiFindInitializationCodeAddress <= InitEnd)) { 02639 02640 // 02641 // This init section is in the kernel, don't free it 02642 // now as it would free this code! 02643 // 02644 02645 *StartVa = InitStart; 02646 *EndVa = InitEnd; 02647 } 02648 else { 02649 MiFreeInitializationCode (InitStart, InitEnd); 02650 } 02651 } 02652 } 02653 i -= 1; 02654 SectionTableEntry += 1; 02655 } 02656 Next = Next->Flink; 02657 } 02658 ExReleaseResource (&PsLoadedModuleResource); 02659 KeLeaveCriticalRegion(); 02660 return; 02661 }

VOID MiFreeInitializationCode (  IN PVOID  StartVa, IN PVOID  EndVa )

Definition at line 2664 of file mminit.c. References ASSERT, FALSE, FreePageList, LOCK_PFN, MI_CONVERT_PHYSICAL_TO_PFN, MI_IS_PHYSICAL_ADDRESS, MI_PFN_ELEMENT, MI_SET_PFN_DELETED, MiDeleteSystemPagableVm(), MiFreeInitializationCode(), MiGetPteAddress, MiInsertPageInList(), MmPageLocationList, MmUnlockPagableImageSection(), NULL, PAGE_SIZE, _MMPFN::u2, _MMPFN::u3, UNLOCK_PFN, and ZeroKernelPte. Referenced by MiFindInitializationCode(), MiFreeInitializationCode(), and MmZeroPageThread(). : This function is called to delete the initialization code. Arguments: StartVa - Supplies the starting address of the range to delete. EndVa - Supplies the ending address of the range to delete. Return Value: None. Environment: Kernel Mode Only. Runs after system initialization. --*/ { PMMPFN Pfn1; PMMPTE PointerPte; PFN_NUMBER PageFrameIndex; KIRQL OldIrql; PVOID UnlockHandle; UnlockHandle = MmLockPagableCodeSection((PVOID)MiFreeInitializationCode); ASSERT(UnlockHandle); if (MI_IS_PHYSICAL_ADDRESS(StartVa)) { LOCK_PFN (OldIrql); while (StartVa < EndVa) { // // On certain architectures (e.g., MIPS) virtual addresses // may be physical and hence have no corresponding PTE. // PageFrameIndex = MI_CONVERT_PHYSICAL_TO_PFN (StartVa); Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); Pfn1->u2.ShareCount = 0; Pfn1->u3.e2.ReferenceCount = 0; MI_SET_PFN_DELETED (Pfn1); MiInsertPageInList (MmPageLocationList[FreePageList], PageFrameIndex); StartVa = (PVOID)((PUCHAR)StartVa + PAGE_SIZE); } UNLOCK_PFN (OldIrql); } else { PointerPte = MiGetPteAddress (StartVa); MiDeleteSystemPagableVm (PointerPte, (PFN_NUMBER) (1 + MiGetPteAddress (EndVa) - PointerPte), ZeroKernelPte, FALSE, NULL); } MmUnlockPagableImageSection(UnlockHandle); return; }

VOID MiInitializeSpecialPool (  VOID   )

Referenced by MiBuildPagedPool().

VOID MiInitializeSpecialPoolCriteria (  IN  VOID  )

Referenced by MmInitSystem().

VOID MiMapBBTMemory (  IN PLOADER_PARAMETER_BLOCK  LoaderBlock  )

Definition at line 1440 of file mminit.c. References ASSERT, _MEMORY_ALLOCATION_DESCRIPTOR::BasePage, BBTBuffer, BBTPagesToReserve, FALSE, KeFlushEntireTb(), _MEMORY_ALLOCATION_DESCRIPTOR::ListEntry, LoaderBBTMemory, _MEMORY_ALLOCATION_DESCRIPTOR::MemoryType, MI_WRITE_VALID_PTE, MiGetPteAddress, MiGetVirtualAddressMappedByPte, MiReserveSystemPtes(), MM_PTE_OWNER_MASK, MM_VA_MAPPED_BY_PDE, NULL, PAGE_SHIFT, _MEMORY_ALLOCATION_DESCRIPTOR::PageCount, PERFINFO_MMINIT_START, PTE_PER_PAGE, SystemPteSpace, TRUE, _MMPTE::u, and ValidUserPte. Referenced by MmInitSystem(). : This function walks through the loader block's memory descriptor list and maps memory reserved for the BBT buffer into the system. The mapped PTEs are PDE-aligned and made user accessible. Arguments: LoaderBlock - Supplies a pointer to the system loader block. Return Value: None. Environment: Kernel Mode Only. System initialization. --*/ { PVOID Va; PMEMORY_ALLOCATION_DESCRIPTOR MemoryDescriptor; PLIST_ENTRY NextMd; PFN_NUMBER NumberOfPagesMapped; PFN_NUMBER NumberOfPages; PFN_NUMBER PageFrameIndex; PMMPTE PointerPte; PMMPTE PointerPde; PMMPTE LastPde; MMPTE TempPte; if (BBTPagesToReserve <= 0) { return; } // // Request enough PTEs such that protection can be applied to the PDEs. // NumberOfPages = (BBTPagesToReserve + (PTE_PER_PAGE - 1)) & ~(PTE_PER_PAGE - 1); PointerPte = MiReserveSystemPtes((ULONG)NumberOfPages, SystemPteSpace, MM_VA_MAPPED_BY_PDE, 0, FALSE); if (PointerPte == NULL) { BBTPagesToReserve = 0; return; } // // Allow user access to the buffer. // PointerPde = MiGetPteAddress (PointerPte); LastPde = MiGetPteAddress (PointerPte + NumberOfPages); ASSERT (LastPde != PointerPde); do { TempPte = *PointerPde; TempPte.u.Long |= MM_PTE_OWNER_MASK; MI_WRITE_VALID_PTE (PointerPde, TempPte); PointerPde += 1; } while (PointerPde < LastPde); KeFlushEntireTb (TRUE, TRUE); Va = MiGetVirtualAddressMappedByPte (PointerPte); TempPte = ValidUserPte; NumberOfPagesMapped = 0; NextMd = LoaderBlock->MemoryDescriptorListHead.Flink; while (NextMd != &LoaderBlock->MemoryDescriptorListHead) { MemoryDescriptor = CONTAINING_RECORD(NextMd, MEMORY_ALLOCATION_DESCRIPTOR, ListEntry); if (MemoryDescriptor->MemoryType == LoaderBBTMemory) { PageFrameIndex = MemoryDescriptor->BasePage; NumberOfPages = MemoryDescriptor->PageCount; if (NumberOfPagesMapped + NumberOfPages > BBTPagesToReserve) { NumberOfPages = BBTPagesToReserve - NumberOfPagesMapped; } NumberOfPagesMapped += NumberOfPages; do { TempPte.u.Hard.PageFrameNumber = PageFrameIndex; MI_WRITE_VALID_PTE (PointerPte, TempPte); PointerPte += 1; PageFrameIndex += 1; NumberOfPages -= 1; } while (NumberOfPages); if (NumberOfPagesMapped == BBTPagesToReserve) { break; } } NextMd = MemoryDescriptor->ListEntry.Flink; } RtlZeroMemory(Va, BBTPagesToReserve << PAGE_SHIFT); // // Tell BBT_Init how many pages were allocated. // if (NumberOfPagesMapped < BBTPagesToReserve) { BBTPagesToReserve = (ULONG)NumberOfPagesMapped; } *(PULONG)Va = BBTPagesToReserve; // // At this point instrumentation code will detect the existence of // buffer and initialize the structures. // BBTBuffer = Va; PERFINFO_MMINIT_START(); }

VOID MiMergeMemoryLimit (  IN OUT PPHYSICAL_MEMORY_DESCRIPTOR  Memory, IN PFN_NUMBER  StartPage, IN PFN_NUMBER  NumberOfPages )

Definition at line 1899 of file mminit.c. References MAX_PHYSICAL_MEMORY_FRAGMENTS. Referenced by MmInitSystem(). : This function ensures the passed range is in the passed in Memory block adding any new data as needed. The passed memory block is assumed to be at least MAX_PHYSICAL_MEMORY_FRAGMENTS large Arguments: Memory - Supplies the memory block to verify run is present in. StartPage - Supplies the first page of the run. NumberOfPages - Supplies the number of pages in the run. Return Value: None. Environment: Kernel Mode Only. System initialization. --*/ { PFN_NUMBER EndPage, sp, ep, i; EndPage = StartPage + NumberOfPages; // // Clip range to area which is not already described // for (i=0; i < Memory->NumberOfRuns; i++) { sp = Memory->Run[i].BasePage; ep = sp + Memory->Run[i].PageCount; if (sp < StartPage) { if (ep > StartPage && ep < EndPage) { // bump beginning page of the target area StartPage = ep; } if (ep > EndPage) { // // Target area is contained totally within this // descriptor. This range is fully accounted for. // StartPage = EndPage; } } else { // sp >= StartPage if (sp < EndPage) { if (ep < EndPage) { // // This descriptor is totally within the target area - // check the area on either side of this descriptor // MiMergeMemoryLimit (Memory, StartPage, sp - StartPage); StartPage = ep; } else { // clip the ending page of the target area EndPage = sp; } } } // // Anything left of target area? // if (StartPage == EndPage) { return ; } } // next descriptor // // The range StartPage - EndPage is a missing. Add it. // if (Memory->NumberOfRuns == MAX_PHYSICAL_MEMORY_FRAGMENTS) { return ; } Memory->Run[Memory->NumberOfRuns].BasePage = StartPage; Memory->Run[Memory->NumberOfRuns].PageCount = EndPage - StartPage; Memory->NumberOfPages += EndPage - StartPage; Memory->NumberOfRuns += 1; }

VOID MiWriteProtectSystemImage (  IN PVOID  DllBase  )

Definition at line 5633 of file sysload.c. References ASSERT, BYTES_TO_PAGES, MI_IS_PHYSICAL_ADDRESS, MI_IS_SESSION_ADDRESS, MiGetPteAddress, MiSetSystemCodeProtection(), NULL, PAGED_CODE, and RtlImageNtHeader(). : This function sets the protection of a system component to read only. Arguments: DllBase - Supplies the base address of the system component. Return Value: None. --*/ { ULONG SectionProtection; ULONG NumberOfSubsections; ULONG SectionVirtualSize; ULONG ImageAlignment; ULONG OffsetToSectionTable; ULONG NumberOfPtes; ULONG_PTR VirtualAddress; ULONG_PTR LastVirtualAddress; PMMPTE PointerPte; PMMPTE FirstPte; PMMPTE LastPte; PMMPTE LastImagePte; PMMPTE WritablePte; PIMAGE_NT_HEADERS NtHeader; PIMAGE_FILE_HEADER FileHeader; PIMAGE_SECTION_HEADER SectionTableEntry; PAGED_CODE(); if (MI_IS_PHYSICAL_ADDRESS(DllBase)) { return; } NtHeader = RtlImageNtHeader (DllBase); ASSERT (NtHeader); ImageAlignment = NtHeader->OptionalHeader.SectionAlignment; // // All session drivers must be one way or the other - no mixing is allowed // within multiple copy-on-write drivers. // if (MI_IS_SESSION_ADDRESS(DllBase) == 0) { // // Images prior to NT5 were not protected from stepping all over // their (and others) code and readonly data. Here we somewhat // preserve that behavior, but don't allow them to step on anyone else. // // // Note that drivers that are built for NT5 have presumably run on // NT5, and these get the benefits of full protection. // if ((NtHeader->OptionalHeader.MajorOperatingSystemVersion < 5) || (NtHeader->OptionalHeader.MajorOperatingSystemVersion > 10)) { return; } if ((NtHeader->OptionalHeader.MajorImageVersion < 5) || (NtHeader->OptionalHeader.MajorImageVersion > 10)) { return; } } NumberOfPtes = BYTES_TO_PAGES (NtHeader->OptionalHeader.SizeOfImage); FileHeader = &NtHeader->FileHeader; NumberOfSubsections = FileHeader->NumberOfSections; ASSERT (NumberOfSubsections != 0); OffsetToSectionTable = sizeof(ULONG) + sizeof(IMAGE_FILE_HEADER) + FileHeader->SizeOfOptionalHeader; SectionTableEntry = (PIMAGE_SECTION_HEADER)((PCHAR)NtHeader + OffsetToSectionTable); // // Verify the image contains subsections ordered by increasing virtual // address and that there are no overlaps. // FirstPte = NULL; LastVirtualAddress = (ULONG_PTR)DllBase; for ( ; NumberOfSubsections > 0; NumberOfSubsections -= 1, SectionTableEntry += 1) { if (SectionTableEntry->Misc.VirtualSize == 0) { SectionVirtualSize = SectionTableEntry->SizeOfRawData; } else { SectionVirtualSize = SectionTableEntry->Misc.VirtualSize; } VirtualAddress = (ULONG_PTR)DllBase + SectionTableEntry->VirtualAddress; if (VirtualAddress <= LastVirtualAddress) { // // Subsections are not in an increasing virtual address ordering. // No protection is provided for such a poorly linked image. // KdPrint (("MM:sysload - Image at %p is badly linked\n", DllBase)); return; } LastVirtualAddress = VirtualAddress + SectionVirtualSize - 1; } NumberOfSubsections = FileHeader->NumberOfSections; ASSERT (NumberOfSubsections != 0); SectionTableEntry = (PIMAGE_SECTION_HEADER)((PCHAR)NtHeader + OffsetToSectionTable); LastVirtualAddress = 0; // // Set writable PTE here so the image headers are excluded. This is // needed so that locking down of sections can continue to edit the // image headers for counts. // WritablePte = MiGetPteAddress ((ULONG_PTR)(SectionTableEntry + NumberOfSubsections) - 1); LastImagePte = MiGetPteAddress(DllBase) + NumberOfPtes; for ( ; NumberOfSubsections > 0; NumberOfSubsections -= 1, SectionTableEntry += 1) { if (SectionTableEntry->Misc.VirtualSize == 0) { SectionVirtualSize = SectionTableEntry->SizeOfRawData; } else { SectionVirtualSize = SectionTableEntry->Misc.VirtualSize; } VirtualAddress = (ULONG_PTR)DllBase + SectionTableEntry->VirtualAddress; PointerPte = MiGetPteAddress (VirtualAddress); if (PointerPte >= LastImagePte) { // // Skip relocation subsections (which aren't given VA space). // break; } SectionProtection = (SectionTableEntry->Characteristics & (IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE)); if (SectionProtection & IMAGE_SCN_MEM_WRITE) { // // This is a writable subsection, skip it. Make sure if it's // sharing a PTE (and update the linker so this doesn't happen // for the kernel at least) that the last PTE isn't made // read only. // WritablePte = MiGetPteAddress (VirtualAddress + SectionVirtualSize - 1); if (LastVirtualAddress) { LastPte = MiGetPteAddress (LastVirtualAddress); if (LastPte == PointerPte) { LastPte -= 1; } if (FirstPte <= LastPte) { ASSERT (PointerPte < LastImagePte); if (LastPte >= LastImagePte) { LastPte = LastImagePte - 1; } MiSetSystemCodeProtection (FirstPte, LastPte); } LastVirtualAddress = 0; } continue; } if (LastVirtualAddress == 0) { // // There is no previous subsection or the previous // subsection was writable. Thus the current starting PTE // could be mapping both a readonly and a readwrite // subsection if the image alignment is less than PAGE_SIZE. // These cases (in either order) are handled here. // if (PointerPte == WritablePte) { LastPte = MiGetPteAddress (VirtualAddress + SectionVirtualSize - 1); if (PointerPte == LastPte) { // // Nothing can be protected in this subsection // due to the image alignment specified for the executable. // continue; } PointerPte += 1; } FirstPte = PointerPte; } LastVirtualAddress = VirtualAddress + SectionVirtualSize - 1; } if (LastVirtualAddress) { LastPte = MiGetPteAddress (LastVirtualAddress); if ((FirstPte <= LastPte) && (FirstPte < LastImagePte)) { if (LastPte >= LastImagePte) { LastPte = LastImagePte - 1; } MiSetSystemCodeProtection (FirstPte, LastPte); } } }

VOID MmFreeLoaderBlock (  IN PLOADER_PARAMETER_BLOCK  LoaderBlock  )

Definition at line 2005 of file mminit.c. References _MEMORY_ALLOCATION_DESCRIPTOR::BasePage, FreePageList, KeBugCheckEx(), KeFlushEntireTb(), KSEG0_BASE, _MEMORY_ALLOCATION_DESCRIPTOR::ListEntry, LoaderNlsData, LoaderOsloaderHeap, LoaderRegistryData, LOCK_PFN, _MEMORY_ALLOCATION_DESCRIPTOR::MemoryType, MI_IS_PHYSICAL_ADDRESS, MI_PFN_ELEMENT, MI_SET_PFN_DELETED, MI_WRITE_INVALID_PTE, MiDecrementShareCountOnly, MiGetPdeAddress, MiGetVirtualAddressMappedByPte, MiInsertPageInList(), MM_MAX_LOADER_BLOCKS, MmPageLocationList, MmVirtualBias, _MEMORY_ALLOCATION_DESCRIPTOR::PageCount, PTE_SHIFT, _MMPFN::PteAddress, TRUE, _MMPFN::u1, _MMPFN::u3, UNLOCK_PFN, ZeroKernelPte, and ZeroPte. 02011 : 02012 02013 This function is called as the last routine in phase 1 initialization. 02014 It frees memory used by the OsLoader. 02015 02016 Arguments: 02017 02018 LoadBlock - Supplies a pointer the system loader block. 02019 02020 Return Value: 02021 02022 None. 02023 02024 Environment: 02025 02026 Kernel Mode Only. System initialization. 02027 02028 --*/ 02029 02030 { 02031 02032 PLIST_ENTRY NextMd; 02033 PMMPTE Pde; 02034 PMEMORY_ALLOCATION_DESCRIPTOR MemoryDescriptor; 02035 MEMORY_ALLOCATION_DESCRIPTOR SavedDescriptor[MM_MAX_LOADER_BLOCKS]; 02036 PFN_NUMBER i; 02037 PFN_NUMBER NextPhysicalPage; 02038 PMMPFN Pfn1; 02039 LONG BlockNumber = -1; 02040 KIRQL OldIrql; 02041 02042 // 02043 // 02044 // Walk through the memory descriptors and add pages to the 02045 // free list in the PFN database. 02046 // 02047 02048 NextMd = LoaderBlock->MemoryDescriptorListHead.Flink; 02049 02050 while (NextMd != &LoaderBlock->MemoryDescriptorListHead) { 02051 02052 MemoryDescriptor = CONTAINING_RECORD(NextMd, 02053 MEMORY_ALLOCATION_DESCRIPTOR, 02054 ListEntry); 02055 02056 02057 switch (MemoryDescriptor->MemoryType) { 02058 case LoaderOsloaderHeap: 02059 case LoaderRegistryData: 02060 case LoaderNlsData: 02061 //case LoaderMemoryData: //this has page table and other stuff. 02062 02063 // 02064 // Capture the data to temporary storage so we won't 02065 // free memory we are referencing. Coalesce it if 02066 // the blocks are adjacent and of the same type. 02067 // 02068 02069 if (BlockNumber != -1 && 02070 MemoryDescriptor->MemoryType == SavedDescriptor[BlockNumber].MemoryType && 02071 MemoryDescriptor->BasePage == SavedDescriptor[BlockNumber].BasePage + SavedDescriptor[BlockNumber].PageCount) { 02072 02073 // 02074 // these blocks are adjacent - merge them 02075 // 02076 02077 SavedDescriptor[BlockNumber].PageCount += MemoryDescriptor->PageCount; 02078 } 02079 else { 02080 BlockNumber += 1; 02081 if (BlockNumber >= MM_MAX_LOADER_BLOCKS) { 02082 KeBugCheckEx (MEMORY_MANAGEMENT, 0, 0, 0, 0); 02083 } 02084 SavedDescriptor[BlockNumber] = *MemoryDescriptor; 02085 } 02086 02087 break; 02088 02089 default: 02090 02091 break; 02092 } 02093 02094 NextMd = MemoryDescriptor->ListEntry.Flink; 02095 } 02096 02097 LOCK_PFN (OldIrql); 02098 02099 while (BlockNumber >= 0) { 02100 02101 i = SavedDescriptor[BlockNumber].PageCount; 02102 NextPhysicalPage = SavedDescriptor[BlockNumber].BasePage; 02103 02104 Pfn1 = MI_PFN_ELEMENT (NextPhysicalPage); 02105 while (i != 0) { 02106 02107 if (Pfn1->u3.e2.ReferenceCount == 0) { 02108 if (Pfn1->u1.Flink == 0) { 02109 02110 // 02111 // Set the PTE address to the physical page for 02112 // virtual address alignment checking. 02113 // 02114 02115 Pfn1->PteAddress = 02116 (PMMPTE)(NextPhysicalPage << PTE_SHIFT); 02117 MiInsertPageInList (MmPageLocationList[FreePageList], 02118 NextPhysicalPage); 02119 } 02120 } else { 02121 02122 if (NextPhysicalPage != 0) { 02123 // 02124 // Remove PTE and insert into the free list. If it is 02125 // a physical address within the PFN database, the PTE 02126 // element does not exist and therefore cannot be updated. 02127 // 02128 02129 if (!MI_IS_PHYSICAL_ADDRESS ( 02130 MiGetVirtualAddressMappedByPte (Pfn1->PteAddress))) { 02131 02132 // 02133 // Not a physical address. 02134 // 02135 02136 *(Pfn1->PteAddress) = ZeroPte; 02137 } 02138 02139 MI_SET_PFN_DELETED (Pfn1); 02140 MiDecrementShareCountOnly (NextPhysicalPage); 02141 } 02142 } 02143 02144 Pfn1++; 02145 i -= 1; 02146 NextPhysicalPage += 1; 02147 } 02148 02149 BlockNumber -= 1; 02150 } 02151 02152 // 02153 // If the kernel has been biased to allow for 3gb of user address space, 02154 // then the first 16mb of memory is doubly mapped to KSEG0_BASE and to 02155 // ALTERNATE_BASE. Therefore, the KSEG0_BASE entries must be unmapped. 02156 // 02157 02158 #if defined(_X86_) 02159 02160 if (MmVirtualBias != 0) { 02161 Pde = MiGetPdeAddress(KSEG0_BASE); 02162 MI_WRITE_INVALID_PTE (Pde, ZeroKernelPte); 02163 MI_WRITE_INVALID_PTE (Pde + 1, ZeroKernelPte); 02164 MI_WRITE_INVALID_PTE (Pde + 2, ZeroKernelPte); 02165 MI_WRITE_INVALID_PTE (Pde + 3, ZeroKernelPte); 02166 02167 #if defined(_X86PAE_) 02168 MI_WRITE_INVALID_PTE (Pde + 4, ZeroKernelPte); 02169 MI_WRITE_INVALID_PTE (Pde + 5, ZeroKernelPte); 02170 MI_WRITE_INVALID_PTE (Pde + 6, ZeroKernelPte); 02171 MI_WRITE_INVALID_PTE (Pde + 7, ZeroKernelPte); 02172 #endif 02173 02174 } 02175 02176 #endif 02177 02178 KeFlushEntireTb (TRUE, TRUE); 02179 UNLOCK_PFN (OldIrql); 02180 return; 02181 }

VOID MmInitializeMemoryLimits (  IN PLOADER_PARAMETER_BLOCK  LoaderBlock, IN PBOOLEAN  IncludeType, OUT PPHYSICAL_MEMORY_DESCRIPTOR  Memory )

Definition at line 1582 of file mminit.c. References ASSERT, _MEMORY_ALLOCATION_DESCRIPTOR::BasePage, FALSE, _MEMORY_ALLOCATION_DESCRIPTOR::ListEntry, LoaderMaximum, _MEMORY_ALLOCATION_DESCRIPTOR::MemoryType, _MEMORY_ALLOCATION_DESCRIPTOR::PageCount, TotalPages, and TRUE. Referenced by IopInitializeResourceMap(), and MmInitSystem(). : This function walks through the loader block's memory descriptor list and builds a list of contiguous physical memory blocks of the desired types. Arguments: LoaderBlock - Supplies a pointer the system loader block. IncludeType - Array of BOOLEANS of size LoaderMaximum. TRUE means include this type of memory in return. Memory - Returns the physical memory blocks. Return Value: None. Environment: Kernel Mode Only. System initialization. --*/ { PMEMORY_ALLOCATION_DESCRIPTOR MemoryDescriptor; PLIST_ENTRY NextMd; PFN_NUMBER i; PFN_NUMBER LowestFound; PFN_NUMBER Found; PFN_NUMBER Merged; PFN_NUMBER NextPage; PFN_NUMBER TotalPages; TotalPages = 0; // // Walk through the memory descriptors and build the physical memory list. // LowestFound = 0; Memory->Run[0].BasePage = 0xffffffff; NextPage = 0xffffffff; Memory->Run[0].PageCount = 0; i = 0; do { Merged = FALSE; Found = FALSE; NextMd = LoaderBlock->MemoryDescriptorListHead.Flink; while (NextMd != &LoaderBlock->MemoryDescriptorListHead) { MemoryDescriptor = CONTAINING_RECORD(NextMd, MEMORY_ALLOCATION_DESCRIPTOR, ListEntry); if (MemoryDescriptor->MemoryType < LoaderMaximum && IncludeType [MemoryDescriptor->MemoryType] ) { // // Try to merge runs. // if (MemoryDescriptor->BasePage == NextPage) { ASSERT (MemoryDescriptor->PageCount != 0); Memory->Run[i - 1].PageCount += MemoryDescriptor->PageCount; NextPage += MemoryDescriptor->PageCount; TotalPages += MemoryDescriptor->PageCount; Merged = TRUE; Found = TRUE; break; } if (MemoryDescriptor->BasePage >= LowestFound) { if (Memory->Run[i].BasePage > MemoryDescriptor->BasePage) { Memory->Run[i].BasePage = MemoryDescriptor->BasePage; Memory->Run[i].PageCount = MemoryDescriptor->PageCount; } Found = TRUE; } } NextMd = MemoryDescriptor->ListEntry.Flink; } if (!Merged && Found) { NextPage = Memory->Run[i].BasePage + Memory->Run[i].PageCount; TotalPages += Memory->Run[i].PageCount; i += 1; } Memory->Run[i].BasePage = 0xffffffff; LowestFound = NextPage; } while (Found); ASSERT (i <= Memory->NumberOfRuns); Memory->NumberOfRuns = (ULONG)i; Memory->NumberOfPages = TotalPages; return; }

BOOLEAN MmInitSystem (  IN ULONG  Phase, IN PLOADER_PARAMETER_BLOCK  LoaderBlock, IN PPHYSICAL_MEMORY_DESCRIPTOR  PhysicalMemoryBlock )

Definition at line 184 of file mminit.c. References ActiveAndValid, _MMPAGE_FILE_EXPANSION::ActualExpansion, ASSERT, _EPROCESS::AweLock, _PHYSICAL_MEMORY_RUN::BasePage, BBTPagesToReserve, CHAR, DbgPrint, _MMPAGE_FILE_EXPANSION::Event, ExAcquireResourceExclusive, ExAllocatePoolWithTag, ExInitializeFastMutex, ExInitializeResource, ExpMultiUserTS, ExReleaseResource, ExVerifySuite(), FALSE, _MMPAGE_FILE_EXPANSION::InProgress, KeBalanceSetManager(), KeInitializeDpc(), KeInitializeEvent, KeInitializeMutant(), KeInitializeSpinLock(), KeInitializeTimerEx(), KeSwapProcessOrStack(), KSEG0_BASE, L, _MMEVENT_COUNT_LIST::ListHead, _MMINPAGE_SUPPORT_LIST::ListHead, _MMWORKING_SET_EXPANSION_HEAD::ListHead, LoaderBad, LoaderBBTMemory, LoaderFirmwarePermanent, LoaderMaximum, LoaderSpecialMemory, LOCK_PFN, MAX_PHYSICAL_MEMORY_FRAGMENTS, MI_EXTEND_ANY_PAGEFILE, MI_GET_PAGE_COLOR_FROM_PTE, MI_GET_PAGE_FRAME_FROM_PTE, MI_MAKE_VALID_PTE, MI_PFN_ELEMENT, MI_SESSION_IMAGE_SIZE, MI_SESSION_SPACE_END, MI_SESSION_SPACE_TOTAL_SIZE, MI_WRITE_VALID_PTE, MiAddSystemPtes(), MiAdjustWorkingSetManagerParameters(), MiBuildPagedPool(), MiChargeCommitmentCantExpand(), MiDumpPfn(), MiDumpValidAddresses(), MiEnableKernelVerifier(), MiEnablePagingTheExecutive(), MiFillMemoryPte, MiFormatPte(), MiGetPdeAddress, MiGetPpeAddress, MiGetPteAddress, MiGetSubsectionAddress, MiGetSubsectionAddressForPte, MiGetVirtualAddressMappedByPte, MiHighestUserPde, MiHighestUserPte, MiHydra, MiInitializeDriverVerifierList(), MiInitializeIoTrackers(), MiInitializeLoadedModuleList(), MiInitializePfn(), MiInitializeSessionIds(), MiInitializeSessionWsSupport(), MiInitializeSpecialPoolCriteria(), MiInitializeSystemCache(), MiInitMachineDependent(), MiIsPteOnPdeBoundary, MiMapBBTMemory(), MiMappedPagesTooOldEvent, MiMaximumSystemCacheSizeExtra, MiMaximumWorkingSet, MiMergeMemoryLimit(), MiModifiedPageLife, MiModifiedPageWriter(), MiModifiedPageWriterTimer, MiModifiedPageWriterTimerDispatch(), MiModifiedPageWriterTimerDpc, MiProtoAddressForPte, MiPteStr, MiPteToProto, MiReloadBootLoadedDrivers(), MiRemoveAnyPage(), MiRemoveZeroPage(), MiRequestedSystemPtes, MiSectionInitialization(), MiSessionBasePte, MiSessionLastPte, MiSessionWideInitializeAddresses(), MiSystemCacheEndExtra, MiSystemCacheStartExtra, MiSystemViewStart, MiTriageSystem(), MiTrimInProgressCount, MiWriteProtectSystemImage(), Mm64BitPhysicalAddress, MM_BOOT_IMAGE_SIZE, MM_DBG_CHECK_PFN_LOCK, MM_DBG_COMMIT_EXTRA_SYSTEM_PTES, MM_DBG_DUMP_BOOT_PTES, MM_DEFAULT_SYSTEM_PTES, MM_DEMAND_ZERO_WRITE_PTE, MM_FLUID_PHYSICAL_PAGES, MM_MAXIMUM_SYSTEM_PTES, MM_MAXIMUM_WORKING_SET, MM_MEDIUM_SYSTEM, MM_MINIMUM_SYSTEM_PTES, MM_NONPAGED_POOL_END, MM_READONLY, MM_SESSION_SPACE_DEFAULT, MM_SMALL_SYSTEM, MM_SPECIAL_POOL_PTES, MM_SYSTEM_CACHE_END, MM_SYSTEM_CACHE_START, MM_SYSTEM_CACHE_START_EXTRA, MM_SYSTEM_VIEW_SIZE, MM_SYSTEM_VIEW_SIZE_IF_HYDRA, MM_SYSTEM_VIEW_START, MM_SYSTEM_VIEW_START_IF_HYDRA, MM_TRACK_COMMIT, MmAttemptForCantExtend, MmAvailablePages, MmAvailablePagesEvent, MmAvailablePagesEventHigh, MmChargeCommitmentLock, MmCodeClusterSize, MmCollidedFlushEvent, MmCollidedLockEvent, MmCriticalSectionTimeout, MmCritsectTimeoutSeconds, MmDataClusterSize, MmDontVerifyRandomDrivers, MmDynamicMemoryMutex, MmEnforceWriteProtection, MmEventCountList, MmExpansionLock, MmHardFaultNotifyRoutine, MmHeapDeCommitFreeBlockThreshold, MmHeapDeCommitTotalFreeThreshold, MmHeapSegmentCommit, MmHeapSegmentReserve, MmHighestUserAddress, MmHighSectionBase, MmImageMappingPteEvent, MmInitializeMemoryLimits(), MmInPageSupportList, MmLargeSystem, MmLargeSystemCache, MmLoadedUserImageList, MmLockConflictList, MmLockPagesLimit, MmLockPagesPercentage, MmMappedFileIoComplete, MmMaximumDeadKernelStacks, MmMaximumNonPagedPoolInBytes, MmMaximumWorkingSetSize, MmMaxUnusedSegmentNonPagedPoolUsage, MmMaxUnusedSegmentPagedPoolUsage, MmMediumSystem, MmMinimumFreePages, MmModifiedPageLifeInSeconds, MmModifiedPageMaximum, MmModifiedPageMinimum, MmModifiedPageWriterEvent, MmMoreThanEnoughFreePages, MmNonPagedSystemStart, MmNumberOfPhysicalPages, MmNumberOfSystemPtes, MmOverCommit, MmPagedPoolEnd, MmPagedPoolStart, MmPageFaultNotifyRoutine, MmPageFileCreationLock, MmPhysicalMemoryBlock, MmProductType, MmProtectFreedNonPagedPool, MmReadClusterSize, MmResidentAvailableAtInit, MmResidentAvailablePages, MmSectionBasedMutex, MmSectionCommitMutex, MmSectionExtendResource, MmSectionExtendSetResource, MmSessionBase, MmSessionSpace, MmSharedUserDataPte, MmSizeOfPagedPoolInBytes, MmSizeOfSystemCacheInPages, MmSmallSystem, MmSnapUnloads, MmSpecialPoolTag, MmSystemCacheEnd, MmSystemCacheStart, MmSystemCacheWorkingSetList, MmSystemCacheWsMaximum, MmSystemCacheWsMinimum, MmSystemLoadLock, MmSystemRangeStart, MmSystemSize, MmSystemWsLock, MmThrottleBottom, MmThrottleTop, MmTotalCommitLimit, MmTotalCommitLimitMaximum, MmTrackLockedPages, MmTrackPtes, MmUnusedSegmentNonPagedPoolReduction, MmUnusedSegmentPagedPoolReduction, MmUnusedSegmentTrimLevel, MmUserProbeAddress, MmVerifyDriverBufferLength, MmVirtualBias, MmWorkingSetExpansionHead, MmWorkingSetManagerEvent, MmZeroingPageEvent, MmZeroingPageThreadActive, NON_PAGED_SYSTEM_END, NonPagedPoolMustSucceed, NT_SUCCESS, NULL, _PHYSICAL_MEMORY_DESCRIPTOR::NumberOfPages, _PHYSICAL_MEMORY_DESCRIPTOR::NumberOfRuns, ObjectAttributes, _MMPFN::OriginalPte, PAGE_SHIFT, PAGE_SIZE, _PHYSICAL_MEMORY_RUN::PageCount, _MMPAGE_FILE_EXPANSION::PageFileNumber, PDE_KTBASE, _EPROCESS::PhysicalVadList, PsCreateSystemThread(), PsGetCurrentProcess, PsLoadedModuleList, PsLoadedModuleResource, PTE_PER_PAGE, PTE_SHIFT, _MMPFN::PteAddress, _MMPFN::PteFrame, _MMPAGE_FILE_EXPANSION::RequestedExpansionSize, RtlImageNtHeader(), _PHYSICAL_MEMORY_DESCRIPTOR::Run, _MMPAGE_FILE_EXPANSION::Segment, SystemPteSpace, ThreadHandle, TRUE, _MMPTE::u, _MMPFN::u2, _MMPFN::u3, UNLOCK_PFN, ValidKernelPde, ValidKernelPte, and ZeroKernelPte. 00192 : 00193 00194 This function is called during Phase 0, phase 1 and at the end 00195 of phase 1 ("phase 2") initialization. 00196 00197 Phase 0 initializes the memory management paging functions, 00198 nonpaged and paged pool, the PFN database, etc. 00199 00200 Phase 1 initializes the section objects, the physical memory 00201 object, and starts the memory management system threads. 00202 00203 Phase 2 frees memory used by the OsLoader. 00204 00205 Arguments: 00206 00207 Phase - System initialization phase. 00208 00209 LoaderBlock - Supplies a pointer to the system loader block. 00210 00211 Return Value: 00212 00213 Returns TRUE if the initialization was successful. 00214 00215 Environment: 00216 00217 Kernel Mode Only. System initialization. 00218 00219 --*/ 00220 00221 { 00222 HANDLE ThreadHandle; 00223 OBJECT_ATTRIBUTES ObjectAttributes; 00224 PMMPTE PointerPte; 00225 PMMPTE PointerPde; 00226 PMMPTE StartPde; 00227 PMMPTE StartPpe; 00228 PMMPTE StartingPte; 00229 PMMPTE EndPde; 00230 PMMPFN Pfn1; 00231 MMPTE Pointer; 00232 PFN_NUMBER i, j; 00233 PFN_NUMBER PageFrameIndex; 00234 PFN_NUMBER DirectoryFrameIndex; 00235 MMPTE TempPte; 00236 KIRQL OldIrql; 00237 LOGICAL First; 00238 PLIST_ENTRY NextEntry; 00239 PLDR_DATA_TABLE_ENTRY DataTableEntry; 00240 ULONG MaximumSystemCacheSize; 00241 ULONG MaximumSystemCacheSizeTotal; 00242 PEPROCESS Process; 00243 PIMAGE_NT_HEADERS NtHeaders; 00244 ULONG_PTR SystemPteMultiplier; 00245 00246 BOOLEAN IncludeType[LoaderMaximum]; 00247 ULONG MemoryAlloc[(sizeof(PHYSICAL_MEMORY_DESCRIPTOR) + 00248 sizeof(PHYSICAL_MEMORY_RUN)*MAX_PHYSICAL_MEMORY_FRAGMENTS) / 00249 sizeof(ULONG)]; 00250 00251 PPHYSICAL_MEMORY_DESCRIPTOR Memory; 00252 00253 // 00254 // Make sure structure alignment is okay. 00255 // 00256 00257 if (Phase == 0) { 00258 MmThrottleTop = 450; 00259 MmThrottleBottom = 127; 00260 00261 // 00262 // Set the highest user address, the system range start address, the 00263 // user probe address, and the virtual bias. 00264 // 00265 00266 #if defined(_AXP64_) || defined(_IA64_) 00267 00268 MmHighestUserAddress = MM_HIGHEST_USER_ADDRESS; 00269 MmUserProbeAddress = MM_USER_PROBE_ADDRESS; 00270 MmSystemRangeStart = MM_SYSTEM_RANGE_START; 00271 00272 #else 00273 00274 MmHighestUserAddress = (PVOID)(KSEG0_BASE - 0x10000 - 1); 00275 MmUserProbeAddress = KSEG0_BASE - 0x10000; 00276 MmSystemRangeStart = (PVOID)KSEG0_BASE; 00277 00278 #endif 00279 00280 MiHighestUserPte = MiGetPteAddress (MmHighestUserAddress); 00281 MiHighestUserPde = MiGetPdeAddress (MmHighestUserAddress); 00282 00283 MmVirtualBias = 0; 00284 00285 // 00286 // Set the highest section base address. 00287 // 00288 // N.B. In 32-bit systems this address must be 2gb or less even for 00289 // systems that run with 3gb enabled. Otherwise, it would not 00290 // be possible to map based sections identically in all processes. 00291 // 00292 00293 MmHighSectionBase = ((PCHAR)MmHighestUserAddress - 0x800000); 00294 00295 if (ExVerifySuite(TerminalServer) == TRUE) { 00296 MiHydra = TRUE; 00297 MiSystemViewStart = MM_SYSTEM_VIEW_START_IF_HYDRA; 00298 MmSessionBase = (ULONG_PTR)MM_SESSION_SPACE_DEFAULT; 00299 00300 } else { 00301 MiSystemViewStart = MM_SYSTEM_VIEW_START; 00302 MiHydra = FALSE; 00303 } 00304 00305 MaximumSystemCacheSize = (MM_SYSTEM_CACHE_END - MM_SYSTEM_CACHE_START) >> PAGE_SHIFT; 00306 00307 // 00308 // If the system has been biased to an alternate base address to 00309 // allow 3gb of user address space, then set the user probe address 00310 // and the maximum system cache size. 00311 // 00312 00313 #if defined(_X86_) 00314 00315 MmVirtualBias = LoaderBlock->u.I386.VirtualBias; 00316 00317 if (MmVirtualBias != 0) { 00318 MmHighestUserAddress = ((PCHAR)MmHighestUserAddress + 0x40000000); 00319 MmSystemRangeStart = ((PCHAR)MmSystemRangeStart + 0x40000000); 00320 MmUserProbeAddress += 0x40000000; 00321 MiMaximumWorkingSet += 0x40000000 >> PAGE_SHIFT; 00322 00323 MiHighestUserPte = MiGetPteAddress (MmHighestUserAddress); 00324 MiHighestUserPde = MiGetPdeAddress (MmHighestUserAddress); 00325 00326 MaximumSystemCacheSize -= MM_BOOT_IMAGE_SIZE >> PAGE_SHIFT; 00327 00328 if (MiHydra == TRUE) { 00329 00330 // 00331 // Moving to 3GB means moving session space to just above 00332 // the system cache (and lowering the system cache max size 00333 // accordingly). 00334 // 00335 00336 MaximumSystemCacheSize -= (MI_SESSION_SPACE_TOTAL_SIZE + MM_SYSTEM_VIEW_SIZE_IF_HYDRA) >> PAGE_SHIFT; 00337 00338 MiSystemViewStart = (ULONG_PTR)(MM_SYSTEM_CACHE_START + 00339 (MaximumSystemCacheSize << PAGE_SHIFT)); 00340 00341 MmSessionBase = MiSystemViewStart + MM_SYSTEM_VIEW_SIZE_IF_HYDRA + MM_BOOT_IMAGE_SIZE; 00342 00343 } else { 00344 MaximumSystemCacheSize -= MM_SYSTEM_VIEW_SIZE >> PAGE_SHIFT; 00345 MiSystemViewStart = (ULONG_PTR)(MM_SYSTEM_CACHE_START + 00346 (MaximumSystemCacheSize << PAGE_SHIFT) + 00347 MM_BOOT_IMAGE_SIZE); 00348 } 00349 } 00350 00351 #else 00352 00353 if (MiHydra == TRUE) { 00354 MaximumSystemCacheSize -= MM_SYSTEM_VIEW_SIZE_IF_HYDRA >> PAGE_SHIFT; 00355 MiSystemViewStart = MM_SYSTEM_VIEW_START_IF_HYDRA; 00356 } 00357 00358 #endif 00359 00360 if (MiHydra == TRUE) { 00361 MmSessionSpace = (PMM_SESSION_SPACE)((ULONG_PTR)MmSessionBase + MI_SESSION_IMAGE_SIZE); 00362 00363 MiSessionBasePte = MiGetPteAddress (MmSessionBase); 00364 MiSessionLastPte = MiGetPteAddress (MI_SESSION_SPACE_END); 00365 } 00366 00367 // 00368 // A few sanity checks to ensure things are as they should be. 00369 // 00370 00371 #if DBG 00372 if ((sizeof(MMWSL) % 8) != 0) { 00373 DbgPrint("working set list is not a quadword sized structure\n"); 00374 } 00375 00376 if ((sizeof(CONTROL_AREA) % 8) != 0) { 00377 DbgPrint("control area list is not a quadword sized structure\n"); 00378 } 00379 00380 if ((sizeof(SUBSECTION) % 8) != 0) { 00381 DbgPrint("subsection list is not a quadword sized structure\n"); 00382 } 00383 00384 // 00385 // Some checks to make sure prototype PTEs can be placed in 00386 // either paged or nonpaged (prototype PTEs for paged pool are here) 00387 // can be put into pte format. 00388 // 00389 00390 PointerPte = (PMMPTE)MmPagedPoolStart; 00391 Pointer.u.Long = MiProtoAddressForPte (PointerPte); 00392 TempPte = Pointer; 00393 PointerPde = MiPteToProto(&TempPte); 00394 if (PointerPte != PointerPde) { 00395 DbgPrint("unable to map start of paged pool as prototype pte %p %p\n", 00396 PointerPde, 00397 PointerPte); 00398 } 00399 00400 PointerPte = 00401 (PMMPTE)((ULONG_PTR)MM_NONPAGED_POOL_END & ~((1 << PTE_SHIFT) - 1)); 00402 00403 Pointer.u.Long = MiProtoAddressForPte (PointerPte); 00404 TempPte = Pointer; 00405 PointerPde = MiPteToProto(&TempPte); 00406 if (PointerPte != PointerPde) { 00407 DbgPrint("unable to map end of nonpaged pool as prototype pte %p %p\n", 00408 PointerPde, 00409 PointerPte); 00410 } 00411 00412 PointerPte = (PMMPTE)(((ULONG_PTR)NON_PAGED_SYSTEM_END - 00413 0x37000 + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)); 00414 00415 for (j = 0; j < 20; j++) { 00416 Pointer.u.Long = MiProtoAddressForPte (PointerPte); 00417 TempPte = Pointer; 00418 PointerPde = MiPteToProto(&TempPte); 00419 if (PointerPte != PointerPde) { 00420 DbgPrint("unable to map end of nonpaged pool as prototype pte %p %p\n", 00421 PointerPde, 00422 PointerPte); 00423 } 00424 00425 PointerPte++; 00426 } 00427 00428 PointerPte = (PMMPTE)(((ULONG_PTR)MM_NONPAGED_POOL_END - 0x133448) & ~(ULONG_PTR)7); 00429 Pointer.u.Long = MiGetSubsectionAddressForPte (PointerPte); 00430 TempPte = Pointer; 00431 PointerPde = (PMMPTE)MiGetSubsectionAddress(&TempPte); 00432 if (PointerPte != PointerPde) { 00433 DbgPrint("unable to map end of nonpaged pool as section pte %p %p\n", 00434 PointerPde, 00435 PointerPte); 00436 00437 MiFormatPte(&TempPte); 00438 } 00439 00440 // 00441 // End of sanity checks. 00442 // 00443 00444 #endif //dbg 00445 00446 if (MmEnforceWriteProtection) { 00447 MiPteStr[0] = (CHAR)1; 00448 } 00449 00450 InitializeListHead( &MmLoadedUserImageList ); 00451 InitializeListHead( &MmLockConflictList ); 00452 00453 MmCriticalSectionTimeout.QuadPart = Int32x32To64( 00454 MmCritsectTimeoutSeconds, 00455 -10000000); 00456 00457 00458 // 00459 // Initialize PFN database mutex and System Address Space creation 00460 // mutex. 00461 // 00462 00463 ExInitializeFastMutex (&MmSectionCommitMutex); 00464 ExInitializeFastMutex (&MmSectionBasedMutex); 00465 ExInitializeFastMutex (&MmDynamicMemoryMutex); 00466 00467 KeInitializeMutant (&MmSystemLoadLock, FALSE); 00468 00469 KeInitializeEvent (&MmAvailablePagesEvent, NotificationEvent, TRUE); 00470 KeInitializeEvent (&MmAvailablePagesEventHigh, NotificationEvent, TRUE); 00471 KeInitializeEvent (&MmMappedFileIoComplete, NotificationEvent, FALSE); 00472 KeInitializeEvent (&MmImageMappingPteEvent, NotificationEvent, FALSE); 00473 KeInitializeEvent (&MmZeroingPageEvent, SynchronizationEvent, FALSE); 00474 KeInitializeEvent (&MmCollidedFlushEvent, NotificationEvent, FALSE); 00475 KeInitializeEvent (&MmCollidedLockEvent, NotificationEvent, FALSE); 00476 KeInitializeEvent (&MiMappedPagesTooOldEvent, NotificationEvent, FALSE); 00477 00478 KeInitializeDpc( &MiModifiedPageWriterTimerDpc, MiModifiedPageWriterTimerDispatch, NULL ); 00479 KeInitializeTimerEx( &MiModifiedPageWriterTimer, SynchronizationTimer ); 00480 00481 MiModifiedPageLife.QuadPart = Int32x32To64( 00482 MmModifiedPageLifeInSeconds, 00483 -10000000); 00484 00485 InitializeListHead (&MmWorkingSetExpansionHead.ListHead); 00486 InitializeListHead (&MmInPageSupportList.ListHead); 00487 InitializeListHead (&MmEventCountList.ListHead); 00488 00489 MmZeroingPageThreadActive = FALSE; 00490 00491 // 00492 // Compute physical memory blocks yet again 00493 // 00494 00495 Memory = (PPHYSICAL_MEMORY_DESCRIPTOR)&MemoryAlloc; 00496 Memory->NumberOfRuns = MAX_PHYSICAL_MEMORY_FRAGMENTS; 00497 00498 // include all memory types ... 00499 for (i=0; i < LoaderMaximum; i++) { 00500 IncludeType[i] = TRUE; 00501 } 00502 00503 // ... expect these.. 00504 IncludeType[LoaderBad] = FALSE; 00505 IncludeType[LoaderFirmwarePermanent] = FALSE; 00506 IncludeType[LoaderSpecialMemory] = FALSE; 00507 IncludeType[LoaderBBTMemory] = FALSE; 00508 00509 MmInitializeMemoryLimits(LoaderBlock, IncludeType, Memory); 00510 00511 #if defined (_X86PAE_) 00512 MiCheckPaeLicense (LoaderBlock, IncludeType, Memory); 00513 #endif 00514 00515 #if defined (_X86PAE_) || defined (_WIN64) 00516 Mm64BitPhysicalAddress = TRUE; 00517 #endif 00518 00519 // 00520 // Add all memory runs in PhysicalMemoryBlock to Memory 00521 // 00522 00523 for (i = 0; i < PhysicalMemoryBlock->NumberOfRuns; i += 1) { 00524 MiMergeMemoryLimit (Memory, 00525 PhysicalMemoryBlock->Run[i].BasePage, 00526 PhysicalMemoryBlock->Run[i].PageCount 00527 ); 00528 } 00529 00530 // 00531 // Sort and merge adjacent runs. 00532 // 00533 00534 for (i=0; i < Memory->NumberOfRuns; i++) { 00535 for (j=i+1; j < Memory->NumberOfRuns; j++) { 00536 if (Memory->Run[j].BasePage < Memory->Run[i].BasePage) { 00537 // swap runs 00538 PhysicalMemoryBlock->Run[0] = Memory->Run[j]; 00539 Memory->Run[j] = Memory->Run[i]; 00540 Memory->Run[i] = PhysicalMemoryBlock->Run[0]; 00541 } 00542 00543 if (Memory->Run[i].BasePage + Memory->Run[i].PageCount == 00544 Memory->Run[j].BasePage) { 00545 // merge runs 00546 Memory->NumberOfRuns -= 1; 00547 Memory->Run[i].PageCount += Memory->Run[j].PageCount; 00548 Memory->Run[j] = Memory->Run[Memory->NumberOfRuns]; 00549 i -= 1; 00550 break; 00551 } 00552 } 00553 } 00554 00555 // 00556 // When safebooting, don't enable special pool, the verifier or any 00557 // other options that track corruption regardless of registry settings. 00558 // 00559 00560 if (strstr(LoaderBlock->LoadOptions, SAFEBOOT_LOAD_OPTION_A)) { 00561 MmVerifyDriverBufferLength = (ULONG)-1; 00562 MmDontVerifyRandomDrivers = TRUE; 00563 MmSpecialPoolTag = (ULONG)-1; 00564 MmSnapUnloads = FALSE; 00565 MmProtectFreedNonPagedPool = FALSE; 00566 MmEnforceWriteProtection = 0; 00567 MmTrackLockedPages = FALSE; 00568 MmTrackPtes = FALSE; 00569 } 00570 else { 00571 MiTriageSystem (LoaderBlock); 00572 } 00573 00574 SystemPteMultiplier = 0; 00575 00576 if (MmNumberOfSystemPtes == 0) { 00577 #if defined (_WIN64) 00578 00579 // 00580 // 64-bit NT is not contrained by virtual address space. No 00581 // tradeoffs between nonpaged pool, paged pool and system PTEs 00582 // need to be made. So just allocate PTEs on a linear scale as 00583 // a function of the amount of RAM. 00584 // 00585 // For example on Alpha64, 4gb of RAM gets 128gb of PTEs by default. 00586 // The page table cost is the inversion of the multiplier based 00587 // on the PTE_PER_PAGE. 00588 // 00589 00590 if ((MiHydra == TRUE) && (ExpMultiUserTS == TRUE)) { 00591 SystemPteMultiplier = 128; 00592 } 00593 else { 00594 SystemPteMultiplier = 64; 00595 } 00596 if (Memory->NumberOfPages < 0x8000) { 00597 SystemPteMultiplier >>= 1; 00598 } 00599 #else 00600 if (Memory->NumberOfPages < MM_MEDIUM_SYSTEM) { 00601 MmNumberOfSystemPtes = MM_MINIMUM_SYSTEM_PTES; 00602 } else { 00603 MmNumberOfSystemPtes = MM_DEFAULT_SYSTEM_PTES; 00604 if (Memory->NumberOfPages > 8192) { 00605 MmNumberOfSystemPtes += MmNumberOfSystemPtes; 00606 00607 // 00608 // Any reasonable Hydra machine gets the maximum. 00609 // 00610 00611 if ((MiHydra == TRUE) && (ExpMultiUserTS == TRUE)) { 00612 MmNumberOfSystemPtes = MM_MAXIMUM_SYSTEM_PTES; 00613 } 00614 } 00615 } 00616 #endif 00617 } 00618 else if (MmNumberOfSystemPtes == (ULONG)-1) { 00619 00620 // 00621 // This registry setting indicates the maximum number of 00622 // system PTEs possible for this machine must be allocated. 00623 // Snap this for later reference. 00624 // 00625 00626 MiRequestedSystemPtes = MmNumberOfSystemPtes; 00627 00628 #if defined (_WIN64) 00629 SystemPteMultiplier = 256; 00630 #else 00631 MmNumberOfSystemPtes = MM_MAXIMUM_SYSTEM_PTES; 00632 #endif 00633 } 00634 00635 if (SystemPteMultiplier != 0) { 00636 if (Memory->NumberOfPages * SystemPteMultiplier > MM_MAXIMUM_SYSTEM_PTES) { 00637 MmNumberOfSystemPtes = MM_MAXIMUM_SYSTEM_PTES; 00638 } 00639 else { 00640 MmNumberOfSystemPtes = (ULONG)(Memory->NumberOfPages * SystemPteMultiplier); 00641 } 00642 } 00643 00644 if (MmNumberOfSystemPtes > MM_MAXIMUM_SYSTEM_PTES) { 00645 MmNumberOfSystemPtes = MM_MAXIMUM_SYSTEM_PTES; 00646 } 00647 00648 if (MmNumberOfSystemPtes < MM_MINIMUM_SYSTEM_PTES) { 00649 MmNumberOfSystemPtes = MM_MINIMUM_SYSTEM_PTES; 00650 } 00651 00652 if (MmHeapSegmentReserve == 0) { 00653 MmHeapSegmentReserve = 1024 * 1024; 00654 } 00655 00656 if (MmHeapSegmentCommit == 0) { 00657 MmHeapSegmentCommit = PAGE_SIZE * 2; 00658 } 00659 00660 if (MmHeapDeCommitTotalFreeThreshold == 0) { 00661 MmHeapDeCommitTotalFreeThreshold = 64 * 1024; 00662 } 00663 00664 if (MmHeapDeCommitFreeBlockThreshold == 0) { 00665 MmHeapDeCommitFreeBlockThreshold = PAGE_SIZE; 00666 } 00667 00668 #ifndef NO_POOL_CHECKS 00669 MiInitializeSpecialPoolCriteria (); 00670 #endif 00671 00672 // 00673 // If the registry indicates drivers are in the suspect list, 00674 // extra system PTEs need to be allocated to support special pool 00675 // for their allocations. 00676 // 00677 00678 if ((MmVerifyDriverBufferLength != (ULONG)-1) || 00679 ((MmSpecialPoolTag != 0) && (MmSpecialPoolTag != (ULONG)-1))) { 00680 MmNumberOfSystemPtes += MM_SPECIAL_POOL_PTES; 00681 } 00682 00683 MmNumberOfSystemPtes += BBTPagesToReserve; 00684 00685 // 00686 // Initialize the machine dependent portion of the hardware. 00687 // 00688 00689 ExInitializeResource (&MmSystemWsLock); 00690 00691 MiInitMachineDependent (LoaderBlock); 00692 00693 #if PFN_CONSISTENCY 00694 MiPfnProtectionEnabled = TRUE; 00695 #endif 00696 00697 MiReloadBootLoadedDrivers (LoaderBlock); 00698 00699 MiInitializeDriverVerifierList (LoaderBlock); 00700 00701 j = (sizeof(PHYSICAL_MEMORY_DESCRIPTOR) + 00702 (sizeof(PHYSICAL_MEMORY_RUN) * 00703 (Memory->NumberOfRuns - 1))); 00704 00705 MmPhysicalMemoryBlock = ExAllocatePoolWithTag (NonPagedPoolMustSucceed, 00706 j, 00707 ' mM'); 00708 00709 RtlCopyMemory (MmPhysicalMemoryBlock, Memory, j); 00710 00711 // 00712 // Setup the system size as small, medium, or large depending 00713 // on memory available. 00714 // 00715 // For internal MM tuning, the following applies 00716 // 00717 // 12Mb is small 00718 // 12-19 is medium 00719 // > 19 is large 00720 // 00721 // 00722 // For all other external tuning, 00723 // < 19 is small 00724 // 19 - 31 is medium for workstation 00725 // 19 - 63 is medium for server 00726 // >= 32 is large for workstation 00727 // >= 64 is large for server 00728 // 00729 00730 MmReadClusterSize = 7; 00731 if (MmNumberOfPhysicalPages <= MM_SMALL_SYSTEM ) { 00732 MmSystemSize = MmSmallSystem; 00733 MmMaximumDeadKernelStacks = 0; 00734 MmModifiedPageMinimum = 40; 00735 MmModifiedPageMaximum = 100; 00736 MmDataClusterSize = 0; 00737 MmCodeClusterSize = 1; 00738 MmReadClusterSize = 2; 00739 00740 } else if (MmNumberOfPhysicalPages <= MM_MEDIUM_SYSTEM ) { 00741 MmSystemSize = MmSmallSystem; 00742 MmMaximumDeadKernelStacks = 2; 00743 MmModifiedPageMinimum = 80; 00744 MmModifiedPageMaximum = 150; 00745 MmSystemCacheWsMinimum += 100; 00746 MmSystemCacheWsMaximum += 150; 00747 MmDataClusterSize = 1; 00748 MmCodeClusterSize = 2; 00749 MmReadClusterSize = 4; 00750 00751 } else { 00752 MmSystemSize = MmMediumSystem; 00753 MmMaximumDeadKernelStacks = 5; 00754 MmModifiedPageMinimum = 150; 00755 MmModifiedPageMaximum = 300; 00756 MmSystemCacheWsMinimum += 400; 00757 MmSystemCacheWsMaximum += 800; 00758 MmDataClusterSize = 3; 00759 MmCodeClusterSize = 7; 00760 } 00761 00762 if (MmNumberOfPhysicalPages < ((24*1024*1024)/PAGE_SIZE)) { 00763 MmSystemCacheWsMinimum = 32; 00764 } 00765 00766 if (MmNumberOfPhysicalPages >= ((32*1024*1024)/PAGE_SIZE)) { 00767 00768 // 00769 // If we are on a workstation, 32Mb and above are considered large systems 00770 // 00771 if ( MmProductType == 0x00690057 ) { 00772 MmSystemSize = MmLargeSystem; 00773 00774 } else { 00775 00776 // 00777 // For servers, 64Mb and greater is a large system 00778 // 00779 00780 if (MmNumberOfPhysicalPages >= ((64*1024*1024)/PAGE_SIZE)) { 00781 MmSystemSize = MmLargeSystem; 00782 } 00783 } 00784 } 00785 00786 if (MmNumberOfPhysicalPages > ((33*1024*1024)/PAGE_SIZE)) { 00787 MmModifiedPageMinimum = 400; 00788 MmModifiedPageMaximum = 800; 00789 MmSystemCacheWsMinimum += 500; 00790 MmSystemCacheWsMaximum += 900; 00791 } 00792 00793 // 00794 // determine if we are on an AS system ( Winnt is not AS) 00795 // 00796 00797 if (MmProductType == 0x00690057) { 00798 SharedUserData->NtProductType = NtProductWinNt; 00799 MmProductType = 0; 00800 MmThrottleTop = 250; 00801 MmThrottleBottom = 30; 00802 00803 } else { 00804 if ( MmProductType == 0x0061004c ) { 00805 SharedUserData->NtProductType = NtProductLanManNt; 00806 00807 } else { 00808 SharedUserData->NtProductType = NtProductServer; 00809 } 00810 00811 MmProductType = 1; 00812 MmThrottleTop = 450; 00813 MmThrottleBottom = 80; 00814 MmMinimumFreePages = 81; 00815 } 00816 00817 MiAdjustWorkingSetManagerParameters((BOOLEAN)(MmProductType == 0 ? TRUE : FALSE)); 00818 00819 // 00820 // Set the ResidentAvailablePages to the number of available 00821 // pages minus the fluid value. 00822 // 00823 00824 MmResidentAvailablePages = MmAvailablePages - MM_FLUID_PHYSICAL_PAGES; 00825 00826 // 00827 // Subtract off the size of the system cache working set. 00828 // 00829 00830 MmResidentAvailablePages -= MmSystemCacheWsMinimum; 00831 MmResidentAvailableAtInit = MmResidentAvailablePages; 00832 00833 00834 if (MmResidentAvailablePages < 0) { 00835 #if DBG 00836 DbgPrint("system cache working set too big\n"); 00837 #endif 00838 return FALSE; 00839 } 00840 00841 // 00842 // Initialize spin lock for charging and releasing page file 00843 // commitment. 00844 // 00845 00846 KeInitializeSpinLock (&MmChargeCommitmentLock); 00847 00848 MiInitializeIoTrackers (); 00849 00850 // 00851 // Initialize spin lock for allowing working set expansion. 00852 // 00853 00854 KeInitializeSpinLock (&MmExpansionLock); 00855 00856 ExInitializeFastMutex (&MmPageFileCreationLock); 00857 00858 // 00859 // Initialize resource for extending sections. 00860 // 00861 00862 ExInitializeResource (&MmSectionExtendResource); 00863 ExInitializeResource (&MmSectionExtendSetResource); 00864 00865 // 00866 // Build the system cache structures. 00867 // 00868 00869 StartPde = MiGetPdeAddress (MmSystemCacheWorkingSetList); 00870 PointerPte = MiGetPteAddress (MmSystemCacheWorkingSetList); 00871 00872 #if defined (_WIN64) 00873 00874 StartPpe = MiGetPteAddress(StartPde); 00875 00876 TempPte = ValidKernelPte; 00877 00878 if (StartPpe->u.Hard.Valid == 0) { 00879 00880 // 00881 // Map in a page directory page for the system cache working set. 00882 // Note that we only populate one page table for this. 00883 // 00884 00885 DirectoryFrameIndex = MiRemoveAnyPage( 00886 MI_GET_PAGE_COLOR_FROM_PTE (StartPpe)); 00887 TempPte.u.Hard.PageFrameNumber = DirectoryFrameIndex; 00888 *StartPpe = TempPte; 00889 00890 00891 Pfn1 = MI_PFN_ELEMENT(DirectoryFrameIndex); 00892 Pfn1->PteFrame = MI_GET_PAGE_FRAME_FROM_PTE ( 00893 MiGetPteAddress(PDE_KTBASE)); 00894 Pfn1->PteAddress = StartPpe; 00895 Pfn1->u2.ShareCount += 1; 00896 Pfn1->u3.e2.ReferenceCount = 1; 00897 Pfn1->u3.e1.PageLocation = ActiveAndValid; 00898 Pfn1->OriginalPte.u.Long = MM_DEMAND_ZERO_WRITE_PTE; 00899 00900 MiFillMemoryPte (StartPde, 00901 PAGE_SIZE, 00902 ZeroKernelPte.u.Long); 00903 } 00904 00905 // 00906 // Map in a page table page. 00907 // 00908 00909 ASSERT (StartPde->u.Hard.Valid == 0); 00910 00911 PageFrameIndex = MiRemoveAnyPage( 00912 MI_GET_PAGE_COLOR_FROM_PTE (StartPde)); 00913 TempPte.u.Hard.PageFrameNumber = PageFrameIndex; 00914 MI_WRITE_VALID_PTE (StartPde, TempPte); 00915 00916 Pfn1 = MI_PFN_ELEMENT(PageFrameIndex); 00917 Pfn1->PteFrame = DirectoryFrameIndex; 00918 Pfn1->PteAddress = StartPde; 00919 Pfn1->u2.ShareCount += 1; 00920 Pfn1->u3.e2.ReferenceCount = 1; 00921 Pfn1->u3.e1.PageLocation = ActiveAndValid; 00922 Pfn1->OriginalPte.u.Long = MM_DEMAND_ZERO_WRITE_PTE; 00923 00924 MiFillMemoryPte (MiGetVirtualAddressMappedByPte (StartPde), 00925 PAGE_SIZE, 00926 ZeroKernelPte.u.Long); 00927 00928 StartPpe = MiGetPpeAddress(MmSystemCacheStart); 00929 StartPde = MiGetPdeAddress(MmSystemCacheStart); 00930 PointerPte = MiGetVirtualAddressMappedByPte (StartPde); 00931 00932 #else 00933 #if !defined(_X86PAE_) 00934 ASSERT ((StartPde + 1) == MiGetPdeAddress (MmSystemCacheStart)); 00935 #endif 00936 #endif 00937 00938 MaximumSystemCacheSizeTotal = MaximumSystemCacheSize; 00939 00940 #if defined(_X86_) 00941 MaximumSystemCacheSizeTotal += MiMaximumSystemCacheSizeExtra; 00942 #endif 00943 00944 // 00945 // Size the system cache based on the amount of physical memory. 00946 // 00947 00948 i = (MmNumberOfPhysicalPages + 65) / 1024; 00949 00950 if (i >= 4) { 00951 00952 // 00953 // System has at least 4032 pages. Make the system 00954 // cache 128mb + 64mb for each additional 1024 pages. 00955 // 00956 00957 MmSizeOfSystemCacheInPages = (PFN_COUNT)( 00958 ((128*1024*1024) >> PAGE_SHIFT) + 00959 ((i - 4) * ((64*1024*1024) >> PAGE_SHIFT))); 00960 if (MmSizeOfSystemCacheInPages > MaximumSystemCacheSizeTotal) { 00961 MmSizeOfSystemCacheInPages = MaximumSystemCacheSizeTotal; 00962 } 00963 } 00964 00965 MmSystemCacheEnd = (PVOID)(((PCHAR)MmSystemCacheStart + 00966 MmSizeOfSystemCacheInPages * PAGE_SIZE) - 1); 00967 00968 #if defined(_X86_) 00969 if (MmSizeOfSystemCacheInPages > MaximumSystemCacheSize) { 00970 ASSERT (MiMaximumSystemCacheSizeExtra != 0); 00971 MmSystemCacheEnd = (PVOID)(((PCHAR)MmSystemCacheStart + 00972 MaximumSystemCacheSize * PAGE_SIZE) - 1); 00973 00974 MiSystemCacheStartExtra = (PVOID)MM_SYSTEM_CACHE_START_EXTRA; 00975 MiSystemCacheEndExtra = (PVOID)(((PCHAR)MiSystemCacheStartExtra + 00976 (MmSizeOfSystemCacheInPages - MaximumSystemCacheSize) * PAGE_SIZE) - 1); 00977 } 00978 else { 00979 MiSystemCacheStartExtra = MmSystemCacheStart; 00980 MiSystemCacheEndExtra = MmSystemCacheEnd; 00981 } 00982 #endif 00983 00984 EndPde = MiGetPdeAddress(MmSystemCacheEnd); 00985 00986 TempPte = ValidKernelPte; 00987 00988 #if defined(_WIN64) 00989 First = (StartPpe->u.Hard.Valid == 0) ? TRUE : FALSE; 00990 #endif 00991 00992 #if !defined (_WIN64) 00993 DirectoryFrameIndex = MI_GET_PAGE_FRAME_FROM_PTE (MiGetPteAddress(PDE_BASE)); 00994 #endif 00995 00996 LOCK_PFN (OldIrql); 00997 while (StartPde <= EndPde) { 00998 00999 #if defined (_WIN64) 01000 if (First == TRUE || MiIsPteOnPdeBoundary(StartPde)) { 01001 First = FALSE; 01002 StartPpe = MiGetPteAddress(StartPde); 01003 01004 // 01005 // Map in a page directory page. 01006 // 01007 01008 DirectoryFrameIndex = MiRemoveAnyPage( 01009 MI_GET_PAGE_COLOR_FROM_PTE (StartPpe)); 01010 TempPte.u.Hard.PageFrameNumber = DirectoryFrameIndex; 01011 *StartPpe = TempPte; 01012 01013 Pfn1 = MI_PFN_ELEMENT(DirectoryFrameIndex); 01014 Pfn1->PteFrame = MI_GET_PAGE_FRAME_FROM_PTE ( 01015 MiGetPteAddress(PDE_KTBASE)); 01016 Pfn1->PteAddress = StartPpe; 01017 Pfn1->u2.ShareCount += 1; 01018 Pfn1->u3.e2.ReferenceCount = 1; 01019 Pfn1->u3.e1.PageLocation = ActiveAndValid; 01020 Pfn1->OriginalPte.u.Long = MM_DEMAND_ZERO_WRITE_PTE; 01021 01022 MiFillMemoryPte (StartPde, 01023 PAGE_SIZE, 01024 ZeroKernelPte.u.Long); 01025 } 01026 #endif 01027 01028 ASSERT (StartPde->u.Hard.Valid == 0); 01029 01030 // 01031 // Map in a page table page. 01032 // 01033 01034 PageFrameIndex = MiRemoveAnyPage( 01035 MI_GET_PAGE_COLOR_FROM_PTE (StartPde)); 01036 TempPte.u.Hard.PageFrameNumber = PageFrameIndex; 01037 MI_WRITE_VALID_PTE (StartPde, TempPte); 01038 01039 Pfn1 = MI_PFN_ELEMENT(PageFrameIndex); 01040 Pfn1->PteFrame = DirectoryFrameIndex; 01041 Pfn1->PteAddress = StartPde; 01042 Pfn1->u2.ShareCount += 1; 01043 Pfn1->u3.e2.ReferenceCount = 1; 01044 Pfn1->u3.e1.PageLocation = ActiveAndValid; 01045 Pfn1->OriginalPte.u.Long = MM_DEMAND_ZERO_WRITE_PTE; 01046 01047 MiFillMemoryPte (PointerPte, 01048 PAGE_SIZE, 01049 ZeroKernelPte.u.Long); 01050 01051 StartPde += 1; 01052 PointerPte += PTE_PER_PAGE; 01053 } 01054 01055 #if defined(_X86_) 01056 if (MiSystemCacheEndExtra != MmSystemCacheEnd) { 01057 01058 StartPde = MiGetPdeAddress (MiSystemCacheStartExtra); 01059 EndPde = MiGetPdeAddress(MiSystemCacheEndExtra); 01060 01061 PointerPte = MiGetPteAddress (MiSystemCacheStartExtra); 01062 01063 while (StartPde <= EndPde) { 01064 01065 ASSERT (StartPde->u.Hard.Valid == 0); 01066 01067 // 01068 // Map in a page directory page. 01069 // 01070 01071 PageFrameIndex = MiRemoveAnyPage( 01072 MI_GET_PAGE_COLOR_FROM_PTE (StartPde)); 01073 TempPte.u.Hard.PageFrameNumber = PageFrameIndex; 01074 MI_WRITE_VALID_PTE (StartPde, TempPte); 01075 01076 Pfn1 = MI_PFN_ELEMENT(PageFrameIndex); 01077 Pfn1->PteFrame = MI_GET_PAGE_FRAME_FROM_PTE ( 01078 MiGetPdeAddress(PDE_BASE)); 01079 Pfn1->PteAddress = StartPde; 01080 Pfn1->u2.ShareCount += 1; 01081 Pfn1->u3.e2.ReferenceCount = 1; 01082 Pfn1->u3.e1.PageLocation = ActiveAndValid; 01083 Pfn1->OriginalPte.u.Long = MM_DEMAND_ZERO_WRITE_PTE; 01084 01085 MiFillMemoryPte (PointerPte, 01086 PAGE_SIZE, 01087 ZeroKernelPte.u.Long); 01088 01089 StartPde += 1; 01090 PointerPte += PTE_PER_PAGE; 01091 } 01092 } 01093 #endif 01094 01095 UNLOCK_PFN (OldIrql); 01096 01097 // 01098 // Initialize the system cache. Only set the large system cache if 01099 // we have a large amount of physical memory. 01100 // 01101 01102 if (MmLargeSystemCache != 0 && MmNumberOfPhysicalPages > 0x7FF0) { 01103 if ((MmAvailablePages > 01104 MmSystemCacheWsMaximum + ((64*1024*1024) >> PAGE_SHIFT))) { 01105 MmSystemCacheWsMaximum = 01106 MmAvailablePages - ((32*1024*1024) >> PAGE_SHIFT); 01107 ASSERT ((LONG)MmSystemCacheWsMaximum > (LONG)MmSystemCacheWsMinimum); 01108 MmMoreThanEnoughFreePages = 256; 01109 } 01110 } 01111 01112 if (MmSystemCacheWsMaximum > (MM_MAXIMUM_WORKING_SET - 5)) { 01113 MmSystemCacheWsMaximum = MM_MAXIMUM_WORKING_SET - 5; 01114 } 01115 01116 if (MmSystemCacheWsMaximum > MmSizeOfSystemCacheInPages) { 01117 MmSystemCacheWsMaximum = MmSizeOfSystemCacheInPages; 01118 if ((MmSystemCacheWsMinimum + 500) > MmSystemCacheWsMaximum) { 01119 MmSystemCacheWsMinimum = MmSystemCacheWsMaximum - 500; 01120 } 01121 } 01122 01123 MiInitializeSystemCache ((ULONG)MmSystemCacheWsMinimum, 01124 (ULONG)MmSystemCacheWsMaximum); 01125 01126 // 01127 // Set the commit page limit to four times the number of available 01128 // pages. This value is updated as paging files are created. 01129 // 01130 01131 MmTotalCommitLimit = MmAvailablePages << 2; 01132 MmTotalCommitLimitMaximum = MmTotalCommitLimit; 01133 01134 MmAttemptForCantExtend.Segment = NULL; 01135 MmAttemptForCantExtend.RequestedExpansionSize = 1; 01136 MmAttemptForCantExtend.ActualExpansion = 1; 01137 MmAttemptForCantExtend.InProgress = FALSE; 01138 MmAttemptForCantExtend.PageFileNumber = MI_EXTEND_ANY_PAGEFILE; 01139 01140 KeInitializeEvent (&MmAttemptForCantExtend.Event, 01141 NotificationEvent, 01142 FALSE); 01143 01144 if (MmOverCommit == 0) { 01145 01146 // If this value was not set via the registry, set the 01147 // over commit value to the number of available pages 01148 // minus 1024 pages (4mb with 4k pages). 01149 // 01150 01151 if (MmAvailablePages > 1024) { 01152 MmOverCommit = MmAvailablePages - 1024; 01153 } 01154 } 01155 01156 // 01157 // Set maximum working set size to 512 pages less total available 01158 // memory. 2mb on machine with 4k pages. 01159 // 01160 01161 MmMaximumWorkingSetSize = (ULONG)(MmAvailablePages - 512); 01162 01163 if (MmMaximumWorkingSetSize > (MM_MAXIMUM_WORKING_SET - 5)) { 01164 MmMaximumWorkingSetSize = MM_MAXIMUM_WORKING_SET - 5; 01165 } 01166 01167 // 01168 // Create the modified page writer event. 01169 // 01170 01171 KeInitializeEvent (&MmModifiedPageWriterEvent, NotificationEvent, FALSE); 01172 01173 // 01174 // Build paged pool. 01175 // 01176 01177 MiBuildPagedPool (); 01178 01179 // 01180 // Initialize the loaded module list. This cannot be done until 01181 // paged pool has been built. 01182 // 01183 01184 if (MiInitializeLoadedModuleList (LoaderBlock) == FALSE) { 01185 #if DBG 01186 DbgPrint("Loaded module list initialization failed\n"); 01187 #endif 01188 return FALSE; 01189 } 01190 01191 // 01192 // Initialize the unused segment thresholds. The assumption is made 01193 // that the filesystem will tack on approximately a 1024-byte paged 01194 // pool charge (regardless of file size) for each file in the cache. 01195 // 01196 01197 if (MmUnusedSegmentTrimLevel < 5) { 01198 MmUnusedSegmentTrimLevel = 5; 01199 } 01200 else if (MmUnusedSegmentTrimLevel > 40) { 01201 MmUnusedSegmentTrimLevel = 40; 01202 } 01203 01204 MmMaxUnusedSegmentPagedPoolUsage = (MmSizeOfPagedPoolInBytes / 100) * (MmUnusedSegmentTrimLevel << 1); 01205 MmUnusedSegmentPagedPoolReduction = MmMaxUnusedSegmentPagedPoolUsage >> 2; 01206 01207 MmMaxUnusedSegmentNonPagedPoolUsage = (MmMaximumNonPagedPoolInBytes / 100) * (MmUnusedSegmentTrimLevel << 1); 01208 MmUnusedSegmentNonPagedPoolReduction = MmMaxUnusedSegmentNonPagedPoolUsage >> 2; 01209 01210 // 01211 // Add more system PTEs if this is a large memory system. 01212 // Note that 64 bit systems can determine the right value at the 01213 // beginning since there is no virtual address space crunch. 01214 // 01215 01216 #if !defined (_WIN64) 01217 if (MmNumberOfPhysicalPages > ((127*1024*1024) >> PAGE_SHIFT)) { 01218 01219 PointerPde = MiGetPdeAddress ((PCHAR)MmPagedPoolEnd + 1); 01220 StartingPte = MiGetPteAddress ((PCHAR)MmPagedPoolEnd + 1); 01221 j = 0; 01222 01223 TempPte = ValidKernelPde; 01224 LOCK_PFN (OldIrql); 01225 while (PointerPde->u.Hard.Valid == 0) { 01226 01227 MiChargeCommitmentCantExpand (1, TRUE); 01228 MM_TRACK_COMMIT (MM_DBG_COMMIT_EXTRA_SYSTEM_PTES, 1); 01229 01230 PageFrameIndex = MiRemoveZeroPage ( 01231 MI_GET_PAGE_COLOR_FROM_PTE (PointerPde)); 01232 TempPte.u.Hard.PageFrameNumber = PageFrameIndex; 01233 MI_WRITE_VALID_PTE (PointerPde, TempPte); 01234 MiInitializePfn (PageFrameIndex, PointerPde, 1); 01235 PointerPde += 1; 01236 StartingPte += PAGE_SIZE / sizeof(MMPTE); 01237 j += PAGE_SIZE / sizeof(MMPTE); 01238 } 01239 01240 UNLOCK_PFN (OldIrql); 01241 01242 if (j != 0) { 01243 StartingPte = MiGetPteAddress ((PCHAR)MmPagedPoolEnd + 1); 01244 MmNonPagedSystemStart = MiGetVirtualAddressMappedByPte (StartingPte); 01245 MmNumberOfSystemPtes += j; 01246 MiAddSystemPtes (StartingPte, j, SystemPteSpace); 01247 } 01248 } 01249 #endif 01250 01251 01252 #if DBG 01253 if (MmDebug & MM_DBG_DUMP_BOOT_PTES) { 01254 MiDumpValidAddresses (); 01255 MiDumpPfn (); 01256 } 01257 #endif 01258 01259 MmPageFaultNotifyRoutine = NULL; 01260 MmHardFaultNotifyRoutine = NULL; 01261 01262 return TRUE; 01263 } 01264 01265 if (Phase == 1) { 01266 01267 #if DBG 01268 MmDebug |= MM_DBG_CHECK_PFN_LOCK; 01269 #endif 01270 01271 #ifdef _X86_ 01272 MiInitMachineDependent (LoaderBlock); 01273 #endif 01274 MiMapBBTMemory(LoaderBlock); 01275 01276 if (!MiSectionInitialization ()) { 01277 return FALSE; 01278 } 01279 01280 Process = PsGetCurrentProcess (); 01281 if (Process->PhysicalVadList.Flink == NULL) { 01282 KeInitializeSpinLock (&Process->AweLock); 01283 InitializeListHead (&Process->PhysicalVadList); 01284 } 01285 01286 #if defined(MM_SHARED_USER_DATA_VA) 01287 01288 // 01289 // Create double mapped page between kernel and user mode. 01290 // 01291 01292 PointerPte = MiGetPteAddress(KI_USER_SHARED_DATA); 01293 ASSERT (PointerPte->u.Hard.Valid == 1); 01294 PageFrameIndex = MI_GET_PAGE_FRAME_FROM_PTE (PointerPte); 01295 01296 MI_MAKE_VALID_PTE (MmSharedUserDataPte, 01297 PageFrameIndex, 01298 MM_READONLY, 01299 PointerPte); 01300 Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); 01301 01302 LOCK_PFN (OldIrql); 01303 01304 Pfn1->OriginalPte.u.Long = MM_DEMAND_ZERO_WRITE_PTE; 01305 01306 UNLOCK_PFN (OldIrql); 01307 #endif 01308 01309 if (MiHydra == TRUE) { 01310 MiSessionWideInitializeAddresses (); 01311 MiInitializeSessionWsSupport (); 01312 MiInitializeSessionIds (); 01313 } 01314 01315 // 01316 // Set up system wide lock pages limit. 01317 // 01318 01319 if ((MmLockPagesPercentage < 5) || (MmLockPagesPercentage >= 100)) { 01320 01321 // 01322 // No (reasonable or max) registry override from the user 01323 // so default to allowing all available memory. 01324 // 01325 01326 MmLockPagesLimit = (PFN_NUMBER)-1; 01327 } 01328 else { 01329 01330 // 01331 // Use the registry value - note it is expressed as a percentage. 01332 // 01333 01334 MmLockPagesLimit = (PFN_NUMBER)((MmAvailablePages * MmLockPagesPercentage) / 100); 01335 } 01336 01337 // 01338 // Start the modified page writer. 01339 // 01340 01341 InitializeObjectAttributes( &ObjectAttributes, NULL, 0, NULL, NULL ); 01342 01343 if (!NT_SUCCESS(PsCreateSystemThread( 01344 &ThreadHandle, 01345 THREAD_ALL_ACCESS, 01346 &ObjectAttributes, 01347 0L, 01348 NULL, 01349 MiModifiedPageWriter, 01350 NULL 01351 ))) { 01352 return FALSE; 01353 } 01354 ZwClose (ThreadHandle); 01355 01356 // 01357 // Start the balance set manager. 01358 // 01359 // The balance set manager performs stack swapping and working 01360 // set management and requires two threads. 01361 // 01362 01363 KeInitializeEvent (&MmWorkingSetManagerEvent, 01364 SynchronizationEvent, 01365 FALSE); 01366 01367 InitializeObjectAttributes( &ObjectAttributes, NULL, 0, NULL, NULL ); 01368 01369 if (!NT_SUCCESS(PsCreateSystemThread( 01370 &ThreadHandle, 01371 THREAD_ALL_ACCESS, 01372 &ObjectAttributes, 01373 0L, 01374 NULL, 01375 KeBalanceSetManager, 01376 NULL 01377 ))) { 01378 01379 return FALSE; 01380 } 01381 ZwClose (ThreadHandle); 01382 01383 if (!NT_SUCCESS(PsCreateSystemThread( 01384 &ThreadHandle, 01385 THREAD_ALL_ACCESS, 01386 &ObjectAttributes, 01387 0L, 01388 NULL, 01389 KeSwapProcessOrStack, 01390 NULL 01391 ))) { 01392 01393 return FALSE; 01394 } 01395 ZwClose (ThreadHandle); 01396 01397 #ifndef NO_POOL_CHECKS 01398 MiInitializeSpecialPoolCriteria (); 01399 #endif 01400 01401 #if defined(_X86_) 01402 MiEnableKernelVerifier (); 01403 #endif 01404 01405 ExAcquireResourceExclusive (&PsLoadedModuleResource, TRUE); 01406 01407 NextEntry = PsLoadedModuleList.Flink; 01408 01409 for ( ; NextEntry != &PsLoadedModuleList; NextEntry = NextEntry->Flink) { 01410 01411 DataTableEntry = CONTAINING_RECORD(NextEntry, 01412 LDR_DATA_TABLE_ENTRY, 01413 InLoadOrderLinks); 01414 01415 NtHeaders = RtlImageNtHeader(DataTableEntry->DllBase); 01416 01417 if ((NtHeaders->OptionalHeader.MajorOperatingSystemVersion >= 5) && 01418 (NtHeaders->OptionalHeader.MajorImageVersion >= 5)) { 01419 DataTableEntry->Flags |= LDRP_ENTRY_NATIVE; 01420 } 01421 01422 MiWriteProtectSystemImage (DataTableEntry->DllBase); 01423 } 01424 ExReleaseResource (&PsLoadedModuleResource); 01425 01426 InterlockedDecrement (&MiTrimInProgressCount); 01427 01428 return TRUE; 01429 } 01430 01431 if (Phase == 2) { 01432 MiEnablePagingTheExecutive(); 01433 return TRUE; 01434 } 01435 01436 return FALSE; 01437 }

NTKERNELAPI BOOLEAN MmIsThisAnNtAsSystem (  VOID   )

Definition at line 3087 of file mminit.c. References MmProductType. Referenced by CcInitializeCacheManager(), ExpWorkerInitialization(), ExpWorkerThread(), FsRtlInitializeTunnels(), IoInitSystem(), MiBuildPagedPool(), ObInitSystem(), and PsChangeQuantumTable(). { return (BOOLEAN)MmProductType; }

MM_SYSTEMSIZE MmQuerySystemSize (  VOID   )

Definition at line 3073 of file mminit.c. References MmSystemSize. Referenced by CcAllocateInitializeBcb(), CcInitializeCacheManager(), ExInitializeRegion(), ExpWorkerInitialization(), IoInitSystem(), KeBalanceSetManager(), ObInitSystem(), PspInitPhase0(), and UdfInitializeGlobalData(). { // // 12Mb is small // 12-19 is medium // > 19 is large // return MmSystemSize; }

NTKERNELAPI VOID FASTCALL MmSetHardFaultNotifyRoutine (  PHARD_FAULT_NOTIFY_ROUTINE  NotifyRoutine  )

Definition at line 3107 of file mminit.c. References MmHardFaultNotifyRoutine. { MmHardFaultNotifyRoutine = NotifyRoutine; }

NTKERNELAPI VOID FASTCALL MmSetPageFaultNotifyRoutine (  PPAGE_FAULT_NOTIFY_ROUTINE  NotifyRoutine  )

Definition at line 3097 of file mminit.c. References MmPageFaultNotifyRoutine. { MmPageFaultNotifyRoutine = NotifyRoutine; }

---

Variable Documentation

PVOID BBTBuffer

Definition at line 34 of file mminit.c. Referenced by MiMapBBTMemory(), and MmCreateTeb().

ULONG BBTPagesToReserve

Definition at line 35 of file mminit.c. Referenced by MiMapBBTMemory(), and MmInitSystem().

KEVENT MiMappedPagesTooOldEvent

Definition at line 131 of file mminit.c. Referenced by MiModifiedPageWriterTimerDispatch(), MiModifiedPageWriterWorker(), and MmInitSystem().

LARGE_INTEGER MiModifiedPageLife

Definition at line 127 of file mminit.c. Referenced by MiInsertPageInList(), MiModifiedPageWriterWorker(), and MmInitSystem().

KTIMER MiModifiedPageWriterTimer

Definition at line 135 of file mminit.c. Referenced by MiInsertPageInList(), MiModifiedPageWriterWorker(), and MmInitSystem().

KDPC MiModifiedPageWriterTimerDpc

Definition at line 133 of file mminit.c. Referenced by MiInsertPageInList(), MiModifiedPageWriterWorker(), and MmInitSystem().

CHAR MiPteStr[]

Definition at line 155 of file mminit.c. Referenced by MiSetSystemCodeProtection(), and MmInitSystem().

ULONG MiSpecialPoolPtes

Definition at line 31 of file mminit.c. Referenced by MiEnablePagingTheExecutive(), MiInitializeSpecialPool(), MmAllocateSpecialPool(), and MmProtectSpecialPool().

BOOLEAN MiTimerPending = FALSE

Definition at line 129 of file mminit.c. Referenced by MiInsertPageInList(), MiModifiedPageWriterTimerDispatch(), and MiModifiedPageWriterWorker().

LONG MiTrimInProgressCount

Definition at line 157 of file mminit.c. Referenced by MmInitSystem(), and MmTrimAllSystemPagableMemory().

ULONG MmCodeClusterSize

Definition at line 40 of file mminit.c. Referenced by MiResolveMappedFileFault(), and MmInitSystem().

ULONG MmDataClusterSize

Definition at line 39 of file mminit.c. Referenced by MiResolveMappedFileFault(), and MmInitSystem().

ULONG MmEnforceWriteProtection

Definition at line 153 of file mminit.c.

MMEVENT_COUNT_LIST MmEventCountList

Definition at line 28 of file mminit.c. Referenced by MiFlushEventCounter(), MiFreeEventCounter(), MiGetEventCounter(), and MmInitSystem().

PHARD_FAULT_NOTIFY_ROUTINE MmHardFaultNotifyRoutine

Definition at line 180 of file mminit.c. Referenced by MiDispatchFault(), MmInitSystem(), and MmSetHardFaultNotifyRoutine().

KEVENT MmImageMappingPteEvent

Definition at line 42 of file mminit.c. Referenced by MiMapImageHeaderInHyperSpace(), and MmInitSystem().

MMINPAGE_SUPPORT_LIST MmInPageSupportList

Definition at line 27 of file mminit.c. Referenced by MiFlushInPageSupportBlock(), MiFreeInPageSupportBlock(), MiGetInPageSupportBlock(), and MmInitSystem().

ULONG MmLargeSystemCache

Definition at line 174 of file mminit.c.

LIST_ENTRY MmLoadedUserImageList

Definition at line 178 of file mminit.c.

LIST_ENTRY MmLockConflictList

Definition at line 44 of file mminit.c. Referenced by MiCheckForUserStackOverflow(), MiInsertConflictInList(), and MmInitSystem().

ULONG MmMaximumWorkingSetSize

Definition at line 151 of file mminit.c.

ULONG MmModifiedPageLifeInSeconds = 300

Definition at line 125 of file mminit.c. Referenced by MmInitSystem().

ULONG MmPagedPoolCommit

Definition at line 32 of file mminit.c.

LOGICAL MmPagedPoolMaximumDesired = FALSE

Definition at line 45 of file mminit.c.

PPAGE_FAULT_NOTIFY_ROUTINE MmPageFaultNotifyRoutine

Definition at line 179 of file mminit.c. Referenced by MmAccessFault(), MmInitSystem(), and MmSetPageFaultNotifyRoutine().

PPHYSICAL_MEMORY_DESCRIPTOR MmPhysicalMemoryBlock

Definition at line 43 of file mminit.c. Referenced by IopCreateSummaryDump(), IopDeleteNonExistentMemory(), IopInitializeDCB(), IopInitializeResourceMap(), IopInitializeSummaryDump(), IopReadDumpRegistry(), MiCheckForCrashDump(), MiEnsureAvailablePageOrWait(), MiFindContiguousMemory(), MmAddPhysicalMemory(), MmAllocatePagesForMdl(), MmGetPhysicalMemoryRanges(), MmInitSystem(), and MmRemovePhysicalMemory().

ULONG MmProductType

Definition at line 176 of file mminit.c.

PFN_NUMBER MmResidentAvailableAtInit

Definition at line 41 of file mminit.c. Referenced by MmInitSystem().

MMPTE MmSharedUserDataPte

Definition at line 25 of file mminit.c. Referenced by MiCheckVirtualAddress(), and MmInitSystem().

ULONG_PTR MmSubsectionBase

Definition at line 37 of file mminit.c.

ULONG_PTR MmSubsectionTopPage

Definition at line 38 of file mminit.c. Referenced by MiAllocatePoolPages(), and MiInitMachineDependent().

KMUTANT MmSystemLoadLock

Definition at line 29 of file mminit.c.

PFN_NUMBER MmSystemPageDirectory

Definition at line 162 of file mminit.c. Referenced by MiAllocatePoolPages(), MiBuildPagedPool(), and MiFillSystemPageDirectory().

PMMPTE MmSystemPagePtes

Definition at line 167 of file mminit.c. Referenced by MiAllocatePoolPages(), MiBuildPagedPool(), MiCheckPdeForPagedPool(), MiFillSystemPageDirectory(), and MiRemoveMappedPtes().

ULONG_PTR MmSystemPtesStart[MaximumPtePoolTypes]

Definition at line 30 of file mminit.c.

MM_SYSTEMSIZE MmSystemSize

Definition at line 172 of file mminit.c. Referenced by MmInitSystem(), MmQuerySystemSize(), and MmSetMemoryPriorityProcess().

ULONG MmTotalSystemCodePages

Definition at line 170 of file mminit.c. Referenced by MiEnablePagingOfDriverAtInit(), and NtQuerySystemInformation().

PERFINFO_MMINIT_DECL

Definition at line 47 of file mminit.c.

---