This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Classes | |
| struct | _POOL_DESCRIPTOR |
| struct | _POOL_HEADER |
| struct | _POOL_TRACKER_TABLE |
| struct | _POOL_TRACKER_BIG_PAGES |
| struct | _MI_LARGE_PAGE_DRIVER_ENTRY |
| struct | _PHYSICAL_MEMORY_RUN |
| struct | _PHYSICAL_MEMORY_DESCRIPTOR |
| struct | _MMCOLOR_TABLES |
| struct | _MI_LARGE_PAGE_RANGES |
| struct | _MMVIEW |
| struct | _MMSESSION |
| struct | _MM_SESSION_SPACE_FLAGS |
| struct | _MM_SESSION_SPACE |
Enumerations | |
| enum | _MMSYSTEM_PTE_POOL_TYPE { SystemPteSpace , NonPagedPoolExpansion , MaximumPtePoolTypes } |
| enum | _MI_PFN_CACHE_ATTRIBUTE { MiNonCached , MiCached , MiWriteCombined , MiNotMapped } |
Macro Definition Documentation
◆ _1GB
◆ _1KB
◆ _1MB
◆ _64K
◆ BASE_POOL_TYPE_MASK
◆ IMAGE_SCN_PROTECTION_MASK
| #define IMAGE_SCN_PROTECTION_MASK (IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE) |
◆ MI_GET_NEXT_COLOR
| #define MI_GET_NEXT_COLOR | ( | ) | (MI_GET_PAGE_COLOR(++MmSystemPageColor)) |
◆ MI_GET_NEXT_PROCESS_COLOR
| #define MI_GET_NEXT_PROCESS_COLOR | ( | x | ) | (MI_GET_PAGE_COLOR(++(x)->NextPageColor)) |
◆ MI_GET_PAGE_COLOR
◆ MI_INITIAL_SESSION_IDS
◆ MI_IS_PAGE_TABLE_ADDRESS
◆ MI_IS_PAGE_TABLE_OR_HYPER_ADDRESS
◆ MI_IS_PFN_DELETED
◆ MI_IS_ROS_PFN
◆ MI_IS_SESSION_ADDRESS
| #define MI_IS_SESSION_ADDRESS | ( | Address | ) | (((Address) >= MmSessionBase) && ((Address) < MiSessionSpaceEnd)) |
◆ MI_IS_SESSION_IMAGE_ADDRESS
| #define MI_IS_SESSION_IMAGE_ADDRESS | ( | Address | ) | (((Address) >= MiSessionImageStart) && ((Address) < MiSessionImageEnd)) |
◆ MI_IS_SESSION_PTE
| #define MI_IS_SESSION_PTE | ( | Pte | ) | ((((PMMPTE)Pte) >= MiSessionBasePte) && (((PMMPTE)Pte) < MiSessionLastPte)) |
◆ MI_IS_SYSTEM_PAGE_TABLE_ADDRESS
| #define MI_IS_SYSTEM_PAGE_TABLE_ADDRESS | ( | Address | ) | (((Address) >= (PVOID)MiAddressToPte(MmSystemRangeStart)) && ((Address) <= (PVOID)PTE_TOP)) |
◆ MI_LOWEST_VAD_ADDRESS
| #define MI_LOWEST_VAD_ADDRESS (PVOID)MM_LOWEST_USER_ADDRESS |
◆ MI_MAKE_SOFTWARE_PTE
◆ MI_PTE_LOOKUP_NEEDED
◆ MI_SESSION_DATA_PAGES_MAXIMUM
| #define MI_SESSION_DATA_PAGES_MAXIMUM (MM_ALLOCATION_GRANULARITY / PAGE_SIZE) |
◆ MI_SESSION_TAG_PAGES_MAXIMUM
| #define MI_SESSION_TAG_PAGES_MAXIMUM (MM_ALLOCATION_GRANULARITY / PAGE_SIZE) |
◆ MI_SET_PFN_DELETED
◆ MI_SYSTEM_VIEW_BUCKET_SIZE
◆ MM_DECOMMIT
| #define MM_DECOMMIT (MM_ZERO_ACCESS | MM_GUARDPAGE) |
◆ MM_DELETE_CHECK
◆ MM_EXECUTE
◆ MM_EXECUTE_READ
◆ MM_EXECUTE_READWRITE
◆ MM_EXECUTE_WRITECOPY
◆ MM_GUARDPAGE
◆ MM_INVALID_PROTECTION
◆ MM_NO_ACCESS_ALLOWED
◆ MM_NOACCESS
| #define MM_NOACCESS (MM_ZERO_ACCESS | MM_WRITECOMBINE) |
◆ MM_NOCACHE
◆ MM_OUTSWAPPED_KSTACK
| #define MM_OUTSWAPPED_KSTACK (MM_EXECUTE_WRITECOPY | MM_WRITECOMBINE) |
◆ MM_PROTECT_ACCESS
◆ MM_PROTECT_SPECIAL
◆ MM_READ_ONLY_ALLOWED
◆ MM_READ_WRITE_ALLOWED
◆ MM_READONLY
◆ MM_READWRITE
◆ MM_SYSLDR_BOOT_LOADED
◆ MM_SYSLDR_NO_IMPORTS
◆ MM_SYSLDR_SINGLE_ENTRY
◆ MM_WRITECOMBINE
◆ MM_WRITECOPY
◆ MM_ZERO_ACCESS
◆ PD_SIZE
◆ POOL_ALLOC_IRQL_INVALID
◆ POOL_BILLED_PROCESS_INVALID
◆ POOL_BLOCK_SIZE
◆ POOL_CORRUPTED_LIST
◆ POOL_ENTRIES_NOT_ALIGNED_NEXT
◆ POOL_ENTRIES_NOT_ALIGNED_PREVIOUS
◆ POOL_ENTRY_ALREADY_FREE
◆ POOL_ENTRY_CORRUPTED
◆ POOL_ENTRY_NOT_ALLOCATED
◆ POOL_ENTRY_NOT_FOUND
◆ POOL_FLAG_CHECK_DEADLOCK
◆ POOL_FLAG_CHECK_RESOURCES
◆ POOL_FLAG_CHECK_TIMERS
◆ POOL_FLAG_CHECK_WORKERS
◆ POOL_FLAG_CRASH_ON_FAILURE
◆ POOL_FLAG_DBGPRINT_ON_FAILURE
◆ POOL_FLAG_SPECIAL_POOL
◆ POOL_FLAG_VERIFIER
◆ POOL_FREE_IRQL_INVALID
◆ POOL_HEADER_IS_ZERO
◆ POOL_HEADER_NOT_ALIGNED
◆ POOL_HEADER_SIZE_INVALID
◆ POOL_LISTS_PER_PAGE
| #define POOL_LISTS_PER_PAGE (PAGE_SIZE / POOL_BLOCK_SIZE) |
◆ POOL_MAX_ALLOC
| #define POOL_MAX_ALLOC (PAGE_SIZE - (sizeof(POOL_HEADER) + POOL_BLOCK_SIZE)) |
◆ POOL_SIZE_OR_INDEX_MISMATCH
◆ PT_SIZE
◆ SYSTEM_PD_SIZE
| #define SYSTEM_PD_SIZE (PPE_PER_PAGE * PD_SIZE) |
Typedef Documentation
◆ MI_LARGE_PAGE_DRIVER_ENTRY
◆ MI_LARGE_PAGE_RANGES
◆ MI_PFN_CACHE_ATTRIBUTE
◆ MM_SESSION_SPACE
| typedef struct _MM_SESSION_SPACE MM_SESSION_SPACE |
◆ MM_SESSION_SPACE_FLAGS
◆ MMCOLOR_TABLES
| typedef struct _MMCOLOR_TABLES MMCOLOR_TABLES |
◆ MMSESSION
| typedef struct _MMSESSION MMSESSION |
◆ MMSYSTEM_PTE_POOL_TYPE
◆ MMVIEW
◆ PHYSICAL_MEMORY_DESCRIPTOR
◆ PHYSICAL_MEMORY_RUN
◆ PMI_LARGE_PAGE_DRIVER_ENTRY
◆ PMI_LARGE_PAGE_RANGES
| typedef struct _MI_LARGE_PAGE_RANGES * PMI_LARGE_PAGE_RANGES |
◆ PMI_PFN_CACHE_ATTRIBUTE
◆ PMM_SESSION_SPACE
| typedef struct _MM_SESSION_SPACE * PMM_SESSION_SPACE |
◆ PMMCOLOR_TABLES
| typedef struct _MMCOLOR_TABLES * PMMCOLOR_TABLES |
◆ PMMSESSION
| typedef struct _MMSESSION * PMMSESSION |
◆ PMMVIEW
◆ POOL_DESCRIPTOR
| typedef struct _POOL_DESCRIPTOR POOL_DESCRIPTOR |
◆ POOL_HEADER
| typedef struct _POOL_HEADER POOL_HEADER |
◆ POOL_TRACKER_BIG_PAGES
◆ POOL_TRACKER_TABLE
◆ PPHYSICAL_MEMORY_DESCRIPTOR
◆ PPHYSICAL_MEMORY_RUN
| typedef struct _PHYSICAL_MEMORY_RUN * PPHYSICAL_MEMORY_RUN |
◆ PPOOL_DESCRIPTOR
| typedef struct _POOL_DESCRIPTOR * PPOOL_DESCRIPTOR |
◆ PPOOL_HEADER
| typedef struct _POOL_HEADER * PPOOL_HEADER |
◆ PPOOL_TRACKER_BIG_PAGES
◆ PPOOL_TRACKER_TABLE
| typedef struct _POOL_TRACKER_TABLE * PPOOL_TRACKER_TABLE |
Enumeration Type Documentation
◆ _MI_PFN_CACHE_ATTRIBUTE
| Enumerator | |
|---|---|
| MiNonCached | |
| MiCached | |
| MiWriteCombined | |
| MiNotMapped | |
Definition at line 408 of file miarm.h.
409{
410 MiNonCached,
411 MiCached,
412 MiWriteCombined,
413 MiNotMapped
enum _MI_PFN_CACHE_ATTRIBUTE MI_PFN_CACHE_ATTRIBUTE
enum _MI_PFN_CACHE_ATTRIBUTE * PMI_PFN_CACHE_ATTRIBUTE
◆ _MMSYSTEM_PTE_POOL_TYPE
| Enumerator | |
|---|---|
| SystemPteSpace | |
| NonPagedPoolExpansion | |
| MaximumPtePoolTypes | |
Definition at line 401 of file miarm.h.
402{
403 SystemPteSpace,
406} MMSYSTEM_PTE_POOL_TYPE;
enum _MMSYSTEM_PTE_POOL_TYPE MMSYSTEM_PTE_POOL_TYPE
Function Documentation
◆ C_ASSERT() [1/2]
| C_ASSERT | ( | POOL_BLOCK_SIZE | = =sizeof(LIST_ENTRY) | ) |
◆ C_ASSERT() [2/2]
| C_ASSERT | ( | sizeof(POOL_HEADER) | = =POOL_BLOCK_SIZE | ) |
◆ ExInitializePoolDescriptor()
| VOID NTAPI ExInitializePoolDescriptor | ( | IN PPOOL_DESCRIPTOR | PoolDescriptor, |
| IN POOL_TYPE | PoolType, | ||
| IN ULONG | PoolIndex, | ||
| IN ULONG | Threshold, | ||
| IN PVOID | PoolLock | ||
| ) |
Definition at line 970 of file expool.c.
975{
976 PLIST_ENTRY NextEntry, LastEntry;
977
978 //
979 // Setup the descriptor based on the caller's request
980 //
981 PoolDescriptor->PoolType = PoolType;
982 PoolDescriptor->PoolIndex = PoolIndex;
983 PoolDescriptor->Threshold = Threshold;
984 PoolDescriptor->LockAddress = PoolLock;
985
986 //
987 // Initialize accounting data
988 //
989 PoolDescriptor->RunningAllocs = 0;
990 PoolDescriptor->RunningDeAllocs = 0;
991 PoolDescriptor->TotalPages = 0;
992 PoolDescriptor->TotalBytes = 0;
993 PoolDescriptor->TotalBigPages = 0;
994
995 //
996 // Nothing pending for now
997 //
998 PoolDescriptor->PendingFrees = NULL;
999 PoolDescriptor->PendingFreeDepth = 0;
1000
1001 //
1002 // Loop all the descriptor's allocation lists and initialize them
1003 //
1004 NextEntry = PoolDescriptor->ListHeads;
1005 LastEntry = NextEntry + POOL_LISTS_PER_PAGE;
1006 while (NextEntry < LastEntry)
1007 {
1008 ExpInitializePoolListHead(NextEntry);
1009 NextEntry++;
1010 }
1011
1012 //
1013 // Note that ReactOS does not support Session Pool Yet
1014 //
1016}
VOID NTAPI ExpInitializePoolListHead(IN PLIST_ENTRY ListHead)
Definition: expool.c:114
Definition: typedefs.h:120
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ _Strict_type_match_ POOL_TYPE PoolType
Definition: wdfdevice.h:3815
Referenced by InitializePool(), and MiInitializeSessionPool().
◆ InitializePool()
Definition at line 1021 of file expool.c.
1023{
1027
1028 //
1029 // Check what kind of pool this is
1030 //
1032 {
1033 //
1034 // Compute the track table size and convert it from a power of two to an
1035 // actual byte size
1036 //
1037 // NOTE: On checked builds, we'll assert if the registry table size was
1038 // invalid, while on retail builds we'll just break out of the loop at
1039 // that point.
1040 //
1043 {
1045 {
1048 }
1049 TableSize >>= 1;
1050 }
1051
1052 //
1053 // If we hit bit 32, than no size was defined in the registry, so
1054 // we'll use the default size of 2048 entries.
1055 //
1056 // Otherwise, use the size from the registry, as long as it's not
1057 // smaller than 64 entries.
1058 //
1060 {
1061 PoolTrackTableSize = 2048;
1062 }
1063 else
1064 {
1066 }
1067
1068 //
1069 // Loop trying with the biggest specified size first, and cut it down
1070 // by a power of two each iteration in case not enough memory exist
1071 //
1073 {
1074 //
1075 // Do not allow overflow
1076 //
1078 {
1079 PoolTrackTableSize >>= 1;
1080 continue;
1081 }
1082
1083 //
1084 // Allocate the tracker table and exit the loop if this worked
1085 //
1087 (PoolTrackTableSize + 1) *
1090
1091 //
1092 // Otherwise, as long as we're not down to the last bit, keep
1093 // iterating
1094 //
1096 {
1097 KeBugCheckEx(MUST_SUCCEED_POOL_EMPTY,
1098 TableSize,
1099 0xFFFFFFFF,
1100 0xFFFFFFFF,
1101 0xFFFFFFFF);
1102 }
1103 PoolTrackTableSize >>= 1;
1104 }
1105
1106 //
1107 // Add one entry, compute the hash, and zero the table
1108 //
1109 PoolTrackTableSize++;
1111
1114
1115 //
1116 // Finally, add the most used tags to speed up those allocations
1117 //
1118 ExpSeedHotTags();
1119
1120 //
1121 // We now do the exact same thing with the tracker table for big pages
1122 //
1125 {
1127 {
1130 }
1131 TableSize >>= 1;
1132 }
1133
1134 //
1135 // For big pages, the default tracker table is 4096 entries, while the
1136 // minimum is still 64
1137 //
1139 {
1140 PoolBigPageTableSize = 4096;
1141 }
1142 else
1143 {
1145 }
1146
1147 //
1148 // Again, run the exact same loop we ran earlier, but this time for the
1149 // big pool tracker instead
1150 //
1152 {
1154 {
1155 PoolBigPageTableSize >>= 1;
1156 continue;
1157 }
1158
1160 PoolBigPageTableSize *
1163
1165 {
1166 KeBugCheckEx(MUST_SUCCEED_POOL_EMPTY,
1167 TableSize,
1168 0xFFFFFFFF,
1169 0xFFFFFFFF,
1170 0xFFFFFFFF);
1171 }
1172
1173 PoolBigPageTableSize >>= 1;
1174 }
1175
1176 //
1177 // An extra entry is not needed for for the big pool tracker, so just
1178 // compute the hash and zero it
1179 //
1184 {
1186 }
1187
1188 //
1189 // During development, print this out so we can see what's happening
1190 //
1195
1196 //
1197 // Insert the generic tracker for all of big pool
1198 //
1202 NonPagedPool);
1203
1204 //
1205 // No support for NUMA systems at this time
1206 //
1208
1209 //
1210 // Initialize the tag spinlock
1211 //
1213
1214 //
1215 // Initialize the nonpaged pool descriptor
1216 //
1219 NonPagedPool,
1220 0,
1221 Threshold,
1222 NULL);
1223 }
1224 else
1225 {
1226 //
1227 // No support for NUMA systems at this time
1228 //
1230
1231 //
1232 // Allocate the pool descriptor
1233 //
1237 'looP');
1239 {
1240 //
1241 // This is really bad...
1242 //
1243 KeBugCheckEx(MUST_SUCCEED_POOL_EMPTY,
1244 0,
1245 -1,
1246 -1,
1247 -1);
1248 }
1249
1250 //
1251 // Setup the vector and guarded mutex for paged pool
1252 //
1258 PagedPool,
1259 0,
1260 Threshold,
1261 ExpPagedPoolMutex);
1262
1263 //
1264 // Insert the generic tracker for all of nonpaged pool
1265 //
1268 NonPagedPool);
1269 }
1270}
VOID NTAPI ExInitializePoolDescriptor(IN PPOOL_DESCRIPTOR PoolDescriptor, IN POOL_TYPE PoolType, IN ULONG PoolIndex, IN ULONG Threshold, IN PVOID PoolLock)
Definition: expool.c:970
VOID NTAPI ExpInsertPoolTracker(IN ULONG Key, IN SIZE_T NumberOfBytes, IN POOL_TYPE PoolType)
Definition: expool.c:851
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
PVOID NTAPI MiAllocatePoolPages(IN POOL_TYPE PoolType, IN SIZE_T SizeInBytes)
Definition: pool.c:422
VOID NTAPI KeBugCheckEx(_In_ ULONG BugCheckCode, _In_ ULONG_PTR BugCheckParameter1, _In_ ULONG_PTR BugCheckParameter2, _In_ ULONG_PTR BugCheckParameter3, _In_ ULONG_PTR BugCheckParameter4)
Definition: rtlcompat.c:108
Definition: ketypes.h:826
Definition: miarm.h:310
Definition: miarm.h:379
Definition: miarm.h:368
_Must_inspect_result_ _In_ WDFIORESLIST _In_ PIO_RESOURCE_DESCRIPTOR Descriptor
Definition: wdfresource.h:342
struct _KGUARDED_MUTEX * PKGUARDED_MUTEX
#define ROUND_TO_PAGES(Size)
Referenced by MiBuildPagedPool(), and MiInitMachineDependent().
◆ MI_ERASE_PTE()
| FORCEINLINE VOID MI_ERASE_PTE | ( | IN PMMPTE | PointerPte | ) |
Definition at line 1006 of file miarm.h.
1007{
1008 /* Zero out the PTE */
1009 ASSERT(PointerPte->u.Long != 0);
1010 PointerPte->u.Long = 0;
1011}
Referenced by MiDeletePte(), MiDeleteSystemPageableVm(), MiDeleteVirtualAddresses(), MiUnmapLockedPagesInUserSpace(), and MmFreeSpecialPool().
◆ MI_GET_PROTOTYPE_PTE_FOR_VPN()
Definition at line 1557 of file miarm.h.
1559{
1560 PMMPTE ProtoPte;
1561
1562 /* Find the offset within the VAD's prototype PTEs */
1563 ProtoPte = Vad->FirstPrototypePte + (Vpn - Vad->StartingVpn);
1564 ASSERT(ProtoPte <= Vad->LastContiguousPte);
1565 return ProtoPte;
1566}
Definition: mmtypes.h:212
Referenced by MiDeleteVirtualAddresses(), MiQueryAddressState(), and NtAllocateVirtualMemory().
◆ MI_IS_MAPPED_PTE()
| FORCEINLINE BOOLEAN MI_IS_MAPPED_PTE | ( | PMMPTE | PointerPte | ) |
◆ MI_IS_PHYSICAL_ADDRESS()
| FORCEINLINE BOOLEAN MI_IS_PHYSICAL_ADDRESS | ( | IN PVOID | Address | ) |
Definition at line 945 of file miarm.h.
946{
947 PMMPDE PointerPde;
948
949 /* Large pages are never paged out, always physically resident */
952}
Referenced by MiDispatchFault(), MiFindInitializationCode(), MiFreeInitializationCode(), MiProtectFreeNonPagedPool(), MiReleaseProcessReferenceToSessionDataPage(), MiSetPagingOfDriver(), MiUnProtectFreeNonPagedPool(), MiWriteProtectSystemImage(), MmChangeKernelResourceSectionProtection(), MmFreeDriverInitialization(), MmFreeLoaderBlock(), MmMakeKernelResourceSectionWritable(), and MmProbeAndLockPages().
◆ MI_IS_PROCESS_WORKING_SET()
| FORCEINLINE BOOLEAN MI_IS_PROCESS_WORKING_SET | ( | PMMSUPPORT | WorkingSet | ) |
Definition at line 661 of file miarm.h.
662{
664}
Referenced by MiInitializeWorkingSetList(), and MmWorkingSetManager().
◆ MI_IS_WS_UNSAFE()
| FORCEINLINE BOOLEAN MI_IS_WS_UNSAFE | ( | IN PEPROCESS | Process | ) |
Definition at line 1114 of file miarm.h.
1115{
1117}
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
Referenced by MiLockProcessWorkingSet(), MiLockProcessWorkingSetShared(), MiLockProcessWorkingSetUnsafe(), MiUnlockProcessWorkingSet(), MiUnlockProcessWorkingSetForFault(), MiUnlockProcessWorkingSetShared(), and MiUnlockProcessWorkingSetUnsafe().
◆ MI_MAKE_HARDWARE_PTE()
| FORCEINLINE VOID MI_MAKE_HARDWARE_PTE | ( | IN PMMPTE | NewPte, |
| IN PMMPTE | MappingPte, | ||
| IN ULONG_PTR | ProtectionMask, | ||
| IN PFN_NUMBER | PageFrameNumber | ||
| ) |
Definition at line 807 of file miarm.h.
811{
812 /* Check that we are not setting valid a page that should not be */
815
816 /* Set the protection and page */
817 NewPte->u.Long = MiDetermineUserGlobalPteMask(MappingPte);
818 NewPte->u.Long |= MmProtectToPteMask[ProtectionMask];
819 NewPte->u.Hard.PageFrameNumber = PageFrameNumber;
820}
FORCEINLINE ULONG_PTR MiDetermineUserGlobalPteMask(IN PVOID PointerPte)
Definition: miarm.h:736
Referenced by MiCompleteProtoPteFault(), MiResolveDemandZeroFault(), MiResolvePageFileFault(), MiResolveProtoPteFault(), MmArmAccessFault(), and MmCreateVirtualMappingUnsafeEx().
◆ MI_MAKE_HARDWARE_PTE_KERNEL()
| FORCEINLINE VOID MI_MAKE_HARDWARE_PTE_KERNEL | ( | IN PMMPTE | NewPte, |
| IN PMMPTE | MappingPte, | ||
| IN ULONG_PTR | ProtectionMask, | ||
| IN PFN_NUMBER | PageFrameNumber | ||
| ) |
Definition at line 773 of file miarm.h.
777{
778 /* Only valid for kernel, non-session PTEs */
782
783 /* Check that we are not setting valid a page that should not be */
786
787 /* Start fresh */
788 NewPte->u.Long = 0;
789
790 /* Set the protection and page */
791 NewPte->u.Hard.PageFrameNumber = PageFrameNumber;
792 NewPte->u.Long |= MmProtectToPteMask[ProtectionMask];
793
794 /* Make this valid & global */
795#ifdef _GLOBAL_PAGES_ARE_AWESOME_
797 NewPte->u.Hard.Global = 1;
798#endif
799 NewPte->u.Hard.Valid = 1;
800}
Referenced by MiArchCreateProcessAddressSpace(), MmChangeKernelResourceSectionProtection(), MmCreateKernelStack(), MmGrowKernelStackEx(), and MmInitSystem().
◆ MI_MAKE_HARDWARE_PTE_USER()
| FORCEINLINE VOID MI_MAKE_HARDWARE_PTE_USER | ( | IN PMMPTE | NewPte, |
| IN PMMPTE | MappingPte, | ||
| IN ULONG_PTR | ProtectionMask, | ||
| IN PFN_NUMBER | PageFrameNumber | ||
| ) |
Definition at line 827 of file miarm.h.
831{
832 /* Only valid for kernel, non-session PTEs */
834
835 /* Start fresh */
836 NewPte->u.Long = 0;
837
838 /* Check that we are not setting valid a page that should not be */
841
842 NewPte->u.Hard.Valid = TRUE;
843 NewPte->u.Hard.Owner = TRUE;
844 NewPte->u.Hard.PageFrameNumber = PageFrameNumber;
845 NewPte->u.Long |= MmProtectToPteMask[ProtectionMask];
846}
Referenced by MiCompleteProtoPteFault(), MiFlushTbAndCapture(), MiMapLockedPagesInUserSpace(), MiResolveDemandZeroFault(), MiResolveProtoPteFault(), and MmArmAccessFault().
◆ MI_MAKE_PROTOTYPE_PTE()
Definition at line 854 of file miarm.h.
856{
858
859 /* Mark this as a prototype */
860 NewPte->u.Long = 0;
861 NewPte->u.Proto.Prototype = 1;
862
863 /*
864 * Prototype PTEs are only valid in paged pool by design, this little trick
865 * lets us only use 30 bits for the adress of the PTE, as long as the area
866 * stays 1024MB At most.
867 */
869
870 /*
871 * 7 bits go in the "low" (but we assume the bottom 2 are zero)
872 * and the other 21 bits go in the "high"
873 */
874 NewPte->u.Proto.ProtoAddressLow = (Offset & 0x1FC) >> 2;
875 NewPte->u.Proto.ProtoAddressHigh = (Offset & 0x3FFFFE00) >> 9;
876}
◆ MI_MAKE_SUBSECTION_PTE()
Definition at line 883 of file miarm.h.
885{
887
888 /* Mark this as a prototype */
889 NewPte->u.Long = 0;
890 NewPte->u.Subsect.Prototype = 1;
891
892 /*
893 * Segments are only valid either in nonpaged pool. We store the 20 bit
894 * difference either from the top or bottom of nonpaged pool, giving a
895 * maximum of 128MB to each delta, meaning nonpaged pool cannot exceed
896 * 256MB.
897 */
899 {
901 NewPte->u.Subsect.WhichPool = PagedPool;
902 }
903 else
904 {
906 NewPte->u.Subsect.WhichPool = NonPagedPool;
907 }
908
909 /*
910 * 4 bits go in the "low" (but we assume the bottom 3 are zero)
911 * and the other 20 bits go in the "high"
912 */
913 NewPte->u.Subsect.SubsectionAddressLow = (Offset & 0x78) >> 3;
914 NewPte->u.Subsect.SubsectionAddressHigh = (Offset & 0xFFFFF80) >> 7;
915}
◆ MI_MAKE_TRANSITION_PTE()
| FORCEINLINE VOID MI_MAKE_TRANSITION_PTE | ( | _Out_ PMMPTE | NewPte, |
| _In_ PFN_NUMBER | Page, | ||
| _In_ ULONG | Protection | ||
| ) |
Definition at line 929 of file miarm.h.
932{
933 NewPte->u.Long = 0;
934 NewPte->u.Trans.Transition = 1;
935 NewPte->u.Trans.Protection = Protection;
936 NewPte->u.Trans.PageFrameNumber = Page;
937}
Referenced by MiResolvePageFileFault(), and TrimWsList().
◆ MI_PFN_ELEMENT()
| FORCEINLINE PMMPFN MI_PFN_ELEMENT | ( | IN PFN_NUMBER | Pfn | ) |
Definition at line 1574 of file miarm.h.
1575{
1576 /* Get the entry */
1578};
Referenced by MiDecrementReferenceCount(), MiDecrementShareCount(), MiDispatchFault(), MiFindContiguousPages(), MiGetPageProtection(), MiInitializeAndChargePfn(), MiInitializePfn(), MiInitializePfnAndMakePteValid(), MiInitializePfnForOtherProcess(), MiInsertPageInFreeList(), MiInsertPageInList(), MiInsertStandbyListAtFront(), MiMapLockedPagesInUserSpace(), MiReleaseProcessReferenceToSessionDataPage(), MiRemoveAnyPage(), MiRemovePageByColor(), MiRemoveZeroPage(), MiResolveDemandZeroFault(), MiResolvePageFileFault(), MiResolveProtoPteFault(), MiSegmentDelete(), MiSessionCommitPageTables(), MiSessionCreateInternal(), MiUnlinkFreeOrZeroedPage(), MiUnlinkPageFromList(), MmArmAccessFault(), and MmFreeSpecialPool().
◆ MI_UPDATE_VALID_PTE()
Definition at line 977 of file miarm.h.
979{
980 /* Write the valid PTE */
981 ASSERT(PointerPte->u.Hard.Valid == 1);
984 *PointerPte = TempPte;
985}
Referenced by MiFlushTbAndCapture(), MiSetSystemCodeProtection(), MmArmAccessFault(), and MmChangeKernelResourceSectionProtection().
◆ MI_WRITE_INVALID_PDE()
Definition at line 1035 of file miarm.h.
1037{
1038 /* Write the invalid PDE */
1039 ASSERT(InvalidPde.u.Hard.Valid == 0);
1040 ASSERT(InvalidPde.u.Long != 0);
1041#ifdef _M_AMD64
1043#endif
1044 *PointerPde = InvalidPde;
1045}
Referenced by MmArmAccessFault().
◆ MI_WRITE_INVALID_PTE()
Definition at line 992 of file miarm.h.
994{
995 /* Write the invalid PTE */
996 ASSERT(InvalidPte.u.Hard.Valid == 0);
997 ASSERT(InvalidPte.u.Long != 0);
998 *PointerPte = InvalidPte;
999}
Referenced by MiAccessCheck(), MiAddMappedPtes(), MiAllocatePoolPages(), MiDecommitPages(), MiDecrementShareCount(), MiMapViewOfDataSection(), MiProcessValidPteList(), MiProtectFreeNonPagedPool(), MiProtectVirtualMemory(), MiResolvePageFileFault(), MiSetProtectionOnSection(), MmArmAccessFault(), MmCommitSessionMappedView(), MmCreateKernelStack(), MmGrowKernelStackEx(), and NtAllocateVirtualMemory().
◆ MI_WRITE_VALID_PDE()
Definition at line 1018 of file miarm.h.
1020{
1021 /* Write the valid PDE */
1022 ASSERT(PointerPde->u.Hard.Valid == 0);
1023#ifdef _M_AMD64
1024 ASSERT(PointerPde->u.Hard.NoExecute == 0);
1025#endif
1027 *PointerPde = TempPde;
1028}
Referenced by MiAllocatePoolPages(), MiBuildPagedPool(), MiFillSystemPageDirectory(), MiInitializeAndChargePfn(), MiRemoveMappedPtes(), MiSessionCommitPageTables(), MiSessionCreateInternal(), and MiSessionInitializeWorkingSetList().
◆ MI_WRITE_VALID_PTE()
Definition at line 959 of file miarm.h.
961{
962 /* Write the valid PTE */
963 ASSERT(PointerPte->u.Hard.Valid == 0);
965#if _M_AMD64
968#endif
969 *PointerPte = TempPte;
970}
Referenced by MiAllocatePoolPages(), MiArchCreateProcessAddressSpace(), MiBuildPagedPool(), MiCompleteProtoPteFault(), MiCopyPfn(), MiDispatchFault(), MiInitializeColorTables(), MiInitializePfnAndMakePteValid(), MiInitMachineDependent(), MiLoadImageSection(), MiMapLockedPagesInUserSpace(), MiMapPageInHyperSpace(), MiMapPagesInZeroSpace(), MiMapPDEs(), MiMapPfnDatabase(), MiMapPPEs(), MiMapPTEs(), MiReloadBootLoadedDrivers(), MiResolveDemandZeroFault(), MiResolvePageFileFault(), MiResolveProtoPteFault(), MiResolveTransitionFault(), MiSessionCreateInternal(), MiUnProtectFreeNonPagedPool(), MiZeroPfn(), MmAllocateNonCachedMemory(), MmArmAccessFault(), MmCreateKernelStack(), MmGrowKernelStackEx(), MmMapIoSpace(), and MmMapLockedPagesSpecifyCache().
◆ MI_WS_OWNER()
| FORCEINLINE BOOLEAN MI_WS_OWNER | ( | IN PEPROCESS | Process | ) |
Definition at line 1077 of file miarm.h.
1078{
1079 /* Check if this process is the owner, and that the thread owns the WS */
1081 {
1083 }
1085 {
1086 DPRINT("Current thread %p is attached to another process %p\n", PsGetCurrentThread(), Process);
1087 }
1089 ((PsGetCurrentThread()->OwnsProcessWorkingSetExclusive) ||
1090 (PsGetCurrentThread()->OwnsProcessWorkingSetShared)));
1091}
Referenced by MiUnlockProcessWorkingSet(), MiUnlockProcessWorkingSetForFault(), MiUnlockProcessWorkingSetShared(), and MiUnlockProcessWorkingSetUnsafe().
◆ MiAcquireExpansionLock()
| FORCEINLINE KIRQL MiAcquireExpansionLock | ( | VOID | ) |
Definition at line 1531 of file miarm.h.
1532{
1534
1540}
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778
Referenced by MiArchCreateProcessAddressSpace(), MiDereferenceSessionFinal(), MiSessionAddProcess(), MiSessionInitializeWorkingSetList(), MiSessionLeader(), MiSessionRemoveProcess(), MmDeleteProcessAddressSpace(), MmGetSessionById(), and MmWorkingSetManager().
◆ MiAllocatePagesForMdl()
| PMDL NTAPI MiAllocatePagesForMdl | ( | IN PHYSICAL_ADDRESS | LowAddress, |
| IN PHYSICAL_ADDRESS | HighAddress, | ||
| IN PHYSICAL_ADDRESS | SkipBytes, | ||
| IN SIZE_T | TotalBytes, | ||
| IN MI_PFN_CACHE_ATTRIBUTE | CacheAttribute, | ||
| IN ULONG | Flags | ||
| ) |
Definition at line 182 of file freelist.c.
188{
191 PPFN_NUMBER MdlPage, LastMdlPage;
193 PMMPFN Pfn1;
194 INT LookForZeroedPages;
196 DPRINT1("ARM3-DEBUG: Being called with %I64x %I64x %I64x %lx %d %lu\n", LowAddress, HighAddress, SkipBytes, TotalBytes, CacheAttribute, MdlFlags);
197
198 //
199 // Convert the low address into a PFN
200 //
202
203 //
204 // Convert, and normalize, the high address into a PFN
205 //
208
209 //
210 // Validate skipbytes and convert them into pages
211 //
214
215 /* This isn't supported at all */
217
218 //
219 // Now compute the number of pages the MDL will cover
220 //
222 do
223 {
224 //
225 // Try creating an MDL for these many pages
226 //
229
230 //
231 // This function is not required to return the amount of pages requested
232 // In fact, it can return as little as 1 page, and callers are supposed
233 // to deal with this scenario. So re-attempt the allocation with less
234 // pages than before, and see if it worked this time.
235 //
236 PageCount -= (PageCount >> 4);
237 } while (PageCount);
238
239 //
240 // Wow, not even a single page was around!
241 //
243
244 //
245 // This is where the page array starts....
246 //
248
249 //
250 // Lock the PFN database
251 //
252 OldIrql = MiAcquirePfnLock();
253
254 //
255 // Are we looking for any pages, without discriminating?
256 //
258 {
259 //
260 // Well then, let's go shopping
261 //
262 while (PagesFound < PageCount)
263 {
264 /* Grab a page */
267
268 /* FIXME: This check should be smarter */
269 Page = 0;
272
274 {
275 /* This is not good... hopefully we have at least SOME pages */
276 ASSERT(PagesFound);
277 break;
278 }
279
280 /* Grab the page entry for it */
282
283 //
284 // Make sure it's really free
285 //
287
288 /* Now setup the page and mark it */
291 MI_SET_PFN_DELETED(Pfn1);
296
297 //
298 // Save it into the MDL
299 //
300 *MdlPage++ = MiGetPfnEntryIndex(Pfn1);
301 PagesFound++;
302 }
303 }
304 else
305 {
306 //
307 // You want specific range of pages. We'll do this in two runs
308 //
309 for (LookForZeroedPages = 1; LookForZeroedPages >= 0; LookForZeroedPages--)
310 {
311 //
312 // Scan the range you specified
313 //
315 {
316 //
317 // Get the PFN entry for this page
318 //
320 ASSERT(Pfn1);
321
322 //
323 // Make sure it's free and if this is our first pass, zeroed
324 //
327
328 /* Remove the page from the free or zero list */
332 MiUnlinkFreeOrZeroedPage(Pfn1);
333
334 //
335 // Sanity checks
336 //
338
339 //
340 // Now setup the page and mark it
341 //
344 MI_SET_PFN_DELETED(Pfn1);
349
350 //
351 // Save this page into the MDL
352 //
353 *MdlPage++ = Page;
354 if (++PagesFound == PageCount) break;
355 }
356
357 //
358 // If the first pass was enough, don't keep going, otherwise, go again
359 //
360 if (PagesFound == PageCount) break;
361 }
362 }
363
364 //
365 // Now release the PFN count
366 //
367 MiReleasePfnLock(OldIrql);
368
369 //
370 // We might've found less pages, but not more ;-)
371 //
373 if (!PagesFound)
374 {
375 //
376 // If we didn' tfind any pages at all, fail
377 //
381 }
382
383 //
384 // Write out how many pages we found
385 //
387
388 //
389 // Terminate the MDL array if there's certain missing pages
390 //
392
393 //
394 // Now go back and loop over all the MDL pages
395 //
397 LastMdlPage = MdlPage + PagesFound;
398 while (MdlPage < LastMdlPage)
399 {
400 //
401 // Check if we've reached the end
402 //
403 Page = *MdlPage++;
405
406 //
407 // Get the PFN entry for the page and check if we should zero it out
408 //
410 ASSERT(Pfn1);
413 }
414
415 //
416 // We're done, mark the pages as locked
417 //
421}
Definition: nsiface.idl:2307
VOID NTAPI MiUnlinkFreeOrZeroedPage(IN PMMPFN Entry)
Definition: pfnlist.c:137
PMDL NTAPI MmCreateMdl(IN PMDL Mdl, IN PVOID Base, IN SIZE_T Length)
Definition: mdlsup.c:378
VOID NTAPI MiZeroPhysicalPage(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:122
union _MMPFN::@1785 u4
union _MMPFN::@1782 u3
union _MMPFN::@1781 u2
struct _MMPFN::@1782::@1788 e2
#define BYTE_OFFSET(Va)
#define ADDRESS_AND_SIZE_TO_SPAN_PAGES(_Va, _Size)
_Must_inspect_result_ _In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS SkipBytes
Definition: mmfuncs.h:227
_Must_inspect_result_ _In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS _In_ SIZE_T TotalBytes
Definition: mmfuncs.h:228
Referenced by MmAllocateNonCachedMemory(), MmAllocatePagesForMdl(), and MmAllocatePagesForMdlEx().
◆ MiCheckForConflictingNode()
| TABLE_SEARCH_RESULT NTAPI MiCheckForConflictingNode | ( | IN ULONG_PTR | StartVpn, |
| IN ULONG_PTR | EndVpn, | ||
| IN PMM_AVL_TABLE | Table, | ||
| OUT PMMADDRESS_NODE * | NodeOrParent | ||
| ) |
Definition at line 150 of file vadnode.c.
154{
155 PMMADDRESS_NODE ParentNode, CurrentNode;
156
158
159 /* If the tree is empty, there is no conflict */
161
162 /* Start looping from the root node */
165 while (CurrentNode)
166 {
167 ParentNode = CurrentNode;
168
169 /* This address comes after */
171 {
172 /* Keep searching on the right */
173 CurrentNode = RtlRightChildAvl(CurrentNode);
174 }
175 else if (EndVpn < CurrentNode->StartingVpn)
176 {
177 /* This address ends before the node starts, search on the left */
178 CurrentNode = RtlLeftChildAvl(CurrentNode);
179 }
180 else
181 {
182 /* This address is part of this node, return it */
183 *NodeOrParent = ParentNode;
184 return TableFoundNode;
185 }
186 }
187
188 /* There is no more child, save the current node as parent */
189 *NodeOrParent = ParentNode;
191 {
192 return TableInsertAsRight;
193 }
194 else
195 {
196 return TableInsertAsLeft;
197 }
198}
Definition: mmtypes.h:645
Referenced by MiInsertVadEx(), MiMapLockedPagesInUserSpace(), MiProtectVirtualMemory(), MmLocateMemoryAreaByAddress(), MmLocateMemoryAreaByRegion(), and NtAllocateVirtualMemory().
◆ MiCheckForContiguousMemory()
| PVOID NTAPI MiCheckForContiguousMemory | ( | IN PVOID | BaseAddress, |
| IN PFN_NUMBER | BaseAddressPages, | ||
| IN PFN_NUMBER | SizeInPages, | ||
| IN PFN_NUMBER | LowestPfn, | ||
| IN PFN_NUMBER | HighestPfn, | ||
| IN PFN_NUMBER | BoundaryPfn, | ||
| IN MI_PFN_CACHE_ATTRIBUTE | CacheAttribute | ||
| ) |
Definition at line 214 of file contmem.c.
221{
222 PMMPTE StartPte, EndPte;
224
225 //
226 // Okay, first of all check if the PFNs match our restrictions
227 //
232
233 //
234 // This is the last page we need to get to and the boundary requested
235 //
236 HighPage = HighestPfn + 1 - SizeInPages;
237 BoundaryMask = ~(BoundaryPfn - 1);
238
239 //
240 // And here's the PTEs for this allocation. Let's go scan them.
241 //
243 EndPte = StartPte + BaseAddressPages;
244 while (StartPte < EndPte)
245 {
246 //
247 // Get this PTE's page number
248 //
251
252 //
253 // Is this the beginning of our adventure?
254 //
255 if (!Pages)
256 {
257 //
258 // Check if this PFN is within our range
259 //
261 {
262 //
263 // It is! Do you care about boundary (alignment)?
264 //
265 if (!(BoundaryPfn) ||
267 {
268 //
269 // You don't care, or you do care but we deliver
270 //
271 Pages++;
272 }
273 }
274
275 //
276 // Have we found all the pages we need by now?
277 // Incidently, this means you only wanted one page
278 //
279 if (Pages == SizeInPages)
280 {
281 //
282 // Mission complete
283 //
285 }
286 }
287 else
288 {
289 //
290 // Have we found a page that doesn't seem to be contiguous?
291 //
293 {
294 //
295 // Ah crap, we have to start over
296 //
297 Pages = 0;
298 continue;
299 }
300
301 //
302 // Otherwise, we're still in the game. Do we have all our pages?
303 //
304 if (++Pages == SizeInPages)
305 {
306 //
307 // We do! This entire range was contiguous, so we'll return it!
308 //
310 }
311 }
312
313 //
314 // Try with the next PTE, remember this PFN
315 //
316 PreviousPage = Page;
317 StartPte++;
318 continue;
319 }
320
321 //
322 // All good returns are within the loop...
323 //
325}
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
Referenced by MiAllocateContiguousMemory().
◆ MiCheckPdeForPagedPool()
Definition at line 479 of file pagfault.c.
480{
482}
Referenced by MiDeletePte(), MiInitializePfn(), MiInitializePfnAndMakePteValid(), and MmArmAccessFault().
◆ MiCheckSecuredVad()
| NTSTATUS NTAPI MiCheckSecuredVad | ( | IN PMMVAD | Vad, |
| IN PVOID | Base, | ||
| IN SIZE_T | Size, | ||
| IN ULONG | ProtectionMask | ||
| ) |
Definition at line 903 of file vadnode.c.
907{
908 ULONG_PTR StartAddress, EndAddress;
909
910 /* Compute start and end address */
912 EndAddress = StartAddress + Size - 1;
913
914 /* Are we deleting/unmapping, or changing? */
916 {
917 /* Changing... are we allowed to do so? */
918 if ((Vad->u.VadFlags.NoChange == 1) &&
919 (Vad->u2.VadFlags2.SecNoChange == 1) &&
920 (Vad->u.VadFlags.Protection != ProtectionMask))
921 {
922 /* Nope, bail out */
925 }
926 }
927 else
928 {
929 /* This is allowed */
930 ProtectionMask = 0;
931 }
932
933 /* ARM3 doesn't support this yet */
934 ASSERT(Vad->u2.VadFlags2.MultipleSecured == 0);
935
936 /* Is this a one-secured VAD, like a TEB or PEB? */
937 if (Vad->u2.VadFlags2.OneSecured)
938 {
939 /* Is this allocation being described by the VAD? */
941 (EndAddress >= ((PMMVAD_LONG)Vad)->u3.Secured.StartVpn))
942 {
943 /* Guard page? */
945 {
948 }
949
950 /* ARM3 doesn't have read-only VADs yet */
952
953 /* Check if read-write protections are allowed */
955 {
958 }
959 }
960 }
961
962 /* All good, allow the change */
964}
Definition: mmtypes.h:750
union _MMVAD_LONG::@2602 u2
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
Referenced by MiUnmapViewOfSection(), and NtAllocateVirtualMemory().
◆ MiComputeColorInformation()
Definition at line 508 of file mminit.c.
509{
510 ULONG L2Associativity;
511
512 /* Check if no setting was provided already */
514 {
515 /* Get L2 cache information */
516 L2Associativity = KeGetPcr()->SecondLevelCacheAssociativity;
517
518 /* The number of colors is the number of cache bytes by set/way */
521 }
522
523 /* Now convert cache bytes into pages */
526 {
527 /* If there was no cache data from the KPCR, use the default colors */
529 }
530 else
531 {
532 /* Otherwise, make sure there aren't too many colors */
534 {
535 /* Set the maximum */
537 }
538
539 /* Make sure there aren't too little colors */
541 {
542 /* Set the default */
544 }
545
546 /* Finally make sure the colors are a power of two */
548 {
549 /* Set the default */
551 }
552 }
553
554 /* Compute the mask and store it */
557}
Referenced by MmArmInitSystem().
◆ MiConvertSharedWorkingSetLockToExclusive()
| FORCEINLINE BOOLEAN MiConvertSharedWorkingSetLockToExclusive | ( | _In_ PETHREAD | Thread, |
| _In_ PMMSUPPORT | Vm | ||
| ) |
Definition at line 1428 of file miarm.h.
1431{
1432 /* Sanity check: No exclusive lock. */
1436
1437 /* And it should have one and only one shared lock */
1438 ASSERT((Thread->OwnsProcessWorkingSetShared + Thread->OwnsSessionWorkingSetShared + Thread->OwnsSystemWorkingSetShared) == 1);
1439
1440 /* Try. */
1443
1445 {
1449 }
1450 else if (Vm->Flags.SessionSpace)
1451 {
1455 }
1456 else
1457 {
1461 }
1462
1464}
FORCEINLINE BOOLEAN ExConvertPushLockSharedToExclusive(IN PEX_PUSH_LOCK PushLock)
Definition: ex.h:1139
ULONG OwnsSessionWorkingSetExclusive
Definition: pstypes.h:1225
ULONG OwnsProcessWorkingSetExclusive
Definition: pstypes.h:1221
ULONG OwnsSystemWorkingSetExclusive
Definition: pstypes.h:1223
Referenced by MmWorkingSetManager().
◆ MiDecrementPageTableReferences()
| FORCEINLINE USHORT MiDecrementPageTableReferences | ( | IN PVOID | Address | ) |
Definition at line 2507 of file miarm.h.
2508{
2510 PMMPFN Pfn;
2511
2512 /* We should not tinker with this one. */
2514
2516
2517 /* Make sure we're locked */
2519
2520 /* If we're decreasing refcount, then it must be valid! */
2522
2523 /* This lies on the PFN */
2525
2528
2530
2532}
#define PXE_SELFMAP
Referenced by _Success_(), MiDeletePde(), MiDeleteVirtualAddresses(), MiUnmapLockedPagesInUserSpace(), and MmDeletePageFileMapping().
◆ MiDecrementReferenceCount()
Definition at line 1236 of file pfnlist.c.
1238{
1239 /* PFN lock must be held */
1240 MI_ASSERT_PFN_LOCK_HELD();
1241
1242 /* Handle RosMm PFNs here, too (in case they got locked/unlocked by ARM3) */
1244 {
1245 MmDereferencePage(PageFrameIndex);
1246 return;
1247 }
1248
1249 /* Sanity checks on the page */
1251 Pfn1 != MI_PFN_ELEMENT(PageFrameIndex) ||
1253 Pfn1->u3.e2.ReferenceCount >= 2500)
1254 {
1255 DPRINT1("PageFrameIndex=0x%lx, MmHighestPhysicalPage=0x%lx\n", PageFrameIndex, MmHighestPhysicalPage);
1256 DPRINT1("Pfn1=%p, Element=%p, RefCount=%u\n", Pfn1, MI_PFN_ELEMENT(PageFrameIndex), Pfn1->u3.e2.ReferenceCount);
1259 ASSERT(Pfn1->u3.e2.ReferenceCount != 0);
1260 ASSERT(Pfn1->u3.e2.ReferenceCount < 2500);
1261 }
1262
1263 /* Dereference the page, bail out if it's still alive */
1265 if (Pfn1->u3.e2.ReferenceCount) return;
1266
1267 /* Nobody should still have reference to this page */
1268 if (Pfn1->u2.ShareCount != 0)
1269 {
1270 /* Otherwise something's really wrong */
1271 KeBugCheckEx(PFN_LIST_CORRUPT, 7, PageFrameIndex, Pfn1->u2.ShareCount, 0);
1272 }
1273
1274 /* And it should be lying on some page list */
1276
1277 /* Did someone set the delete flag? */
1279 {
1280 /* Insert it into the free list, there's nothing left to do */
1281 MiInsertPageInFreeList(PageFrameIndex);
1282 return;
1283 }
1284
1285 /* Check to see which list this page should go into */
1286 if (Pfn1->u3.e1.Modified == 1)
1287 {
1288 /* Push it into the modified page list */
1290 }
1291 else
1292 {
1293 /* Otherwise, insert this page into the standby list */
1294 ASSERT(Pfn1->u3.e1.RemovalRequested == 0);
1295 MiInsertStandbyListAtFront(PageFrameIndex);
1296 }
1297}
VOID NTAPI MiInsertPageInFreeList(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:611
VOID NTAPI MiInsertPageInList(IN PMMPFNLIST ListHead, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:779
VOID FASTCALL MiInsertStandbyListAtFront(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:719
Referenced by MiDecrementShareCount(), MiDeletePte(), MiDereferencePfnAndDropLockCount(), and MmFreePagesFromMdl().
◆ MiDecrementShareCount()
Definition at line 1141 of file pfnlist.c.
1143{
1144 PMMPTE PointerPte;
1146
1147 ASSERT(PageFrameIndex > 0);
1151
1153
1154 /* Page must be in-use */
1156 (Pfn1->u3.e1.PageLocation != StandbyPageList))
1157 {
1158 /* Otherwise we have PFN corruption */
1159 KeBugCheckEx(PFN_LIST_CORRUPT,
1160 0x99,
1161 PageFrameIndex,
1162 Pfn1->u3.e1.PageLocation,
1163 0);
1164 }
1165
1166 /* Page should at least have one reference */
1167 ASSERT(Pfn1->u3.e2.ReferenceCount != 0);
1168
1169 /* Check if the share count is now 0 */
1170 ASSERT(Pfn1->u2.ShareCount < 0xF000000);
1171 if (!--Pfn1->u2.ShareCount)
1172 {
1173 /* Was this a prototype PTE? */
1174 if (Pfn1->u3.e1.PrototypePte)
1175 {
1176 /* Grab the PTE address and make sure it's in prototype pool */
1177 PointerPte = Pfn1->PteAddress;
1179
1180 /* The PTE that backs it should also be valdi */
1181 PointerPte = MiAddressToPte(PointerPte);
1183
1184 /* Get the original prototype PTE and turn it into a transition PTE */
1185 PointerPte = Pfn1->PteAddress;
1186 TempPte = *PointerPte;
1187 TempPte.u.Soft.Transition = 1;
1189 TempPte.u.Soft.Prototype = 0;
1190 TempPte.u.Soft.Protection = Pfn1->OriginalPte.u.Soft.Protection;
1192 DPRINT("Marking PTE: %p as transition (%p - %lx)\n", PointerPte, Pfn1, MiGetPfnEntryIndex(Pfn1));
1193 }
1194
1195 /* Put the page in transition */
1196 Pfn1->u3.e1.PageLocation = TransitionPage;
1197
1198 /* PFN lock must be held */
1199 MI_ASSERT_PFN_LOCK_HELD();
1200
1201 if (Pfn1->u3.e2.ReferenceCount == 1)
1202 {
1203 /* Is there still a PFN for this page? */
1205 {
1206 /* Clear the last reference */
1207 Pfn1->u3.e2.ReferenceCount = 0;
1208 ASSERT(Pfn1->OriginalPte.u.Soft.Prototype == 0);
1209
1210 /* Mark the page temporarily as valid, we're going to make it free soon */
1211 Pfn1->u3.e1.PageLocation = ActiveAndValid;
1212
1213 /* Bring it back into the free list */
1214 MiInsertPageInFreeList(PageFrameIndex);
1215 }
1216 else
1217 {
1218 /* PFN not yet deleted, drop a ref count */
1219 MiDecrementReferenceCount(Pfn1, PageFrameIndex);
1220 }
1221 }
1222 else
1223 {
1224 /* Otherwise, just drop the reference count */
1226 }
1227 }
1228}
FORCEINLINE VOID MI_WRITE_INVALID_PTE(IN PMMPTE PointerPte, IN MMPTE InvalidPte)
Definition: miarm.h:992
VOID NTAPI MiDecrementReferenceCount(IN PMMPFN Pfn1, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:1236
Referenced by FreeWsleIndex(), MiDeletePte(), MiDeleteSystemPageableVm(), MiFreeContiguousMemory(), MiProcessValidPteList(), MiProtectVirtualMemory(), MiReleaseProcessReferenceToSessionDataPage(), MiRemoveMappedPtes(), MiUnmapLockedPagesInUserSpace(), MmDeleteKernelStack(), MmDeleteProcessAddressSpace(), MmFreeLoaderBlock(), MmFreeSpecialPool(), and TrimWsList().
◆ MiDeleteARM3Section()
Definition at line 3316 of file section.c.
3317{
3319 PCONTROL_AREA ControlArea;
3321
3323
3325 {
3326 /* Remove the node from the global section address tree */
3330 }
3331
3332 /* Lock the PFN database */
3333 OldIrql = MiAcquirePfnLock();
3334
3337
3338 ControlArea = SectionObject->Segment->ControlArea;
3339
3340 /* Dereference */
3341 ControlArea->NumberOfSectionReferences--;
3342 ControlArea->NumberOfUserReferences--;
3343
3345
3346 /* Check it. It will delete it if there is no more reference to it */
3348}
VOID NTAPI MiCheckControlArea(IN PCONTROL_AREA ControlArea, IN KIRQL OldIrql)
Definition: section.c:714
VOID FASTCALL KeReleaseGuardedMutex(IN OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:53
VOID FASTCALL KeAcquireGuardedMutex(IN PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:42
VOID NTAPI MiRemoveNode(IN PMMADDRESS_NODE Node, IN PMM_AVL_TABLE Table)
Definition: vadnode.c:440
struct _SECTION * PSECTION
Definition: mmtypes.h:520
union _CONTROL_AREA::@2591 u
Definition: mmtypes.h:810
Referenced by MmpDeleteSection().
◆ MiDeletePde()
Definition at line 2541 of file miarm.h.
2544{
2545 /* Only for user-mode ones */
2547
2548 /* Kill this one as a PTE */
2550#if _MI_PAGING_LEVELS >= 3
2551 /* Cascade down */
2553 {
2555#if _MI_PAGING_LEVELS == 4
2557 {
2559 }
2560#endif
2561 }
2562#endif
2563}
VOID NTAPI MiDeletePte(IN PMMPTE PointerPte, IN PVOID VirtualAddress, IN PEPROCESS CurrentProcess, IN PMMPTE PrototypePte)
Definition: virtual.c:369
FORCEINLINE USHORT MiDecrementPageTableReferences(IN PVOID Address)
Definition: miarm.h:2507
Referenced by _Success_(), MiDeleteVirtualAddresses(), MiUnmapLockedPagesInUserSpace(), and MmDeletePageFileMapping().
◆ MiDeletePte()
| VOID NTAPI MiDeletePte | ( | IN PMMPTE | PointerPte, |
| IN PVOID | VirtualAddress, | ||
| IN PEPROCESS | CurrentProcess, | ||
| IN PMMPTE | PrototypePte | ||
| ) |
Definition at line 369 of file virtual.c.
373{
374 PMMPFN Pfn1;
376 PFN_NUMBER PageFrameIndex;
377 PMMPDE PointerPde;
378
379 /* PFN lock must be held */
380 MI_ASSERT_PFN_LOCK_HELD();
381
382 /* WorkingSet must be exclusively locked */
384
385 /* This must be current process. */
387
388 /* Capture the PTE */
389 TempPte = *PointerPte;
390
391 /* See if the PTE is valid */
393 {
394 /* Prototype and paged out PTEs not supported yet */
397
399 {
400 /* Get the PFN entry */
402 Pfn1 = MiGetPfnEntry(PageFrameIndex);
403
405
406 /* Make sure the saved PTE address is valid */
408
409 /* Destroy the PTE */
410 MI_ERASE_PTE(PointerPte);
411
412 /* Drop the reference on the page table. */
414
415 /* In case of shared page, the prototype PTE must be in transition, not the process one */
417
418 /* Delete the PFN */
419 MI_SET_PFN_DELETED(Pfn1);
420
421 /* It must be either free (refcount == 0) or being written (refcount == 1) */
423
424 /* See if we must free it ourselves, or if it will be freed once I/O is over */
426 {
427 /* And it should be in standby or modified list */
428 ASSERT((Pfn1->u3.e1.PageLocation == ModifiedPageList) || (Pfn1->u3.e1.PageLocation == StandbyPageList));
429
430 /* Unlink it and set its reference count to one */
431 MiUnlinkPageFromList(Pfn1);
433
434 /* This will put it back in free list and clean properly up */
435 MiDecrementReferenceCount(Pfn1, PageFrameIndex);
436 }
437 return;
438 }
439 }
440
441 /* Get the PFN entry */
443 Pfn1 = MiGetPfnEntry(PageFrameIndex);
444
445 /* Check if this is a valid, prototype PTE */
447 {
448 /* Get the PDE and make sure it's faulted in */
449 PointerPde = MiPteToPde(PointerPte);
451 {
452#if (_MI_PAGING_LEVELS == 2)
453 /* Could be paged pool access from a new process -- synchronize the page directories */
455 {
456#endif
457 /* The PDE must be valid at this point */
458 KeBugCheckEx(MEMORY_MANAGEMENT,
459 0x61940,
460 (ULONG_PTR)PointerPte,
461 PointerPte->u.Long,
463 }
464#if (_MI_PAGING_LEVELS == 2)
465 }
466#endif
467 /* Drop the share count on the page table */
468 PointerPde = MiPteToPde(PointerPte);
471
472 /* Drop the share count */
473 MiDecrementShareCount(Pfn1, PageFrameIndex);
474
475 /* Either a fork, or this is the shared user data page */
477 {
478 /* If it's not the shared user page, then crash, since there's no fork() yet */
481 {
482 /* Must be some sort of memory corruption */
483 KeBugCheckEx(MEMORY_MANAGEMENT,
484 0x400,
485 (ULONG_PTR)PointerPte,
488 }
489 }
490
491 /* Erase it */
492 MI_ERASE_PTE(PointerPte);
493 }
494 else
495 {
496 /* Make sure the saved PTE address is valid */
498 {
499 /* The PFN entry is illegal, or invalid */
500 KeBugCheckEx(MEMORY_MANAGEMENT,
501 0x401,
502 (ULONG_PTR)PointerPte,
503 PointerPte->u.Long,
505 }
506
507 /* Erase the PTE */
508 MI_ERASE_PTE(PointerPte);
509
510 /* There should only be 1 shared reference count */
512
513 /* Drop the reference on the page table. */
515
516 /* Mark the PFN for deletion and dereference what should be the last ref */
517 MI_SET_PFN_DELETED(Pfn1);
518 MiDecrementShareCount(Pfn1, PageFrameIndex);
519
520 /* We should eventually do this */
521 //CurrentProcess->NumberOfPrivatePages--;
522 }
523
524 /* Flush the TLB */
525 KeFlushCurrentTb();
526}
FORCEINLINE BOOLEAN MM_ANY_WS_LOCK_HELD_EXCLUSIVE(_In_ PETHREAD Thread)
Definition: miarm.h:1065
VOID NTAPI MiDecrementShareCount(IN PMMPFN Pfn1, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:1141
NTSTATUS FASTCALL MiCheckPdeForPagedPool(IN PVOID Address)
Definition: pagfault.c:479
VOID NTAPI MiDecrementReferenceCount(IN PMMPFN Pfn1, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:1236
_Must_inspect_result_ _In_ WDFDMATRANSACTION _In_ PFN_WDF_PROGRAM_DMA _In_ WDF_DMA_DIRECTION _In_ PMDL _In_ PVOID VirtualAddress
Definition: wdfdmatransaction.h:189
#define PAGE_ALIGN(Va)
Referenced by MiDeletePde(), MiDeleteVirtualAddresses(), MiResolveProtoPteFault(), and MmArmAccessFault().
◆ MiDeleteSystemPageableVm()
| PFN_COUNT NTAPI MiDeleteSystemPageableVm | ( | IN PMMPTE | PointerPte, |
| IN PFN_NUMBER | PageCount, | ||
| IN ULONG | Flags, | ||
| OUT PPFN_NUMBER | ValidPages | ||
| ) |
Definition at line 275 of file virtual.c.
279{
280 PFN_COUNT ActualPages = 0;
282 PMMPFN Pfn1, Pfn2;
283 PFN_NUMBER PageFrameIndex, PageTableIndex;
286
287 /* Lock the system working set */
289
290 /* Loop all pages */
291 while (PageCount)
292 {
293 /* Make sure there's some data about the page */
294 if (PointerPte->u.Long)
295 {
296 /* Normally this is one possibility -- freeing a valid page */
297 if (PointerPte->u.Hard.Valid)
298 {
299 /* Get the page PFN */
300 PageFrameIndex = PFN_FROM_PTE(PointerPte);
301 Pfn1 = MiGetPfnEntry(PageFrameIndex);
302
303 /* Should not have any working set data yet */
305
306 /* Actual valid, legitimate, pages */
307 if (ValidPages) (*ValidPages)++;
308
309 /* Get the page table entry */
311 Pfn2 = MiGetPfnEntry(PageTableIndex);
312
313 /* Lock the PFN database */
314 OldIrql = MiAcquirePfnLock();
315
316 /* Delete it the page */
317 MI_SET_PFN_DELETED(Pfn1);
318 MiDecrementShareCount(Pfn1, PageFrameIndex);
319
320 /* Decrement the page table too */
321 MiDecrementShareCount(Pfn2, PageTableIndex);
322
323 /* Release the PFN database */
324 MiReleasePfnLock(OldIrql);
325
326 /* Destroy the PTE */
327 MI_ERASE_PTE(PointerPte);
328 }
329 else
330 {
331 /* As always, only handle current ARM3 scenarios */
332 ASSERT(PointerPte->u.Soft.Prototype == 0);
333 ASSERT(PointerPte->u.Soft.Transition == 0);
334
335 /*
336 * The only other ARM3 possibility is a demand zero page, which would
337 * mean freeing some of the paged pool pages that haven't even been
338 * touched yet, as part of a larger allocation.
339 *
340 * Right now, we shouldn't expect any page file information in the PTE
341 */
342 ASSERT(PointerPte->u.Soft.PageFileHigh == 0);
343
344 /* Destroy the PTE */
345 MI_ERASE_PTE(PointerPte);
346 }
347
348 /* Actual legitimate pages */
349 ActualPages++;
350 }
351
352 /* Keep going */
353 PointerPte++;
354 PageCount--;
355 }
356
357 /* Release the working set */
359
360 /* Flush the entire TLB */
362
363 /* Done */
364 return ActualPages;
365}
FORCEINLINE VOID MiLockWorkingSet(IN PETHREAD Thread, IN PMMSUPPORT WorkingSet)
Definition: miarm.h:1265
FORCEINLINE VOID MiUnlockWorkingSet(IN PETHREAD Thread, IN PMMSUPPORT WorkingSet)
Definition: miarm.h:1351
VOID NTAPI KeFlushEntireTb(IN BOOLEAN Invalid, IN BOOLEAN AllProcessors)
Definition: cpu.c:617
Definition: pstypes.h:1102
union _MMPFN::@1780 u1
Referenced by MiFreeInitializationCode(), MiFreePoolPages(), MmFreeDriverInitialization(), and MmFreeSpecialPool().
◆ MiDeleteVirtualAddresses()
Definition at line 530 of file virtual.c.
533{
535 PMMPDE PointerPde;
536#if (_MI_PAGING_LEVELS >= 3)
537 PMMPPE PointerPpe;
538#endif
539#if (_MI_PAGING_LEVELS >= 4)
540 PMMPPE PointerPxe;
541#endif
543 PEPROCESS CurrentProcess;
546 PSUBSECTION Subsection;
547
548 /* Get out if this is a fake VAD, RosMm will free the marea pages */
549 if ((Vad) && (Vad->u.VadFlags.Spare == 1)) return;
550
551 /* Get the current process */
552 CurrentProcess = PsGetCurrentProcess();
553
554 /* Check if this is a section VAD or a VM VAD */
555 if (!(Vad) || (Vad->u.VadFlags.PrivateMemory) || !(Vad->FirstPrototypePte))
556 {
557 /* Don't worry about prototypes */
559 }
560 else
561 {
562 /* Get the prototype PTE */
563 PrototypePte = Vad->FirstPrototypePte;
564 LastPrototypePte = Vad->FirstPrototypePte + 1;
565 }
566
567 /* In all cases, we don't support fork() yet */
569
570 /* Loop the PTE for each VA (EndingAddress is inclusive!) */
571 while (Va <= EndingAddress)
572 {
573#if (_MI_PAGING_LEVELS >= 4)
574 /* Get the PXE and check if it's valid */
577 {
578 /* Check for unmapped range and skip it */
580 {
581 /* There are gaps in the address space */
582 AddressGap = TRUE;
583
584 /* Update Va and continue looping */
586 continue;
587 }
588
589 /* Make the PXE valid */
591 }
592#endif
593#if (_MI_PAGING_LEVELS >= 3)
594 /* Get the PPE and check if it's valid */
597 {
598 /* Check for unmapped range and skip it */
600 {
601 /* There are gaps in the address space */
602 AddressGap = TRUE;
603
604 /* Update Va and continue looping */
606 continue;
607 }
608
609 /* Make the PPE valid */
611 }
612#endif
613 /* Skip invalid PDEs */
616 {
617 /* There are gaps in the address space */
618 AddressGap = TRUE;
619
620 /* Check if all the PDEs are invalid, so there's nothing to free */
622 continue;
623 }
624
625 /* Now check if the PDE is mapped in */
627 {
628 /* It isn't, so map it in */
629 PointerPte = MiPteToAddress(PointerPde);
630 MiMakeSystemAddressValid(PointerPte, CurrentProcess);
631 }
632
633 /* Now we should have a valid PDE, mapped in, and still have some VA */
635 ASSERT(Va <= EndingAddress);
636
637 /* Check if this is a section VAD with gaps in it */
638 if ((AddressGap) && (LastPrototypePte))
639 {
640 /* We need to skip to the next correct prototype PTE */
642
643 /* And we need the subsection to skip to the next last prototype PTE */
645 if (Subsection)
646 {
647 /* Found it! */
649 }
650 else
651 {
652 /* No more subsections, we are done with prototype PTEs */
654 }
655 }
656
657 /* Lock the PFN Database while we delete the PTEs */
658 OldIrql = MiAcquirePfnLock();
659 PointerPte = MiAddressToPte(Va);
660 do
661 {
662 /* Making sure the PDE is still valid */
664
665 /* Capture the PDE and make sure it exists */
666 TempPte = *PointerPte;
668 {
669 /* Check if the PTE is actually mapped in */
671 {
672 /* Are we dealing with section VAD? */
674 {
675 /* We need to skip to the next correct prototype PTE */
677
678 /* And we need the subsection to skip to the next last prototype PTE */
680 if (Subsection)
681 {
682 /* Found it! */
684 }
685 else
686 {
687 /* No more subsections, we are done with prototype PTEs */
689 }
690 }
691
692 /* Check for prototype PTE */
694 (TempPte.u.Soft.Prototype == 1))
695 {
696 /* Just nuke it */
697 MI_ERASE_PTE(PointerPte);
698 }
699 else
700 {
701 /* Delete the PTE proper */
702 MiDeletePte(PointerPte,
703 (PVOID)Va,
704 CurrentProcess,
705 PrototypePte);
706 }
707 }
708 else
709 {
710 /* The PTE was never mapped, just nuke it here */
711 MI_ERASE_PTE(PointerPte);
712 }
713
715 {
717
718 /* Delete the PDE proper */
719 MiDeletePde(PointerPde, CurrentProcess);
720
721 /* Continue with the next PDE */
723
724 /* Use this to detect address gaps */
725 PointerPte++;
726 break;
727 }
728 }
729
730 /* Update the address and PTE for it */
731 Va += PAGE_SIZE;
732 PointerPte++;
733 PrototypePte++;
735
736 /* Release the lock */
737 MiReleasePfnLock(OldIrql);
738
739 if (Va > EndingAddress) return;
740
741 /* Check if we exited the loop regularly */
742 AddressGap = (PointerPte != MiAddressToPte(Va));
743 }
744}
FORCEINLINE PMMPTE MI_GET_PROTOTYPE_PTE_FOR_VPN(IN PMMVAD Vad, IN ULONG_PTR Vpn)
Definition: miarm.h:1557
FORCEINLINE VOID MiDeletePde(_In_ PMMPDE PointerPde, _In_ PEPROCESS CurrentProcess)
Definition: miarm.h:2541
PSUBSECTION NTAPI MiLocateSubsection(IN PMMVAD Vad, IN ULONG_PTR Vpn)
Definition: section.c:556
VOID NTAPI MiDeletePte(IN PMMPTE PointerPte, IN PVOID VirtualAddress, IN PEPROCESS CurrentProcess, IN PMMPTE PrototypePte)
Definition: virtual.c:369
ULONG NTAPI MiMakeSystemAddressValid(IN PVOID PageTableVirtualAddress, IN PEPROCESS CurrentProcess)
Definition: virtual.c:183
Definition: pstypes.h:1261
Definition: mmtypes.h:572
Referenced by MiRemoveMappedView(), MmCleanProcessAddressSpace(), MmDeleteTeb(), and NtFreeVirtualMemory().
◆ MiDereferencePfnAndDropLockCount()
| FORCEINLINE VOID MiDereferencePfnAndDropLockCount | ( | IN PMMPFN | Pfn1 | ) |
Definition at line 1615 of file miarm.h.
1616{
1617 USHORT RefCount, OldRefCount;
1618 PFN_NUMBER PageFrameIndex;
1619
1620 /* Loop while we decrement the page successfully */
1621 do
1622 {
1623 /* There should be at least one reference */
1624 OldRefCount = Pfn1->u3.e2.ReferenceCount;
1625 ASSERT(OldRefCount != 0);
1626
1627 /* Are we the last one */
1628 if (OldRefCount == 1)
1629 {
1630 /* The page shoudln't be shared not active at this point */
1631 ASSERT(Pfn1->u3.e2.ReferenceCount == 1);
1633 ASSERT(Pfn1->u2.ShareCount == 0);
1634
1635 /* Is it a prototype PTE? */
1636 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1637 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1638 {
1639 /* FIXME: We should return commit */
1641 }
1642
1643 /* Update the counter, and drop a reference the long way */
1645 PageFrameIndex = MiGetPfnEntryIndex(Pfn1);
1646 MiDecrementReferenceCount(Pfn1, PageFrameIndex);
1647 return;
1648 }
1649
1650 /* Drop a reference the short way, and that's it */
1652 OldRefCount - 1,
1653 OldRefCount);
1654 ASSERT(RefCount != 0);
1655 } while (OldRefCount != RefCount);
1656
1657 /* If we got here, there should be more than one reference */
1658 ASSERT(RefCount > 1);
1659 if (RefCount == 2)
1660 {
1661 /* Is it still being shared? */
1662 if (Pfn1->u2.ShareCount >= 1)
1663 {
1664 /* Then it should be valid */
1666
1667 /* Is it a prototype PTE? */
1668 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1669 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1670 {
1671 /* We don't handle ethis */
1673 }
1674
1675 /* Update the counter */
1677 }
1678 }
1679}
Referenced by MI_UNLOCK_VA(), MiCompleteProtoPteFault(), MiDispatchFault(), and MmUnlockPages().
◆ MiDetermineUserGlobalPteMask()
| FORCEINLINE ULONG_PTR MiDetermineUserGlobalPteMask | ( | IN PVOID | PointerPte | ) |
Definition at line 736 of file miarm.h.
737{
739
740 /* Start fresh */
741 TempPte.u.Long = 0;
742
743 /* Make it valid and accessed */
746
747 /* Is this for user-mode? */
748 if (
750 MiIsUserPxe(PointerPte) ||
751#endif
753 MiIsUserPpe(PointerPte) ||
754#endif
755 MiIsUserPde(PointerPte) ||
756 MiIsUserPte(PointerPte))
757 {
758 /* Set the owner bit */
760 }
761
762 /* FIXME: We should also set the global bit */
763
764 /* Return the protection */
766}
Referenced by MI_MAKE_HARDWARE_PTE(), and MiResolveTransitionFault().
◆ MiDropLockCount()
| FORCEINLINE VOID MiDropLockCount | ( | IN PMMPFN | Pfn1 | ) |
Definition at line 1585 of file miarm.h.
1586{
1587 /* This page shouldn't be locked, but it should be valid */
1588 ASSERT(Pfn1->u3.e2.ReferenceCount != 0);
1589 ASSERT(Pfn1->u2.ShareCount == 0);
1590
1591 /* Is this the last reference to the page */
1592 if (Pfn1->u3.e2.ReferenceCount == 1)
1593 {
1594 /* It better not be valid */
1596
1597 /* Is it a prototype PTE? */
1598 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1599 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1600 {
1601 /* FIXME: We should return commit */
1603 }
1604
1605 /* Update the counter */
1607 }
1608}
Referenced by MiResolveTransitionFault().
◆ MiFindContiguousPages()
| PFN_NUMBER NTAPI MiFindContiguousPages | ( | IN PFN_NUMBER | LowestPfn, |
| IN PFN_NUMBER | HighestPfn, | ||
| IN PFN_NUMBER | BoundaryPfn, | ||
| IN PFN_NUMBER | SizeInPages, | ||
| IN MEMORY_CACHING_TYPE | CacheType | ||
| ) |
Definition at line 22 of file contmem.c.
27{
30 PMMPFN Pfn1, EndPfn;
32 PAGED_CODE();
33 ASSERT(SizeInPages != 0);
34
35 //
36 // Convert the boundary PFN into an alignment mask
37 //
38 BoundaryMask = ~(BoundaryPfn - 1);
39
40 /* Disable APCs */
41 KeEnterGuardedRegion();
42
43 //
44 // Loop all the physical memory blocks
45 //
46 do
47 {
48 //
49 // Capture the base page and length of this memory block
50 //
53
54 //
55 // Check how far this memory block will go
56 //
57 LastPage = Page + PageCount;
58
59 //
60 // Trim it down to only the PFNs we're actually interested in
61 //
62 if ((LastPage - 1) > HighestPfn) LastPage = HighestPfn + 1;
64
65 //
66 // Skip this run if it's empty or fails to contain all the pages we need
67 //
69
70 //
71 // Now scan all the relevant PFNs in this run
72 //
73 Length = 0;
75 {
76 //
77 // If this PFN is in use, ignore it
78 //
80 {
81 Length = 0;
82 continue;
83 }
84
85 //
86 // If we haven't chosen a start PFN yet and the caller specified an
87 // alignment, make sure the page matches the alignment restriction
88 //
91 {
92 //
93 // It does not, so bail out
94 //
95 continue;
96 }
97
98 //
99 // Increase the number of valid pages, and check if we have enough
100 //
102 {
103 //
104 // It appears we've amassed enough legitimate pages, rollback
105 //
106 Pfn1 -= (Length - 1);
108
109 //
110 // Acquire the PFN lock
111 //
112 OldIrql = MiAcquirePfnLock();
113 do
114 {
115 //
116 // Things might've changed for us. Is the page still free?
117 //
119
120 //
121 // So far so good. Is this the last confirmed valid page?
122 //
124 {
125 //
126 // Sanity check that we didn't go out of bounds
127 //
129
130 //
131 // Loop until all PFN entries have been processed
132 //
133 EndPfn = Pfn1 - SizeInPages + 1;
134 do
135 {
136 //
137 // This PFN is now a used page, set it up
138 //
141 MiUnlinkFreeOrZeroedPage(Pfn1);
150
151 //
152 // Check if this is the last PFN, otherwise go on
153 //
154 if (Pfn1 == EndPfn) break;
155 Pfn1--;
157
158 //
159 // Mark the first and last PFN so we can find them later
160 //
162 (Pfn1 + SizeInPages - 1)->u3.e1.EndOfAllocation = 1;
163
164 //
165 // Now it's safe to let go of the PFN lock
166 //
167 MiReleasePfnLock(OldIrql);
168
169 //
170 // Quick sanity check that the last PFN is consistent
171 //
172 EndPfn = Pfn1 + SizeInPages;
174
175 //
176 // Compute the first page, and make sure it's consistent
177 //
181
182 /* Enable APCs and return the page */
183 KeLeaveGuardedRegion();
185 }
186
187 //
188 // Keep going. The purpose of this loop is to reconfirm that
189 // after acquiring the PFN lock these pages are still usable
190 //
191 Pfn1++;
192 Page++;
194
195 //
196 // If we got here, something changed while we hadn't acquired
197 // the PFN lock yet, so we'll have to restart
198 //
199 MiReleasePfnLock(OldIrql);
200 Length = 0;
201 }
202 }
204
205 //
206 // And if we get here, it means no suitable physical memory runs were found
207 //
208 KeLeaveGuardedRegion();
209 return 0;
210}
Referenced by MiFindContiguousMemory().
◆ MiFindEmptyAddressRangeDownBasedTree()
| NTSTATUS NTAPI MiFindEmptyAddressRangeDownBasedTree | ( | IN SIZE_T | Length, |
| IN ULONG_PTR | BoundaryAddress, | ||
| IN ULONG_PTR | Alignment, | ||
| IN PMM_AVL_TABLE | Table, | ||
| OUT PULONG_PTR | Base | ||
| ) |
Definition at line 799 of file vadnode.c.
804{
806 ULONG_PTR LowVpn, BestVpn;
807
809
810 /* Sanity checks */
812 ASSERT(BoundaryAddress);
814
815 /* Compute page length, make sure the boundary address is valid */
818
819 /* Check if the table is empty */
822 {
823 /* Tree is empty, the candidate address is already the best one */
824 *Base = BestVpn;
826 }
827
828 /* Go to the right-most node which should be the biggest address */
831
832 /* Check if we can fit in here */
835 {
836#if (NTDDI_VERSION >= NTDDI_VISTA)
837 /* Return the address. */
838 *Base = BestVpn;
839#else
840 /* Note: this is a compatibility hack that mimics a bug in the 2k3
841 kernel. It will can waste up to Alignment bytes of memory above
842 the allocation. This bug was fixed in Windows Vista */
844#endif
846 }
847
848 /* Now loop the Vad nodes */
849 do
850 {
851 /* Break out if we've reached the last node */
853 if (!LowestNode) break;
854
855 /* Check if this node could contain the requested address */
858 (LowVpn < Node->StartingVpn) &&
860 {
861 /* Check if we need to take BoundaryAddress into account */
862 if (BoundaryAddress < Node->StartingVpn)
863 {
864 /* Return the optimal VPN address */
865 *Base = BestVpn;
867 }
868 else
869 {
870 /* The upper margin is given by the Node's starting address */
873 }
874 }
875
876 /* Move to the next node */
877 Node = LowestNode;
879
880 /* Check if there's enough space before the lowest Vad */
883 {
884 /* Check if it fits in perfectly */
885 if (BoundaryAddress < Node->StartingVpn)
886 {
887 /* Return the optimal VPN address */
888 *Base = BestVpn;
890 }
891
892 /* Return an aligned base address within this node */
895 }
896
897 /* No address space left at all */
899}
Definition: ftraster.c:321
Definition: dlist.c:348
PMMADDRESS_NODE NTAPI MiGetPreviousNode(IN PMMADDRESS_NODE Node)
Definition: vadnode.c:513
Referenced by MmCreateArm3Section().
◆ MiFindEmptyAddressRangeDownTree()
| TABLE_SEARCH_RESULT NTAPI MiFindEmptyAddressRangeDownTree | ( | IN SIZE_T | Length, |
| IN ULONG_PTR | BoundaryAddress, | ||
| IN ULONG_PTR | Alignment, | ||
| IN PMM_AVL_TABLE | Table, | ||
| OUT PULONG_PTR | Base, | ||
| OUT PMMADDRESS_NODE * | Parent | ||
| ) |
Definition at line 681 of file vadnode.c.
687{
689 ULONG_PTR LowVpn, HighVpn, AlignmentVpn;
690 PFN_NUMBER PageCount;
691
693
694 /* Sanity checks */
695 ASSERT(BoundaryAddress);
698
699 /* Calculate page numbers for the length and alignment */
703
704 /* Check for kernel mode table (memory areas) */
706 {
708 }
709 else
710 {
712 }
713
714 /* Check if there is enough space below the boundary */
716 {
717 return TableFoundNode;
718 }
719
720 /* Check if the table is empty */
722 {
723 /* Tree is empty, the candidate address is already the best one */
725 return TableEmptyTree;
726 }
727
728 /* Calculate the initial upper margin */
729 HighVpn = (BoundaryAddress + 1) >> PAGE_SHIFT;
730
731 /* Starting from the root, follow the right children until we found a node
732 that ends above the boundary */
736
737 /* Now loop the Vad nodes */
739 {
740 /* Calculate the lower margin */
742
743 /* Check if the current bounds are suitable */
744 if ((HighVpn > LowVpn) && ((HighVpn - LowVpn) >= PageCount))
745 {
746 /* There is enough space to add our node */
747 LowVpn = ALIGN_DOWN_BY(HighVpn - PageCount, AlignmentVpn);
749
750 /* Can we use the current node as parent? */
752 {
753 /* Node has no right child, so use it as parent */
755 return TableInsertAsRight;
756 }
757 else
758 {
759 /* Node has a right child. This means we must have already
760 moved one node left from the right-most node we started
761 with, thus we already have an OldNode! */
763
764 /* The node we had before is the most left grandchild of
765 that right child, use it as parent. */
767 *Parent = OldNode;
768 return TableInsertAsLeft;
769 }
770 }
771
772 /* Update the upper margin if necessary */
774
775 /* Remember the current node and go to the previous node */
776 OldNode = Node;
778 }
779
780 /* Check if there's enough space before the lowest Vad */
782 if ((HighVpn > LowVpn) && ((HighVpn - LowVpn) >= PageCount))
783 {
784 /* There is enough space to add our address */
787 *Parent = OldNode;
788 return TableInsertAsLeft;
789 }
790
791 /* No address space left at all */
792 *Base = 0;
794 return TableFoundNode;
795}
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn UINT32 *TableIdx UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE Parent
Definition: acpixf.h:732
Referenced by MiInsertVadEx(), and MmFindGap().
◆ MiFindEmptyAddressRangeInTree()
| TABLE_SEARCH_RESULT NTAPI MiFindEmptyAddressRangeInTree | ( | IN SIZE_T | Length, |
| IN ULONG_PTR | Alignment, | ||
| IN PMM_AVL_TABLE | Table, | ||
| OUT PMMADDRESS_NODE * | PreviousVad, | ||
| OUT PULONG_PTR | Base | ||
| ) |
Definition at line 584 of file vadnode.c.
589{
591 ULONG_PTR PageCount, AlignmentVpn, LowVpn, HighestVpn;
593
595
596 /* Calculate page numbers for the length, alignment, and starting address */
600
601 /* Check for kernel mode table (memory areas) */
603 {
605 }
606
607 /* Check if the table is empty */
609 {
610 /* Tree is empty, the candidate address is already the best one */
612 return TableEmptyTree;
613 }
614
615 /* Otherwise, follow the leftmost child of the right root node's child */
618
619 /* Start a search to find a gap */
620 PreviousNode = NULL;
622 {
623 /* Check if the gap below the current node is suitable */
625 {
626 /* There is enough space to add our node */
628
629 /* Can we use the current node as parent? */
631 {
632 /* Node has no left child, so use it as parent */
633 *PreviousVad = Node;
634 return TableInsertAsLeft;
635 }
636 else
637 {
638 /* Node has a left child, this means that the previous node is
639 the right-most child of it's left child and can be used as
640 the parent. In case we use the space before the left-most
641 node, it's left child must be NULL. */
644 *PreviousVad = PreviousNode;
645 return TableInsertAsRight;
646 }
647 }
648
649 /* The next candidate is above the current node */
652
653 /* Remember the current node and go to the next node */
654 PreviousNode = Node;
656 }
657
658 /* We're up to the highest VAD, will this allocation fit above it? */
660
661 /* Check for kernel mode table (memory areas) */
663 {
665 }
666
667 if (HighestVpn >= LowVpn + PageCount)
668 {
669 /* Yes! Use this VAD to store the allocation */
670 *PreviousVad = PreviousNode;
672 return TableInsertAsRight;
673 }
674
675 /* Nyet, there's no free address space for this allocation, so we'll fail */
676 return TableFoundNode;
677}
#define BYTES_TO_PAGES(Size)
Referenced by MiInsertVadEx(), MiMapLockedPagesInUserSpace(), and MmFindGap().
◆ MiGetNextNode()
| PMMADDRESS_NODE NTAPI MiGetNextNode | ( | IN PMMADDRESS_NODE | Node | ) |
Definition at line 549 of file vadnode.c.
550{
552
553 /* Get the right child */
555 {
556 /* Get left-most child */
560 }
561
565 {
566 /* The parent should be a left child, return the real predecessor */
568 {
569 /* Return it */
571 }
572
573 /* Keep lopping until we find our parent */
576 }
577
578 /* Nothing found */
580}
Referenced by MiFindEmptyAddressRangeInTree(), and MiQueryMemoryBasicInformation().
◆ MiGetPageProtection()
Definition at line 1353 of file virtual.c.
1354{
1356 PMMPFN Pfn;
1357 PEPROCESS CurrentProcess;
1358 PETHREAD CurrentThread;
1359 BOOLEAN WsSafe, WsShared;
1362 PAGED_CODE();
1363
1364 /* Copy this PTE's contents */
1365 TempPte = *PointerPte;
1366
1367 /* Assure it's not totally zero */
1369
1370 /* Check for a special prototype format */
1372 (TempPte.u.Soft.Prototype == 1))
1373 {
1374 /* Check if the prototype PTE is not yet pointing to a PTE */
1376 {
1377 /* The prototype PTE contains the protection */
1379 }
1380
1381 /* Get a pointer to the underlying shared PTE */
1383
1384 /* Since the PTE we want to read can be paged out at any time, we need
1385 to release the working set lock first, so that it can be paged in */
1386 CurrentThread = PsGetCurrentThread();
1387 CurrentProcess = PsGetCurrentProcess();
1388 MiUnlockProcessWorkingSetForFault(CurrentProcess,
1389 CurrentThread,
1390 &WsSafe,
1391 &WsShared);
1392
1393 /* Now read the PTE value */
1394 TempPte = *PointerPte;
1395
1396 /* Check if that one is invalid */
1398 {
1399 /* We get the protection directly from this PTE */
1401 }
1402 else
1403 {
1404 /* The PTE is valid, so we might need to get the protection from
1405 the PFN. Lock the PFN database */
1406 OldIrql = MiAcquirePfnLock();
1407
1408 /* Check if the PDE is still valid */
1410 {
1411 /* It's not, make it valid */
1413 }
1414
1415 /* Now it's safe to read the PTE value again */
1416 TempPte = *PointerPte;
1418
1419 /* Check again if the PTE is invalid */
1421 {
1422 /* The PTE is not valid, so we can use it's protection field */
1424 }
1425 else
1426 {
1427 /* The PTE is valid, so we can find the protection in the
1428 OriginalPte field of the PFN */
1431 }
1432
1433 /* Release the PFN database */
1434 MiReleasePfnLock(OldIrql);
1435 }
1436
1437 /* Lock the working set again */
1438 MiLockProcessWorkingSetForFault(CurrentProcess,
1439 CurrentThread,
1440 WsSafe,
1441 WsShared);
1442
1444 }
1445
1446 /* In the easy case of transition or demand zero PTE just return its protection */
1448
1449 /* If we get here, the PTE is valid, so look up the page in PFN database */
1452 {
1453 /* Return protection of the original pte */
1456 }
1457
1458 /* This is software PTE */
1464}
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
FORCEINLINE VOID MiUnlockProcessWorkingSetForFault(IN PEPROCESS Process, IN PETHREAD Thread, OUT PBOOLEAN Safe, OUT PBOOLEAN Shared)
Definition: miarm.h:1468
FORCEINLINE VOID MiLockProcessWorkingSetForFault(IN PEPROCESS Process, IN PETHREAD Thread, IN BOOLEAN Safe, IN BOOLEAN Shared)
Definition: miarm.h:1501
ULONG NTAPI MiMakeSystemAddressValidPfn(IN PVOID VirtualAddress, IN KIRQL OldIrql)
Definition: virtual.c:235
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T _In_ SECTION_INHERIT _In_ ULONG _In_ ULONG Protect
Definition: zwfuncs.h:221
Referenced by MiProtectVirtualMemory(), MiQueryAddressState(), MiSetProtectionOnSection(), and NtAllocateVirtualMemory().
◆ MiGetPreviousNode()
| PMMADDRESS_NODE NTAPI MiGetPreviousNode | ( | IN PMMADDRESS_NODE | Node | ) |
Definition at line 513 of file vadnode.c.
514{
516
517 /* Get the left child */
519 {
520 /* Get right-most child */
524 }
525
529 {
530 /* The parent should be a right child, return the real predecessor */
532 {
533 /* Return it unless it's the root */
536 }
537
538 /* Keep lopping until we find our parent */
541 }
542
543 /* Nothing found */
545}
Referenced by MiFindEmptyAddressRangeDownBasedTree(), and MiFindEmptyAddressRangeDownTree().