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 966 of file expool.c.
971{
972 PLIST_ENTRY NextEntry, LastEntry;
973
974 //
975 // Setup the descriptor based on the caller's request
976 //
977 PoolDescriptor->PoolType = PoolType;
978 PoolDescriptor->PoolIndex = PoolIndex;
979 PoolDescriptor->Threshold = Threshold;
980 PoolDescriptor->LockAddress = PoolLock;
981
982 //
983 // Initialize accounting data
984 //
985 PoolDescriptor->RunningAllocs = 0;
986 PoolDescriptor->RunningDeAllocs = 0;
987 PoolDescriptor->TotalPages = 0;
988 PoolDescriptor->TotalBytes = 0;
989 PoolDescriptor->TotalBigPages = 0;
990
991 //
992 // Nothing pending for now
993 //
994 PoolDescriptor->PendingFrees = NULL;
995 PoolDescriptor->PendingFreeDepth = 0;
996
997 //
998 // Loop all the descriptor's allocation lists and initialize them
999 //
1000 NextEntry = PoolDescriptor->ListHeads;
1001 LastEntry = NextEntry + POOL_LISTS_PER_PAGE;
1002 while (NextEntry < LastEntry)
1003 {
1004 ExpInitializePoolListHead(NextEntry);
1005 NextEntry++;
1006 }
1007
1008 //
1009 // Note that ReactOS does not support Session Pool Yet
1010 //
1012}
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 1017 of file expool.c.
1019{
1023
1024 //
1025 // Check what kind of pool this is
1026 //
1028 {
1029 //
1030 // Compute the track table size and convert it from a power of two to an
1031 // actual byte size
1032 //
1033 // NOTE: On checked builds, we'll assert if the registry table size was
1034 // invalid, while on retail builds we'll just break out of the loop at
1035 // that point.
1036 //
1039 {
1041 {
1044 }
1045 TableSize >>= 1;
1046 }
1047
1048 //
1049 // If we hit bit 32, than no size was defined in the registry, so
1050 // we'll use the default size of 2048 entries.
1051 //
1052 // Otherwise, use the size from the registry, as long as it's not
1053 // smaller than 64 entries.
1054 //
1056 {
1057 PoolTrackTableSize = 2048;
1058 }
1059 else
1060 {
1062 }
1063
1064 //
1065 // Loop trying with the biggest specified size first, and cut it down
1066 // by a power of two each iteration in case not enough memory exist
1067 //
1069 {
1070 //
1071 // Do not allow overflow
1072 //
1074 {
1075 PoolTrackTableSize >>= 1;
1076 continue;
1077 }
1078
1079 //
1080 // Allocate the tracker table and exit the loop if this worked
1081 //
1083 (PoolTrackTableSize + 1) *
1086
1087 //
1088 // Otherwise, as long as we're not down to the last bit, keep
1089 // iterating
1090 //
1092 {
1093 KeBugCheckEx(MUST_SUCCEED_POOL_EMPTY,
1094 TableSize,
1095 0xFFFFFFFF,
1096 0xFFFFFFFF,
1097 0xFFFFFFFF);
1098 }
1099 PoolTrackTableSize >>= 1;
1100 }
1101
1102 //
1103 // Add one entry, compute the hash, and zero the table
1104 //
1105 PoolTrackTableSize++;
1107
1110
1111 //
1112 // Finally, add the most used tags to speed up those allocations
1113 //
1114 ExpSeedHotTags();
1115
1116 //
1117 // We now do the exact same thing with the tracker table for big pages
1118 //
1121 {
1123 {
1126 }
1127 TableSize >>= 1;
1128 }
1129
1130 //
1131 // For big pages, the default tracker table is 4096 entries, while the
1132 // minimum is still 64
1133 //
1135 {
1136 PoolBigPageTableSize = 4096;
1137 }
1138 else
1139 {
1141 }
1142
1143 //
1144 // Again, run the exact same loop we ran earlier, but this time for the
1145 // big pool tracker instead
1146 //
1148 {
1150 {
1151 PoolBigPageTableSize >>= 1;
1152 continue;
1153 }
1154
1156 PoolBigPageTableSize *
1159
1161 {
1162 KeBugCheckEx(MUST_SUCCEED_POOL_EMPTY,
1163 TableSize,
1164 0xFFFFFFFF,
1165 0xFFFFFFFF,
1166 0xFFFFFFFF);
1167 }
1168
1169 PoolBigPageTableSize >>= 1;
1170 }
1171
1172 //
1173 // An extra entry is not needed for for the big pool tracker, so just
1174 // compute the hash and zero it
1175 //
1180 {
1182 }
1183
1184 //
1185 // During development, print this out so we can see what's happening
1186 //
1191
1192 //
1193 // Insert the generic tracker for all of big pool
1194 //
1198 NonPagedPool);
1199
1200 //
1201 // No support for NUMA systems at this time
1202 //
1204
1205 //
1206 // Initialize the tag spinlock
1207 //
1209
1210 //
1211 // Initialize the nonpaged pool descriptor
1212 //
1215 NonPagedPool,
1216 0,
1217 Threshold,
1218 NULL);
1219 }
1220 else
1221 {
1222 //
1223 // No support for NUMA systems at this time
1224 //
1226
1227 //
1228 // Allocate the pool descriptor
1229 //
1233 'looP');
1235 {
1236 //
1237 // This is really bad...
1238 //
1239 KeBugCheckEx(MUST_SUCCEED_POOL_EMPTY,
1240 0,
1241 -1,
1242 -1,
1243 -1);
1244 }
1245
1246 //
1247 // Setup the vector and guarded mutex for paged pool
1248 //
1254 PagedPool,
1255 0,
1256 Threshold,
1257 ExpPagedPoolMutex);
1258
1259 //
1260 // Insert the generic tracker for all of nonpaged pool
1261 //
1264 NonPagedPool);
1265 }
1266}
VOID NTAPI ExInitializePoolDescriptor(IN PPOOL_DESCRIPTOR PoolDescriptor, IN POOL_TYPE PoolType, IN ULONG PoolIndex, IN ULONG Threshold, IN PVOID PoolLock)
Definition: expool.c:966
VOID NTAPI ExpInsertPoolTracker(IN ULONG Key, IN SIZE_T NumberOfBytes, IN POOL_TYPE PoolType)
Definition: expool.c:847
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:814
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 MmCreateVirtualMappingUnsafe().
◆ 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(), 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:792
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::@1772 u3
union _MMPFN::@1775 u4
union _MMPFN::@1771 u2
struct _MMPFN::@1772::@1778 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 78 of file vadnode.c.
82{
83 PMMADDRESS_NODE ParentNode, CurrentNode;
84
85 /* If the tree is empty, there is no conflict */
87
88 /* Start looping from the root node */
91 while (CurrentNode)
92 {
93 ParentNode = CurrentNode;
94
95 /* This address comes after */
97 {
98 /* Keep searching on the right */
99 CurrentNode = RtlRightChildAvl(CurrentNode);
100 }
101 else if (EndVpn < CurrentNode->StartingVpn)
102 {
103 /* This address ends before the node starts, search on the left */
104 CurrentNode = RtlLeftChildAvl(CurrentNode);
105 }
106 else
107 {
108 /* This address is part of this node, return it */
109 *NodeOrParent = ParentNode;
111 }
112 }
113
114 /* There is no more child, save the current node as parent */
115 *NodeOrParent = ParentNode;
117 {
119 }
120 else
121 {
123 }
124}
Definition: mmtypes.h:642
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 475 of file pagfault.c.
476{
478}
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 815 of file vadnode.c.
819{
820 ULONG_PTR StartAddress, EndAddress;
821
822 /* Compute start and end address */
824 EndAddress = StartAddress + Size - 1;
825
826 /* Are we deleting/unmapping, or changing? */
828 {
829 /* Changing... are we allowed to do so? */
830 if ((Vad->u.VadFlags.NoChange == 1) &&
831 (Vad->u2.VadFlags2.SecNoChange == 1) &&
832 (Vad->u.VadFlags.Protection != ProtectionMask))
833 {
834 /* Nope, bail out */
837 }
838 }
839 else
840 {
841 /* This is allowed */
842 ProtectionMask = 0;
843 }
844
845 /* ARM3 doesn't support this yet */
846 ASSERT(Vad->u2.VadFlags2.MultipleSecured == 0);
847
848 /* Is this a one-secured VAD, like a TEB or PEB? */
849 if (Vad->u2.VadFlags2.OneSecured)
850 {
851 /* Is this allocation being described by the VAD? */
853 (EndAddress >= ((PMMVAD_LONG)Vad)->u3.Secured.StartVpn))
854 {
855 /* Guard page? */
857 {
860 }
861
862 /* ARM3 doesn't have read-only VADs yet */
864
865 /* Check if read-write protections are allowed */
867 {
870 }
871 }
872 }
873
874 /* All good, allow the change */
876}
Definition: mmtypes.h:747
union _MMVAD_LONG::@2592 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:1138
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 1224 of file pfnlist.c.
1226{
1227 /* PFN lock must be held */
1228 MI_ASSERT_PFN_LOCK_HELD();
1229
1230 /* Sanity checks on the page */
1232 Pfn1 != MI_PFN_ELEMENT(PageFrameIndex) ||
1234 Pfn1->u3.e2.ReferenceCount >= 2500)
1235 {
1236 DPRINT1("PageFrameIndex=0x%lx, MmHighestPhysicalPage=0x%lx\n", PageFrameIndex, MmHighestPhysicalPage);
1237 DPRINT1("Pfn1=%p, Element=%p, RefCount=%u\n", Pfn1, MI_PFN_ELEMENT(PageFrameIndex), Pfn1->u3.e2.ReferenceCount);
1240 ASSERT(Pfn1->u3.e2.ReferenceCount != 0);
1241 ASSERT(Pfn1->u3.e2.ReferenceCount < 2500);
1242 }
1243
1244 /* Dereference the page, bail out if it's still alive */
1246 if (Pfn1->u3.e2.ReferenceCount) return;
1247
1248 /* Nobody should still have reference to this page */
1249 if (Pfn1->u2.ShareCount != 0)
1250 {
1251 /* Otherwise something's really wrong */
1252 KeBugCheckEx(PFN_LIST_CORRUPT, 7, PageFrameIndex, Pfn1->u2.ShareCount, 0);
1253 }
1254
1255 /* And it should be lying on some page list */
1257
1258 /* Did someone set the delete flag? */
1260 {
1261 /* Insert it into the free list, there's nothing left to do */
1262 MiInsertPageInFreeList(PageFrameIndex);
1263 return;
1264 }
1265
1266 /* Check to see which list this page should go into */
1267 if (Pfn1->u3.e1.Modified == 1)
1268 {
1269 /* Push it into the modified page list */
1271 }
1272 else
1273 {
1274 /* Otherwise, insert this page into the standby list */
1275 ASSERT(Pfn1->u3.e1.RemovalRequested == 0);
1276 MiInsertStandbyListAtFront(PageFrameIndex);
1277 }
1278}
VOID NTAPI MiInsertPageInFreeList(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:603
VOID NTAPI MiInsertPageInList(IN PMMPFNLIST ListHead, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:771
VOID FASTCALL MiInsertStandbyListAtFront(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:711
Referenced by MiDecrementShareCount(), MiDeletePte(), MiDereferencePfnAndDropLockCount(), and MmFreePagesFromMdl().
◆ MiDecrementShareCount()
Definition at line 1133 of file pfnlist.c.
1135{
1136 PMMPTE PointerPte;
1138
1139 ASSERT(PageFrameIndex > 0);
1143
1145
1146 /* Page must be in-use */
1148 (Pfn1->u3.e1.PageLocation != StandbyPageList))
1149 {
1150 /* Otherwise we have PFN corruption */
1151 KeBugCheckEx(PFN_LIST_CORRUPT,
1152 0x99,
1153 PageFrameIndex,
1154 Pfn1->u3.e1.PageLocation,
1155 0);
1156 }
1157
1158 /* Page should at least have one reference */
1159 ASSERT(Pfn1->u3.e2.ReferenceCount != 0);
1160
1161 /* Check if the share count is now 0 */
1162 ASSERT(Pfn1->u2.ShareCount < 0xF000000);
1163 if (!--Pfn1->u2.ShareCount)
1164 {
1165 /* Was this a prototype PTE? */
1166 if (Pfn1->u3.e1.PrototypePte)
1167 {
1168 /* Grab the PTE address and make sure it's in prototype pool */
1169 PointerPte = Pfn1->PteAddress;
1171
1172 /* The PTE that backs it should also be valdi */
1173 PointerPte = MiAddressToPte(PointerPte);
1175
1176 /* Get the original prototype PTE and turn it into a transition PTE */
1177 PointerPte = Pfn1->PteAddress;
1178 TempPte = *PointerPte;
1179 TempPte.u.Soft.Transition = 1;
1181 TempPte.u.Soft.Prototype = 0;
1182 TempPte.u.Soft.Protection = Pfn1->OriginalPte.u.Soft.Protection;
1184 DPRINT("Marking PTE: %p as transition (%p - %lx)\n", PointerPte, Pfn1, MiGetPfnEntryIndex(Pfn1));
1185 }
1186
1187 /* Put the page in transition */
1188 Pfn1->u3.e1.PageLocation = TransitionPage;
1189
1190 /* PFN lock must be held */
1191 MI_ASSERT_PFN_LOCK_HELD();
1192
1193 if (Pfn1->u3.e2.ReferenceCount == 1)
1194 {
1195 /* Is there still a PFN for this page? */
1197 {
1198 /* Clear the last reference */
1199 Pfn1->u3.e2.ReferenceCount = 0;
1200 ASSERT(Pfn1->OriginalPte.u.Soft.Prototype == 0);
1201
1202 /* Mark the page temporarily as valid, we're going to make it free soon */
1203 Pfn1->u3.e1.PageLocation = ActiveAndValid;
1204
1205 /* Bring it back into the free list */
1206 MiInsertPageInFreeList(PageFrameIndex);
1207 }
1208 else
1209 {
1210 /* PFN not yet deleted, drop a ref count */
1211 MiDecrementReferenceCount(Pfn1, PageFrameIndex);
1212 }
1213 }
1214 else
1215 {
1216 /* Otherwise, just drop the reference count */
1218 }
1219 }
1220}
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:1224
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:360
struct _SECTION * PSECTION
Definition: mmtypes.h:517
union _CONTROL_AREA::@2581 u
Definition: mmtypes.h:807
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:1133
NTSTATUS FASTCALL MiCheckPdeForPagedPool(IN PVOID Address)
Definition: pagfault.c:475
VOID NTAPI MiDecrementReferenceCount(IN PMMPFN Pfn1, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:1224
_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:438
Definition: pstypes.h:1102
union _MMPFN::@1770 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:569
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 713 of file vadnode.c.
718{
720 ULONG_PTR LowVpn, BestVpn;
721
722 /* Sanity checks */
724 ASSERT(BoundaryAddress);
726
727 /* Compute page length, make sure the boundary address is valid */
730
731 /* Check if the table is empty */
734 {
735 /* Tree is empty, the candidate address is already the best one */
736 *Base = BestVpn;
738 }
739
740 /* Go to the right-most node which should be the biggest address */
743
744 /* Check if we can fit in here */
747 {
748#if (NTDDI_VERSION >= NTDDI_VISTA)
749 /* Return the address. */
750 *Base = BestVpn;
751#else
752 /* Note: this is a compatibility hack that mimics a bug in the 2k3
753 kernel. It will can waste up to Alignment bytes of memory above
754 the allocation. This bug was fixed in Windows Vista */
756#endif
758 }
759
760 /* Now loop the Vad nodes */
761 do
762 {
763 /* Break out if we've reached the last node */
765 if (!LowestNode) break;
766
767 /* Check if this node could contain the requested address */
770 (LowVpn < Node->StartingVpn) &&
772 {
773 /* Check if we need to take BoundaryAddress into account */
774 if (BoundaryAddress < Node->StartingVpn)
775 {
776 /* Return the optimal VPN address */
777 *Base = BestVpn;
779 }
780 else
781 {
782 /* The upper margin is given by the Node's starting address */
785 }
786 }
787
788 /* Move to the next node */
789 Node = LowestNode;
791
792 /* Check if there's enough space before the lowest Vad */
795 {
796 /* Check if it fits in perfectly */
797 if (BoundaryAddress < Node->StartingVpn)
798 {
799 /* Return the optimal VPN address */
800 *Base = BestVpn;
802 }
803
804 /* Return an aligned base address within this node */
807 }
808
809 /* No address space left at all */
811}
Definition: ftraster.c:321
Definition: dlist.c:348
PMMADDRESS_NODE NTAPI MiGetPreviousNode(IN PMMADDRESS_NODE Node)
Definition: vadnode.c:431
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 597 of file vadnode.c.
603{
605 ULONG_PTR LowVpn, HighVpn, AlignmentVpn;
606 PFN_NUMBER PageCount;
607
608 /* Sanity checks */
609 ASSERT(BoundaryAddress);
612
613 /* Calculate page numbers for the length and alignment */
617
618 /* Check for kernel mode table (memory areas) */
620 {
622 }
623 else
624 {
626 }
627
628 /* Check if there is enough space below the boundary */
630 {
632 }
633
634 /* Check if the table is empty */
636 {
637 /* Tree is empty, the candidate address is already the best one */
640 }
641
642 /* Calculate the initial upper margin */
643 HighVpn = (BoundaryAddress + 1) >> PAGE_SHIFT;
644
645 /* Starting from the root, follow the right children until we found a node
646 that ends above the boundary */
650
651 /* Now loop the Vad nodes */
653 {
654 /* Calculate the lower margin */
656
657 /* Check if the current bounds are suitable */
658 if ((HighVpn > LowVpn) && ((HighVpn - LowVpn) >= PageCount))
659 {
660 /* There is enough space to add our node */
661 LowVpn = ALIGN_DOWN_BY(HighVpn - PageCount, AlignmentVpn);
663
664 /* Can we use the current node as parent? */
666 {
667 /* Node has no right child, so use it as parent */
670 }
671 else
672 {
673 /* Node has a right child. This means we must have already
674 moved one node left from the right-most node we started
675 with, thus we already have an OldNode! */
677
678 /* The node we had before is the most left grandchild of
679 that right child, use it as parent. */
681 *Parent = OldNode;
683 }
684 }
685
686 /* Update the upper margin if necessary */
688
689 /* Remember the current node and go to the previous node */
690 OldNode = Node;
692 }
693
694 /* Check if there's enough space before the lowest Vad */
696 if ((HighVpn > LowVpn) && ((HighVpn - LowVpn) >= PageCount))
697 {
698 /* There is enough space to add our address */
701 *Parent = OldNode;
703 }
704
705 /* No address space left at all */
706 *Base = 0;
709}
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 502 of file vadnode.c.
507{
509 ULONG_PTR PageCount, AlignmentVpn, LowVpn, HighestVpn;
511
512 /* Calculate page numbers for the length, alignment, and starting address */
516
517 /* Check for kernel mode table (memory areas) */
519 {
521 }
522
523 /* Check if the table is empty */
525 {
526 /* Tree is empty, the candidate address is already the best one */
529 }
530
531 /* Otherwise, follow the leftmost child of the right root node's child */
534
535 /* Start a search to find a gap */
536 PreviousNode = NULL;
538 {
539 /* Check if the gap below the current node is suitable */
541 {
542 /* There is enough space to add our node */
544
545 /* Can we use the current node as parent? */
547 {
548 /* Node has no left child, so use it as parent */
549 *PreviousVad = Node;
551 }
552 else
553 {
554 /* Node has a left child, this means that the previous node is
555 the right-most child of it's left child and can be used as
556 the parent. In case we use the space before the left-most
557 node, it's left child must be NULL. */
560 *PreviousVad = PreviousNode;
562 }
563 }
564
565 /* The next candidate is above the current node */
568
569 /* Remember the current node and go to the next node */
570 PreviousNode = Node;
572 }
573
574 /* We're up to the highest VAD, will this allocation fit above it? */
576
577 /* Check for kernel mode table (memory areas) */
579 {
581 }
582
583 if (HighestVpn >= LowVpn + PageCount)
584 {
585 /* Yes! Use this VAD to store the allocation */
586 *PreviousVad = PreviousNode;
589 }
590
591 /* Nyet, there's no free address space for this allocation, so we'll fail */
593}
#define BYTES_TO_PAGES(Size)
Referenced by MiInsertVadEx(), MiMapLockedPagesInUserSpace(), and MmFindGap().
◆ MiGetNextNode()
| PMMADDRESS_NODE NTAPI MiGetNextNode | ( | IN PMMADDRESS_NODE | Node | ) |
Definition at line 467 of file vadnode.c.
468{
470
471 /* Get the right child */
473 {
474 /* Get left-most child */
478 }
479
483 {
484 /* The parent should be a left child, return the real predecessor */
486 {
487 /* Return it */
489 }
490
491 /* Keep lopping until we find our parent */
494 }
495
496 /* Nothing found */
498}
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 431 of file vadnode.c.
432{
434
435 /* Get the left child */
437 {
438 /* Get right-most child */
442 }
443
447 {
448 /* The parent should be a right child, return the real predecessor */
450 {
451 /* Return it unless it's the root */
454 }
455
456 /* Keep lopping until we find our parent */
459 }
460
461 /* Nothing found */
463}
Referenced by MiFindEmptyAddressRangeDownBasedTree(), and MiFindEmptyAddressRangeDownTree().