allocpag.c File Reference

#include "mi.h"

Go to the source code of this file.

Classes
struct	_MI_BAD_TAGS
Defines
#define	MM_SMALL_ALLOCATIONS   4
#define	MI_MEMORY_MAKER(Thread)
#define	MI_THREE_SECONDS   3
#define	MiInsertContiguousTag(a, b, c)
Typedefs
typedef _MI_BAD_TAGS	MI_BAD_TAGS
typedef _MI_BAD_TAGS *	PMI_BAD_TAGS
Functions
VOID	MiInitializeSpecialPool (VOID)
VOID	MiInitializeSpecialPoolCriteria (IN VOID)
VOID	MiSpecialPoolTimerDispatch (IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
PVOID	MmSqueezeBadTags (IN SIZE_T NumberOfBytes, IN ULONG Tag, IN POOL_TYPE PoolType, IN ULONG SpecialPoolType)
LOGICAL	MmSetSpecialPool (IN LOGICAL Enable)
PVOID	MiAllocateSpecialPool (IN SIZE_T NumberOfBytes, IN ULONG Tag, IN POOL_TYPE PoolType, IN ULONG SpecialPoolType)
VOID	MmFreeSpecialPool (IN PVOID P)
LOGICAL	MiProtectSpecialPool (IN PVOID VirtualAddress, IN ULONG NewProtect)
VOID	MiMakeSpecialPoolPagable (IN PVOID VirtualAddress, IN PMMPTE PointerPte)
VOID	MiProtectFreeNonPagedPool (IN PVOID VirtualAddress, IN ULONG SizeInPages)
LOGICAL	MiUnProtectFreeNonPagedPool (IN PVOID VirtualAddress, IN ULONG SizeInPages)
VOID	MiProtectedPoolInsertList (IN PLIST_ENTRY ListHead, IN PLIST_ENTRY Entry, IN LOGICAL InsertHead)
VOID	MiProtectedPoolRemoveEntryList (IN PLIST_ENTRY Entry)
POOL_TYPE	MmDeterminePoolType (IN PVOID VirtualAddress)
PVOID	MiSessionPoolVector (VOID)
VOID	MiSessionPoolAllocated (IN PVOID VirtualAddress, IN SIZE_T NumberOfBytes, IN POOL_TYPE PoolType)
VOID	MiSessionPoolFreed (IN PVOID VirtualAddress, IN SIZE_T NumberOfBytes, IN POOL_TYPE PoolType)
LOGICAL	MmResourcesAvailable (IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN EX_POOL_PRIORITY Priority)
VOID	MiFreeNonPagedPool (IN PVOID StartingAddress, IN PFN_NUMBER NumberOfPages)
PVOID	MiAllocatePoolPages (IN POOL_TYPE PoolType, IN SIZE_T SizeInBytes, IN ULONG IsLargeSessionAllocation)
ULONG	MiFreePoolPages (IN PVOID StartingAddress)
VOID	MiInitializeNonPagedPool (VOID)
SIZE_T	MmQuerySpecialPoolBlockSize (IN PVOID P)
VOID	MiInitializeSpecialPoolCriteria (VOID)
VOID	MiEnableRandomSpecialPool (IN LOGICAL Enable)
PVOID	MmAllocateSpecialPool (IN SIZE_T NumberOfBytes, IN ULONG Tag, IN POOL_TYPE PoolType, IN ULONG SpecialPoolType)
VOID	MiCheckSessionPoolAllocations (VOID)
NTSTATUS	MiInitializeSessionPool (VOID)
VOID	MiFreeSessionPoolBitMaps (VOID)
PVOID	MiFindContiguousMemory (IN PFN_NUMBER LowestPfn, IN PFN_NUMBER HighestPfn, IN PFN_NUMBER BoundaryPfn, IN PFN_NUMBER SizeInPages, IN PVOID CallingAddress)
LOGICAL	MmIsHydraAddress (IN PVOID VirtualAddress)
LOGICAL	MmIsSpecialPoolAddressFree (IN PVOID VirtualAddress)
LOGICAL	MmProtectSpecialPool (IN PVOID VirtualAddress, IN ULONG NewProtect)
Variables
ULONG	MmPagedPoolCommit
PFN_NUMBER	MmAllocatedNonPagedPool
PFN_NUMBER	MiEndOfInitialPoolFrame
PVOID	MmNonPagedPoolExpansionStart
LIST_ENTRY	MmNonPagedPoolFreeListHead [MI_MAX_FREE_LIST_HEADS]
POOL_DESCRIPTOR	NonPagedPoolDescriptor
LOGICAL	MmPagedPoolMaximumDesired
ULONG	MmUnusedSegmentForceFree
ULONG	MmSpecialPoolTag
PVOID	MmSpecialPoolStart
PVOID	MmSpecialPoolEnd
ULONG	MmSpecialPoolRejected [5]
LOGICAL	MmSpecialPoolCatchOverruns = TRUE
PMMPTE	MiSpecialPoolFirstPte
PMMPTE	MiSpecialPoolLastPte
ULONG	MiSpecialPagesNonPaged
ULONG	MiSpecialPagesPagable
ULONG	MmSpecialPagesInUse
ULONG	MiSpecialPagesNonPagedPeak
ULONG	MiSpecialPagesPagablePeak
ULONG	MiSpecialPagesInUsePeak
ULONG	MiSpecialPagesNonPagedMaximum
ULONG	MiSpecialPoolPtes
LOGICAL	MiSpecialPoolEnabled = TRUE
MI_BAD_TAGS	MiBadTags
KTIMER	MiSpecialPoolTimer
KDPC	MiSpecialPoolTimerDpc
LARGE_INTEGER	MiTimerDueTime
ULONG	InitializationPhase

---

Define Documentation

#define MI_MEMORY_MAKER (  Thread   )

Value: ((Thread->StartAddress == (PVOID)MiModifiedPageWriter) || \ (Thread->StartAddress == (PVOID)MiMappedPageWriter) || \ (Thread->StartAddress == (PVOID)MiDereferenceSegmentThread)) Definition at line 143 of file allocpag.c. Referenced by MiAllocatePoolPages(), and MmResourcesAvailable().

#define MI_THREE_SECONDS   3

Definition at line 3197 of file allocpag.c. Referenced by MiInitializeSpecialPoolCriteria().

#define MiInsertContiguousTag (  a, b, c   )

Definition at line 4564 of file allocpag.c. Referenced by MiFindContiguousMemory().

#define MM_SMALL_ALLOCATIONS   4

Definition at line 122 of file allocpag.c. Referenced by MiFreePoolPages().

---

Typedef Documentation

typedef struct _MI_BAD_TAGS MI_BAD_TAGS

typedef struct _MI_BAD_TAGS * PMI_BAD_TAGS

---

Function Documentation

PVOID MiAllocatePoolPages (  IN POOL_TYPE  PoolType, IN SIZE_T  SizeInBytes, IN ULONG  IsLargeSessionAllocation )

Definition at line 807 of file allocpag.c. References ActiveAndValid, _MM_PAGED_POOL_INFO::AllocatedPagedPool, ASSERT, BASE_POOL_TYPE_MASK, BYTES_TO_PAGES, _MM_SESSION_SPACE::CommittedPages, CONSISTENCY_LOCK_PFN2, CONSISTENCY_UNLOCK_PFN2, DbgPrint, _MM_PAGED_POOL_INFO::EndOfPagedPoolBitmap, FALSE, _MMWSL::FirstDynamic, _MM_PAGED_POOL_INFO::FirstPteForPagedPool, Index, KeBugCheckEx(), KeSetEvent(), KSEG0_BASE, KSEG2_BASE, L, _MM_PAGED_POOL_INFO::LastPteForPagedPool, _MMFREE_POOL_ENTRY::List, List, LOCK_PFN, LOCK_PFN2, LOCK_SESSION_SPACE_WS, MI_CONVERT_PHYSICAL_TO_PFN, MI_GET_PAGE_COLOR_FROM_PTE, MI_GET_PAGE_FRAME_FROM_PTE, MI_IS_PHYSICAL_ADDRESS, MI_MAX_FREE_LIST_HEADS, MI_MEMORY_MAKER, MI_PFN_ELEMENT, MI_UNUSED_SEGMENTS_SURPLUS, MI_WRITE_VALID_PTE, MiAddValidPageToWorkingSet(), MiChargeCommitmentCantExpand(), MiFillMemoryPte, MiFreeNonPagedPool(), MiGetPdeAddress, MiGetPteAddress, MiGetVirtualAddressMappedByPte, MiInitializePfn(), MiInitializePfnForOtherProcess(), MiIssuePageExtendRequestNoWait(), MiLocateWsle(), MiProtectedPoolInsertList(), MiProtectedPoolRemoveEntryList(), MiProtectFreeNonPagedPool(), MiRemoveAnyPage(), MiReserveSystemPtes(), MiSessionPoolAllocated(), MiSwapWslEntries(), MiUnProtectFreeNonPagedPool(), MM_BUMP_COUNTER, MM_BUMP_SESS_COUNTER, MM_DBG_COMMIT_NONPAGED_POOL_EXPANSION, MM_DBG_COMMIT_PAGED_POOL_PAGES, MM_DBG_COMMIT_PAGED_POOL_PAGETABLE, MM_DBG_SESSION_COMMIT_PAGEDPOOL_PAGES, MM_DBG_SESSION_PAGEDPOOL_PAGETABLE_ALLOC1, MM_DEMAND_ZERO_WRITE_PTE, MM_FREE_POOL_SIGNATURE, MM_KERNEL_DEMAND_ZERO_PTE, MM_KERNEL_NOACCESS_PTE, MM_KSEG2_BASE, MM_TRACK_COMMIT, MmAllocatedNonPagedPool, MmAvailablePages, MMFREE_POOL_ENTRY, MmKseg2Frame, MmNonPagedMustSucceed, MmNonPagedPoolExpansionStart, MmNonPagedPoolFreeListHead, MmNumberOfFreeNonPagedPool, MmPageAlignedPoolBase, MmPagedPoolCommit, MmPagedPoolInfo, MmProtectFreedNonPagedPool, MmResidentAvailablePages, MmSessionBase, MmSessionSpace, MmSubsectionBase, MmSubsectionTopPage, MmSystemPageDirectory, MmSystemPagePtes, MmUnusedSegmentCleanup, MmUnusedSegmentForceFree, MmUnusedSegmentList, MUST_SUCCEED_POOL_TYPE_MASK, _MM_PAGED_POOL_INFO::NextPdeForPagedPoolExpansion, _MM_SESSION_SPACE::NonPagablePages, NonPagedPool, NonPagedPoolDescriptor, NonPagedPoolExpansion, NULL, _MMPFN::OriginalPte, PAGE_SHIFT, PAGE_SIZE, PagedPool, _MM_PAGED_POOL_INFO::PagedPoolAllocationMap, _MM_PAGED_POOL_INFO::PagedPoolCommit, _MM_PAGED_POOL_INFO::PagedPoolHint, _MM_SESSION_SPACE::PagedPoolInfo, _MM_PAGED_POOL_INFO::PagedPoolLargeSessionAllocationMap, _MM_SESSION_SPACE::PagedPoolStart, _MM_SESSION_SPACE::PageTables, PDE_PER_PAGE, PMM_PAGED_POOL_INFO, PMMFREE_POOL_ENTRY, POOL_VERIFIER_MASK, PsGetCurrentThread, PTE_PER_PAGE, _MMPFN::PteAddress, _MMPFN::PteFrame, RtlClearBits(), RtlFindClearBitsAndSet(), RtlSetBits(), SESSION_POOL_MASK, _MM_SESSION_SPACE::SessionPageDirectoryIndex, _MMFREE_POOL_ENTRY::Signature, _MMFREE_POOL_ENTRY::Size, _POOL_DESCRIPTOR::TotalBigPages, _POOL_DESCRIPTOR::TotalPages, TRUE, _MMPTE::u, _MMWSLE::u1, _MMPFN::u1, _MMPFN::u2, _MMPFN::u3, UNLOCK_PFN, UNLOCK_PFN2, UNLOCK_SESSION_SPACE_WS, ValidKernelPde, ValidKernelPdeLocal, ValidKernelPte, VerifierLargePagedPoolMap, _MM_SESSION_SPACE::Vm, _MMSUPPORT::VmWorkingSetList, and _MM_SESSION_SPACE::Wsle. Referenced by AllocatePoolInternal(), ExAllocatePool(), ExAllocatePoolWithTag(), ExpAddTagForBigPages(), ExpInsertPoolTracker(), InitializePool(), and MiInitializeSystemPtes(). 00815 : 00816 00817 This function allocates a set of pages from the specified pool 00818 - and returns the starting virtual address to the caller. 00819 00820 For the NonPagedPoolMustSucceed case, the caller must first 00821 attempt to get NonPagedPool and if and ONLY IF that fails, then 00822 MiAllocatePoolPages should be called again with the PoolType of 00823 NonPagedPoolMustSucceed. 00824 00825 Arguments: 00826 00827 PoolType - Supplies the type of pool from which to obtain pages. 00828 00829 SizeInBytes - Supplies the size of the request in bytes. The actual 00830 size returned is rounded up to a page boundary. 00831 00832 IsLargeSessionAllocation - Supplies nonzero if the allocation is a single 00833 large session allocation. Zero otherwise. 00834 00835 Return Value: 00836 00837 Returns a pointer to the allocated pool, or NULL if no more pool is 00838 available. 00839 00840 Environment: 00841 00842 These functions are used by the general pool allocation routines 00843 and should not be called directly. 00844 00845 Mutexes guarding the pool databases must be held when calling 00846 these functions. 00847 00848 Kernel mode, IRQL at DISPATCH_LEVEL. 00849 00850 --*/ 00851 00852 { 00853 PFN_NUMBER SizeInPages; 00854 ULONG StartPosition; 00855 ULONG EndPosition; 00856 PMMPTE StartingPte; 00857 PMMPTE PointerPte; 00858 PMMPFN Pfn1; 00859 MMPTE TempPte; 00860 PFN_NUMBER PageFrameIndex; 00861 PVOID BaseVa; 00862 KIRQL OldIrql; 00863 KIRQL SessionIrql; 00864 PFN_NUMBER i; 00865 PLIST_ENTRY Entry; 00866 PMMFREE_POOL_ENTRY FreePageInfo; 00867 PMM_SESSION_SPACE SessionSpace; 00868 PMM_PAGED_POOL_INFO PagedPoolInfo; 00869 PVOID VirtualAddress; 00870 ULONG Index; 00871 PMMPTE SessionPte; 00872 ULONG WsEntry; 00873 ULONG WsSwapEntry; 00874 ULONG PageTableCount; 00875 LOGICAL FreedPool; 00876 LOGICAL SignalDereferenceThread; 00877 PETHREAD Thread; 00878 00879 SizeInPages = BYTES_TO_PAGES (SizeInBytes); 00880 00881 #if DBG 00882 if (MmCheckRequestInPages != 0) { 00883 ASSERT (SizeInPages < MmCheckRequestInPages); 00884 } 00885 #endif 00886 00887 if (PoolType & MUST_SUCCEED_POOL_TYPE_MASK) { 00888 00889 // 00890 // Pool expansion failed, see if any Must Succeed 00891 // pool is still left. 00892 // 00893 00894 if (MmNonPagedMustSucceed == NULL) { 00895 00896 // 00897 // No more pool exists. Bug Check. 00898 // 00899 00900 KeBugCheckEx (MUST_SUCCEED_POOL_EMPTY, 00901 SizeInBytes, 00902 NonPagedPoolDescriptor.TotalPages, 00903 NonPagedPoolDescriptor.TotalBigPages, 00904 MmAvailablePages); 00905 } 00906 00907 // 00908 // Remove a page from the must succeed pool. More than one is illegal. 00909 // 00910 00911 if (SizeInBytes > PAGE_SIZE) { 00912 KeBugCheckEx (BAD_POOL_CALLER, 00913 0x98, 00914 (ULONG_PTR)SizeInBytes, 00915 (ULONG_PTR)SizeInPages, 00916 PoolType); 00917 } 00918 00919 BaseVa = MmNonPagedMustSucceed; 00920 00921 if (IsLargeSessionAllocation != 0) { 00922 00923 // 00924 // Mark this as a large session allocation in the PFN database. 00925 // 00926 00927 if (MI_IS_PHYSICAL_ADDRESS(BaseVa)) { 00928 PageFrameIndex = MI_CONVERT_PHYSICAL_TO_PFN (BaseVa); 00929 } else { 00930 PointerPte = MiGetPteAddress(BaseVa); 00931 ASSERT (PointerPte->u.Hard.Valid == 1); 00932 PageFrameIndex = MI_GET_PAGE_FRAME_FROM_PTE (PointerPte); 00933 } 00934 Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); 00935 00936 ASSERT (Pfn1->u3.e1.LargeSessionAllocation == 0); 00937 00938 CONSISTENCY_LOCK_PFN2 (OldIrql); 00939 00940 Pfn1->u3.e1.LargeSessionAllocation = 1; 00941 00942 CONSISTENCY_UNLOCK_PFN2 (OldIrql); 00943 00944 MiSessionPoolAllocated (BaseVa, PAGE_SIZE, NonPagedPool); 00945 } 00946 else if (PoolType & POOL_VERIFIER_MASK) { 00947 00948 if (MI_IS_PHYSICAL_ADDRESS(BaseVa)) { 00949 PageFrameIndex = MI_CONVERT_PHYSICAL_TO_PFN (BaseVa); 00950 } else { 00951 PointerPte = MiGetPteAddress(BaseVa); 00952 ASSERT (PointerPte->u.Hard.Valid == 1); 00953 PageFrameIndex = MI_GET_PAGE_FRAME_FROM_PTE (PointerPte); 00954 } 00955 00956 Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); 00957 00958 ASSERT (Pfn1->u3.e1.VerifierAllocation == 0); 00959 Pfn1->u3.e1.VerifierAllocation = 1; 00960 } 00961 00962 MmNonPagedMustSucceed = (PVOID)(*(PULONG_PTR)BaseVa); 00963 return BaseVa; 00964 } 00965 00966 if ((PoolType & BASE_POOL_TYPE_MASK) == NonPagedPool) { 00967 00968 Index = (ULONG)(SizeInPages - 1); 00969 00970 if (Index >= MI_MAX_FREE_LIST_HEADS) { 00971 Index = MI_MAX_FREE_LIST_HEADS - 1; 00972 } 00973 00974 // 00975 // NonPaged pool is linked together through the pages themselves. 00976 // 00977 00978 while (Index < MI_MAX_FREE_LIST_HEADS) { 00979 00980 Entry = MmNonPagedPoolFreeListHead[Index].Flink; 00981 00982 while (Entry != &MmNonPagedPoolFreeListHead[Index]) { 00983 00984 if (MmProtectFreedNonPagedPool == TRUE) { 00985 MiUnProtectFreeNonPagedPool ((PVOID)Entry, 0); 00986 } 00987 00988 // 00989 // The list is not empty, see if this one has enough space. 00990 // 00991 00992 FreePageInfo = CONTAINING_RECORD(Entry, 00993 MMFREE_POOL_ENTRY, 00994 List); 00995 00996 ASSERT (FreePageInfo->Signature == MM_FREE_POOL_SIGNATURE); 00997 if (FreePageInfo->Size >= SizeInPages) { 00998 00999 // 01000 // This entry has sufficient space, remove 01001 // the pages from the end of the allocation. 01002 // 01003 01004 FreePageInfo->Size -= SizeInPages; 01005 01006 BaseVa = (PVOID)((PCHAR)FreePageInfo + 01007 (FreePageInfo->Size << PAGE_SHIFT)); 01008 01009 if (MmProtectFreedNonPagedPool == FALSE) { 01010 RemoveEntryList (&FreePageInfo->List); 01011 } 01012 else { 01013 MiProtectedPoolRemoveEntryList (&FreePageInfo->List); 01014 } 01015 01016 if (FreePageInfo->Size != 0) { 01017 01018 // 01019 // Insert any remainder into the correct list. 01020 // 01021 01022 Index = (ULONG)(FreePageInfo->Size - 1); 01023 if (Index >= MI_MAX_FREE_LIST_HEADS) { 01024 Index = MI_MAX_FREE_LIST_HEADS - 1; 01025 } 01026 01027 if (MmProtectFreedNonPagedPool == FALSE) { 01028 InsertTailList (&MmNonPagedPoolFreeListHead[Index], 01029 &FreePageInfo->List); 01030 } 01031 else { 01032 MiProtectedPoolInsertList (&MmNonPagedPoolFreeListHead[Index], 01033 &FreePageInfo->List, 01034 FALSE); 01035 01036 MiProtectFreeNonPagedPool ((PVOID)FreePageInfo, 01037 (ULONG)FreePageInfo->Size); 01038 } 01039 } 01040 01041 // 01042 // Adjust the number of free pages remaining in the pool. 01043 // 01044 01045 MmNumberOfFreeNonPagedPool -= SizeInPages; 01046 ASSERT ((LONG)MmNumberOfFreeNonPagedPool >= 0); 01047 01048 // 01049 // Mark start and end of allocation in the PFN database. 01050 // 01051 01052 if (MI_IS_PHYSICAL_ADDRESS(BaseVa)) { 01053 01054 // 01055 // On certain architectures, virtual addresses 01056 // may be physical and hence have no corresponding PTE. 01057 // 01058 01059 PageFrameIndex = MI_CONVERT_PHYSICAL_TO_PFN (BaseVa); 01060 } else { 01061 PointerPte = MiGetPteAddress(BaseVa); 01062 ASSERT (PointerPte->u.Hard.Valid == 1); 01063 PageFrameIndex = MI_GET_PAGE_FRAME_FROM_PTE (PointerPte); 01064 } 01065 Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); 01066 01067 ASSERT (Pfn1->u3.e1.StartOfAllocation == 0); 01068 ASSERT (Pfn1->u3.e1.VerifierAllocation == 0); 01069 01070 CONSISTENCY_LOCK_PFN2 (OldIrql); 01071 01072 Pfn1->u3.e1.StartOfAllocation = 1; 01073 01074 if (PoolType & POOL_VERIFIER_MASK) { 01075 Pfn1->u3.e1.VerifierAllocation = 1; 01076 } 01077 01078 CONSISTENCY_UNLOCK_PFN2 (OldIrql); 01079 01080 // 01081 // Mark this as a large session allocation in the PFN database. 01082 // 01083 01084 if (IsLargeSessionAllocation != 0) { 01085 ASSERT (Pfn1->u3.e1.LargeSessionAllocation == 0); 01086 01087 CONSISTENCY_LOCK_PFN2 (OldIrql); 01088 01089 Pfn1->u3.e1.LargeSessionAllocation = 1; 01090 01091 CONSISTENCY_UNLOCK_PFN2 (OldIrql); 01092 01093 MiSessionPoolAllocated (BaseVa, 01094 SizeInPages << PAGE_SHIFT, 01095 NonPagedPool); 01096 } 01097 01098 // 01099 // Calculate the ending PTE's address. 01100 // 01101 01102 if (SizeInPages != 1) { 01103 if (MI_IS_PHYSICAL_ADDRESS(BaseVa)) { 01104 Pfn1 += SizeInPages - 1; 01105 } else { 01106 PointerPte += SizeInPages - 1; 01107 ASSERT (PointerPte->u.Hard.Valid == 1); 01108 Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); 01109 } 01110 } 01111 else if (MmProtectFreedNonPagedPool == FALSE) { 01112 01113 // 01114 // Map this with KSEG0 if possible. 01115 // 01116 #if defined (_X86_) 01117 if ((BaseVa > (PVOID)MM_KSEG2_BASE) && 01118 (PageFrameIndex >= MI_CONVERT_PHYSICAL_TO_PFN(MmSubsectionBase)) && 01119 (PageFrameIndex < MmSubsectionTopPage) && 01120 (MmKseg2Frame != 0)) 01121 #elif defined (_ALPHA_) 01122 if ((BaseVa > (PVOID)KSEG2_BASE) && 01123 (PageFrameIndex >= MI_CONVERT_PHYSICAL_TO_PFN(MmSubsectionBase)) && 01124 (PageFrameIndex < MmSubsectionTopPage)) 01125 #else 01126 if ((BaseVa > (PVOID)KSEG2_BASE) && 01127 (PageFrameIndex < MmSubsectionTopPage)) 01128 #endif 01129 { 01130 BaseVa = (PVOID)(KSEG0_BASE + (PageFrameIndex << PAGE_SHIFT)); 01131 } 01132 } 01133 01134 ASSERT (Pfn1->u3.e1.EndOfAllocation == 0); 01135 01136 CONSISTENCY_LOCK_PFN2 (OldIrql); 01137 01138 Pfn1->u3.e1.EndOfAllocation = 1; 01139 01140 CONSISTENCY_UNLOCK_PFN2 (OldIrql); 01141 01142 MmAllocatedNonPagedPool += SizeInPages; 01143 return BaseVa; 01144 } 01145 01146 Entry = FreePageInfo->List.Flink; 01147 01148 if (MmProtectFreedNonPagedPool == TRUE) { 01149 MiProtectFreeNonPagedPool ((PVOID)FreePageInfo, 01150 (ULONG)FreePageInfo->Size); 01151 } 01152 } 01153 Index += 1; 01154 } 01155 01156 // 01157 // No more entries on the list, expand nonpaged pool if 01158 // possible to satisfy this request. 01159 // 01160 01161 // 01162 // Check to see if there are too many unused segments laying 01163 // around. If so, set an event so they get deleted. 01164 // 01165 01166 if (MI_UNUSED_SEGMENTS_SURPLUS()) { 01167 KeSetEvent (&MmUnusedSegmentCleanup, 0, FALSE); 01168 } 01169 01170 LOCK_PFN2 (OldIrql); 01171 01172 // 01173 // Make sure we have 1 more than the number of pages 01174 // requested available. 01175 // 01176 01177 if (MmAvailablePages <= SizeInPages) { 01178 01179 UNLOCK_PFN2 (OldIrql); 01180 01181 // 01182 // There are no free physical pages to expand 01183 // nonpaged pool. 01184 // 01185 01186 return NULL; 01187 } 01188 01189 // 01190 // Try to find system PTEs to expand the pool into. 01191 // 01192 01193 StartingPte = MiReserveSystemPtes ((ULONG)SizeInPages, 01194 NonPagedPoolExpansion, 01195 0, 01196 0, 01197 FALSE); 01198 01199 if (StartingPte == NULL) { 01200 01201 // 01202 // There are no free physical PTEs to expand nonpaged pool. 01203 // If there are any cached expansion PTEs, free them now in 01204 // an attempt to get enough contiguous VA for our caller. 01205 // 01206 01207 if ((SizeInPages > 1) && (MmNumberOfFreeNonPagedPool != 0)) { 01208 01209 FreedPool = FALSE; 01210 01211 for (Index = 0; Index < MI_MAX_FREE_LIST_HEADS; Index += 1) { 01212 01213 Entry = MmNonPagedPoolFreeListHead[Index].Flink; 01214 01215 while (Entry != &MmNonPagedPoolFreeListHead[Index]) { 01216 01217 if (MmProtectFreedNonPagedPool == TRUE) { 01218 MiUnProtectFreeNonPagedPool ((PVOID)Entry, 0); 01219 } 01220 01221 // 01222 // The list is not empty, see if this one is virtually 01223 // mapped. 01224 // 01225 01226 FreePageInfo = CONTAINING_RECORD(Entry, 01227 MMFREE_POOL_ENTRY, 01228 List); 01229 01230 if ((!MI_IS_PHYSICAL_ADDRESS(FreePageInfo)) && 01231 ((PVOID)FreePageInfo >= MmNonPagedPoolExpansionStart)) { 01232 if (MmProtectFreedNonPagedPool == FALSE) { 01233 RemoveEntryList (&FreePageInfo->List); 01234 } 01235 else { 01236 MiProtectedPoolRemoveEntryList (&FreePageInfo->List); 01237 } 01238 01239 MmNumberOfFreeNonPagedPool -= FreePageInfo->Size; 01240 ASSERT ((LONG)MmNumberOfFreeNonPagedPool >= 0); 01241 01242 UNLOCK_PFN2 (OldIrql); 01243 01244 FreedPool = TRUE; 01245 01246 MiFreeNonPagedPool ((PVOID)FreePageInfo, 01247 FreePageInfo->Size); 01248 01249 LOCK_PFN2 (OldIrql); 01250 Index = 0; 01251 break; 01252 } 01253 01254 Entry = FreePageInfo->List.Flink; 01255 01256 if (MmProtectFreedNonPagedPool == TRUE) { 01257 MiProtectFreeNonPagedPool ((PVOID)FreePageInfo, 01258 (ULONG)FreePageInfo->Size); 01259 } 01260 } 01261 } 01262 01263 if (FreedPool == TRUE) { 01264 StartingPte = MiReserveSystemPtes ((ULONG)SizeInPages, 01265 NonPagedPoolExpansion, 01266 0, 01267 0, 01268 FALSE); 01269 01270 if (StartingPte != NULL) { 01271 goto gotpool; 01272 } 01273 } 01274 } 01275 01276 UNLOCK_PFN2 (OldIrql); 01277 01278 nopool: 01279 01280 // 01281 // Running low on pool - if this request is not for session pool, 01282 // force unused segment trimming when appropriate. 01283 // 01284 01285 SignalDereferenceThread = FALSE; 01286 LOCK_PFN2 (OldIrql); 01287 if (MmUnusedSegmentForceFree == 0) { 01288 if (!IsListEmpty(&MmUnusedSegmentList)) { 01289 SignalDereferenceThread = TRUE; 01290 MmUnusedSegmentForceFree = 30; 01291 } 01292 } 01293 UNLOCK_PFN2 (OldIrql); 01294 if (SignalDereferenceThread == TRUE) { 01295 KeSetEvent (&MmUnusedSegmentCleanup, 0, FALSE); 01296 } 01297 01298 return NULL; 01299 } 01300 01301 gotpool: 01302 01303 // 01304 // Update the count of available resident pages. 01305 // 01306 01307 MmResidentAvailablePages -= SizeInPages; 01308 MM_BUMP_COUNTER(0, SizeInPages); 01309 01310 // 01311 // Charge commitment as non paged pool uses physical memory. 01312 // 01313 01314 MM_TRACK_COMMIT (MM_DBG_COMMIT_NONPAGED_POOL_EXPANSION, SizeInPages); 01315 01316 MiChargeCommitmentCantExpand (SizeInPages, TRUE); 01317 01318 // 01319 // Expand the pool. 01320 // 01321 01322 PointerPte = StartingPte; 01323 TempPte = ValidKernelPte; 01324 MmAllocatedNonPagedPool += SizeInPages; 01325 i = SizeInPages; 01326 01327 do { 01328 PageFrameIndex = MiRemoveAnyPage ( 01329 MI_GET_PAGE_COLOR_FROM_PTE (PointerPte)); 01330 01331 Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); 01332 01333 Pfn1->u3.e2.ReferenceCount = 1; 01334 Pfn1->u2.ShareCount = 1; 01335 Pfn1->PteAddress = PointerPte; 01336 Pfn1->OriginalPte.u.Long = MM_DEMAND_ZERO_WRITE_PTE; 01337 Pfn1->PteFrame = MI_GET_PAGE_FRAME_FROM_PTE (MiGetPteAddress(PointerPte)); 01338 01339 Pfn1->u3.e1.PageLocation = ActiveAndValid; 01340 Pfn1->u3.e1.LargeSessionAllocation = 0; 01341 Pfn1->u3.e1.VerifierAllocation = 0; 01342 01343 TempPte.u.Hard.PageFrameNumber = PageFrameIndex; 01344 MI_WRITE_VALID_PTE (PointerPte, TempPte); 01345 PointerPte += 1; 01346 SizeInPages -= 1; 01347 } while (SizeInPages > 0); 01348 01349 Pfn1->u3.e1.EndOfAllocation = 1; 01350 01351 Pfn1 = MI_PFN_ELEMENT (StartingPte->u.Hard.PageFrameNumber); 01352 Pfn1->u3.e1.StartOfAllocation = 1; 01353 01354 ASSERT (Pfn1->u3.e1.VerifierAllocation == 0); 01355 01356 if (PoolType & POOL_VERIFIER_MASK) { 01357 Pfn1->u3.e1.VerifierAllocation = 1; 01358 } 01359 01360 // 01361 // Mark this as a large session allocation in the PFN database. 01362 // 01363 01364 ASSERT (Pfn1->u3.e1.LargeSessionAllocation == 0); 01365 01366 if (IsLargeSessionAllocation != 0) { 01367 Pfn1->u3.e1.LargeSessionAllocation = 1; 01368 01369 MiSessionPoolAllocated(MiGetVirtualAddressMappedByPte (StartingPte), 01370 i << PAGE_SHIFT, 01371 NonPagedPool); 01372 } 01373 01374 UNLOCK_PFN2 (OldIrql); 01375 01376 BaseVa = MiGetVirtualAddressMappedByPte (StartingPte); 01377 01378 if (i == 1) { 01379 01380 // 01381 // Map this with KSEG0 if possible. 01382 // 01383 01384 #if defined (_X86_) 01385 if ((PageFrameIndex >= MI_CONVERT_PHYSICAL_TO_PFN(MmSubsectionBase)) && 01386 (PageFrameIndex < MmSubsectionTopPage) && 01387 (MmKseg2Frame != 0)) 01388 #elif defined (_ALPHA_) 01389 if ((PageFrameIndex >= MI_CONVERT_PHYSICAL_TO_PFN(MmSubsectionBase)) && 01390 (PageFrameIndex < MmSubsectionTopPage)) 01391 #else 01392 if (PageFrameIndex < MmSubsectionTopPage) 01393 #endif 01394 { 01395 BaseVa = (PVOID)(KSEG0_BASE + (PageFrameIndex << PAGE_SHIFT)); 01396 } 01397 } 01398 01399 return BaseVa; 01400 } 01401 01402 // 01403 // Paged Pool. 01404 // 01405 01406 if ((PoolType & SESSION_POOL_MASK) == 0) { 01407 SessionSpace = (PMM_SESSION_SPACE)0; 01408 PagedPoolInfo = &MmPagedPoolInfo; 01409 } 01410 else { 01411 SessionSpace = MmSessionSpace; 01412 PagedPoolInfo = &SessionSpace->PagedPoolInfo; 01413 } 01414 01415 StartPosition = RtlFindClearBitsAndSet ( 01416 PagedPoolInfo->PagedPoolAllocationMap, 01417 (ULONG)SizeInPages, 01418 PagedPoolInfo->PagedPoolHint 01419 ); 01420 01421 if ((StartPosition == 0xFFFFFFFF) && (PagedPoolInfo->PagedPoolHint != 0)) { 01422 01423 if (MI_UNUSED_SEGMENTS_SURPLUS()) { 01424 KeSetEvent (&MmUnusedSegmentCleanup, 0, FALSE); 01425 } 01426 01427 // 01428 // No free bits were found, check from the start of 01429 // the bit map. 01430 01431 StartPosition = RtlFindClearBitsAndSet ( 01432 PagedPoolInfo->PagedPoolAllocationMap, 01433 (ULONG)SizeInPages, 01434 0 01435 ); 01436 } 01437 01438 // 01439 // If start position = -1, no room in pool. Attempt to expand PagedPool. 01440 // 01441 01442 if (StartPosition == 0xFFFFFFFF) { 01443 01444 // 01445 // Attempt to expand the paged pool. 01446 // 01447 01448 StartPosition = (((ULONG)SizeInPages - 1) / PTE_PER_PAGE) + 1; 01449 01450 // 01451 // Make sure there is enough space to create the prototype PTEs. 01452 // 01453 01454 if (((StartPosition - 1) + PagedPoolInfo->NextPdeForPagedPoolExpansion) > 01455 MiGetPteAddress (PagedPoolInfo->LastPteForPagedPool)) { 01456 01457 // 01458 // Can't expand pool any more. If this request is not for session 01459 // pool, force unused segment trimming when appropriate. 01460 // 01461 01462 if (SessionSpace == NULL) { 01463 goto nopool; 01464 } 01465 01466 return NULL; 01467 } 01468 01469 if (SessionSpace) { 01470 TempPte = ValidKernelPdeLocal; 01471 PageTableCount = StartPosition; 01472 } 01473 else { 01474 TempPte = ValidKernelPde; 01475 } 01476 01477 LOCK_PFN (OldIrql); 01478 01479 // 01480 // Make sure we have 1 more than the number of pages 01481 // requested available. 01482 // 01483 01484 if (MmAvailablePages <= StartPosition) { 01485 01486 UNLOCK_PFN (OldIrql); 01487 01488 // 01489 // There are no free physical pages to expand 01490 // paged pool. 01491 // 01492 01493 return NULL; 01494 } 01495 01496 // 01497 // Update the count of available resident pages. 01498 // 01499 01500 MmResidentAvailablePages -= StartPosition; 01501 MM_BUMP_COUNTER(1, StartPosition); 01502 01503 // 01504 // Expand the pool. 01505 // 01506 01507 EndPosition = (ULONG)((PagedPoolInfo->NextPdeForPagedPoolExpansion - 01508 MiGetPteAddress(PagedPoolInfo->FirstPteForPagedPool)) * 01509 PTE_PER_PAGE); 01510 01511 RtlClearBits (PagedPoolInfo->PagedPoolAllocationMap, 01512 EndPosition, 01513 (ULONG) StartPosition * PTE_PER_PAGE); 01514 01515 PointerPte = PagedPoolInfo->NextPdeForPagedPoolExpansion; 01516 StartingPte = (PMMPTE)MiGetVirtualAddressMappedByPte(PointerPte); 01517 PagedPoolInfo->NextPdeForPagedPoolExpansion += StartPosition; 01518 01519 do { 01520 ASSERT (PointerPte->u.Hard.Valid == 0); 01521 01522 MM_TRACK_COMMIT (MM_DBG_COMMIT_PAGED_POOL_PAGETABLE, 1); 01523 01524 MiChargeCommitmentCantExpand (1, TRUE); 01525 01526 PageFrameIndex = MiRemoveAnyPage ( 01527 MI_GET_PAGE_COLOR_FROM_PTE (PointerPte)); 01528 01529 TempPte.u.Hard.PageFrameNumber = PageFrameIndex; 01530 MI_WRITE_VALID_PTE (PointerPte, TempPte); 01531 01532 // 01533 // Map valid PDE into system (or session) address space as well. 01534 // 01535 01536 VirtualAddress = MiGetVirtualAddressMappedByPte (PointerPte); 01537 01538 #if defined (_WIN64) 01539 01540 MiInitializePfn (PageFrameIndex, 01541 PointerPte, 01542 1); 01543 01544 #else 01545 01546 if (SessionSpace) { 01547 01548 Index = (ULONG)(PointerPte - MiGetPdeAddress (MmSessionBase)); 01549 ASSERT (MmSessionSpace->PageTables[Index].u.Long == 0); 01550 MmSessionSpace->PageTables[Index] = TempPte; 01551 01552 MiInitializePfnForOtherProcess (PageFrameIndex, 01553 PointerPte, 01554 MmSessionSpace->SessionPageDirectoryIndex); 01555 01556 MM_BUMP_SESS_COUNTER(MM_DBG_SESSION_PAGEDPOOL_PAGETABLE_ALLOC1, 1); 01557 } 01558 else { 01559 #if !defined (_X86PAE_) 01560 MmSystemPagePtes [((ULONG_PTR)PointerPte & 01561 ((sizeof(MMPTE) * PDE_PER_PAGE) - 1)) / sizeof(MMPTE)] = 01562 TempPte; 01563 MiInitializePfnForOtherProcess (PageFrameIndex, 01564 PointerPte, 01565 MmSystemPageDirectory); 01566 #else 01567 MmSystemPagePtes [((ULONG_PTR)PointerPte & 01568 (PD_PER_SYSTEM * (sizeof(MMPTE) * PDE_PER_PAGE) - 1)) / sizeof(MMPTE)] = 01569 TempPte; 01570 MiInitializePfnForOtherProcess (PageFrameIndex, 01571 PointerPte, 01572 MmSystemPageDirectory[(PointerPte - MiGetPdeAddress(0)) / PDE_PER_PAGE]); 01573 #endif 01574 } 01575 #endif 01576 01577 KeFillEntryTb ((PHARDWARE_PTE) PointerPte, VirtualAddress, FALSE); 01578 01579 MiFillMemoryPte (StartingPte, 01580 PAGE_SIZE, 01581 MM_KERNEL_NOACCESS_PTE); 01582 01583 PointerPte += 1; 01584 StartingPte += PAGE_SIZE / sizeof(MMPTE); 01585 StartPosition -= 1; 01586 } while (StartPosition > 0); 01587 01588 UNLOCK_PFN (OldIrql); 01589 01590 if (SessionSpace) { 01591 01592 PointerPte -= PageTableCount; 01593 01594 LOCK_SESSION_SPACE_WS (SessionIrql); 01595 01596 MmSessionSpace->NonPagablePages += PageTableCount; 01597 MmSessionSpace->CommittedPages += PageTableCount; 01598 01599 do { 01600 Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); 01601 01602 ASSERT (Pfn1->u1.Event == 0); 01603 Pfn1->u1.Event = (PVOID) PsGetCurrentThread (); 01604 01605 SessionPte = MiGetVirtualAddressMappedByPte (PointerPte); 01606 01607 MiAddValidPageToWorkingSet (SessionPte, 01608 PointerPte, 01609 Pfn1, 01610 0); 01611 01612 WsEntry = MiLocateWsle (SessionPte, 01613 MmSessionSpace->Vm.VmWorkingSetList, 01614 Pfn1->u1.WsIndex); 01615 01616 if (WsEntry >= MmSessionSpace->Vm.VmWorkingSetList->FirstDynamic) { 01617 01618 WsSwapEntry = MmSessionSpace->Vm.VmWorkingSetList->FirstDynamic; 01619 01620 if (WsEntry != MmSessionSpace->Vm.VmWorkingSetList->FirstDynamic) { 01621 01622 // 01623 // Swap this entry with the one at first dynamic. 01624 // 01625 01626 MiSwapWslEntries (WsEntry, WsSwapEntry, &MmSessionSpace->Vm); 01627 } 01628 01629 MmSessionSpace->Vm.VmWorkingSetList->FirstDynamic += 1; 01630 } 01631 else { 01632 WsSwapEntry = WsEntry; 01633 } 01634 01635 // 01636 // Indicate that the page is locked. 01637 // 01638 01639 MmSessionSpace->Wsle[WsSwapEntry].u1.e1.LockedInWs = 1; 01640 01641 PointerPte += 1; 01642 PageTableCount -= 1; 01643 } while (PageTableCount > 0); 01644 UNLOCK_SESSION_SPACE_WS (SessionIrql); 01645 } 01646 01647 StartPosition = RtlFindClearBitsAndSet ( 01648 PagedPoolInfo->PagedPoolAllocationMap, 01649 (ULONG)SizeInPages, 01650 EndPosition 01651 ); 01652 01653 ASSERT (StartPosition != 0xffffffff); 01654 } 01655 01656 // 01657 // This is paged pool, the start and end can't be saved 01658 // in the PFN database as the page isn't always resident 01659 // in memory. The ideal place to save the start and end 01660 // would be in the prototype PTE, but there are no free 01661 // bits. To solve this problem, a bitmap which parallels 01662 // the allocation bitmap exists which contains set bits 01663 // in the positions where an allocation ends. This 01664 // allows pages to be deallocated with only their starting 01665 // address. 01666 // 01667 // For sanity's sake, the starting address can be verified 01668 // from the 2 bitmaps as well. If the page before the starting 01669 // address is not allocated (bit is zero in allocation bitmap) 01670 // then this page is obviously a start of an allocation block. 01671 // If the page before is allocated and the other bit map does 01672 // not indicate the previous page is the end of an allocation, 01673 // then the starting address is wrong and a bug check should 01674 // be issued. 01675 // 01676 01677 if (SizeInPages == 1) { 01678 PagedPoolInfo->PagedPoolHint = StartPosition + (ULONG)SizeInPages; 01679 } 01680 01681 if (MiChargeCommitmentCantExpand (SizeInPages, FALSE) == FALSE) { 01682 Thread = PsGetCurrentThread (); 01683 if (MI_MEMORY_MAKER(Thread)) { 01684 MiChargeCommitmentCantExpand (SizeInPages, TRUE); 01685 } 01686 else { 01687 RtlClearBits (PagedPoolInfo->PagedPoolAllocationMap, 01688 StartPosition, 01689 (ULONG)SizeInPages); 01690 01691 // 01692 // Could not commit the page(s), return NULL indicating 01693 // no pool was allocated. Note that the lack of commit may be due 01694 // to unused segments and the MmSharedCommit, prototype PTEs, etc 01695 // associated with them. So force a reduction now. 01696 // 01697 01698 MiIssuePageExtendRequestNoWait (SizeInPages); 01699 01700 SignalDereferenceThread = FALSE; 01701 LOCK_PFN (OldIrql); 01702 if (MmUnusedSegmentForceFree == 0) { 01703 if (!IsListEmpty(&MmUnusedSegmentList)) { 01704 SignalDereferenceThread = TRUE; 01705 MmUnusedSegmentForceFree = 30; 01706 } 01707 } 01708 UNLOCK_PFN (OldIrql); 01709 if (SignalDereferenceThread == TRUE) { 01710 KeSetEvent (&MmUnusedSegmentCleanup, 0, FALSE); 01711 } 01712 01713 return NULL; 01714 } 01715 } 01716 01717 MM_TRACK_COMMIT (MM_DBG_COMMIT_PAGED_POOL_PAGES, SizeInPages); 01718 01719 if (SessionSpace) { 01720 LOCK_SESSION_SPACE_WS (OldIrql); 01721 SessionSpace->CommittedPages += SizeInPages; 01722 MM_BUMP_SESS_COUNTER(MM_DBG_SESSION_COMMIT_PAGEDPOOL_PAGES, SizeInPages); 01723 UNLOCK_SESSION_SPACE_WS (OldIrql); 01724 BaseVa = (PVOID)((PCHAR)SessionSpace->PagedPoolStart + 01725 (StartPosition << PAGE_SHIFT)); 01726 } 01727 else { 01728 MmPagedPoolCommit += (ULONG)SizeInPages; 01729 BaseVa = (PVOID)((PUCHAR)MmPageAlignedPoolBase[PagedPool] + 01730 (StartPosition << PAGE_SHIFT)); 01731 } 01732 01733 #if DBG 01734 PointerPte = MiGetPteAddress (BaseVa); 01735 for (i = 0; i < SizeInPages; i += 1) { 01736 if (*(ULONG *)PointerPte != MM_KERNEL_NOACCESS_PTE) { 01737 DbgPrint("MiAllocatePoolPages: PP not zero PTE (%x %x %x)\n", 01738 BaseVa, PointerPte, *PointerPte); 01739 DbgBreakPoint(); 01740 } 01741 PointerPte += 1; 01742 } 01743 #endif 01744 PointerPte = MiGetPteAddress (BaseVa); 01745 MiFillMemoryPte (PointerPte, 01746 SizeInPages * sizeof(MMPTE), 01747 MM_KERNEL_DEMAND_ZERO_PTE); 01748 01749 PagedPoolInfo->PagedPoolCommit += SizeInPages; 01750 EndPosition = StartPosition + (ULONG)SizeInPages - 1; 01751 RtlSetBits (PagedPoolInfo->EndOfPagedPoolBitmap, EndPosition, 1L); 01752 01753 // 01754 // Mark this as a large session allocation in the PFN database. 01755 // 01756 01757 if (IsLargeSessionAllocation != 0) { 01758 RtlSetBits (PagedPoolInfo->PagedPoolLargeSessionAllocationMap, 01759 StartPosition, 01760 1L); 01761 01762 MiSessionPoolAllocated (BaseVa, 01763 SizeInPages << PAGE_SHIFT, 01764 PagedPool); 01765 } 01766 else if (PoolType & POOL_VERIFIER_MASK) { 01767 RtlSetBits (VerifierLargePagedPoolMap, 01768 StartPosition, 01769 1L); 01770 } 01771 01772 PagedPoolInfo->AllocatedPagedPool += SizeInPages; 01773 01774 return BaseVa; 01775 }

PVOID MiAllocateSpecialPool (  IN SIZE_T  NumberOfBytes, IN ULONG  Tag, IN POOL_TYPE  PoolType, IN ULONG  SpecialPoolType )

Definition at line 3472 of file allocpag.c. References APC_LEVEL, ASSERT, BASE_POOL_TYPE_MASK, DISPATCH_LEVEL, FALSE, Header, KeBugCheckEx(), KeQueryTickCount(), LOCK_PFN2, MI_GET_PAGE_COLOR_FROM_PTE, MI_SET_PTE_DIRTY, MI_SPECIAL_POOL_PAGABLE, MI_SPECIAL_POOL_PTE_NONPAGABLE, MI_SPECIAL_POOL_PTE_PAGABLE, MI_SPECIAL_POOL_VERIFIER, MI_WRITE_VALID_PTE, MiChargeCommitmentCantExpand(), MiGetVirtualAddressMappedByPte, MiInitializePfn(), MiMakeSpecialPoolPagable(), MiNumberOfExtraSystemPdes, MiRemoveAnyPage(), MiSpecialPagesInUsePeak, MiSpecialPagesNonPaged, MiSpecialPagesNonPagedMaximum, MiSpecialPagesNonPagedPeak, MiSpecialPagesPagable, MiSpecialPagesPagablePeak, MiSpecialPoolEnabled, MiSpecialPoolFirstPte, MM_BUMP_COUNTER, MM_EMPTY_PTE_LIST, MmAvailablePages, MmNumberOfPagingFiles, MmResidentAvailablePages, MMSECT, MmSpecialPagesInUse, MmSpecialPoolCatchOverruns, MmSpecialPoolRejected, MmSystemPteBase, NonPagedPool, NULL, PAGE_SIZE, PagedPool, POOL_OVERHEAD, POOL_QUOTA_MASK, POOL_VERIFIER_MASK, TRUE, _MMPTE::u, UNLOCK_PFN2, and ValidKernelPte. Referenced by MmAllocateSpecialPool(). : This routine allocates virtual memory from special pool. This allocation is made from the end of a physical page with the next PTE set to no access so that any reads or writes will cause an immediate fatal system crash. This lets us catch components that corrupt pool. Arguments: NumberOfBytes - Supplies the number of bytes to commit. Tag - Supplies the tag of the requested allocation. PoolType - Supplies the pool type of the requested allocation. SpecialPoolType - Supplies the special pool type of the requested allocation. - 0 indicates overruns. - 1 indicates underruns. - 2 indicates use the systemwide pool policy. Return Value: A non-NULL pointer if the requested allocation was fulfilled from special pool. NULL if the allocation was not made. Environment: Kernel mode, no locks (not even pool locks) held. --*/ { MMPTE TempPte; PFN_NUMBER PageFrameIndex; PMMPTE PointerPte; KIRQL OldIrql; PVOID Entry; PPOOL_HEADER Header; LARGE_INTEGER CurrentTime; LOGICAL CatchOverruns; if ((PoolType & BASE_POOL_TYPE_MASK) == PagedPool) { if (KeGetCurrentIrql() > APC_LEVEL) { KeBugCheckEx (SPECIAL_POOL_DETECTED_MEMORY_CORRUPTION, KeGetCurrentIrql(), PoolType, NumberOfBytes, 0x30); } } else { if (KeGetCurrentIrql() > DISPATCH_LEVEL) { KeBugCheckEx (SPECIAL_POOL_DETECTED_MEMORY_CORRUPTION, KeGetCurrentIrql(), PoolType, NumberOfBytes, 0x30); } } #if defined (_X86_) && !defined (_X86PAE_) if (MiNumberOfExtraSystemPdes != 0) { extern ULONG MMSECT; // // Prototype PTEs cannot come from lower special pool because // their address is encoded into PTEs and the encoding only covers // a max of 1GB from the start of paged pool. Likewise fork // prototype PTEs. // if (Tag == MMSECT || Tag == 'lCmM') { return NULL; } } #endif #if !defined (_WIN64) && !defined (_X86PAE_) if (Tag == 'bSmM' || Tag == 'iCmM' || Tag == 'aCmM') { // // Mm subsections cannot come from this special pool because they // get encoded into PTEs - they must come from normal nonpaged pool. // return NULL; } #endif TempPte = ValidKernelPte; LOCK_PFN2 (OldIrql); if (MiSpecialPoolEnabled == FALSE) { // // The special pool allocation code is currently disabled. // UNLOCK_PFN2 (OldIrql); return NULL; } if (MmAvailablePages < 200) { UNLOCK_PFN2 (OldIrql); MmSpecialPoolRejected[0] += 1; return NULL; } // // Don't get too aggressive until a paging file gets set up. // if (MmNumberOfPagingFiles == 0 && MmSpecialPagesInUse > MmAvailablePages / 2) { UNLOCK_PFN2 (OldIrql); MmSpecialPoolRejected[3] += 1; return NULL; } if (MiSpecialPoolFirstPte->u.List.NextEntry == MM_EMPTY_PTE_LIST) { UNLOCK_PFN2 (OldIrql); MmSpecialPoolRejected[2] += 1; return NULL; } if (MmResidentAvailablePages < 100) { UNLOCK_PFN2 (OldIrql); MmSpecialPoolRejected[4] += 1; return NULL; } // // Cap nonpaged allocations to prevent runaways. // if ((PoolType & BASE_POOL_TYPE_MASK) == NonPagedPool) { if (MiSpecialPagesNonPaged > MiSpecialPagesNonPagedMaximum) { UNLOCK_PFN2 (OldIrql); MmSpecialPoolRejected[1] += 1; return NULL; } MmResidentAvailablePages -= 1; MM_BUMP_COUNTER(31, 1); MiSpecialPagesNonPaged += 1; if (MiSpecialPagesNonPaged > MiSpecialPagesNonPagedPeak) { MiSpecialPagesNonPagedPeak = MiSpecialPagesNonPaged; } } else { MiSpecialPagesPagable += 1; if (MiSpecialPagesPagable > MiSpecialPagesPagablePeak) { MiSpecialPagesPagablePeak = MiSpecialPagesPagable; } } PointerPte = MiSpecialPoolFirstPte; ASSERT (MiSpecialPoolFirstPte->u.List.NextEntry != MM_EMPTY_PTE_LIST); MiSpecialPoolFirstPte = PointerPte->u.List.NextEntry + MmSystemPteBase; PageFrameIndex = MiRemoveAnyPage (MI_GET_PAGE_COLOR_FROM_PTE (PointerPte)); MmSpecialPagesInUse += 1; if (MmSpecialPagesInUse > MiSpecialPagesInUsePeak) { MiSpecialPagesInUsePeak = MmSpecialPagesInUse; } TempPte.u.Hard.PageFrameNumber = PageFrameIndex; if ((PoolType & BASE_POOL_TYPE_MASK) == PagedPool) { MI_SET_PTE_DIRTY (TempPte); } MI_WRITE_VALID_PTE (PointerPte, TempPte); MiInitializePfn (PageFrameIndex, PointerPte, 1); UNLOCK_PFN2 (OldIrql); // // Fill the page with a random pattern. // KeQueryTickCount(&CurrentTime); Entry = MiGetVirtualAddressMappedByPte (PointerPte); RtlFillMemory (Entry, PAGE_SIZE, (UCHAR) CurrentTime.LowPart); if ((PoolType & BASE_POOL_TYPE_MASK) == PagedPool) { MiMakeSpecialPoolPagable (Entry, PointerPte); (PointerPte + 1)->u.Soft.PageFileHigh = MI_SPECIAL_POOL_PTE_PAGABLE; } else { (PointerPte + 1)->u.Soft.PageFileHigh = MI_SPECIAL_POOL_PTE_NONPAGABLE; } if (SpecialPoolType == 0) { CatchOverruns = TRUE; } else if (SpecialPoolType == 1) { CatchOverruns = FALSE; } else if (MmSpecialPoolCatchOverruns == TRUE) { CatchOverruns = TRUE; } else { CatchOverruns = FALSE; } if (CatchOverruns == TRUE) { Header = (PPOOL_HEADER) Entry; Entry = (PVOID)(((LONG_PTR)(((PCHAR)Entry + (PAGE_SIZE - NumberOfBytes)))) & ~((LONG_PTR)POOL_OVERHEAD - 1)); } else { Header = (PPOOL_HEADER) ((PCHAR)Entry + PAGE_SIZE - POOL_OVERHEAD); } // // Zero the header and stash any information needed at release time. // RtlZeroMemory (Header, POOL_OVERHEAD); Header->Ulong1 = (ULONG)NumberOfBytes; ASSERT (NumberOfBytes <= PAGE_SIZE - POOL_OVERHEAD && PAGE_SIZE <= 32 * 1024); if ((PoolType & BASE_POOL_TYPE_MASK) == PagedPool) { Header->Ulong1 |= MI_SPECIAL_POOL_PAGABLE; } if (PoolType & POOL_VERIFIER_MASK) { Header->Ulong1 |= MI_SPECIAL_POOL_VERIFIER; } Header->BlockSize = (UCHAR) CurrentTime.LowPart; Header->PoolTag = Tag; MiChargeCommitmentCantExpand (1, TRUE); ASSERT ((Header->PoolType & POOL_QUOTA_MASK) == 0); return Entry; }

VOID MiCheckSessionPoolAllocations (  VOID   )

Definition at line 4116 of file allocpag.c. References ASSERT, DbgPrint, else, KeBugCheckEx(), MiGetPdeAddress, MiGetVirtualAddressMappedByPte, MM_KERNEL_NOACCESS_PTE, MmSessionSpace, _MM_SESSION_SPACE::NonPagedPoolAllocations, _MM_SESSION_SPACE::NonPagedPoolBytes, PAGED_CODE, _MM_SESSION_SPACE::PagedPoolAllocations, _MM_SESSION_SPACE::PagedPoolBytes, _MM_SESSION_SPACE::PagedPoolEnd, _MM_SESSION_SPACE::PagedPoolStart, PTE_PER_PAGE, _MM_SESSION_SPACE::SessionId, and _MMPTE::u. Referenced by MiDereferenceSession(). : Ensure that the current session has no pool allocations since it is about to exit. All session allocations must be freed prior to session exit. Arguments: None. Return Value: None. Environment: Kernel mode. --*/ { ULONG i; PMMPTE StartPde; PMMPTE EndPde; PMMPTE PointerPte; PVOID VirtualAddress; PAGED_CODE(); if (MmSessionSpace->NonPagedPoolBytes || MmSessionSpace->PagedPoolBytes) { // // All page tables for this session's paged pool must be freed by now. // Being here means they aren't - this is fatal. Force in any valid // pages so that a debugger can show who the guilty party is. // StartPde = MiGetPdeAddress (MmSessionSpace->PagedPoolStart); EndPde = MiGetPdeAddress (MmSessionSpace->PagedPoolEnd); while (StartPde <= EndPde) { if (StartPde->u.Long != 0 && StartPde->u.Long != MM_KERNEL_NOACCESS_PTE) { // // Hunt through the page table page for valid pages and force // them in. Note this also forces in the page table page if // it is not already. // PointerPte = MiGetVirtualAddressMappedByPte (StartPde); for (i = 0; i < PTE_PER_PAGE; i += 1) { if (PointerPte->u.Long != 0 && PointerPte->u.Long != MM_KERNEL_NOACCESS_PTE) { VirtualAddress = MiGetVirtualAddressMappedByPte (PointerPte); *(volatile BOOLEAN *)VirtualAddress = *(volatile BOOLEAN *)VirtualAddress; #if DBG DbgPrint("MiCheckSessionPoolAllocations: Address %p still valid\n", VirtualAddress); #endif } PointerPte += 1; } } StartPde += 1; } #if DBG DbgPrint ("MiCheckSessionPoolAllocations: This exiting session (ID %d) is leaking pool !\n", MmSessionSpace->SessionId); DbgPrint ("This means win32k.sys, rdpdd.sys, atmfd.sys or a video/font driver is broken\n"); DbgPrint ("%d nonpaged allocation leaks for %d bytes and %d paged allocation leaks for %d bytes\n", MmSessionSpace->NonPagedPoolAllocations, MmSessionSpace->NonPagedPoolBytes, MmSessionSpace->PagedPoolAllocations, MmSessionSpace->PagedPoolBytes); #endif KeBugCheckEx (SESSION_HAS_VALID_POOL_ON_EXIT, (ULONG_PTR)MmSessionSpace->SessionId, MmSessionSpace->PagedPoolBytes, MmSessionSpace->NonPagedPoolBytes, #if defined (_WIN64) (MmSessionSpace->NonPagedPoolAllocations << 32) | (MmSessionSpace->PagedPoolAllocations) #else (MmSessionSpace->NonPagedPoolAllocations << 16) | (MmSessionSpace->PagedPoolAllocations) #endif ); } ASSERT (MmSessionSpace->NonPagedPoolAllocations == 0); ASSERT (MmSessionSpace->PagedPoolAllocations == 0); }

VOID MiEnableRandomSpecialPool (  IN LOGICAL  Enable  )

Definition at line 3398 of file allocpag.c. References MiBadTags, and _MI_BAD_TAGS::RandomizerEnabled. Referenced by MiApplyDriverVerifier(), and MiVerifyingDriverUnloading(). { MiBadTags.RandomizerEnabled = Enable; }

PVOID MiFindContiguousMemory (  IN PFN_NUMBER  LowestPfn, IN PFN_NUMBER  HighestPfn, IN PFN_NUMBER  BoundaryPfn, IN PFN_NUMBER  SizeInPages, IN PVOID  CallingAddress )

Definition at line 4569 of file allocpag.c. References ActiveAndValid, ASSERT, _PHYSICAL_MEMORY_RUN::BasePage, ExFreePool(), ExInsertPoolTag(), ExLockPool(), ExPageLockHandle, ExUnlockPool(), FALSE, FreePageList, Index, List, _MMFREE_POOL_ENTRY::List, LOCK_PFN2, MI_CHECK_PAGE_ALIGNMENT, MI_CONVERT_PHYSICAL_TO_PFN, MI_GET_PAGE_COLOR_FROM_VA, MI_GET_PAGE_FRAME_FROM_PTE, MI_IS_PHYSICAL_ADDRESS, MI_MAX_FREE_LIST_HEADS, MI_PFN_ELEMENT, MI_WRITE_VALID_PTE, MiChargeCommitmentCantExpand(), MiCheckForContiguousMemory(), MiGetPteAddress, MiGetVirtualAddressMappedByPte, MiInsertContiguousTag, MiProtectedPoolRemoveEntryList(), MiProtectFreeNonPagedPool(), MiReserveSystemPtes(), MiRestoreTransitionPte(), MiUnlinkFreeOrZeroedPage(), MiUnlinkPageFromList(), MiUnProtectFreeNonPagedPool(), MM_BUMP_COUNTER, MM_COLOR_MASK, MM_DBG_COMMIT_CONTIGUOUS_PAGES, MM_DEMAND_ZERO_WRITE_PTE, MM_FREE_POOL_SIGNATURE, MM_TRACK_COMMIT, MmAllocatedNonPagedPool, MmDynamicMemoryMutex, MmLockPagableSectionByHandle(), MmNonPagedPoolFreeListHead, MmNumberOfFreeNonPagedPool, MmPhysicalMemoryBlock, MmProtectFreedNonPagedPool, MmResidentAvailablePages, MmUnlockPagableImageSection(), NonPagedPool, NonPagedPoolDescriptor, NonPagedPoolExpansion, NULL, _PHYSICAL_MEMORY_DESCRIPTOR::NumberOfRuns, _MMPFN::OriginalPte, PAGE_ALIGN, PAGE_SHIFT, PAGE_SIZE, _PHYSICAL_MEMORY_RUN::PageCount, PAGED_CODE, _MMPFN::PteAddress, _MMPFN::PteFrame, _PHYSICAL_MEMORY_DESCRIPTOR::Run, _MMFREE_POOL_ENTRY::Signature, _MMFREE_POOL_ENTRY::Size, StandbyPageList, _POOL_DESCRIPTOR::TotalBigPages, TRUE, _MMPTE::u, _MMPFN::u1, _MMPFN::u2, _MMPFN::u3, UNLOCK_PFN2, ValidKernelPte, and ZeroedPageList. Referenced by MiAllocateContiguousMemory(). : This function searches nonpaged pool and the free, zeroed, and standby lists for contiguous pages that satisfy the request. Arguments: LowestPfn - Supplies the lowest acceptable physical page number. HighestPfn - Supplies the highest acceptable physical page number. BoundaryPfn - Supplies the page frame number multiple the allocation must not cross. 0 indicates it can cross any boundary. SizeInPages - Supplies the number of pages to allocate. CallingAddress - Supplies the calling address of the allocator. Return Value: NULL - a contiguous range could not be found to satisfy the request. NON-NULL - Returns a pointer (virtual address in the nonpaged portion of the system) to the allocated physically contiguous memory. Environment: Kernel mode, IRQL of APC_LEVEL or below. --*/ { PMMPTE PointerPte; PMMPFN Pfn1; PVOID BaseAddress; PVOID BaseAddress2; KIRQL OldIrql; KIRQL OldIrql2; PMMFREE_POOL_ENTRY FreePageInfo; PLIST_ENTRY Entry; ULONG start; ULONG Index; PFN_NUMBER count; PFN_NUMBER Page; PFN_NUMBER LastPage; PFN_NUMBER found; PFN_NUMBER BoundaryMask; MMPTE TempPte; ULONG PageColor; ULONG AllocationPosition; PVOID Va; LOGICAL AddressIsPhysical; PFN_NUMBER SpanInPages; PFN_NUMBER SpanInPages2; PAGED_CODE (); BaseAddress = NULL; BoundaryMask = ~(BoundaryPfn - 1); // // A suitable pool page was not allocated via the pool allocator. // Grab the pool lock and manually search for a page which meets // the requirements. // MmLockPagableSectionByHandle (ExPageLockHandle); ExAcquireFastMutex (&MmDynamicMemoryMutex); OldIrql = ExLockPool (NonPagedPool); // // Trace through the page allocator's pool headers for a page which // meets the requirements. // // // NonPaged pool is linked together through the pages themselves. // Index = (ULONG)(SizeInPages - 1); if (Index >= MI_MAX_FREE_LIST_HEADS) { Index = MI_MAX_FREE_LIST_HEADS - 1; } while (Index < MI_MAX_FREE_LIST_HEADS) { Entry = MmNonPagedPoolFreeListHead[Index].Flink; while (Entry != &MmNonPagedPoolFreeListHead[Index]) { if (MmProtectFreedNonPagedPool == TRUE) { MiUnProtectFreeNonPagedPool ((PVOID)Entry, 0); } // // The list is not empty, see if this one meets the physical // requirements. // FreePageInfo = CONTAINING_RECORD(Entry, MMFREE_POOL_ENTRY, List); ASSERT (FreePageInfo->Signature == MM_FREE_POOL_SIGNATURE); if (FreePageInfo->Size >= SizeInPages) { // // This entry has sufficient space, check to see if the // pages meet the physical requirements. // Va = MiCheckForContiguousMemory (PAGE_ALIGN(Entry), FreePageInfo->Size, SizeInPages, LowestPfn, HighestPfn, BoundaryPfn); if (Va != NULL) { // // These pages meet the requirements. The returned // address may butt up on the end, the front or be // somewhere in the middle. Split the Entry based // on which case it is. // Entry = PAGE_ALIGN(Entry); if (MmProtectFreedNonPagedPool == FALSE) { RemoveEntryList (&FreePageInfo->List); } else { MiProtectedPoolRemoveEntryList (&FreePageInfo->List); } // // Adjust the number of free pages remaining in the pool. // The TotalBigPages calculation appears incorrect for the // case where we're splitting a block, but it's done this // way because ExFreePool corrects it when we free the // fragment block below. Likewise for // MmAllocatedNonPagedPool and MmNumberOfFreeNonPagedPool // which is corrected by MiFreePoolPages for the fragment. // NonPagedPoolDescriptor.TotalBigPages += (ULONG)FreePageInfo->Size; MmAllocatedNonPagedPool += FreePageInfo->Size; MmNumberOfFreeNonPagedPool -= FreePageInfo->Size; ASSERT ((LONG)MmNumberOfFreeNonPagedPool >= 0); if (Va == Entry) { // // Butted against the front. // AllocationPosition = 0; } else if (((PCHAR)Va + (SizeInPages << PAGE_SHIFT)) == ((PCHAR)Entry + (FreePageInfo->Size << PAGE_SHIFT))) { // // Butted against the end. // AllocationPosition = 2; } else { // // Somewhere in the middle. // AllocationPosition = 1; } // // Pages are being removed from the front of // the list entry and the whole list entry // will be removed and then the remainder inserted. // // // Mark start and end for the block at the top of the // list. // if (MI_IS_PHYSICAL_ADDRESS(Va)) { // // On certain architectures, virtual addresses // may be physical and hence have no corresponding PTE. // AddressIsPhysical = TRUE; Pfn1 = MI_PFN_ELEMENT (MI_CONVERT_PHYSICAL_TO_PFN (Va)); } else { AddressIsPhysical = FALSE; PointerPte = MiGetPteAddress(Va); ASSERT (PointerPte->u.Hard.Valid == 1); Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); } ASSERT (Pfn1->u3.e1.VerifierAllocation == 0); ASSERT (Pfn1->u3.e1.LargeSessionAllocation == 0); ASSERT (Pfn1->u3.e1.StartOfAllocation == 0); Pfn1->u3.e1.StartOfAllocation = 1; // // Calculate the ending PFN address, note that since // these pages are contiguous, just add to the PFN. // Pfn1 += SizeInPages - 1; ASSERT (Pfn1->u3.e1.VerifierAllocation == 0); ASSERT (Pfn1->u3.e1.LargeSessionAllocation == 0); ASSERT (Pfn1->u3.e1.EndOfAllocation == 0); Pfn1->u3.e1.EndOfAllocation = 1; if (SizeInPages == FreePageInfo->Size) { // // Unlock the pool and return. // BaseAddress = (PVOID)Va; goto Done; } BaseAddress = NULL; if (AllocationPosition != 2) { // // The end piece needs to be freed as the removal // came from the front or the middle. // BaseAddress = (PVOID)((PCHAR)Va + (SizeInPages << PAGE_SHIFT)); SpanInPages = FreePageInfo->Size - SizeInPages - (((ULONG_PTR)Va - (ULONG_PTR)Entry) >> PAGE_SHIFT); // // Mark start and end of the allocation in the PFN database. // if (AddressIsPhysical == TRUE) { // // On certain architectures, virtual addresses // may be physical and hence have no corresponding PTE. // Pfn1 = MI_PFN_ELEMENT (MI_CONVERT_PHYSICAL_TO_PFN (BaseAddress)); } else { PointerPte = MiGetPteAddress(BaseAddress); ASSERT (PointerPte->u.Hard.Valid == 1); Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); } ASSERT (Pfn1->u3.e1.VerifierAllocation == 0); ASSERT (Pfn1->u3.e1.LargeSessionAllocation == 0); ASSERT (Pfn1->u3.e1.StartOfAllocation == 0); Pfn1->u3.e1.StartOfAllocation = 1; // // Calculate the ending PTE's address, can't depend on // these pages being physically contiguous. // if (AddressIsPhysical == TRUE) { Pfn1 += (SpanInPages - 1); } else { PointerPte += (SpanInPages - 1); ASSERT (PointerPte->u.Hard.Valid == 1); Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); } ASSERT (Pfn1->u3.e1.EndOfAllocation == 0); Pfn1->u3.e1.EndOfAllocation = 1; ASSERT (((ULONG_PTR)BaseAddress & (PAGE_SIZE -1)) == 0); SpanInPages2 = SpanInPages; } BaseAddress2 = BaseAddress; BaseAddress = NULL; if (AllocationPosition != 0) { // // The front piece needs to be freed as the removal // came from the middle or the end. // BaseAddress = (PVOID)Entry; SpanInPages = ((ULONG_PTR)Va - (ULONG_PTR)Entry) >> PAGE_SHIFT; // // Mark start and end of the allocation in the PFN database. // if (AddressIsPhysical == TRUE) { // // On certain architectures, virtual addresses // may be physical and hence have no corresponding PTE. // Pfn1 = MI_PFN_ELEMENT (MI_CONVERT_PHYSICAL_TO_PFN (BaseAddress)); } else { PointerPte = MiGetPteAddress(BaseAddress); ASSERT (PointerPte->u.Hard.Valid == 1); Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); } ASSERT (Pfn1->u3.e1.VerifierAllocation == 0); ASSERT (Pfn1->u3.e1.LargeSessionAllocation == 0); ASSERT (Pfn1->u3.e1.StartOfAllocation == 0); Pfn1->u3.e1.StartOfAllocation = 1; // // Calculate the ending PTE's address, can't depend on // these pages being physically contiguous. // if (AddressIsPhysical == TRUE) { Pfn1 += (SpanInPages - 1); } else { PointerPte += (SpanInPages - 1); ASSERT (PointerPte->u.Hard.Valid == 1); Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); } ASSERT (Pfn1->u3.e1.EndOfAllocation == 0); Pfn1->u3.e1.EndOfAllocation = 1; ASSERT (((ULONG_PTR)BaseAddress & (PAGE_SIZE -1)) == 0); } // // Unlock the pool. // ExUnlockPool (NonPagedPool, OldIrql); ExReleaseFastMutex (&MmDynamicMemoryMutex); // // Free the split entry at BaseAddress back into the pool. // Note that we have overcharged the pool - the entire free // chunk has been billed. Here we return the piece we // didn't use and correct the momentary overbilling. // // The start and end allocation bits of this split entry // which we just set up enable ExFreePool and his callees // to correctly adjust the billing. // if (BaseAddress) { ExInsertPoolTag ('tnoC', BaseAddress, SpanInPages << PAGE_SHIFT, NonPagedPool); ExFreePool (BaseAddress); } if (BaseAddress2) { ExInsertPoolTag ('tnoC', BaseAddress2, SpanInPages2 << PAGE_SHIFT, NonPagedPool); ExFreePool (BaseAddress2); } BaseAddress = Va; goto Done1; } } Entry = FreePageInfo->List.Flink; if (MmProtectFreedNonPagedPool == TRUE) { MiProtectFreeNonPagedPool ((PVOID)FreePageInfo, (ULONG)FreePageInfo->Size); } } Index += 1; } // // No entry was found in free nonpaged pool that meets the requirements. // Search the PFN database for pages that meet the requirements. // start = 0; do { count = MmPhysicalMemoryBlock->Run[start].PageCount; Page = MmPhysicalMemoryBlock->Run[start].BasePage; // // Close the gaps, then examine the range for a fit. // LastPage = Page + count; if (LastPage - 1 > HighestPfn) { LastPage = HighestPfn + 1; } if (Page < LowestPfn) { Page = LowestPfn; } if ((count != 0) && (Page + SizeInPages <= LastPage)) { // // A fit may be possible in this run, check whether the pages // are on the right list. // found = 0; Pfn1 = MI_PFN_ELEMENT (Page); LOCK_PFN2 (OldIrql2); do { if ((Pfn1->u3.e1.PageLocation == ZeroedPageList) || (Pfn1->u3.e1.PageLocation == FreePageList) || (Pfn1->u3.e1.PageLocation == StandbyPageList)) { if ((Pfn1->u1.Flink != 0) && (Pfn1->u2.Blink != 0) && (Pfn1->u3.e2.ReferenceCount == 0)) { // // Before starting a new run, ensure that it // can satisfy the boundary requirements (if any). // if ((found == 0) && (BoundaryPfn != 0)) { if (((Page ^ (Page + SizeInPages - 1)) & BoundaryMask) != 0) { // // This run's physical address does not meet the // requirements. // goto NextPage; } } found += 1; if (found == SizeInPages) { // // A match has been found, remove these // pages, add them to the free pool and // return. // Page = 1 + Page - found; // // Try to find system PTES to expand the pool into. // PointerPte = MiReserveSystemPtes ((ULONG)SizeInPages, NonPagedPoolExpansion, 0, 0, FALSE); if (PointerPte == NULL) { UNLOCK_PFN2 (OldIrql2); goto Done; } MmResidentAvailablePages -= SizeInPages; MM_BUMP_COUNTER(3, SizeInPages); MiChargeCommitmentCantExpand (SizeInPages, TRUE); MM_TRACK_COMMIT (MM_DBG_COMMIT_CONTIGUOUS_PAGES, SizeInPages); BaseAddress = MiGetVirtualAddressMappedByPte (PointerPte); PageColor = MI_GET_PAGE_COLOR_FROM_VA(BaseAddress); TempPte = ValidKernelPte; MmAllocatedNonPagedPool += SizeInPages; NonPagedPoolDescriptor.TotalBigPages += (ULONG)SizeInPages; Pfn1 = MI_PFN_ELEMENT (Page - 1); do { Pfn1 += 1; if (Pfn1->u3.e1.PageLocation == StandbyPageList) { MiUnlinkPageFromList (Pfn1); MiRestoreTransitionPte (Page); } else { MiUnlinkFreeOrZeroedPage (Page); } MI_CHECK_PAGE_ALIGNMENT(Page, PageColor & MM_COLOR_MASK); Pfn1->u3.e1.PageColor = PageColor & MM_COLOR_MASK; PageColor += 1; TempPte.u.Hard.PageFrameNumber = Page; MI_WRITE_VALID_PTE (PointerPte, TempPte); Pfn1->u3.e2.ReferenceCount = 1; Pfn1->u2.ShareCount = 1; Pfn1->PteAddress = PointerPte; Pfn1->OriginalPte.u.Long = MM_DEMAND_ZERO_WRITE_PTE; Pfn1->PteFrame = MI_GET_PAGE_FRAME_FROM_PTE (MiGetPteAddress(PointerPte)); Pfn1->u3.e1.PageLocation = ActiveAndValid; Pfn1->u3.e1.VerifierAllocation = 0; Pfn1->u3.e1.LargeSessionAllocation = 0; if (found == SizeInPages) { Pfn1->u3.e1.StartOfAllocation = 1; } PointerPte += 1; Page += 1; found -= 1; } while (found); Pfn1->u3.e1.EndOfAllocation = 1; UNLOCK_PFN2 (OldIrql2); goto Done; } } else { found = 0; } } else { found = 0; } NextPage: Page += 1; Pfn1 += 1; } while (Page < LastPage); UNLOCK_PFN2 (OldIrql2); } start += 1; } while (start != MmPhysicalMemoryBlock->NumberOfRuns); Done: ExUnlockPool (NonPagedPool, OldIrql); ExReleaseFastMutex (&MmDynamicMemoryMutex); Done1: MmUnlockPagableImageSection (ExPageLockHandle); if (BaseAddress) { MiInsertContiguousTag (BaseAddress, SizeInPages << PAGE_SHIFT, CallingAddress); ExInsertPoolTag ('tnoC', BaseAddress, SizeInPages << PAGE_SHIFT, NonPagedPool); } return BaseAddress; }

VOID MiFreeNonPagedPool (  IN PVOID  StartingAddress, IN PFN_NUMBER  NumberOfPages )

Definition at line 708 of file allocpag.c. References ASSERT, KeFlushSingleTb(), LOCK_PFN2, MI_GET_PAGE_FRAME_FROM_PTE, MI_MAKING_MULTIPLE_PTES_INVALID, MI_PFN_ELEMENT, MI_SET_PFN_DELETED, MiDecrementReferenceCount(), MiGetPteAddress, MiReleaseSystemPtes(), MiReturnCommitment(), MM_BUMP_COUNTER, MM_DBG_COMMIT_RETURN_NONPAGED_POOL_EXPANSION, MM_TRACK_COMMIT, MmResidentAvailablePages, NonPagedPoolExpansion, PAGE_SIZE, StandbyPageList, TRUE, _MMPTE::u, _MMPFN::u2, _MMPFN::u3, UNLOCK_PFN2, VOID(), and ZeroKernelPte. Referenced by MiAllocatePoolPages(), and MiFreePoolPages(). : This function releases virtually mapped nonpaged expansion pool. Arguments: StartingAddress - Supplies the starting address. NumberOfPages - Supplies the number of pages to free. Return Value: None. Environment: These functions are used by the internal Mm page allocation/free routines only and should not be called directly. Mutexes guarding the pool databases must be held when calling this function. --*/ { PFN_NUMBER i; KIRQL OldIrql; PMMPFN Pfn1; PMMPTE PointerPte; PFN_NUMBER PageFrameIndex; MI_MAKING_MULTIPLE_PTES_INVALID (TRUE); PointerPte = MiGetPteAddress (StartingAddress); // // Return commitment. // MiReturnCommitment (NumberOfPages); MM_TRACK_COMMIT (MM_DBG_COMMIT_RETURN_NONPAGED_POOL_EXPANSION, NumberOfPages); LOCK_PFN2 (OldIrql); for (i = 0; i < NumberOfPages; i += 1) { PageFrameIndex = MI_GET_PAGE_FRAME_FROM_PTE (PointerPte); // // Set the pointer to the PTE as empty so the page // is deleted when the reference count goes to zero. // Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); ASSERT (Pfn1->u2.ShareCount == 1); Pfn1->u2.ShareCount = 0; MI_SET_PFN_DELETED (Pfn1); #if DBG Pfn1->u3.e1.PageLocation = StandbyPageList; #endif //DBG MiDecrementReferenceCount (PageFrameIndex); (VOID)KeFlushSingleTb (StartingAddress, TRUE, TRUE, (PHARDWARE_PTE)PointerPte, ZeroKernelPte.u.Flush); StartingAddress = (PVOID)((PCHAR)StartingAddress + PAGE_SIZE); PointerPte += 1; } // // Update the count of available resident pages. // MmResidentAvailablePages += NumberOfPages; MM_BUMP_COUNTER(2, NumberOfPages); UNLOCK_PFN2(OldIrql); PointerPte -= NumberOfPages; MiReleaseSystemPtes (PointerPte, (ULONG)NumberOfPages, NonPagedPoolExpansion); }

ULONG MiFreePoolPages (  IN PVOID  StartingAddress  )

Definition at line 1778 of file allocpag.c. References _MM_PAGED_POOL_INFO::AllocatedPagedPool, ASSERT, _MM_SESSION_SPACE::CommittedPages, CONSISTENCY_LOCK_PFN2, CONSISTENCY_UNLOCK_PFN2, DbgPrint, _MM_PAGED_POOL_INFO::EndOfPagedPoolBitmap, FALSE, _MM_PAGED_POOL_INFO::FirstPteForPagedPool, Index, KeBugCheckEx(), L, _MMFREE_POOL_ENTRY::List, LOCK_SESSION_SPACE_WS, MI_CONVERT_PHYSICAL_TO_PFN, MI_GET_PAGE_FRAME_FROM_PTE, MI_IS_PHYSICAL_ADDRESS, MI_IS_SESSION_POOL_ADDRESS, MI_MAGIC_AWE_PTEFRAME, MI_MAX_FREE_LIST_HEADS, MI_PFN_ELEMENT, MiDeleteSystemPagableVm(), MiEndOfInitialPoolFrame, MiFreeNonPagedPool(), MiGetPteAddress, MiGetVirtualAddressMappedByPte, MiHydra, MiProtectedPoolInsertList(), MiProtectedPoolRemoveEntryList(), MiProtectFreeNonPagedPool(), MiReturnCommitment(), MiSessionPoolFreed(), MiUnProtectFreeNonPagedPool(), MM_BUMP_SESS_COUNTER, MM_DBG_COMMIT_RETURN_PAGED_POOL_PAGES, MM_DBG_SESSION_COMMIT_POOL_FREED, MM_FREE_POOL_SIGNATURE, MM_KERNEL_NOACCESS_PTE, MM_SMALL_ALLOCATIONS, MM_TRACK_COMMIT, MmAllocatedNonPagedPool, MmExpandedPoolBitPosition, MmHighestPhysicalPage, MmMustSucceedPoolBitPosition, MmNonPagedMustSucceed, MmNonPagedPoolEnd, MmNonPagedPoolExpansionStart, MmNonPagedPoolFreeListHead, MmNonPagedPoolStart, MmNumberOfFreeNonPagedPool, MmPageAlignedPoolBase, MmPagedPoolCommit, MmPagedPoolEnd, MmPagedPoolInfo, MmPagedPoolStart, MmPfnDatabase, MmProtectFreedNonPagedPool, MmSessionSpace, MmSizeOfNonPagedPoolInBytes, MmSizeOfPagedPoolInBytes, NoAccessPte, NonPagedPool, NULL, _MMFREE_POOL_ENTRY::Owner, PAGE_SHIFT, PAGE_SIZE, PagedPool, _MM_PAGED_POOL_INFO::PagedPoolAllocationMap, _MM_PAGED_POOL_INFO::PagedPoolCommit, _MM_PAGED_POOL_INFO::PagedPoolHint, _MM_SESSION_SPACE::PagedPoolInfo, _MM_PAGED_POOL_INFO::PagedPoolLargeSessionAllocationMap, _MM_SESSION_SPACE::PagedPoolStart, POOL_TYPE, _MMPFN::PteAddress, _MMPFN::PteFrame, RtlClearBits(), _MMFREE_POOL_ENTRY::Signature, _MMFREE_POOL_ENTRY::Size, TRUE, _MMPTE::u, _MMPFN::u3, UNLOCK_SESSION_SPACE_WS, VerifierFreeTrackedPool(), and VerifierLargePagedPoolMap. Referenced by DeallocatePoolInternal(), ExFreePool(), ExFreePoolWithTag(), ExpAddTagForBigPages(), ExpInsertPoolTracker(), and MiInitMachineDependent(). 01784 : 01785 01786 This function returns a set of pages back to the pool from 01787 which they were obtained. Once the pages have been deallocated 01788 the region provided by the allocation becomes available for 01789 allocation to other callers, i.e. any data in the region is now 01790 trashed and cannot be referenced. 01791 01792 Arguments: 01793 01794 StartingAddress - Supplies the starting address which was returned 01795 in a previous call to MiAllocatePoolPages. 01796 01797 Return Value: 01798 01799 Returns the number of pages deallocated. 01800 01801 Environment: 01802 01803 These functions are used by the general pool allocation routines 01804 and should not be called directly. 01805 01806 Mutexes guarding the pool databases must be held when calling 01807 these functions. 01808 01809 --*/ 01810 01811 { 01812 ULONG StartPosition; 01813 ULONG Index; 01814 PFN_NUMBER i; 01815 PFN_NUMBER NumberOfPages; 01816 POOL_TYPE PoolType; 01817 PMMPTE PointerPte; 01818 PMMPFN Pfn1; 01819 PFN_NUMBER PageFrameIndex; 01820 KIRQL OldIrql; 01821 ULONG IsLargeSessionAllocation; 01822 ULONG IsLargeVerifierAllocation; 01823 PMMFREE_POOL_ENTRY Entry; 01824 PMMFREE_POOL_ENTRY NextEntry; 01825 PMM_PAGED_POOL_INFO PagedPoolInfo; 01826 PMM_SESSION_SPACE SessionSpace; 01827 LOGICAL SessionAllocation; 01828 MMPTE NoAccessPte; 01829 PFN_NUMBER PagesFreed; 01830 01831 NumberOfPages = 1; 01832 01833 // 01834 // Determine Pool type base on the virtual address of the block 01835 // to deallocate. 01836 // 01837 // This assumes NonPagedPool starts at a higher virtual address 01838 // then PagedPool. 01839 // 01840 01841 if ((StartingAddress >= MmPagedPoolStart) && 01842 (StartingAddress <= MmPagedPoolEnd)) { 01843 PoolType = PagedPool; 01844 SessionSpace = NULL; 01845 PagedPoolInfo = &MmPagedPoolInfo; 01846 StartPosition = (ULONG)(((PCHAR)StartingAddress - 01847 (PCHAR)MmPageAlignedPoolBase[PoolType]) >> PAGE_SHIFT); 01848 } 01849 else if (MI_IS_SESSION_POOL_ADDRESS (StartingAddress) == TRUE) { 01850 ASSERT (MiHydra == TRUE); 01851 PoolType = PagedPool; 01852 SessionSpace = MmSessionSpace; 01853 ASSERT (SessionSpace); 01854 PagedPoolInfo = &SessionSpace->PagedPoolInfo; 01855 StartPosition = (ULONG)(((PCHAR)StartingAddress - 01856 (PCHAR)SessionSpace->PagedPoolStart) >> PAGE_SHIFT); 01857 } 01858 else { 01859 01860 if (StartingAddress < MM_SYSTEM_RANGE_START) { 01861 KeBugCheckEx (BAD_POOL_CALLER, 01862 0x40, 01863 (ULONG_PTR)StartingAddress, 01864 (ULONG_PTR)MM_SYSTEM_RANGE_START, 01865 0); 01866 } 01867 01868 PoolType = NonPagedPool; 01869 SessionSpace = NULL; 01870 PagedPoolInfo = &MmPagedPoolInfo; 01871 StartPosition = (ULONG)(((PCHAR)StartingAddress - 01872 (PCHAR)MmPageAlignedPoolBase[PoolType]) >> PAGE_SHIFT); 01873 } 01874 01875 // 01876 // Check to ensure this page is really the start of an allocation. 01877 // 01878 01879 if (PoolType == NonPagedPool) { 01880 01881 if (StartPosition < MmMustSucceedPoolBitPosition) { 01882 01883 PULONG_PTR NextList; 01884 01885 // 01886 // This is must succeed pool, don't free it, just 01887 // add it to the front of the list. 01888 // 01889 // Note - only a single page can be released at a time. 01890 // 01891 01892 if (MI_IS_PHYSICAL_ADDRESS(StartingAddress)) { 01893 PageFrameIndex = MI_CONVERT_PHYSICAL_TO_PFN (StartingAddress); 01894 } else { 01895 PointerPte = MiGetPteAddress(StartingAddress); 01896 ASSERT (PointerPte->u.Hard.Valid == 1); 01897 PageFrameIndex = MI_GET_PAGE_FRAME_FROM_PTE (PointerPte); 01898 } 01899 Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); 01900 01901 if (Pfn1->u3.e1.VerifierAllocation == 1) { 01902 Pfn1->u3.e1.VerifierAllocation = 0; 01903 VerifierFreeTrackedPool (StartingAddress, 01904 PAGE_SIZE, 01905 NonPagedPool, 01906 FALSE); 01907 } 01908 01909 // 01910 // Check for this being a large session allocation. If it is, 01911 // we need to return the pool charge accordingly. 01912 // 01913 01914 if (Pfn1->u3.e1.LargeSessionAllocation) { 01915 Pfn1->u3.e1.LargeSessionAllocation = 0; 01916 MiSessionPoolFreed (StartingAddress, 01917 PAGE_SIZE, 01918 NonPagedPool); 01919 } 01920 01921 NextList = (PULONG_PTR)StartingAddress; 01922 *NextList = (ULONG_PTR)MmNonPagedMustSucceed; 01923 MmNonPagedMustSucceed = StartingAddress; 01924 return (ULONG)NumberOfPages; 01925 } 01926 01927 if (MI_IS_PHYSICAL_ADDRESS (StartingAddress)) { 01928 01929 // 01930 // On certain architectures, virtual addresses 01931 // may be physical and hence have no corresponding PTE. 01932 // 01933 01934 Pfn1 = MI_PFN_ELEMENT (MI_CONVERT_PHYSICAL_TO_PFN (StartingAddress)); 01935 if (StartPosition >= MmExpandedPoolBitPosition) { 01936 PointerPte = Pfn1->PteAddress; 01937 StartingAddress = MiGetVirtualAddressMappedByPte (PointerPte); 01938 } 01939 } else { 01940 PointerPte = MiGetPteAddress (StartingAddress); 01941 Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); 01942 } 01943 01944 if (Pfn1->u3.e1.StartOfAllocation == 0) { 01945 KeBugCheckEx (BAD_POOL_CALLER, 01946 0x41, 01947 (ULONG_PTR)StartingAddress, 01948 (ULONG_PTR)(Pfn1 - MmPfnDatabase), 01949 MmHighestPhysicalPage); 01950 } 01951 01952 CONSISTENCY_LOCK_PFN2 (OldIrql); 01953 01954 ASSERT (Pfn1->PteFrame != MI_MAGIC_AWE_PTEFRAME); 01955 01956 IsLargeVerifierAllocation = Pfn1->u3.e1.VerifierAllocation; 01957 IsLargeSessionAllocation = Pfn1->u3.e1.LargeSessionAllocation; 01958 01959 Pfn1->u3.e1.StartOfAllocation = 0; 01960 Pfn1->u3.e1.VerifierAllocation = 0; 01961 Pfn1->u3.e1.LargeSessionAllocation = 0; 01962 01963 CONSISTENCY_UNLOCK_PFN2 (OldIrql); 01964 01965 #if DBG 01966 if ((Pfn1->u3.e2.ReferenceCount > 1) && 01967 (Pfn1->u3.e1.WriteInProgress == 0)) { 01968 DbgPrint ("MM: MiFreePoolPages - deleting pool locked for I/O %lx\n", 01969 Pfn1); 01970 ASSERT (Pfn1->u3.e2.ReferenceCount == 1); 01971 } 01972 #endif //DBG 01973 01974 // 01975 // Find end of allocation and release the pages. 01976 // 01977 01978 while (Pfn1->u3.e1.EndOfAllocation == 0) { 01979 if (MI_IS_PHYSICAL_ADDRESS(StartingAddress)) { 01980 Pfn1 += 1; 01981 } else { 01982 PointerPte += 1; 01983 Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); 01984 } 01985 NumberOfPages += 1; 01986 #if DBG 01987 if ((Pfn1->u3.e2.ReferenceCount > 1) && 01988 (Pfn1->u3.e1.WriteInProgress == 0)) { 01989 DbgPrint ("MM:MiFreePoolPages - deleting pool locked for I/O %lx\n", 01990 Pfn1); 01991 ASSERT (Pfn1->u3.e2.ReferenceCount == 1); 01992 } 01993 #endif //DBG 01994 } 01995 01996 MmAllocatedNonPagedPool -= NumberOfPages; 01997 01998 if (IsLargeVerifierAllocation != 0) { 01999 VerifierFreeTrackedPool (StartingAddress, 02000 NumberOfPages << PAGE_SHIFT, 02001 NonPagedPool, 02002 FALSE); 02003 } 02004 02005 if (IsLargeSessionAllocation != 0) { 02006 MiSessionPoolFreed (StartingAddress, 02007 NumberOfPages << PAGE_SHIFT, 02008 NonPagedPool); 02009 } 02010 02011 CONSISTENCY_LOCK_PFN2 (OldIrql); 02012 02013 Pfn1->u3.e1.EndOfAllocation = 0; 02014 02015 CONSISTENCY_UNLOCK_PFN2 (OldIrql); 02016 02017 #if DBG 02018 if (MiFillFreedPool != 0) { 02019 RtlFillMemoryUlong (StartingAddress, 02020 PAGE_SIZE * NumberOfPages, 02021 MiFillFreedPool); 02022 } 02023 #endif //DBG 02024 02025 if (StartingAddress > MmNonPagedPoolExpansionStart) { 02026 02027 // 02028 // This page was from the expanded pool, should 02029 // it be freed? 02030 // 02031 // NOTE: all pages in the expanded pool area have PTEs 02032 // so no physical address checks need to be performed. 02033 // 02034 02035 if ((NumberOfPages > 3) || (MmNumberOfFreeNonPagedPool > 5)) { 02036 02037 // 02038 // Free these pages back to the free page list. 02039 // 02040 02041 MiFreeNonPagedPool (StartingAddress, NumberOfPages); 02042 02043 return (ULONG)NumberOfPages; 02044 } 02045 } 02046 02047 // 02048 // Add the pages to the list of free pages. 02049 // 02050 02051 MmNumberOfFreeNonPagedPool += NumberOfPages; 02052 02053 // 02054 // Check to see if the next allocation is free. 02055 // We cannot walk off the end of nonpaged initial or expansion 02056 // pages as the highest initial allocation is never freed and 02057 // the highest expansion allocation is guard-paged. 02058 // 02059 02060 i = NumberOfPages; 02061 02062 ASSERT (MiEndOfInitialPoolFrame != 0); 02063 02064 if ((PFN_NUMBER)(Pfn1 - MmPfnDatabase) == MiEndOfInitialPoolFrame) { 02065 PointerPte += 1; 02066 Pfn1 = NULL; 02067 } 02068 else if (MI_IS_PHYSICAL_ADDRESS(StartingAddress)) { 02069 Pfn1 += 1; 02070 ASSERT ((PCHAR)StartingAddress + NumberOfPages < (PCHAR)MmNonPagedPoolStart + MmSizeOfNonPagedPoolInBytes); 02071 } else { 02072 PointerPte += 1; 02073 ASSERT ((PCHAR)StartingAddress + NumberOfPages <= (PCHAR)MmNonPagedPoolEnd); 02074 02075 // 02076 // Unprotect the previously freed pool so it can be merged. 02077 // 02078 02079 if (MmProtectFreedNonPagedPool == TRUE) { 02080 MiUnProtectFreeNonPagedPool ( 02081 (PVOID)MiGetVirtualAddressMappedByPte(PointerPte), 02082 0); 02083 } 02084 02085 if (PointerPte->u.Hard.Valid == 1) { 02086 Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); 02087 } else { 02088 Pfn1 = NULL; 02089 } 02090 } 02091 02092 if ((Pfn1 != NULL) && (Pfn1->u3.e1.StartOfAllocation == 0)) { 02093 02094 // 02095 // This range of pages is free. Remove this entry 02096 // from the list and add these pages to the current 02097 // range being freed. 02098 // 02099 02100 Entry = (PMMFREE_POOL_ENTRY)((PCHAR)StartingAddress 02101 + (NumberOfPages << PAGE_SHIFT)); 02102 ASSERT (Entry->Signature == MM_FREE_POOL_SIGNATURE); 02103 ASSERT (Entry->Owner == Entry); 02104 #if DBG 02105 { 02106 PMMPTE DebugPte; 02107 PMMPFN DebugPfn; 02108 02109 DebugPfn = NULL; 02110 02111 if (MI_IS_PHYSICAL_ADDRESS(StartingAddress)) { 02112 02113 // 02114 // On certain architectures, virtual addresses 02115 // may be physical and hence have no corresponding PTE. 02116 // 02117 02118 DebugPfn = MI_PFN_ELEMENT (MI_CONVERT_PHYSICAL_TO_PFN (Entry)); 02119 DebugPfn += Entry->Size; 02120 if ((PFN_NUMBER)((DebugPfn - 1) - MmPfnDatabase) != MiEndOfInitialPoolFrame) { 02121 ASSERT (DebugPfn->u3.e1.StartOfAllocation == 1); 02122 } 02123 } else { 02124 DebugPte = PointerPte + Entry->Size; 02125 if ((DebugPte-1)->u.Hard.Valid == 1) { 02126 DebugPfn = MI_PFN_ELEMENT ((DebugPte-1)->u.Hard.PageFrameNumber); 02127 if ((PFN_NUMBER)(DebugPfn - MmPfnDatabase) != MiEndOfInitialPoolFrame) { 02128 if (DebugPte->u.Hard.Valid == 1) { 02129 DebugPfn = MI_PFN_ELEMENT (DebugPte->u.Hard.PageFrameNumber); 02130 ASSERT (DebugPfn->u3.e1.StartOfAllocation == 1); 02131 } 02132 } 02133 02134 } 02135 } 02136 } 02137 #endif //DBG 02138 02139 i += Entry->Size; 02140 if (MmProtectFreedNonPagedPool == FALSE) { 02141 RemoveEntryList (&Entry->List); 02142 } 02143 else { 02144 MiProtectedPoolRemoveEntryList (&Entry->List); 02145 } 02146 } 02147 02148 // 02149 // Check to see if the previous page is the end of an allocation. 02150 // If it is not the end of an allocation, it must be free and 02151 // therefore this allocation can be tagged onto the end of 02152 // that allocation. 02153 // 02154 // We cannot walk off the beginning of expansion pool because it is 02155 // guard-paged. If the initial pool is superpaged instead, we are also 02156 // safe as the must succeed pages always have EndOfAllocation set. 02157 // 02158 02159 Entry = (PMMFREE_POOL_ENTRY)StartingAddress; 02160 02161 if (MI_IS_PHYSICAL_ADDRESS(StartingAddress)) { 02162 ASSERT (StartingAddress != MmNonPagedPoolStart); 02163 02164 Pfn1 = MI_PFN_ELEMENT (MI_CONVERT_PHYSICAL_TO_PFN ( 02165 (PVOID)((PCHAR)Entry - PAGE_SIZE))); 02166 02167 } else { 02168 PointerPte -= NumberOfPages + 1; 02169 02170 // 02171 // Unprotect the previously freed pool so it can be merged. 02172 // 02173 02174 if (MmProtectFreedNonPagedPool == TRUE) { 02175 MiUnProtectFreeNonPagedPool ( 02176 (PVOID)MiGetVirtualAddressMappedByPte(PointerPte), 02177 0); 02178 } 02179 02180 if (PointerPte->u.Hard.Valid == 1) { 02181 Pfn1 = MI_PFN_ELEMENT (PointerPte->u.Hard.PageFrameNumber); 02182 } else { 02183 Pfn1 = NULL; 02184 } 02185 } 02186 if (Pfn1 != NULL) { 02187 if (Pfn1->u3.e1.EndOfAllocation == 0) { 02188 02189 // 02190 // This range of pages is free, add these pages to 02191 // this entry. The owner field points to the address 02192 // of the list entry which is linked into the free pool 02193 // pages list. 02194 // 02195 02196 Entry = (PMMFREE_POOL_ENTRY)((PCHAR)StartingAddress - PAGE_SIZE); 02197 ASSERT (Entry->Signature == MM_FREE_POOL_SIGNATURE); 02198 Entry = Entry->Owner; 02199 02200 // 02201 // Unprotect the previously freed pool so we can merge it 02202 // 02203 02204 if (MmProtectFreedNonPagedPool == TRUE) { 02205 MiUnProtectFreeNonPagedPool ((PVOID)Entry, 0); 02206 } 02207 02208 // 02209 // If this entry became larger than MM_SMALL_ALLOCATIONS 02210 // pages, move it to the tail of the list. This keeps the 02211 // small allocations at the front of the list. 02212 // 02213 02214 if (Entry->Size < MI_MAX_FREE_LIST_HEADS - 1) { 02215 02216 if (MmProtectFreedNonPagedPool == FALSE) { 02217 RemoveEntryList (&Entry->List); 02218 } 02219 else { 02220 MiProtectedPoolRemoveEntryList (&Entry->List); 02221 } 02222 02223 // 02224 // Add these pages to the previous entry. 02225 // 02226 02227 Entry->Size += i; 02228 02229 Index = (ULONG)(Entry->Size - 1); 02230 02231 if (Index >= MI_MAX_FREE_LIST_HEADS) { 02232 Index = MI_MAX_FREE_LIST_HEADS - 1; 02233 } 02234 02235 if (MmProtectFreedNonPagedPool == FALSE) { 02236 InsertTailList (&MmNonPagedPoolFreeListHead[Index], 02237 &Entry->List); 02238 } 02239 else { 02240 MiProtectedPoolInsertList (&MmNonPagedPoolFreeListHead[Index], 02241 &Entry->List, 02242 Entry->Size < MM_SMALL_ALLOCATIONS ? 02243 TRUE : FALSE); 02244 } 02245 } 02246 else { 02247 02248 // 02249 // Add these pages to the previous entry. 02250 // 02251 02252 Entry->Size += i; 02253 } 02254 } 02255 } 02256 02257 if (Entry == (PMMFREE_POOL_ENTRY)StartingAddress) { 02258 02259 // 02260 // This entry was not combined with the previous, insert it 02261 // into the list. 02262 // 02263 02264 Entry->Size = i; 02265 02266 Index = (ULONG)(Entry->Size - 1); 02267 02268 if (Index >= MI_MAX_FREE_LIST_HEADS) { 02269 Index = MI_MAX_FREE_LIST_HEADS - 1; 02270 } 02271 02272 if (MmProtectFreedNonPagedPool == FALSE) { 02273 InsertTailList (&MmNonPagedPoolFreeListHead[Index], 02274 &Entry->List); 02275 } 02276 else { 02277 MiProtectedPoolInsertList (&MmNonPagedPoolFreeListHead[Index], 02278 &Entry->List, 02279 Entry->Size < MM_SMALL_ALLOCATIONS ? 02280 TRUE : FALSE); 02281 } 02282 } 02283 02284 // 02285 // Set the owner field in all these pages. 02286 // 02287 02288 NextEntry = (PMMFREE_POOL_ENTRY)StartingAddress; 02289 while (i > 0) { 02290 NextEntry->Owner = Entry; 02291 #if DBG 02292 NextEntry->Signature = MM_FREE_POOL_SIGNATURE; 02293 #endif 02294 02295 NextEntry = (PMMFREE_POOL_ENTRY)((PCHAR)NextEntry + PAGE_SIZE); 02296 i -= 1; 02297 } 02298 02299 #if DBG 02300 NextEntry = Entry; 02301 for (i = 0; i < Entry->Size; i += 1) { 02302 PMMPTE DebugPte; 02303 PMMPFN DebugPfn; 02304 if (MI_IS_PHYSICAL_ADDRESS(StartingAddress)) { 02305 02306 // 02307 // On certain architectures, virtual addresses 02308 // may be physical and hence have no corresponding PTE. 02309 // 02310 02311 DebugPfn = MI_PFN_ELEMENT (MI_CONVERT_PHYSICAL_TO_PFN (NextEntry)); 02312 } else { 02313 02314 DebugPte = MiGetPteAddress (NextEntry); 02315 DebugPfn = MI_PFN_ELEMENT (DebugPte->u.Hard.PageFrameNumber); 02316 } 02317 ASSERT (DebugPfn->u3.e1.StartOfAllocation == 0); 02318 ASSERT (DebugPfn->u3.e1.EndOfAllocation == 0); 02319 ASSERT (NextEntry->Owner == Entry); 02320 NextEntry = (PMMFREE_POOL_ENTRY)((PCHAR)NextEntry + PAGE_SIZE); 02321 } 02322 #endif 02323 02324 // 02325 // Prevent anyone from touching non paged pool after freeing it. 02326 // 02327 02328 if (MmProtectFreedNonPagedPool == TRUE) { 02329 MiProtectFreeNonPagedPool ((PVOID)Entry, (ULONG)Entry->Size); 02330 } 02331 02332 return (ULONG)NumberOfPages; 02333 02334 } else { 02335 02336 // 02337 // Paged pool. Need to verify start of allocation using 02338 // end of allocation bitmap. 02339 // 02340 02341 if (!RtlCheckBit (PagedPoolInfo->PagedPoolAllocationMap, StartPosition)) { 02342 KeBugCheckEx (BAD_POOL_CALLER, 02343 0x50, 02344 (ULONG_PTR)StartingAddress, 02345 (ULONG_PTR)StartPosition, 02346 MmSizeOfPagedPoolInBytes); 02347 } 02348 02349 #if DBG 02350 if (StartPosition > 0) { 02351 if (RtlCheckBit (PagedPoolInfo->PagedPoolAllocationMap, StartPosition - 1)) { 02352 if (!RtlCheckBit (PagedPoolInfo->EndOfPagedPoolBitmap, StartPosition - 1)) { 02353 02354 // 02355 // In the middle of an allocation... bugcheck. 02356 // 02357 02358 DbgPrint("paged pool in middle of allocation\n"); 02359 KeBugCheckEx (MEMORY_MANAGEMENT, 02360 0x41286, 02361 (ULONG_PTR)PagedPoolInfo->PagedPoolAllocationMap, 02362 (ULONG_PTR)PagedPoolInfo->EndOfPagedPoolBitmap, 02363 StartPosition); 02364 } 02365 } 02366 } 02367 #endif 02368 02369 i = StartPosition; 02370 PointerPte = PagedPoolInfo->FirstPteForPagedPool + i; 02371 02372 // 02373 // Find the last allocated page and check to see if any 02374 // of the pages being deallocated are in the paging file. 02375 // 02376 02377 while (!RtlCheckBit (PagedPoolInfo->EndOfPagedPoolBitmap, i)) { 02378 NumberOfPages += 1; 02379 i += 1; 02380 } 02381 02382 NoAccessPte.u.Long = MM_KERNEL_NOACCESS_PTE; 02383 02384 if (SessionSpace) { 02385 02386 // 02387 // This is needed purely to verify no one leaks pool. This 02388 // could be removed if we believe everyone was good. 02389 // 02390 02391 if (RtlCheckBit (PagedPoolInfo->PagedPoolLargeSessionAllocationMap, 02392 StartPosition)) { 02393 02394 RtlClearBits (PagedPoolInfo->PagedPoolLargeSessionAllocationMap, 02395 StartPosition, 02396 1L); 02397 02398 MiSessionPoolFreed (MiGetVirtualAddressMappedByPte (PointerPte), 02399 NumberOfPages << PAGE_SHIFT, 02400 PagedPool); 02401 } 02402 02403 SessionAllocation = TRUE; 02404 } 02405 else { 02406 SessionAllocation = FALSE; 02407 02408 if (VerifierLargePagedPoolMap) { 02409 02410 if (RtlCheckBit (VerifierLargePagedPoolMap, StartPosition)) { 02411 02412 RtlClearBits (VerifierLargePagedPoolMap, 02413 StartPosition, 02414 1L); 02415 02416 VerifierFreeTrackedPool (MiGetVirtualAddressMappedByPte (PointerPte), 02417 NumberOfPages << PAGE_SHIFT, 02418 PagedPool, 02419 FALSE); 02420 } 02421 } 02422 } 02423 02424 PagesFreed = MiDeleteSystemPagableVm (PointerPte, 02425 NumberOfPages, 02426 NoAccessPte, 02427 SessionAllocation, 02428 NULL); 02429 02430 ASSERT (PagesFreed == NumberOfPages); 02431 02432 if (SessionSpace) { 02433 LOCK_SESSION_SPACE_WS (OldIrql); 02434 MmSessionSpace->CommittedPages -= NumberOfPages; 02435 02436 MM_BUMP_SESS_COUNTER(MM_DBG_SESSION_COMMIT_POOL_FREED, 02437 NumberOfPages); 02438 02439 UNLOCK_SESSION_SPACE_WS (OldIrql); 02440 } 02441 else { 02442 MmPagedPoolCommit -= (ULONG)NumberOfPages; 02443 } 02444 02445 MiReturnCommitment (NumberOfPages); 02446 02447 MM_TRACK_COMMIT (MM_DBG_COMMIT_RETURN_PAGED_POOL_PAGES, NumberOfPages); 02448 02449 // 02450 // Clear the end of allocation bit in the bit map. 02451 // 02452 02453 RtlClearBits (PagedPoolInfo->EndOfPagedPoolBitmap, (ULONG)i, 1L); 02454 02455 PagedPoolInfo->PagedPoolCommit -= NumberOfPages; 02456 PagedPoolInfo->AllocatedPagedPool -= NumberOfPages; 02457 02458 // 02459 // Clear the allocation bits in the bit map. 02460 // 02461 02462 RtlClearBits (PagedPoolInfo->PagedPoolAllocationMap, 02463 StartPosition, 02464 (ULONG)NumberOfPages 02465 ); 02466 02467 if (StartPosition < PagedPoolInfo->PagedPoolHint) { 02468 PagedPoolInfo->PagedPoolHint = StartPosition; 02469 } 02470 02471 return (ULONG)NumberOfPages; 02472 } 02473 }

VOID MiFreeSessionPoolBitMaps (  VOID   )

Definition at line 4478 of file allocpag.c. References _MM_PAGED_POOL_INFO::EndOfPagedPoolBitmap, ExFreePool(), MmSessionSpace, NULL, PAGED_CODE, _MM_PAGED_POOL_INFO::PagedPoolAllocationMap, _MM_SESSION_SPACE::PagedPoolInfo, and _MM_PAGED_POOL_INFO::PagedPoolLargeSessionAllocationMap. Referenced by MiDereferenceSession(), MiInitializeSessionPool(), and MiSessionCreateInternal(). : Free the current session's pool bitmap structures. Arguments: None. Return Value: None. Environment: Kernel mode. --*/ { PAGED_CODE(); if (MmSessionSpace->PagedPoolInfo.PagedPoolAllocationMap ) { ExFreePool (MmSessionSpace->PagedPoolInfo.PagedPoolAllocationMap); MmSessionSpace->PagedPoolInfo.PagedPoolAllocationMap = NULL; } if (MmSessionSpace->PagedPoolInfo.EndOfPagedPoolBitmap ) { ExFreePool (MmSessionSpace->PagedPoolInfo.EndOfPagedPoolBitmap); MmSessionSpace->PagedPoolInfo.EndOfPagedPoolBitmap = NULL; } if (MmSessionSpace->PagedPoolInfo.PagedPoolLargeSessionAllocationMap) { ExFreePool (MmSessionSpace->PagedPoolInfo.PagedPoolLargeSessionAllocationMap); MmSessionSpace->PagedPoolInfo.PagedPoolLargeSessionAllocationMap = NULL; } }

VOID MiInitializeNonPagedPool (  VOID   )

Definition at line 2476 of file allocpag.c. References ASSERT, BYTES_TO_PAGES, Index, MI_CONVERT_PHYSICAL_TO_PFN, MI_GET_PAGE_FRAME_FROM_PTE, MI_IS_PHYSICAL_ADDRESS, MI_MAX_FREE_LIST_HEADS, MiEndOfInitialPoolFrame, MiGetPteAddress, MiInitializeSystemPtes(), MM_FREE_POOL_SIGNATURE, MmExpandedPoolBitPosition, MmMaximumNonPagedPoolInBytes, MmMustSucceedPoolBitPosition, MmNonPagedMustSucceed, MmNonPagedPoolExpansionStart, MmNonPagedPoolFreeListHead, MmNonPagedPoolStart, MmNumberOfFreeNonPagedPool, MmSizeOfNonPagedMustSucceed, MmSizeOfNonPagedPoolInBytes, NonPagedPoolExpansion, PAGE_SIZE, PAGED_CODE, _MMFREE_POOL_ENTRY::Signature, Size, and _MMPTE::u. Referenced by MiInitMachineDependent(). 02482 : 02483 02484 This function initializes the NonPaged pool. 02485 02486 NonPaged Pool is linked together through the pages. 02487 02488 Arguments: 02489 02490 None. 02491 02492 Return Value: 02493 02494 None. 02495 02496 Environment: 02497 02498 Kernel mode, during initialization. 02499 02500 --*/ 02501 02502 { 02503 ULONG PagesInPool; 02504 ULONG Size; 02505 ULONG Index; 02506 PMMFREE_POOL_ENTRY FreeEntry; 02507 PMMFREE_POOL_ENTRY FirstEntry; 02508 PMMPTE PointerPte; 02509 PFN_NUMBER i; 02510 PULONG_PTR ThisPage; 02511 PULONG_PTR NextPage; 02512 PVOID EndOfInitialPool; 02513 PFN_NUMBER PageFrameIndex; 02514 02515 PAGED_CODE(); 02516 02517 // 02518 // Initialize the list heads for free pages. 02519 // 02520 02521 for (Index = 0; Index < MI_MAX_FREE_LIST_HEADS; Index += 1) { 02522 InitializeListHead (&MmNonPagedPoolFreeListHead[Index]); 02523 } 02524 02525 // 02526 // Initialize the must succeed pool (this occupies the first 02527 // pages of the pool area). 02528 // 02529 02530 // 02531 // Allocate NonPaged pool for the NonPagedPoolMustSucceed pool. 02532 // 02533 02534 MmNonPagedMustSucceed = (PCHAR)MmNonPagedPoolStart; 02535 02536 i = MmSizeOfNonPagedMustSucceed - PAGE_SIZE; 02537 02538 MmMustSucceedPoolBitPosition = BYTES_TO_PAGES(MmSizeOfNonPagedMustSucceed); 02539 02540 ThisPage = (PULONG_PTR)MmNonPagedMustSucceed; 02541 02542 while (i > 0) { 02543 NextPage = (PULONG_PTR)((PCHAR)ThisPage + PAGE_SIZE); 02544 *ThisPage = (ULONG_PTR)NextPage; 02545 ThisPage = NextPage; 02546 i -= PAGE_SIZE; 02547 } 02548 *ThisPage = 0; 02549 02550 // 02551 // Set up the remaining pages as non paged pool pages. 02552 // 02553 02554 ASSERT ((MmSizeOfNonPagedMustSucceed & (PAGE_SIZE - 1)) == 0); 02555 FreeEntry = (PMMFREE_POOL_ENTRY)((PCHAR)MmNonPagedPoolStart + 02556 MmSizeOfNonPagedMustSucceed); 02557 FirstEntry = FreeEntry; 02558 02559 PagesInPool = BYTES_TO_PAGES(MmSizeOfNonPagedPoolInBytes - 02560 MmSizeOfNonPagedMustSucceed); 02561 02562 // 02563 // Set the location of expanded pool. 02564 // 02565 02566 MmExpandedPoolBitPosition = BYTES_TO_PAGES (MmSizeOfNonPagedPoolInBytes); 02567 02568 MmNumberOfFreeNonPagedPool = PagesInPool; 02569 02570 Index = (ULONG)(MmNumberOfFreeNonPagedPool - 1); 02571 if (Index >= MI_MAX_FREE_LIST_HEADS) { 02572 Index = MI_MAX_FREE_LIST_HEADS - 1; 02573 } 02574 02575 InsertHeadList (&MmNonPagedPoolFreeListHead[Index], &FreeEntry->List); 02576 02577 FreeEntry->Size = PagesInPool; 02578 #if DBG 02579 FreeEntry->Signature = MM_FREE_POOL_SIGNATURE; 02580 #endif 02581 FreeEntry->Owner = FirstEntry; 02582 02583 while (PagesInPool > 1) { 02584 FreeEntry = (PMMFREE_POOL_ENTRY)((PCHAR)FreeEntry + PAGE_SIZE); 02585 #if DBG 02586 FreeEntry->Signature = MM_FREE_POOL_SIGNATURE; 02587 #endif 02588 FreeEntry->Owner = FirstEntry; 02589 PagesInPool -= 1; 02590 } 02591 02592 // 02593 // Set the last nonpaged pool PFN so coalescing on free doesn't go 02594 // past the end of the initial pool. 02595 // 02596 02597 EndOfInitialPool = (PVOID)((ULONG_PTR)MmNonPagedPoolStart + MmSizeOfNonPagedPoolInBytes - 1); 02598 02599 if (MI_IS_PHYSICAL_ADDRESS(EndOfInitialPool)) { 02600 PageFrameIndex = MI_CONVERT_PHYSICAL_TO_PFN (EndOfInitialPool); 02601 } else { 02602 PointerPte = MiGetPteAddress(EndOfInitialPool); 02603 ASSERT (PointerPte->u.Hard.Valid == 1); 02604 PageFrameIndex = MI_GET_PAGE_FRAME_FROM_PTE (PointerPte); 02605 } 02606 MiEndOfInitialPoolFrame = PageFrameIndex; 02607 02608 // 02609 // Set up the system PTEs for nonpaged pool expansion. 02610 // 02611 02612 PointerPte = MiGetPteAddress (MmNonPagedPoolExpansionStart); 02613 ASSERT (PointerPte->u.Hard.Valid == 0); 02614 02615 Size = BYTES_TO_PAGES(MmMaximumNonPagedPoolInBytes - 02616 MmSizeOfNonPagedPoolInBytes); 02617 02618 // 02619 // Insert a guard PTE at the bottom of expanded nonpaged pool. 02620 // 02621 02622 Size -= 1; 02623 PointerPte += 1; 02624 02625 MiInitializeSystemPtes (PointerPte, 02626 Size, 02627 NonPagedPoolExpansion 02628 ); 02629 02630 // 02631 // A guard PTE is built at the top by our caller. This allows us to 02632 // freely increment virtual addresses in MiFreePoolPages and just check 02633 // for a blank PTE. 02634 // 02635 }

NTSTATUS MiInitializeSessionPool (  VOID   )

Definition at line 4222 of file allocpag.c. References _MM_PAGED_POOL_INFO::AllocatedPagedPool, ASSERT, _MM_SESSION_SPACE::CommittedPages, _MM_PAGED_POOL_INFO::EndOfPagedPoolBitmap, ExInitializeFastMutex, ExpInitializePoolDescriptor(), FALSE, _MM_PAGED_POOL_INFO::FirstPteForPagedPool, Index, _MM_PAGED_POOL_INFO::LastPteForPagedPool, LOCK_PFN, MI_FLUSH_SINGLE_SESSION_TB, MI_GET_PAGE_COLOR_FROM_PTE, MI_PFN_ELEMENT, MI_SESSION_POOL, MI_SESSION_POOL_SIZE, MI_SET_PFN_DELETED, MI_WRITE_VALID_PTE, MiChargeCommitment(), MiCreateBitMap, MiDecrementShareAndValidCount, MiDecrementShareCountOnly, MiEnsureAvailablePageOrWait(), MiFillMemoryPte, MiFreeSessionPoolBitMaps(), MiGetPdeAddress, MiGetPdeSessionIndex, MiGetPteAddress, MiInitializePfnForOtherProcess(), MiRemoveAnyPage(), MiReturnCommitment(), MM_BUMP_COUNTER, MM_BUMP_SESS_COUNTER, MM_BUMP_SESSION_FAILURES, MM_DBG_COMMIT_RETURN_PAGED_POOL_PAGES, MM_DBG_COMMIT_RETURN_SESSION_POOL_PAGE_TABLES, MM_DBG_COMMIT_SESSION_POOL_PAGE_TABLES, MM_DBG_SESSION_PAGEDPOOL_PAGETABLE_ALLOC, MM_DBG_SESSION_PAGEDPOOL_PAGETABLE_FREE_FAIL1, MM_KERNEL_NOACCESS_PTE, MM_SESSION_FAILURE_NO_COMMIT, MM_SESSION_FAILURE_NO_NONPAGED_POOL, MM_SESSION_FAILURE_NO_RESIDENT, MM_TRACK_COMMIT, MmAvailablePages, MmResidentAvailablePages, MmSessionSpace, _MM_PAGED_POOL_INFO::NextPdeForPagedPoolExpansion, _MM_SESSION_SPACE::NonPagablePages, NonPagedPool, NULL, PAGE_SHIFT, PAGE_SIZE, _MM_SESSION_SPACE::PagedPool, _MM_PAGED_POOL_INFO::PagedPoolAllocationMap, _MM_SESSION_SPACE::PagedPoolBasePde, _MM_PAGED_POOL_INFO::PagedPoolCommit, _MM_SESSION_SPACE::PagedPoolEnd, _MM_PAGED_POOL_INFO::PagedPoolHint, _MM_SESSION_SPACE::PagedPoolInfo, _MM_PAGED_POOL_INFO::PagedPoolLargeSessionAllocationMap, _MM_SESSION_SPACE::PagedPoolMutex, PagedPoolSession, _MM_SESSION_SPACE::PagedPoolStart, _MM_SESSION_SPACE::PageTables, PPOOL_DESCRIPTOR, PTE_PER_PAGE, _MMPFN::PteFrame, RtlClearAllBits(), RtlClearBits(), RtlSetAllBits(), SESSION_GLOBAL, _MM_SESSION_SPACE::SessionPageDirectoryIndex, TRUE, _MMPTE::u, _MMPFN::u1, _MMPFN::u2, UNLOCK_PFN, ValidKernelPdeLocal, and ZeroKernelPte. Referenced by MiSessionCreateInternal(). : Initialize the current session's pool structure. Arguments: None. Return Value: Status of the pool initialization. Environment: Kernel mode. --*/ { ULONG Index; MMPTE TempPte; PMMPTE PointerPde, PointerPte; PFN_NUMBER PageFrameIndex; PPOOL_DESCRIPTOR PoolDescriptor; PMM_SESSION_SPACE SessionGlobal; PMM_PAGED_POOL_INFO PagedPoolInfo; KIRQL OldIrql; PMMPFN Pfn1; MMPTE PreviousPte; #if DBG PMMPTE StartPde, EndPde; #endif SessionGlobal = SESSION_GLOBAL(MmSessionSpace); ExInitializeFastMutex (&SessionGlobal->PagedPoolMutex); PoolDescriptor = &MmSessionSpace->PagedPool; ExpInitializePoolDescriptor (PoolDescriptor, PagedPoolSession, 0, 0, &SessionGlobal->PagedPoolMutex); MmSessionSpace->PagedPoolStart = (PVOID)MI_SESSION_POOL; MmSessionSpace->PagedPoolEnd = (PVOID)((MI_SESSION_POOL + MI_SESSION_POOL_SIZE)-1); PagedPoolInfo = &MmSessionSpace->PagedPoolInfo; PagedPoolInfo->PagedPoolCommit = 0; PagedPoolInfo->PagedPoolHint = 0; PagedPoolInfo->AllocatedPagedPool = 0; // // Build the page table page for paged pool. // PointerPde = MiGetPdeAddress (MmSessionSpace->PagedPoolStart); MmSessionSpace->PagedPoolBasePde = PointerPde; PointerPte = MiGetPteAddress (MmSessionSpace->PagedPoolStart); PagedPoolInfo->FirstPteForPagedPool = PointerPte; PagedPoolInfo->LastPteForPagedPool = MiGetPteAddress (MmSessionSpace->PagedPoolEnd); #if DBG // // Session pool better be unused. // StartPde = MiGetPdeAddress (MmSessionSpace->PagedPoolStart); EndPde = MiGetPdeAddress (MmSessionSpace->PagedPoolEnd); while (StartPde <= EndPde) { ASSERT (StartPde->u.Long == 0); StartPde += 1; } #endif // // Mark all PDEs as empty. // MiFillMemoryPte (PointerPde, sizeof(MMPTE) * (1 + MiGetPdeAddress (MmSessionSpace->PagedPoolEnd) - PointerPde), ZeroKernelPte.u.Long); if (MiChargeCommitment (1, NULL) == FALSE) { MM_BUMP_SESSION_FAILURES (MM_SESSION_FAILURE_NO_COMMIT); return STATUS_NO_MEMORY; } MM_TRACK_COMMIT (MM_DBG_COMMIT_SESSION_POOL_PAGE_TABLES, 1); TempPte = ValidKernelPdeLocal; LOCK_PFN (OldIrql); if (MmAvailablePages <= 1) { UNLOCK_PFN (OldIrql); MiReturnCommitment (1); MM_TRACK_COMMIT (MM_DBG_COMMIT_RETURN_SESSION_POOL_PAGE_TABLES, 1); MM_BUMP_SESSION_FAILURES (MM_SESSION_FAILURE_NO_RESIDENT); return STATUS_NO_MEMORY; } MmResidentAvailablePages -= 1; MM_BUMP_COUNTER(42, 1); MM_BUMP_SESS_COUNTER(MM_DBG_SESSION_PAGEDPOOL_PAGETABLE_ALLOC, 1); MiEnsureAvailablePageOrWait (NULL, NULL); // // Allocate and map in the initial page table page for session pool. // PageFrameIndex = MiRemoveAnyPage (MI_GET_PAGE_COLOR_FROM_PTE (PointerPde)); TempPte.u.Hard.PageFrameNumber = PageFrameIndex; MI_WRITE_VALID_PTE (PointerPde, TempPte); MiInitializePfnForOtherProcess (PageFrameIndex, PointerPde, MmSessionSpace->SessionPageDirectoryIndex); Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); // // This page will be locked into working set and assigned an index when // the working set is set up on return. // ASSERT (Pfn1->u1.WsIndex == 0); UNLOCK_PFN (OldIrql); KeFillEntryTb ((PHARDWARE_PTE) PointerPde, PointerPte, FALSE); #if !defined (_WIN64) Index = MiGetPdeSessionIndex (MmSessionSpace->PagedPoolStart); ASSERT (MmSessionSpace->PageTables[Index].u.Long == 0); MmSessionSpace->PageTables[Index] = TempPte; #endif MmSessionSpace->NonPagablePages += 1; MmSessionSpace->CommittedPages += 1; MiFillMemoryPte (PointerPte, PAGE_SIZE, MM_KERNEL_NOACCESS_PTE); PagedPoolInfo->NextPdeForPagedPoolExpansion = PointerPde + 1; // // Initialize the bitmaps. // MiCreateBitMap (&PagedPoolInfo->PagedPoolAllocationMap, MI_SESSION_POOL_SIZE >> PAGE_SHIFT, NonPagedPool); if (PagedPoolInfo->PagedPoolAllocationMap == NULL) { MM_BUMP_SESSION_FAILURES (MM_SESSION_FAILURE_NO_NONPAGED_POOL); goto Failure; } // // We start with all pages in the virtual address space as "busy", and // clear bits to make pages available as we dynamically expand the pool. // RtlSetAllBits( PagedPoolInfo->PagedPoolAllocationMap ); // // Indicate first page worth of PTEs are available. // RtlClearBits (PagedPoolInfo->PagedPoolAllocationMap, 0, PTE_PER_PAGE); // // Create the end of allocation range bitmap. // MiCreateBitMap (&PagedPoolInfo->EndOfPagedPoolBitmap, MI_SESSION_POOL_SIZE >> PAGE_SHIFT, NonPagedPool); if (PagedPoolInfo->EndOfPagedPoolBitmap == NULL) { MM_BUMP_SESSION_FAILURES (MM_SESSION_FAILURE_NO_NONPAGED_POOL); goto Failure; } RtlClearAllBits (PagedPoolInfo->EndOfPagedPoolBitmap); // // Create the large session allocation bitmap. // MiCreateBitMap (&PagedPoolInfo->PagedPoolLargeSessionAllocationMap, MI_SESSION_POOL_SIZE >> PAGE_SHIFT, NonPagedPool); if (PagedPoolInfo->PagedPoolLargeSessionAllocationMap == NULL) { MM_BUMP_SESSION_FAILURES (MM_SESSION_FAILURE_NO_NONPAGED_POOL); goto Failure; } RtlClearAllBits (PagedPoolInfo->PagedPoolLargeSessionAllocationMap); return STATUS_SUCCESS; Failure: MiFreeSessionPoolBitMaps (); LOCK_PFN (OldIrql); ASSERT (MmSessionSpace->SessionPageDirectoryIndex == Pfn1->PteFrame); ASSERT (Pfn1->u2.ShareCount == 1); MiDecrementShareAndValidCount (Pfn1->PteFrame); MI_SET_PFN_DELETED (Pfn1); MiDecrementShareCountOnly (PageFrameIndex); MI_FLUSH_SINGLE_SESSION_TB (MiGetPteAddress(PointerPde), TRUE, TRUE, (PHARDWARE_PTE)PointerPde, ZeroKernelPte.u.Flush, PreviousPte); MmSessionSpace->NonPagablePages -= 1; MmSessionSpace->CommittedPages -= 1; MmResidentAvailablePages += 1; MM_BUMP_COUNTER(51, 1); MM_BUMP_SESS_COUNTER(MM_DBG_SESSION_PAGEDPOOL_PAGETABLE_FREE_FAIL1, 1); UNLOCK_PFN (OldIrql); MiReturnCommitment (1); MM_TRACK_COMMIT (MM_DBG_COMMIT_RETURN_PAGED_POOL_PAGES, 1); return STATUS_NO_MEMORY; }

VOID MiInitializeSpecialPool (  VOID   )

Definition at line 2974 of file allocpag.c. References ExpMultiUserTS, FALSE, LOCK_PFN, MiGetVirtualAddressMappedByPte, MiHydra, MiNumberOfExtraSystemPdes, MiRequestedSystemPtes, MiReserveSystemPtes(), MiSpecialPagesNonPagedMaximum, MiSpecialPoolFirstPte, MiSpecialPoolLastPte, MiSpecialPoolPtes, MM_EMPTY_PTE_LIST, MM_SPECIAL_POOL_PTES, MmNumberOfPhysicalPages, MmNumberOfSystemPtes, MmPagedPoolMaximumDesired, MmResidentAvailablePages, MmSpecialPoolEnd, MmSpecialPoolStart, MmSpecialPoolTag, MmSystemPteBase, MmVerifyDriverBufferLength, NULL, PTE_PER_PAGE, SystemPteSpace, TRUE, _MMPTE::u, and UNLOCK_PFN. : This routine initializes the special pool used to catch pool corruptors. Arguments: None. Return Value: None. Environment: Kernel mode, no locks held. --*/ { ULONG BugCheckOnFailure; KIRQL OldIrql; PMMPTE PointerPte; if ((MmVerifyDriverBufferLength == (ULONG)-1) && ((MmSpecialPoolTag == 0) || (MmSpecialPoolTag == (ULONG)-1))) { return; } #if PFN_CONSISTENCY MiUnMapPfnDatabase (); #endif LOCK_PFN (OldIrql); // // Even though we asked for some number of system PTEs to map special pool, // we may not have been given them all. Large memory systems are // autoconfigured so that a large nonpaged pool is the default. // x86 systems booted with the 3GB switch and all Alphas don't have enough // contiguous virtual address space to support this, so our request may // have been trimmed. Handle that intelligently here so we don't exhaust // the system PTE pool and fail to handle thread stacks and I/O. // if (MmNumberOfSystemPtes < 0x3000) { MiSpecialPoolPtes = MmNumberOfSystemPtes / 6; } else { MiSpecialPoolPtes = MmNumberOfSystemPtes / 3; } #if !defined (_WIN64) // // 32-bit systems are very cramped on virtual address space. Apply // a cap here to prevent overzealousness. // if (MiSpecialPoolPtes > MM_SPECIAL_POOL_PTES) { MiSpecialPoolPtes = MM_SPECIAL_POOL_PTES; } #endif #ifdef _X86_ // // For x86, we can actually use an additional range of special PTEs to // map memory with and so we can raise the limit from 25000 to approximately // 96000. // if ((MiNumberOfExtraSystemPdes != 0) && ((MiHydra == FALSE) || (ExpMultiUserTS == FALSE)) && (MiRequestedSystemPtes != (ULONG)-1)) { if (MmPagedPoolMaximumDesired == TRUE) { // // The low PTEs between 0xA4000000 & 0xC0000000 must be used // for both regular system PTE usage and special pool usage. // MiSpecialPoolPtes = (MiNumberOfExtraSystemPdes / 2) * PTE_PER_PAGE; } else { // // The low PTEs between 0xA4000000 & 0xC0000000 can be used // exclusively for special pool. // MiSpecialPoolPtes = MiNumberOfExtraSystemPdes * PTE_PER_PAGE; } } #endif // // A PTE disappears for double mapping the system page directory. // When guard paging for system PTEs is enabled, a few more go also. // Thus, not being able to get all the PTEs we wanted is not fatal and // we just back off a bit and retry. // // // Always request an even number of PTEs so each one can be guard paged. // MiSpecialPoolPtes &= ~0x1; BugCheckOnFailure = FALSE; do { MiSpecialPoolFirstPte = MiReserveSystemPtes (MiSpecialPoolPtes, SystemPteSpace, 0, 0, BugCheckOnFailure); if (MiSpecialPoolFirstPte != NULL) { break; } if (MiSpecialPoolPtes == 0) { BugCheckOnFailure = TRUE; continue; } MiSpecialPoolPtes -= 2; } while (1); // // Build the list of PTE pairs. // MiSpecialPoolLastPte = MiSpecialPoolFirstPte + MiSpecialPoolPtes; MmSpecialPoolStart = MiGetVirtualAddressMappedByPte (MiSpecialPoolFirstPte); PointerPte = MiSpecialPoolFirstPte; while (PointerPte < MiSpecialPoolLastPte) { PointerPte->u.List.NextEntry = ((PointerPte + 2) - MmSystemPteBase); PointerPte += 2; } PointerPte -= 2; PointerPte->u.List.NextEntry = MM_EMPTY_PTE_LIST; MiSpecialPoolLastPte = PointerPte; MmSpecialPoolEnd = MiGetVirtualAddressMappedByPte (MiSpecialPoolLastPte + 1); // // Cap nonpaged special pool based on the memory size. // MiSpecialPagesNonPagedMaximum = (ULONG)(MmResidentAvailablePages >> 4); if (MmNumberOfPhysicalPages > 0x3FFF) { MiSpecialPagesNonPagedMaximum = (ULONG)(MmResidentAvailablePages >> 3); } UNLOCK_PFN (OldIrql); }

VOID MiInitializeSpecialPoolCriteria (  VOID   )

Definition at line 3270 of file allocpag.c. References _MI_BAD_TAGS::AllOthers, _MI_BAD_TAGS::Enabled, InitializationPhase, KeInitializeDpc(), KeInitializeTimer(), KeQuerySystemTime(), KeSetTimerEx(), MI_THREE_SECONDS, MiBadTags, MiSpecialPoolTimer, MiSpecialPoolTimerDispatch(), MiSpecialPoolTimerDpc, MiTimerDueTime, MmSpecialPoolTag, NULL, _MI_BAD_TAGS::RandomizerEnabled, RtlTimeToTimeFields(), _MI_BAD_TAGS::TargetChar, and TimeFields. { LARGE_INTEGER SystemTime; TIME_FIELDS TimeFields; if (InitializationPhase == 0) { #if defined (_MI_SPECIAL_POOL_BY_DEFAULT) if (MmSpecialPoolTag == 0) { MmSpecialPoolTag = (ULONG)-2; } #endif return; } if (MmSpecialPoolTag != (ULONG)-2) { return; } KeQuerySystemTime (&SystemTime); RtlTimeToTimeFields (&SystemTime, &TimeFields); if (TimeFields.Second <= 25) { MiBadTags.TargetChar = (UCHAR)('a' + (UCHAR)TimeFields.Second); } else if (TimeFields.Second <= 51) { MiBadTags.TargetChar = (UCHAR)('A' + (UCHAR)(TimeFields.Second - 26)); } else { MiBadTags.AllOthers = 1; } MiBadTags.RandomizerEnabled = 1; // // Initialize a periodic timer to go off every three seconds. // KeInitializeDpc (&MiSpecialPoolTimerDpc, MiSpecialPoolTimerDispatch, NULL); KeInitializeTimer (&MiSpecialPoolTimer); MiTimerDueTime.QuadPart = Int32x32To64 (MI_THREE_SECONDS, -10000000); KeSetTimerEx (&MiSpecialPoolTimer, MiTimerDueTime, MI_THREE_SECONDS * 1000, &MiSpecialPoolTimerDpc); MiBadTags.Enabled += 1; }

VOID MiInitializeSpecialPoolCriteria (  IN  VOID  )

VOID MiMakeSpecialPoolPagable (  IN PVOID  VirtualAddress, IN PMMPTE  PointerPte )

Definition at line 4034 of file allocpag.c. References _MMSUPPORT::AllowWorkingSetAdjustment, APC_LEVEL, ASSERT, CONSISTENCY_LOCK_PFN, CONSISTENCY_UNLOCK_PFN, LOCK_EXPANSION_IF_ALPHA, LOCK_SYSTEM_WS, MI_GET_PAGE_FRAME_FROM_TRANSITION_PTE, MI_PFN_ELEMENT, MiAddValidPageToWorkingSet(), MiGrowWsleHash(), MM_GROW_WSLE_HASH, MmSystemCacheWs, PsGetCurrentThread, TRUE, _MMPFN::u1, UNLOCK_EXPANSION_IF_ALPHA, and UNLOCK_SYSTEM_WS. Referenced by MiAllocateSpecialPool(). : Make a special pool allocation pagable. Arguments: VirtualAddress - Supplies the faulting address. PointerPte - Supplies the PTE for the faulting address. Return Value: None. Environment: Kernel mode, no locks (not even pool locks) held. --*/ { PMMPFN Pfn1; MMPTE TempPte; #if defined(_ALPHA_) && !defined(_AXP64_) KIRQL OldIrql; #endif KIRQL PreviousIrql; PFN_NUMBER PageFrameIndex; #if PFN_CONSISTENCY KIRQL PfnIrql; #endif LOCK_SYSTEM_WS (PreviousIrql); // // As this page is now allocated, add it to the system working set to // make it pagable. // TempPte = *PointerPte; PageFrameIndex = MI_GET_PAGE_FRAME_FROM_TRANSITION_PTE (&TempPte); Pfn1 = MI_PFN_ELEMENT (PageFrameIndex); ASSERT (Pfn1->u1.Event == 0); CONSISTENCY_LOCK_PFN (PfnIrql); Pfn1->u1.Event = (PVOID) PsGetCurrentThread(); CONSISTENCY_UNLOCK_PFN (PfnIrql); MiAddValidPageToWorkingSet (VirtualAddress, PointerPte, Pfn1, 0); ASSERT (KeGetCurrentIrql() == APC_LEVEL); if (MmSystemCacheWs.AllowWorkingSetAdjustment == MM_GROW_WSLE_HASH) { MiGrowWsleHash (&MmSystemCacheWs); #if defined(_ALPHA_) && !defined(_AXP64_) LOCK_EXPANSION_IF_ALPHA (OldIrql); #endif MmSystemCacheWs.AllowWorkingSetAdjustment = TRUE; #if defined(_ALPHA_) && !defined(_AXP64_) UNLOCK_EXPANSION_IF_ALPHA (OldIrql); #endif } UNLOCK_SYSTEM_WS (PreviousIrql); }

VOID MiProtectedPoolInsertList (  IN PLIST_ENTRY  ListHead, IN PLIST_ENTRY  Entry, IN LOGICAL  InsertHead )

Definition at line 282 of file allocpag.c. References MiProtectFreeNonPagedPool(), MiUnProtectFreeNonPagedPool(), and TRUE. Referenced by MiAllocatePoolPages(), and MiFreePoolPages(). : This function inserts the entry into the protected list. Arguments: ListHead - Supplies the list head to add onto. Entry - Supplies the list entry to insert. InsertHead - If TRUE, insert at the head otherwise at the tail. Return Value: None. Environment: Kernel mode. --*/ { PVOID FreeFlink; PVOID FreeBlink; PVOID VirtualAddress; // // Either the flink or the blink may be pointing // at protected nonpaged pool. Unprotect now. // FreeFlink = (PVOID)0; FreeBlink = (PVOID)0; if (IsListEmpty(ListHead) == 0) { VirtualAddress = (PVOID)ListHead->Flink; if (MiUnProtectFreeNonPagedPool (VirtualAddress, 1) == TRUE) { FreeFlink = VirtualAddress; } } if (((PVOID)Entry == ListHead->Blink) == 0) { VirtualAddress = (PVOID)ListHead->Blink; if (MiUnProtectFreeNonPagedPool (VirtualAddress, 1) == TRUE) { FreeBlink = VirtualAddress; } } if (InsertHead == TRUE) { InsertHeadList (ListHead, Entry); } else { InsertTailList (ListHead, Entry); } if (FreeFlink) { // // Reprotect the flink. // MiProtectFreeNonPagedPool (FreeFlink, 1); } if (FreeBlink) { // // Reprotect the blink. // MiProtectFreeNonPagedPool (FreeBlink, 1); } }

VOID MiProtectedPoolRemoveEntryList (  IN PLIST_ENTRY  Entry  )

Definition at line 365 of file allocpag.c. References MiProtectFreeNonPagedPool(), MiUnProtectFreeNonPagedPool(), and TRUE. Referenced by MiAllocatePoolPages(), MiFindContiguousMemory(), and MiFreePoolPages(). : This function unlinks the list pointer from protected freed nonpaged pool. Arguments: Entry - Supplies the list entry to remove. Return Value: None. Environment: Kernel mode. --*/ { PVOID FreeFlink; PVOID FreeBlink; PVOID VirtualAddress; // // Either the flink or the blink may be pointing // at protected nonpaged pool. Unprotect now. // FreeFlink = (PVOID)0; FreeBlink = (PVOID)0; if (IsListEmpty(Entry) == 0) { VirtualAddress = (PVOID)Entry->Flink; if (MiUnProtectFreeNonPagedPool (VirtualAddress, 1) == TRUE) { FreeFlink = VirtualAddress; } } if (((PVOID)Entry == Entry->Blink) == 0) { VirtualAddress = (PVOID)Entry->Blink; if (MiUnProtectFreeNonPagedPool (VirtualAddress, 1) == TRUE) { FreeBlink = VirtualAddress; } } RemoveEntryList (Entry); if (FreeFlink) { // // Reprotect the flink. // MiProtectFreeNonPagedPool (FreeFlink, 1); } if (FreeBlink) { // // Reprotect the blink. // MiProtectFreeNonPagedPool (FreeBlink, 1); } }

VOID MiProtectFreeNonPagedPool (  IN PVOID  VirtualAddress, IN ULONG  SizeInPages )

Definition at line 150 of file allocpag.c. References KeFlushSingleTb(), MI_IS_PHYSICAL_ADDRESS, MiGetPteAddress, PAGE_SIZE, TRUE, and _MMPTE::u. Referenced by MiAllocatePoolPages(), MiFindContiguousMemory(), MiFreePoolPages(), MiProtectedPoolInsertList(), MiProtectedPoolRemoveEntryList(), and MmSetKernelDumpRange(). : This function protects freed nonpaged pool. Arguments: VirtualAddress - Supplies the freed pool address to protect. SizeInPages - Supplies the size of the request in pages. Return Value: None. Environment: Kernel mode. --*/ { ULONG i; MMPTE PteContents; PMMPTE PointerPte; // // Prevent anyone from touching the free non paged pool // if (MI_IS_PHYSICAL_ADDRESS(VirtualAddress) == 0) { PointerPte = MiGetPteAddress (VirtualAddress); for (i = 0; i < SizeInPages; i += 1) { PteContents = *PointerPte; PteContents.u.Hard.Valid = 0; PteContents.u.Soft.Prototype = 1; KeFlushSingleTb (VirtualAddress, TRUE, TRUE, (PHARDWARE_PTE)PointerPte, PteContents.u.Flush); VirtualAddress = (PVOID)((PCHAR)VirtualAddress + PAGE_SIZE); PointerPte += 1; } } }

LOGICAL MiProtectSpecialPool (  IN PVOID  VirtualAddress, IN ULONG  NewProtect )

Definition at line 5278 of file allocpag.c. References ASSERT, EXCEPTION_EXECUTE_HANDLER, FALSE, KeFlushSingleTb(), LOCK_PFN2, LOCK_SYSTEM_WS, MI_CAPTURE_DIRTY_BIT_TO_PFN, MI_MAKE_VALID_PTE, MI_PFN_ELEMENT, MI_SPECIAL_POOL_PTE_NONPAGABLE, MI_SPECIAL_POOL_PTE_PAGABLE, MI_WRITE_VALID_PTE_NEW_PROTECTION, MiGetPteAddress, MiMakeProtectionMask(), MiRemovePageFromWorkingSet(), MM_EXECUTE_WRITECOPY, MM_NOACCESS, MM_NOCACHE, MM_WRITECOPY, MmSpecialPoolEnd, MmSystemCacheWs, _MMPFN::OriginalPte, TRUE, _MMPTE::u, _MMPFN::u1, UNLOCK_PFN2, UNLOCK_SYSTEM_WS, and WSLE_NUMBER. Referenced by MmProtectSpecialPool(). 05285 : 05286 05287 This function protects a special pool allocation. 05288 05289 Arguments: 05290 05291 VirtualAddress - Supplies the special pool address to protect. 05292 05293 NewProtect - Supplies the protection to set the pages to (PAGE_XX). 05294 05295 Return Value: 05296 05297 TRUE if the protection was successfully applied, FALSE if not. 05298 05299 Environment: 05300 05301 Kernel mode, IRQL at APC_LEVEL or below for pagable pool, DISPATCH or 05302 below for nonpagable pool. 05303 05304 Note that setting an allocation to NO_ACCESS implies that an accessible 05305 protection must be applied by the caller prior to this allocation being 05306 freed. 05307 05308 --*/ 05309 05310 { 05311 KIRQL OldIrql; 05312 KIRQL OldIrql2; 05313 MMPTE PteContents; 05314 MMPTE NewPteContents; 05315 MMPTE PreviousPte; 05316 PMMPTE PointerPte; 05317 PMMPFN Pfn1; 05318 ULONG ProtectionMask; 05319 WSLE_NUMBER WsIndex; 05320 LOGICAL SystemWsLocked; 05321 05322 if ((VirtualAddress < MmSpecialPoolStart) || (VirtualAddress >= MmSpecialPoolEnd)) { 05323 return (ULONG)-1; 05324 } 05325 05326 try { 05327 ProtectionMask = MiMakeProtectionMask (NewProtect); 05328 } except (EXCEPTION_EXECUTE_HANDLER) { 05329 return (ULONG)-1; 05330 } 05331 05332 SystemWsLocked = FALSE; 05333 05334 PointerPte = MiGetPteAddress (VirtualAddress); 05335 05336 if ((PointerPte + 1)->u.Soft.PageFileHigh == MI_SPECIAL_POOL_PTE_PAGABLE) { 05337 LOCK_SYSTEM_WS (OldIrql); 05338 SystemWsLocked = TRUE; 05339 } 05340 05341 PteContents = *PointerPte; 05342 05343 if (ProtectionMask == MM_NOACCESS) { 05344 05345 if ((PointerPte + 1)->u.Soft.PageFileHigh == MI_SPECIAL_POOL_PTE_PAGABLE) { 05346 retry1: 05347 ASSERT (SystemWsLocked == TRUE); 05348 if (PteContents.u.Hard.Valid == 1) { 05349 05350 Pfn1 = MI_PFN_ELEMENT (PteContents.u.Hard.PageFrameNumber); 05351 WsIndex = Pfn1->u1.WsIndex; 05352 ASSERT (WsIndex != 0); 05353 Pfn1->OriginalPte.u.Soft.Protection = ProtectionMask; 05354 MiRemovePageFromWorkingSet (PointerPte, 05355 Pfn1, 05356 &MmSystemCacheWs); 05357 } 05358 else if (PteContents.u.Soft.Transition == 1) { 05359 05360 LOCK_PFN2 (OldIrql2); 05361 05362 PteContents = *(volatile MMPTE *)PointerPte; 05363 05364 if (PteContents.u.Soft.Transition == 0) { 05365 UNLOCK_PFN2 (OldIrql2); 05366 goto retry1; 05367 } 05368 05369 Pfn1 = MI_PFN_ELEMENT (PteContents.u.Trans.PageFrameNumber); 05370 Pfn1->OriginalPte.u.Soft.Protection = ProtectionMask; 05371 PointerPte->u.Soft.Protection = ProtectionMask; 05372 UNLOCK_PFN2(OldIrql2); 05373 } 05374 else { 05375 05376 // 05377 // Must be page file space or demand zero. 05378 // 05379 05380 PointerPte->u.Soft.Protection = ProtectionMask; 05381 } 05382 ASSERT (SystemWsLocked == TRUE); 05383 UNLOCK_SYSTEM_WS (OldIrql); 05384 } 05385 else { 05386 05387 ASSERT (SystemWsLocked == FALSE); 05388 05389 // 05390 // Make it no access regardless of its previous protection state. 05391 // Note that the page frame number is preserved. 05392 // 05393 05394 PteContents.u.Hard.Valid = 0; 05395 PteContents.u.Soft.Prototype = 0; 05396 PteContents.u.Soft.Protection = MM_NOACCESS; 05397 05398 Pfn1 = MI_PFN_ELEMENT (PteContents.u.Hard.PageFrameNumber); 05399 05400 LOCK_PFN2 (OldIrql2); 05401 05402 Pfn1->OriginalPte.u.Soft.Protection = ProtectionMask; 05403 05404 PreviousPte.u.Flush = KeFlushSingleTb (VirtualAddress, 05405 TRUE, 05406 TRUE, 05407 (PHARDWARE_PTE)PointerPte, 05408 PteContents.u.Flush); 05409 05410 MI_CAPTURE_DIRTY_BIT_TO_PFN (&PreviousPte, Pfn1); 05411 05412 UNLOCK_PFN2(OldIrql2); 05413 } 05414 05415 return TRUE; 05416 } 05417 05418 // 05419 // No guard pages, noncached pages or copy-on-write for special pool. 05420 // 05421 05422 if ((ProtectionMask >= MM_NOCACHE) || (ProtectionMask == MM_WRITECOPY) || (ProtectionMask == MM_EXECUTE_WRITECOPY)) { 05423 if (SystemWsLocked == TRUE) { 05424 UNLOCK_SYSTEM_WS (OldIrql); 05425 } 05426 return FALSE; 05427 } 05428 05429 // 05430 // Set accessible permissions - the page may already be protected or not. 05431 // 05432 05433 if ((PointerPte + 1)->u.Soft.PageFileHigh == MI_SPECIAL_POOL_PTE_NONPAGABLE) { 05434 05435 Pfn1 = MI_PFN_ELEMENT (PteContents.u.Hard.PageFrameNumber); 05436 Pfn1->OriginalPte.u.Soft.Protection = ProtectionMask; 05437 05438 MI_MAKE_VALID_PTE (NewPteContents, 05439 PteContents.u.Hard.PageFrameNumber, 05440 ProtectionMask, 05441 PointerPte); 05442 05443 MI_WRITE_VALID_PTE_NEW_PROTECTION (PointerPte, NewPteContents); 05444 05445 ASSERT (SystemWsLocked == FALSE); 05446 return TRUE; 05447 } 05448 05449 retry2: 05450 05451 ASSERT (SystemWsLocked == TRUE); 05452 05453 if (PteContents.u.Hard.Valid == 1) { 05454 05455 Pfn1 = MI_PFN_ELEMENT (PteContents.u.Hard.PageFrameNumber); 05456 ASSERT (Pfn1->u1.WsIndex != 0); 05457 05458 LOCK_PFN2 (OldIrql2); 05459 05460 Pfn1->OriginalPte.u.Soft.Protection = ProtectionMask; 05461 05462 MI_MAKE_VALID_PTE (PteContents, 05463 PteContents.u.Hard.PageFrameNumber, 05464 ProtectionMask, 05465 PointerPte); 05466 05467 PreviousPte.u.Flush = KeFlushSingleTb (VirtualAddress, 05468 TRUE, 05469 TRUE, 05470 (PHARDWARE_PTE)PointerPte, 05471 PteContents.u.Flush); 05472 05473 MI_CAPTURE_DIRTY_BIT_TO_PFN (&PreviousPte, Pfn1); 05474 05475 UNLOCK_PFN2 (OldIrql2); 05476 } 05477 else if (PteContents.u.Soft.Transition == 1) { 05478 05479 LOCK_PFN2 (OldIrql2); 05480 05481 PteContents = *(volatile MMPTE *)PointerPte; 05482 05483 if (PteContents.u.Soft.Transition == 0) { 05484 UNLOCK_PFN2 (OldIrql2); 05485 goto retry2; 05486 } 05487 05488 Pfn1 = MI_PFN_ELEMENT (PteContents.u.Trans.PageFrameNumber); 05489 Pfn1->OriginalPte.u.Soft.Protection = ProtectionMask; 05490 PointerPte->u.Soft.Protection = ProtectionMask; 05491 UNLOCK_PFN2(OldIrql2); 05492 } 05493 else { 05494 05495 // 05496 // Must be page file space or demand zero. 05497 // 05498 05499 PointerPte->u.Soft.Protection = ProtectionMask; 05500 } 05501 05502 UNLOCK_SYSTEM_WS (OldIrql); 05503 return TRUE; 05504 } }

VOID MiSessionPoolAllocated (  IN PVOID  VirtualAddress, IN SIZE_T  NumberOfBytes, IN POOL_TYPE  PoolType )

Definition at line 505 of file allocpag.c. References ASSERT, BASE_POOL_TYPE_MASK, FALSE, MI_IS_SESSION_POOL_ADDRESS, MmSessionSpace, NonPagedPool, _MM_SESSION_SPACE::NonPagedPoolAllocations, _MM_SESSION_SPACE::NonPagedPoolBytes, _MM_SESSION_SPACE::PagedPoolAllocations, _MM_SESSION_SPACE::PagedPoolBytes, and TRUE. Referenced by ExAllocatePoolWithTag(), and MiAllocatePoolPages(). : This function charges the new pool allocation for the current session. On session exit, this charge must be zero. Arguments: VirtualAddress - Supplies the allocated pool address. NumberOfBytes - Supplies the number of bytes allocated. PoolType - Supplies the type of the above pool allocation. Return Value: None. --*/ { if ((PoolType & BASE_POOL_TYPE_MASK) == NonPagedPool) { ASSERT (MI_IS_SESSION_POOL_ADDRESS(VirtualAddress) == FALSE); MmSessionSpace->NonPagedPoolBytes += NumberOfBytes; MmSessionSpace->NonPagedPoolAllocations += 1; } else { ASSERT (MI_IS_SESSION_POOL_ADDRESS(VirtualAddress) == TRUE); MmSessionSpace->PagedPoolBytes += NumberOfBytes; MmSessionSpace->PagedPoolAllocations += 1; } }

VOID MiSessionPoolFreed (  IN PVOID  VirtualAddress, IN SIZE_T  NumberOfBytes, IN POOL_TYPE  PoolType )

Definition at line 547 of file allocpag.c. References ASSERT, BASE_POOL_TYPE_MASK, FALSE, MI_IS_SESSION_POOL_ADDRESS, MmSessionSpace, NonPagedPool, _MM_SESSION_SPACE::NonPagedPoolAllocations, _MM_SESSION_SPACE::NonPagedPoolBytes, _MM_SESSION_SPACE::PagedPoolAllocations, _MM_SESSION_SPACE::PagedPoolBytes, and TRUE. Referenced by ExFreePoolWithTag(), and MiFreePoolPages(). : This function returns the specified pool allocation for the current session. On session exit, this charge must be zero. Arguments: VirtualAddress - Supplies the pool address being freed. NumberOfBytes - Supplies the number of bytes being freed. PoolType - Supplies the type of the above pool allocation. Return Value: None. --*/ { if ((PoolType & BASE_POOL_TYPE_MASK) == NonPagedPool) { ASSERT (MI_IS_SESSION_POOL_ADDRESS(VirtualAddress) == FALSE); MmSessionSpace->NonPagedPoolBytes -= NumberOfBytes; MmSessionSpace->NonPagedPoolAllocations -= 1; } else { ASSERT (MI_IS_SESSION_POOL_ADDRESS(VirtualAddress) == TRUE); MmSessionSpace->PagedPoolBytes -= NumberOfBytes; MmSessionSpace->PagedPoolAllocations -= 1; } }

PVOID MiSessionPoolVector (  VOID   )

Definition at line 479 of file allocpag.c. References MmSessionSpace, and _MM_SESSION_SPACE::PagedPool. Referenced by ExpInitializePoolDescriptor(). : This function returns the session pool descriptor for the current session. Arguments: None. Return Value: Pool descriptor. --*/ { return (PVOID)&MmSessionSpace->PagedPool; }

VOID MiSpecialPoolTimerDispatch (  IN PKDPC  Dpc, IN PVOID  DeferredContext, IN PVOID  SystemArgument1, IN PVOID  SystemArgument2 )

Definition at line 3201 of file allocpag.c. References _MI_BAD_TAGS::Allocations, _MI_BAD_TAGS::AllOthers, _MI_BAD_TAGS::Dispatches, _MI_BAD_TAGS::Enabled, MiBadTags, and _MI_BAD_TAGS::TargetChar. Referenced by MiInitializeSpecialPoolCriteria(). : This routine is executed every 3 seconds. Just toggle the enable bit. If not many squeezed allocations have been made then just leave it continuously enabled. Switch to a different tag if it looks like this one isn't getting any hits. No locks needed. Arguments: Dpc - Supplies a pointer to a control object of type DPC. DeferredContext - Optional deferred context; not used. SystemArgument1 - Optional argument 1; not used. SystemArgument2 - Optional argument 2; not used. Return Value: None. --*/ { UCHAR NewChar; UNREFERENCED_PARAMETER (Dpc); UNREFERENCED_PARAMETER (DeferredContext); UNREFERENCED_PARAMETER (SystemArgument1); UNREFERENCED_PARAMETER (SystemArgument2); MiBadTags.Dispatches += 1; if (MiBadTags.Allocations > 500) { MiBadTags.Enabled += 1; } else if ((MiBadTags.Allocations == 0) && (MiBadTags.Dispatches > 100)) { if (MiBadTags.AllOthers == 0) { NewChar = (UCHAR)(MiBadTags.TargetChar + 1); if (NewChar >= 'a' && NewChar <= 'z') { MiBadTags.TargetChar = NewChar; } else if (NewChar == 'z' + 1) { MiBadTags.TargetChar = 'a'; } else if (NewChar >= 'A' && NewChar <= 'Z') { MiBadTags.TargetChar = NewChar; } else { MiBadTags.TargetChar = 'A'; } } } }

LOGICAL MiUnProtectFreeNonPagedPool (  IN PVOID  VirtualAddress, IN ULONG  SizeInPages )

Definition at line 209 of file allocpag.c. References FALSE, MI_IS_PHYSICAL_ADDRESS, MI_WRITE_VALID_PTE, MiGetPteAddress, TRUE, and _MMPTE::u. Referenced by MiAllocatePoolPages(), MiFindContiguousMemory(), MiFreePoolPages(), MiProtectedPoolInsertList(), MiProtectedPoolRemoveEntryList(), and MmSetKernelDumpRange(). : This function unprotects freed nonpaged pool. Arguments: VirtualAddress - Supplies the freed pool address to unprotect. SizeInPages - Supplies the size of the request in pages - zero indicates to keep going until there are no more protected PTEs (ie: the caller doesn't know how many protected PTEs there are). Return Value: TRUE if pages were unprotected, FALSE if not. Environment: Kernel mode. --*/ { PMMPTE PointerPte; MMPTE PteContents; ULONG PagesDone; PagesDone = 0; // // Unprotect the previously freed pool so it can be manipulated // if (MI_IS_PHYSICAL_ADDRESS(VirtualAddress) == 0) { PointerPte = MiGetPteAddress((PVOID)VirtualAddress); PteContents = *PointerPte; while (PteContents.u.Hard.Valid == 0 && PteContents.u.Soft.Prototype == 1) { PteContents.u.Hard.Valid = 1; PteContents.u.Soft.Prototype = 0; MI_WRITE_VALID_PTE (PointerPte, PteContents); PagesDone += 1; if (PagesDone == SizeInPages) { break; } PointerPte += 1; PteContents = *PointerPte; } } if (PagesDone == 0) { return FALSE; } return TRUE; }

PVOID MmAllocateSpecialPool (  IN SIZE_T  NumberOfBytes, IN ULONG  Tag, IN POOL_TYPE  PoolType, IN ULONG  SpecialPoolType )

Definition at line 3408 of file allocpag.c. References MiAllocateSpecialPool(), MiSpecialPoolPtes, and NULL. Referenced by ExAllocatePoolWithTag(), ExAllocatePoolWithTagPriority(), and MmSqueezeBadTags(). : This routine allocates virtual memory from special pool. This allocation is made from the end of a physical page with the next PTE set to no access so that any reads or writes will cause an immediate fatal system crash. This lets us catch components that corrupt pool. Arguments: NumberOfBytes - Supplies the number of bytes to commit. Tag - Supplies the tag of the requested allocation. PoolType - Supplies the pool type of the requested allocation. SpecialPoolType - Supplies the special pool type of the requested allocation. - 0 indicates overruns. - 1 indicates underruns. - 2 indicates use the systemwide pool policy. Return Value: A non-NULL pointer if the requested allocation was fulfilled from special pool. NULL if the allocation was not made. Environment: Kernel mode, no pool locks held. Note this is a nonpagable wrapper so that machines without special pool can still support drivers allocating nonpaged pool at DISPATCH_LEVEL requesting special pool. --*/ { if (MiSpecialPoolPtes == 0) { // // The special pool allocation code was never initialized. // return NULL; } return MiAllocateSpecialPool (NumberOfBytes, Tag, PoolType, SpecialPoolType); }

POOL_TYPE MmDeterminePoolType (  IN PVOID  VirtualAddress  )

Definition at line 437 of file allocpag.c. References MI_IS_SESSION_POOL_ADDRESS, MmPagedPoolEnd, MmPagedPoolStart, NonPagedPool, PagedPool, PagedPoolSession, and TRUE. Referenced by CheckPool(), ExFreePool(), ExFreePoolSanityChecks(), ExFreePoolWithTag(), ExInitializeResource(), ExInitializeResourceLite(), and ExReinitializeResourceLite(). : This function determines which pool a virtual address resides within. Arguments: VirtualAddress - Supplies the virtual address to determine which pool it resides within. Return Value: Returns the POOL_TYPE (PagedPool, NonPagedPool, PagedPoolSession or NonPagedPoolSession), it never returns any information about MustSucceed pool types. Environment: Kernel Mode Only. --*/ { if ((VirtualAddress >= MmPagedPoolStart) && (VirtualAddress <= MmPagedPoolEnd)) { return PagedPool; } if (MI_IS_SESSION_POOL_ADDRESS (VirtualAddress) == TRUE) { return PagedPoolSession; } return NonPagedPool; }

VOID MmFreeSpecialPool (  IN PVOID  P  )

Referenced by ExFreePoolWithTag().

LOGICAL MmIsHydraAddress (  IN PVOID  VirtualAddress  )

Definition at line 5146 of file allocpag.c. References MI_IS_SESSION_ADDRESS. Referenced by KeBugCheckEx(). : This function returns TRUE if a Hydra address is specified. FALSE is returned if not. Arguments: VirtualAddress - Supplies the address in question. Return Value: See above. Environment: Kernel mode. Note this routine is present and nonpaged for both Hydra and non-Hydra systems. --*/ { return MI_IS_SESSION_ADDRESS (VirtualAddress); }

LOGICAL MmIsSpecialPoolAddressFree (  IN PVOID  VirtualAddress  )

Definition at line 5177 of file allocpag.c. References ASSERT, FALSE, MI_SPECIAL_POOL_PTE_NONPAGABLE, MI_SPECIAL_POOL_PTE_PAGABLE, MiGetPteAddress, MmSpecialPoolEnd, MmSpecialPoolStart, TRUE, and _MMPTE::u. Referenced by KeBugCheckEx(). : This function returns TRUE if a special pool address has been freed. FALSE is returned if it is inuse (ie: the caller overran). Arguments: VirtualAddress - Supplies the special pool address in question. Return Value: See above. Environment: Kernel mode. --*/ { PMMPTE PointerPte; // // Caller must check that the address in in special pool. // ASSERT (VirtualAddress >= MmSpecialPoolStart && VirtualAddress < MmSpecialPoolEnd); PointerPte = MiGetPteAddress(VirtualAddress); // // Take advantage of the fact that adjacent PTEs have the paged/nonpaged // bits set when in use and these bits are cleared on free. Note also // that freed pages get their PTEs chained together through PageFileHigh. // if ((PointerPte->u.Soft.PageFileHigh == MI_SPECIAL_POOL_PTE_PAGABLE) || (PointerPte->u.Soft.PageFileHigh == MI_SPECIAL_POOL_PTE_NONPAGABLE)) { return FALSE; } return TRUE; }

LOGICAL MmProtectSpecialPool (  IN PVOID  VirtualAddress, IN ULONG  NewProtect )

Definition at line 5228 of file allocpag.c. References MiProtectSpecialPool(), and MiSpecialPoolPtes. Referenced by IovpProtectedIrpMakeTouchable(), and IovpProtectedIrpMakeUntouchable(). : This function protects a special pool allocation. Arguments: VirtualAddress - Supplies the special pool address to protect. NewProtect - Supplies the protection to set the pages to (PAGE_XX). Return Value: TRUE if the protection was successfully applied, FALSE if not. Environment: Kernel mode, IRQL at APC_LEVEL or below for pagable pool, DISPATCH or below for nonpagable pool. Note that setting an allocation to NO_ACCESS implies that an accessible protection must be applied by the caller prior to this allocation being freed. Note this is a nonpagable wrapper so that machines without special pool can still support code attempting to protect special pool at DISPATCH_LEVEL. --*/ { if (MiSpecialPoolPtes == 0) { // // The special pool allocation code was never initialized. // return (ULONG)-1; } return MiProtectSpecialPool (VirtualAddress, NewProtect); }

SIZE_T MmQuerySpecialPoolBlockSize (  IN PVOID  P  )

Definition at line 2927 of file allocpag.c. References ASSERT, Header, MI_SPECIAL_POOL_PAGABLE, MI_SPECIAL_POOL_VERIFIER, MmSpecialPoolEnd, MmSpecialPoolStart, PAGE_ALIGN, PAGE_SIZE, POOL_OVERHEAD, and PPOOL_HEADER. Referenced by ExQueryPoolBlockSize(). : This routine returns the size of a special pool allocation. Arguments: VirtualAddress - Supplies the special pool virtual address to query. Return Value: The size in bytes of the allocation. Environment: Kernel mode, APC_LEVEL or below for pagable addresses, DISPATCH_LEVEL or below for nonpaged addresses. --*/ { PPOOL_HEADER Header; ASSERT ((P >= MmSpecialPoolStart) && (P < MmSpecialPoolEnd)); if (((ULONG_PTR)P & (PAGE_SIZE - 1))) { Header = PAGE_ALIGN (P); } else { Header = (PPOOL_HEADER)((PCHAR)PAGE_ALIGN (P) + PAGE_SIZE - POOL_OVERHEAD); } return (SIZE_T)(Header->Ulong1 & ~(MI_SPECIAL_POOL_PAGABLE | MI_SPECIAL_POOL_VERIFIER)); }

LOGICAL MmResourcesAvailable (  IN POOL_TYPE  PoolType, IN SIZE_T  NumberOfBytes, IN EX_POOL_PRIORITY  Priority )

Definition at line 589 of file allocpag.c. References ASSERT, BASE_POOL_TYPE_MASK, BYTES_TO_PAGES, EX_POOL_PRIORITY, FALSE, HighPoolPriority, KeSetEvent(), LOCK_PFN2, MI_MEMORY_MAKER, MI_SESSION_POOL_SIZE, MI_UNUSED_SEGMENTS_SURPLUS, MiIssuePageExtendRequestNoWait(), MmAllocatedNonPagedPool, MmMaximumNonPagedPoolInBytes, MmPagedPoolInfo, MmSessionSpace, MmSizeOfPagedPoolInBytes, MmTotalCommitLimitMaximum, MmTotalCommittedPages, MmUnusedSegmentCleanup, MmUnusedSegmentForceFree, MmUnusedSegmentList, MUST_SUCCEED_POOL_TYPE_MASK, NonPagedPool, NormalPoolPriority, PAGE_SHIFT, PagedPool, _MM_SESSION_SPACE::PagedPoolBytes, PsGetCurrentThread, SESSION_POOL_MASK, TRUE, and UNLOCK_PFN2. Referenced by ExAllocatePoolWithTagPriority(). : This function examines various resources to determine if this pool allocation should be allowed to proceed. Arguments: PoolType - Supplies the type of pool to retrieve information about. NumberOfBytes - Supplies the number of bytes to allocate. Priority - Supplies an indication as to how important it is that this request succeed under low available resource conditions. Return Value: TRUE if the pool allocation should be allowed to proceed, FALSE if not. --*/ { KIRQL OldIrql; PFN_NUMBER NumberOfPages; SIZE_T FreePoolInBytes; PETHREAD Thread; LOGICAL SignalDereferenceThread; ASSERT (Priority != HighPoolPriority); ASSERT ((PoolType & MUST_SUCCEED_POOL_TYPE_MASK) == 0); NumberOfPages = BYTES_TO_PAGES (NumberOfBytes); if ((PoolType & BASE_POOL_TYPE_MASK) == NonPagedPool) { FreePoolInBytes = MmMaximumNonPagedPoolInBytes - (MmAllocatedNonPagedPool << PAGE_SHIFT); } else if (PoolType & SESSION_POOL_MASK) { FreePoolInBytes = MI_SESSION_POOL_SIZE - MmSessionSpace->PagedPoolBytes; } else { FreePoolInBytes = MmSizeOfPagedPoolInBytes - (MmPagedPoolInfo.AllocatedPagedPool << PAGE_SHIFT); } // // Check available VA space. // if (Priority == NormalPoolPriority) { if ((SIZE_T)NumberOfBytes + 512*1024 > FreePoolInBytes) { Thread = PsGetCurrentThread (); if (!MI_MEMORY_MAKER(Thread)) { goto nopool; } } } else { if ((SIZE_T)NumberOfBytes + 2*1024*1024 > FreePoolInBytes) { Thread = PsGetCurrentThread (); if (!MI_MEMORY_MAKER(Thread)) { goto nopool; } } } // // Paged allocations (session and normal) can also fail for lack of commit. // if ((PoolType & BASE_POOL_TYPE_MASK) == PagedPool) { if (MmTotalCommittedPages + NumberOfPages > MmTotalCommitLimitMaximum) { Thread = PsGetCurrentThread (); if (!MI_MEMORY_MAKER(Thread)) { MiIssuePageExtendRequestNoWait (NumberOfPages); goto nopool; } } } return TRUE; nopool: // // Running low on pool - if this request is not for session pool, // force unused segment trimming when appropriate. // if ((PoolType & SESSION_POOL_MASK) == 0) { if (MI_UNUSED_SEGMENTS_SURPLUS()) { KeSetEvent (&MmUnusedSegmentCleanup, 0, FALSE); } else { SignalDereferenceThread = FALSE; LOCK_PFN2 (OldIrql); if (MmUnusedSegmentForceFree == 0) { if (!IsListEmpty(&MmUnusedSegmentList)) { SignalDereferenceThread = TRUE; MmUnusedSegmentForceFree = 30; } } UNLOCK_PFN2 (OldIrql); if (SignalDereferenceThread == TRUE) { KeSetEvent (&MmUnusedSegmentCleanup, 0, FALSE); } } } return FALSE; }

LOGICAL MmSetSpecialPool (  IN LOGICAL  Enable  )

Referenced by KeStartAllProcessors().

PVOID MmSqueezeBadTags (  IN SIZE_T  NumberOfBytes, IN ULONG  Tag, IN POOL_TYPE  PoolType, IN ULONG  SpecialPoolType )

Referenced by ExAllocatePoolWithTag().

---

Variable Documentation

ULONG InitializationPhase

Definition at line 3267 of file allocpag.c.

MI_BAD_TAGS MiBadTags

Definition at line 3192 of file allocpag.c. Referenced by MiEnableRandomSpecialPool(), MiInitializeSpecialPoolCriteria(), MiSpecialPoolTimerDispatch(), and MmSqueezeBadTags().

PFN_NUMBER MiEndOfInitialPoolFrame

Definition at line 112 of file allocpag.c. Referenced by MiFreePoolPages(), and MiInitializeNonPagedPool().

ULONG MiSpecialPagesInUsePeak

Definition at line 2918 of file allocpag.c. Referenced by MiAllocateSpecialPool().

ULONG MiSpecialPagesNonPaged

Definition at line 2912 of file allocpag.c. Referenced by MiAllocateSpecialPool(), and MmFreeSpecialPool().

ULONG MiSpecialPagesNonPagedMaximum

Definition at line 2920 of file allocpag.c. Referenced by MiAllocateSpecialPool(), and MiInitializeSpecialPool().

ULONG MiSpecialPagesNonPagedPeak

Definition at line 2916 of file allocpag.c. Referenced by MiAllocateSpecialPool().

ULONG MiSpecialPagesPagable

Definition at line 2913 of file allocpag.c. Referenced by MiAllocateSpecialPool(), and MmFreeSpecialPool().

ULONG MiSpecialPagesPagablePeak

Definition at line 2917 of file allocpag.c. Referenced by MiAllocateSpecialPool().

LOGICAL MiSpecialPoolEnabled = TRUE

Definition at line 2924 of file allocpag.c. Referenced by MiAllocateSpecialPool(), and MmSetSpecialPool().

PMMPTE MiSpecialPoolFirstPte

Definition at line 2909 of file allocpag.c. Referenced by MiAllocateSpecialPool(), and MiInitializeSpecialPool().

PMMPTE MiSpecialPoolLastPte

Definition at line 2910 of file allocpag.c. Referenced by MiInitializeSpecialPool(), and MmFreeSpecialPool().

ULONG MiSpecialPoolPtes

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

KTIMER MiSpecialPoolTimer

Definition at line 3193 of file allocpag.c. Referenced by MiInitializeSpecialPoolCriteria().

KDPC MiSpecialPoolTimerDpc

Definition at line 3194 of file allocpag.c. Referenced by MiInitializeSpecialPoolCriteria().

LARGE_INTEGER MiTimerDueTime

Definition at line 3195 of file allocpag.c. Referenced by MiInitializeSpecialPoolCriteria().

PFN_NUMBER MmAllocatedNonPagedPool

Definition at line 111 of file allocpag.c.

PVOID MmNonPagedPoolExpansionStart

Definition at line 114 of file allocpag.c. Referenced by MiAllocatePoolPages(), MiFreePoolPages(), MiInitializeNonPagedPool(), MiInitMachineDependent(), and MmAccessFault().

LIST_ENTRY MmNonPagedPoolFreeListHead[MI_MAX_FREE_LIST_HEADS]

Definition at line 116 of file allocpag.c. Referenced by MiAllocatePoolPages(), MiFindContiguousMemory(), MiFreePoolPages(), MiInitializeNonPagedPool(), and MmSetKernelDumpRange().

ULONG MmPagedPoolCommit

Definition at line 109 of file allocpag.c.

LOGICAL MmPagedPoolMaximumDesired

Definition at line 120 of file allocpag.c. Referenced by MiBuildPagedPool(), MiInitializeSpecialPool(), and MiInitMachineDependent().

ULONG MmSpecialPagesInUse

Definition at line 2914 of file allocpag.c. Referenced by MiAllocateSpecialPool(), and MmFreeSpecialPool().

LOGICAL MmSpecialPoolCatchOverruns = TRUE

Definition at line 2906 of file allocpag.c.

PVOID MmSpecialPoolEnd

Definition at line 2903 of file allocpag.c.

ULONG MmSpecialPoolRejected[5]

Definition at line 2905 of file allocpag.c. Referenced by MiAllocateSpecialPool().

PVOID MmSpecialPoolStart

Definition at line 2902 of file allocpag.c.

ULONG MmSpecialPoolTag

Definition at line 2901 of file allocpag.c.

ULONG MmUnusedSegmentForceFree

Definition at line 141 of file allocpag.c. Referenced by MiAllocatePoolPages(), MiRemoveUnusedSegments(), and MmResourcesAvailable().

POOL_DESCRIPTOR NonPagedPoolDescriptor

Definition at line 118 of file allocpag.c.

---