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
◆ COLORED_LIST_HEAD
| #define COLORED_LIST_HEAD (((ULONG_PTR)1 << MI_PTE_FRAME_BITS) - 1) |
◆ IMAGE_SCN_PROTECTION_MASK
| #define IMAGE_SCN_PROTECTION_MASK (IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE) |
◆ LIST_HEAD
| #define LIST_HEAD ULONG_PTR_MAX |
◆ 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
◆ PTE_MAPPING_ADDRESS_EMPTY
◆ PTE_MAPPING_ADDRESS_INVALID
◆ PTE_MAPPING_ADDRESS_NOT_OWNED
◆ PTE_MAPPING_EMPTY
◆ PTE_MAPPING_NONE
◆ PTE_MAPPING_NOT_OWNED
◆ PTE_MAPPING_RESERVED
◆ PTE_UNMAPPING_ADDRESS_NOT_OWNED
◆ 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 412 of file miarm.h.
413{
414 MiNonCached,
415 MiCached,
416 MiWriteCombined,
417 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 405 of file miarm.h.
406{
407 SystemPteSpace,
410} 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 969 of file expool.c.
974{
975 PLIST_ENTRY NextEntry, LastEntry;
976
977 //
978 // Setup the descriptor based on the caller's request
979 //
980 PoolDescriptor->PoolType = PoolType;
981 PoolDescriptor->PoolIndex = PoolIndex;
982 PoolDescriptor->Threshold = Threshold;
983 PoolDescriptor->LockAddress = PoolLock;
984
985 //
986 // Initialize accounting data
987 //
988 PoolDescriptor->RunningAllocs = 0;
989 PoolDescriptor->RunningDeAllocs = 0;
990 PoolDescriptor->TotalPages = 0;
991 PoolDescriptor->TotalBytes = 0;
992 PoolDescriptor->TotalBigPages = 0;
993
994 //
995 // Nothing pending for now
996 //
997 PoolDescriptor->PendingFrees = NULL;
998 PoolDescriptor->PendingFreeDepth = 0;
999
1000 //
1001 // Loop all the descriptor's allocation lists and initialize them
1002 //
1003 NextEntry = PoolDescriptor->ListHeads;
1004 LastEntry = NextEntry + POOL_LISTS_PER_PAGE;
1005 while (NextEntry < LastEntry)
1006 {
1007 ExpInitializePoolListHead(NextEntry);
1008 NextEntry++;
1009 }
1010
1011 //
1012 // Note that ReactOS does not support Session Pool Yet
1013 //
1015}
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 1020 of file expool.c.
1022{
1026
1027 //
1028 // Check what kind of pool this is
1029 //
1031 {
1032 //
1033 // Compute the track table size and convert it from a power of two to an
1034 // actual byte size
1035 //
1036 // NOTE: On checked builds, we'll assert if the registry table size was
1037 // invalid, while on retail builds we'll just break out of the loop at
1038 // that point.
1039 //
1042 {
1044 {
1047 }
1048 TableSize >>= 1;
1049 }
1050
1051 //
1052 // If we hit bit 32, than no size was defined in the registry, so
1053 // we'll use the default size of 2048 entries.
1054 //
1055 // Otherwise, use the size from the registry, as long as it's not
1056 // smaller than 64 entries.
1057 //
1059 {
1060 PoolTrackTableSize = 2048;
1061 }
1062 else
1063 {
1065 }
1066
1067 //
1068 // Loop trying with the biggest specified size first, and cut it down
1069 // by a power of two each iteration in case not enough memory exist
1070 //
1072 {
1073 //
1074 // Do not allow overflow
1075 //
1077 {
1078 PoolTrackTableSize >>= 1;
1079 continue;
1080 }
1081
1082 //
1083 // Allocate the tracker table and exit the loop if this worked
1084 //
1086 (PoolTrackTableSize + 1) *
1089
1090 //
1091 // Otherwise, as long as we're not down to the last bit, keep
1092 // iterating
1093 //
1095 {
1096 KeBugCheckEx(MUST_SUCCEED_POOL_EMPTY,
1097 TableSize,
1098 0xFFFFFFFF,
1099 0xFFFFFFFF,
1100 0xFFFFFFFF);
1101 }
1102 PoolTrackTableSize >>= 1;
1103 }
1104
1105 //
1106 // Add one entry, compute the hash, and zero the table
1107 //
1108 PoolTrackTableSize++;
1110
1113
1114 //
1115 // Finally, add the most used tags to speed up those allocations
1116 //
1117 ExpSeedHotTags();
1118
1119 //
1120 // We now do the exact same thing with the tracker table for big pages
1121 //
1124 {
1126 {
1129 }
1130 TableSize >>= 1;
1131 }
1132
1133 //
1134 // For big pages, the default tracker table is 4096 entries, while the
1135 // minimum is still 64
1136 //
1138 {
1139 PoolBigPageTableSize = 4096;
1140 }
1141 else
1142 {
1144 }
1145
1146 //
1147 // Again, run the exact same loop we ran earlier, but this time for the
1148 // big pool tracker instead
1149 //
1151 {
1153 {
1154 PoolBigPageTableSize >>= 1;
1155 continue;
1156 }
1157
1159 PoolBigPageTableSize *
1162
1164 {
1165 KeBugCheckEx(MUST_SUCCEED_POOL_EMPTY,
1166 TableSize,
1167 0xFFFFFFFF,
1168 0xFFFFFFFF,
1169 0xFFFFFFFF);
1170 }
1171
1172 PoolBigPageTableSize >>= 1;
1173 }
1174
1175 //
1176 // An extra entry is not needed for for the big pool tracker, so just
1177 // compute the hash and zero it
1178 //
1183 {
1185 }
1186
1187 //
1188 // During development, print this out so we can see what's happening
1189 //
1194
1195 //
1196 // Insert the generic tracker for all of big pool
1197 //
1201 NonPagedPool);
1202
1203 //
1204 // No support for NUMA systems at this time
1205 //
1207
1208 //
1209 // Initialize the tag spinlock
1210 //
1212
1213 //
1214 // Initialize the nonpaged pool descriptor
1215 //
1218 NonPagedPool,
1219 0,
1220 Threshold,
1221 NULL);
1222 }
1223 else
1224 {
1225 //
1226 // No support for NUMA systems at this time
1227 //
1229
1230 //
1231 // Allocate the pool descriptor
1232 //
1236 'looP');
1238 {
1239 //
1240 // This is really bad...
1241 //
1242 KeBugCheckEx(MUST_SUCCEED_POOL_EMPTY,
1243 0,
1244 -1,
1245 -1,
1246 -1);
1247 }
1248
1249 //
1250 // Setup the vector and guarded mutex for paged pool
1251 //
1257 PagedPool,
1258 0,
1259 Threshold,
1260 ExpPagedPoolMutex);
1261
1262 //
1263 // Insert the generic tracker for all of nonpaged pool
1264 //
1267 NonPagedPool);
1268 }
1269}
VOID NTAPI ExInitializePoolDescriptor(IN PPOOL_DESCRIPTOR PoolDescriptor, IN POOL_TYPE PoolType, IN ULONG PoolIndex, IN ULONG Threshold, IN PVOID PoolLock)
Definition: expool.c:969
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:314
Definition: miarm.h:383
Definition: miarm.h:372
_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 1009 of file miarm.h.
1010{
1011 /* Zero out the PTE */
1012 ASSERT(PointerPte->u.Long != 0);
1013 PointerPte->u.Long = 0;
1014}
Referenced by MiDeletePte(), MiDeleteSystemPageableVm(), MiDeleteVirtualAddresses(), MiUnmapLockedPagesInUserSpace(), and MmFreeSpecialPool().
◆ MI_GET_PROTOTYPE_PTE_FOR_VPN()
Definition at line 1560 of file miarm.h.
1562{
1563 PMMPTE ProtoPte;
1564
1565 /* Find the offset within the VAD's prototype PTEs */
1566 ProtoPte = Vad->FirstPrototypePte + (Vpn - Vad->StartingVpn);
1567 ASSERT(ProtoPte <= Vad->LastContiguousPte);
1568 return ProtoPte;
1569}
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 949 of file miarm.h.
950{
951 PMMPDE PointerPde;
952
953 /* Large pages are never paged out, always physically resident */
956}
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 665 of file miarm.h.
666{
668}
Referenced by MiInitializeWorkingSetList(), and MmWorkingSetManager().
◆ MI_IS_WS_UNSAFE()
| FORCEINLINE BOOLEAN MI_IS_WS_UNSAFE | ( | IN PEPROCESS | Process | ) |
Definition at line 1117 of file miarm.h.
1118{
1120}
_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 811 of file miarm.h.
815{
816 /* Check that we are not setting valid a page that should not be */
819
820 /* Set the protection and page */
821 NewPte->u.Long = MiDetermineUserGlobalPteMask(MappingPte);
822 NewPte->u.Long |= MmProtectToPteMask[ProtectionMask];
823 NewPte->u.Hard.PageFrameNumber = PageFrameNumber;
824}
FORCEINLINE ULONG_PTR MiDetermineUserGlobalPteMask(IN PVOID PointerPte)
Definition: miarm.h:740
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 777 of file miarm.h.
781{
782 /* Only valid for kernel, non-session PTEs */
786
787 /* Check that we are not setting valid a page that should not be */
790
791 /* Start fresh */
792 NewPte->u.Long = 0;
793
794 /* Set the protection and page */
795 NewPte->u.Hard.PageFrameNumber = PageFrameNumber;
796 NewPte->u.Long |= MmProtectToPteMask[ProtectionMask];
797
798 /* Make this valid & global */
799#ifdef _GLOBAL_PAGES_ARE_AWESOME_
801 NewPte->u.Hard.Global = 1;
802#endif
803 NewPte->u.Hard.Valid = 1;
804}
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 831 of file miarm.h.
835{
836 /* Only valid for kernel, non-session PTEs */
838
839 /* Start fresh */
840 NewPte->u.Long = 0;
841
842 /* Check that we are not setting valid a page that should not be */
845
846 NewPte->u.Hard.Valid = TRUE;
847 NewPte->u.Hard.Owner = TRUE;
848 NewPte->u.Hard.PageFrameNumber = PageFrameNumber;
849 NewPte->u.Long |= MmProtectToPteMask[ProtectionMask];
850}
Referenced by MiCompleteProtoPteFault(), MiFlushTbAndCapture(), MiMapLockedPagesInUserSpace(), MiResolveDemandZeroFault(), MiResolveProtoPteFault(), and MmArmAccessFault().
◆ MI_MAKE_PROTOTYPE_PTE()
Definition at line 858 of file miarm.h.
860{
862
863 /* Mark this as a prototype */
864 NewPte->u.Long = 0;
865 NewPte->u.Proto.Prototype = 1;
866
867 /*
868 * Prototype PTEs are only valid in paged pool by design, this little trick
869 * lets us only use 30 bits for the address of the PTE, as long as the area
870 * stays 1024MB At most.
871 */
873
874 /*
875 * 7 bits go in the "low" (but we assume the bottom 2 are zero)
876 * and the other 21 bits go in the "high"
877 */
878 NewPte->u.Proto.ProtoAddressLow = (Offset & 0x1FC) >> 2;
879 NewPte->u.Proto.ProtoAddressHigh = (Offset & 0x3FFFFE00) >> 9;
880}
◆ MI_MAKE_SUBSECTION_PTE()
Definition at line 887 of file miarm.h.
889{
891
892 /* Mark this as a prototype */
893 NewPte->u.Long = 0;
894 NewPte->u.Subsect.Prototype = 1;
895
896 /*
897 * Segments are only valid either in nonpaged pool. We store the 20 bit
898 * difference either from the top or bottom of nonpaged pool, giving a
899 * maximum of 128MB to each delta, meaning nonpaged pool cannot exceed
900 * 256MB.
901 */
903 {
905 NewPte->u.Subsect.WhichPool = PagedPool;
906 }
907 else
908 {
910 NewPte->u.Subsect.WhichPool = NonPagedPool;
911 }
912
913 /*
914 * 4 bits go in the "low" (but we assume the bottom 3 are zero)
915 * and the other 20 bits go in the "high"
916 */
917 NewPte->u.Subsect.SubsectionAddressLow = (Offset & 0x78) >> 3;
918 NewPte->u.Subsect.SubsectionAddressHigh = (Offset & 0xFFFFF80) >> 7;
919}
◆ MI_MAKE_TRANSITION_PTE()
| FORCEINLINE VOID MI_MAKE_TRANSITION_PTE | ( | _Out_ PMMPTE | NewPte, |
| _In_ PFN_NUMBER | Page, | ||
| _In_ ULONG | Protection | ||
| ) |
Definition at line 933 of file miarm.h.
936{
937 NewPte->u.Long = 0;
938 NewPte->u.Trans.Transition = 1;
939 NewPte->u.Trans.Protection = Protection;
940 NewPte->u.Trans.PageFrameNumber = Page;
941}
Referenced by MiResolvePageFileFault(), and TrimWsList().
◆ MI_PFN_ELEMENT()
| FORCEINLINE PMMPFN MI_PFN_ELEMENT | ( | IN PFN_NUMBER | Pfn | ) |
Definition at line 1577 of file miarm.h.
1578{
1579 /* Get the entry */
1581};
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 981 of file miarm.h.
983{
984 /* Write the valid PTE */
985 ASSERT(PointerPte->u.Hard.Valid == 1);
988 *PointerPte = TempPte;
989}
Referenced by MiFlushTbAndCapture(), MiSetSystemCodeProtection(), MmArmAccessFault(), and MmChangeKernelResourceSectionProtection().
◆ MI_WRITE_INVALID_PDE()
Definition at line 1038 of file miarm.h.
1040{
1041 /* Write the invalid PDE */
1042 ASSERT(InvalidPde.u.Hard.Valid == 0);
1043 ASSERT(InvalidPde.u.Long != 0);
1044#ifdef _M_AMD64
1046#endif
1047 *PointerPde = InvalidPde;
1048}
Referenced by MmArmAccessFault().
◆ MI_WRITE_INVALID_PTE()
Definition at line 996 of file miarm.h.
998{
999 /* Write the invalid PTE */
1000 ASSERT(InvalidPte.u.Hard.Valid == 0);
1001 *PointerPte = InvalidPte;
1002}
Referenced by _IRQL_requires_max_(), MiAccessCheck(), MiAddMappedPtes(), MiAllocatePoolPages(), MiDecommitPages(), MiDecrementShareCount(), MiMapViewOfDataSection(), MiProcessValidPteList(), MiProtectFreeNonPagedPool(), MiProtectVirtualMemory(), MiResolvePageFileFault(), MmArmAccessFault(), MmCommitSessionMappedView(), MmCreateKernelStack(), MmGrowKernelStackEx(), and NtAllocateVirtualMemory().
◆ MI_WRITE_VALID_PDE()
Definition at line 1021 of file miarm.h.
1023{
1024 /* Write the valid PDE */
1025 ASSERT(PointerPde->u.Hard.Valid == 0);
1026#ifdef _M_AMD64
1027 ASSERT(PointerPde->u.Hard.NoExecute == 0);
1028#endif
1030 *PointerPde = TempPde;
1031}
Referenced by MiAllocatePoolPages(), MiBuildPagedPool(), MiFillSystemPageDirectory(), MiInitializeAndChargePfn(), MiRemoveMappedPtes(), MiSessionCommitPageTables(), MiSessionCreateInternal(), and MiSessionInitializeWorkingSetList().
◆ MI_WRITE_VALID_PTE()
Definition at line 963 of file miarm.h.
965{
966 /* Write the valid PTE */
967 ASSERT(PointerPte->u.Hard.Valid == 0);
969#if _M_AMD64
972#endif
973 *PointerPte = TempPte;
974}
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(), MmMapLockedPagesSpecifyCache(), and MmMapLockedPagesWithReservedMapping().
◆ MI_WS_OWNER()
| FORCEINLINE BOOLEAN MI_WS_OWNER | ( | IN PEPROCESS | Process | ) |
Definition at line 1080 of file miarm.h.
1081{
1082 /* Check if this process is the owner, and that the thread owns the WS */
1084 {
1086 }
1088 {
1089 DPRINT("Current thread %p is attached to another process %p\n", PsGetCurrentThread(), Process);
1090 }
1092 ((PsGetCurrentThread()->OwnsProcessWorkingSetExclusive) ||
1093 (PsGetCurrentThread()->OwnsProcessWorkingSetShared)));
1094}
Referenced by MiUnlockProcessWorkingSet(), MiUnlockProcessWorkingSetForFault(), MiUnlockProcessWorkingSetShared(), and MiUnlockProcessWorkingSetUnsafe().
◆ MiAcquireExpansionLock()
| FORCEINLINE KIRQL MiAcquireExpansionLock | ( | VOID | ) |
Definition at line 1534 of file miarm.h.
1535{
1537
1543}
_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;
195
197 DPRINT("ARM3-DEBUG: Being called with %I64x %I64x %I64x %lx %d %lu\n", LowAddress, HighAddress, SkipBytes, TotalBytes, CacheAttribute, MdlFlags);
198
199 //
200 // Convert the low address into a PFN
201 //
203
204 //
205 // Convert, and normalize, the high address into a PFN
206 //
209
210 //
211 // Validate skipbytes and convert them into pages
212 //
215
216 /* This isn't supported at all */
218
219 //
220 // Now compute the number of pages the MDL will cover
221 //
223 do
224 {
225 //
226 // Try creating an MDL for these many pages
227 //
230
231 //
232 // This function is not required to return the amount of pages requested
233 // In fact, it can return as little as 1 page, and callers are supposed
234 // to deal with this scenario. So re-attempt the allocation with less
235 // pages than before, and see if it worked this time.
236 //
237 PageCount -= (PageCount >> 4);
238 } while (PageCount);
239
240 //
241 // Wow, not even a single page was around!
242 //
244
245 //
246 // This is where the page array starts....
247 //
249
250 //
251 // Lock the PFN database
252 //
253 OldIrql = MiAcquirePfnLock();
254
255 //
256 // Are we looking for any pages, without discriminating?
257 //
259 {
260 //
261 // Well then, let's go shopping
262 //
263 while (PagesFound < PageCount)
264 {
265 /* Grab a page */
268
269 /* FIXME: This check should be smarter */
270 Page = 0;
273
275 {
276 /* This is not good... hopefully we have at least SOME pages */
277 ASSERT(PagesFound);
278 break;
279 }
280
281 /* Grab the page entry for it */
283
284 //
285 // Make sure it's really free
286 //
288
289 /* Now setup the page and mark it */
292 MI_SET_PFN_DELETED(Pfn1);
297
298 //
299 // Save it into the MDL
300 //
301 *MdlPage++ = MiGetPfnEntryIndex(Pfn1);
302 PagesFound++;
303 }
304 }
305 else
306 {
307 //
308 // You want specific range of pages. We'll do this in two runs
309 //
310 for (LookForZeroedPages = 1; LookForZeroedPages >= 0; LookForZeroedPages--)
311 {
312 //
313 // Scan the range you specified
314 //
316 {
317 //
318 // Get the PFN entry for this page
319 //
321 if (!Pfn1) continue;
322
323 //
324 // Make sure it's free and if this is our first pass, zeroed
325 //
328
329 /* Remove the page from the free or zero list */
333 MiUnlinkFreeOrZeroedPage(Pfn1);
334
335 //
336 // Sanity checks
337 //
339
340 //
341 // Now setup the page and mark it
342 //
345 MI_SET_PFN_DELETED(Pfn1);
350
351 //
352 // Save this page into the MDL
353 //
354 *MdlPage++ = Page;
355 if (++PagesFound == PageCount) break;
356 }
357
358 //
359 // If the first pass was enough, don't keep going, otherwise, go again
360 //
361 if (PagesFound == PageCount) break;
362 }
363 }
364
365 //
366 // Now release the PFN count
367 //
368 MiReleasePfnLock(OldIrql);
369
370 //
371 // We might've found less pages, but not more ;-)
372 //
374 if (!PagesFound)
375 {
376 //
377 // If we didn' tfind any pages at all, fail
378 //
382 }
383
384 //
385 // Write out how many pages we found
386 //
388
389 //
390 // Terminate the MDL array if there's certain missing pages
391 //
393
394 //
395 // Now go back and loop over all the MDL pages
396 //
398 LastMdlPage = MdlPage + PagesFound;
399 while (MdlPage < LastMdlPage)
400 {
401 //
402 // Check if we've reached the end
403 //
404 Page = *MdlPage++;
406
407 //
408 // Get the PFN entry for the page and check if we should zero it out
409 //
411 ASSERT(Pfn1);
414 }
415
416 //
417 // We're done, mark the pages as locked
418 //
422}
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
struct _MMPFN::@1930::@1936 e2
union _MMPFN::@1929 u2
union _MMPFN::@1930 u3
union _MMPFN::@1933 u4
#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 157 of file vadnode.c.
161{
162 PMMADDRESS_NODE ParentNode, CurrentNode;
163
165
166 /* If the tree is empty, there is no conflict */
168
169 /* Start looping from the root node */
172 while (CurrentNode)
173 {
174 ParentNode = CurrentNode;
175
176 /* This address comes after */
178 {
179 /* Keep searching on the right */
180 CurrentNode = RtlRightChildAvl(CurrentNode);
181 }
182 else if (EndVpn < CurrentNode->StartingVpn)
183 {
184 /* This address ends before the node starts, search on the left */
185 CurrentNode = RtlLeftChildAvl(CurrentNode);
186 }
187 else
188 {
189 /* This address is part of this node, return it */
190 *NodeOrParent = ParentNode;
191 return TableFoundNode;
192 }
193 }
194
195 /* There is no more child, save the current node as parent */
196 *NodeOrParent = ParentNode;
198 {
199 return TableInsertAsRight;
200 }
201 else
202 {
203 return TableInsertAsLeft;
204 }
205}
Definition: mmtypes.h:645
Referenced by MiInsertVadEx(), MiMapLockedPagesInUserSpace(), MiProtectVirtualMemory(), MmIsAddressRangeFree(), 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 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:750
union _MMVAD_LONG::@2802 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 499 of file mminit.c.
500{
501 ULONG L2Associativity;
502
503 /* Check if no setting was provided already */
505 {
506 /* Get L2 cache information */
507 L2Associativity = KeGetPcr()->SecondLevelCacheAssociativity;
508
509 /* The number of colors is the number of cache bytes by set/way */
512 }
513
514 /* Now convert cache bytes into pages */
517 {
518 /* If there was no cache data from the KPCR, use the default colors */
520 }
521 else
522 {
523 /* Otherwise, make sure there aren't too many colors */
525 {
526 /* Set the maximum */
528 }
529
530 /* Make sure there aren't too little colors */
532 {
533 /* Set the default */
535 }
536
537 /* Finally make sure the colors are a power of two */
539 {
540 /* Set the default */
542 }
543 }
544
545 /* Compute the mask and store it */
548}
Referenced by MmArmInitSystem().
◆ MiConvertSharedWorkingSetLockToExclusive()
| FORCEINLINE BOOLEAN MiConvertSharedWorkingSetLockToExclusive | ( | _In_ PETHREAD | Thread, |
| _In_ PMMSUPPORT | Vm | ||
| ) |
Definition at line 1431 of file miarm.h.
1434{
1435 /* Sanity check: No exclusive lock. */
1439
1440 /* And it should have one and only one shared lock */
1441 ASSERT((Thread->OwnsProcessWorkingSetShared + Thread->OwnsSessionWorkingSetShared + Thread->OwnsSystemWorkingSetShared) == 1);
1442
1443 /* Try. */
1446
1448 {
1452 }
1453 else if (Vm->Flags.SessionSpace)
1454 {
1458 }
1459 else
1460 {
1464 }
1465
1467}
FORCEINLINE BOOLEAN ExConvertPushLockSharedToExclusive(IN PEX_PUSH_LOCK PushLock)
Definition: ex.h:1142
ULONG OwnsSessionWorkingSetExclusive
Definition: pstypes.h:1226
ULONG OwnsProcessWorkingSetExclusive
Definition: pstypes.h:1222
ULONG OwnsSystemWorkingSetExclusive
Definition: pstypes.h:1224
Referenced by MmWorkingSetManager().
◆ MiDecrementPageTableReferences()
| FORCEINLINE USHORT MiDecrementPageTableReferences | ( | IN PVOID | Address | ) |
Definition at line 2501 of file miarm.h.
2502{
2504 PMMPFN Pfn;
2505
2506 /* We should not tinker with this one. */
2508
2510
2511 /* Make sure we're locked */
2513
2514 /* If we're decreasing refcount, then it must be valid! */
2516
2517 /* This lies on the PFN */
2519
2522
2524
2526}
#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:996
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 2951 of file section.c.
2952{
2954 PCONTROL_AREA ControlArea;
2956
2958
2960 {
2961 /* Remove the node from the global section address tree */
2965 }
2966
2967 /* Lock the PFN database */
2968 OldIrql = MiAcquirePfnLock();
2969
2972
2973 ControlArea = SectionObject->Segment->ControlArea;
2974
2975 /* Dereference */
2976 ControlArea->NumberOfSectionReferences--;
2977 ControlArea->NumberOfUserReferences--;
2978
2980
2981 /* Check it. It will delete it if there is no more reference to it */
2983}
static VOID 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:403
struct _SECTION * PSECTION
Definition: mmtypes.h:520
union _CONTROL_AREA::@2791 u
Definition: mmtypes.h:810
Referenced by MmpDeleteSection().
◆ MiDeletePde()
Definition at line 2535 of file miarm.h.
2538{
2539 /* Only for user-mode ones */
2541
2542 /* Kill this one as a PTE */
2544#if _MI_PAGING_LEVELS >= 3
2545 /* Cascade down */
2547 {
2549#if _MI_PAGING_LEVELS == 4
2551 {
2553 }
2554#endif
2555 }
2556#endif
2557}
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:2501
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:1068
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:1268
FORCEINLINE VOID MiUnlockWorkingSet(IN PETHREAD Thread, IN PMMSUPPORT WorkingSet)
Definition: miarm.h:1354
VOID NTAPI KeFlushEntireTb(IN BOOLEAN Invalid, IN BOOLEAN AllProcessors)
Definition: cpu.c:661
Definition: pstypes.h:1103
union _MMPFN::@1928 u1
Referenced by MiFreeInitializationCode(), MiFreePoolPages(), MmFreeDriverInitialization(), and MmFreeSpecialPool().
◆ MiDeleteVirtualAddresses()
| VOID NTAPI MiDeleteVirtualAddresses | ( | _In_ ULONG_PTR | Va, |
| _In_ ULONG_PTR | EndingAddress, | ||
| _In_opt_ PMMVAD | Vad | ||
| ) |
Definition at line 530 of file virtual.c.
534{
536 PMMPDE PointerPde;
537#if (_MI_PAGING_LEVELS >= 3)
538 PMMPPE PointerPpe;
539#endif
540#if (_MI_PAGING_LEVELS >= 4)
541 PMMPPE PointerPxe;
542#endif
544 PEPROCESS CurrentProcess;
547 PSUBSECTION Subsection;
548
549 /* We should never get RosMm memory areas here */
551
552 /* Get the current process */
553 CurrentProcess = PsGetCurrentProcess();
554
555 /* Check if this is a section VAD or a VM VAD */
556 if (!(Vad) || (Vad->u.VadFlags.PrivateMemory) || !(Vad->FirstPrototypePte))
557 {
558 /* Don't worry about prototypes */
560 }
561 else
562 {
563 /* Get the prototype PTE */
564 PrototypePte = Vad->FirstPrototypePte;
565 LastPrototypePte = Vad->FirstPrototypePte + 1;
566 }
567
568 /* In all cases, we don't support fork() yet */
570
571 /* Loop the PTE for each VA (EndingAddress is inclusive!) */
572 while (Va <= EndingAddress)
573 {
574#if (_MI_PAGING_LEVELS >= 4)
575 /* Get the PXE and check if it's valid */
578 {
579 /* Check for unmapped range and skip it */
581 {
582 /* There are gaps in the address space */
583 AddressGap = TRUE;
584
585 /* Update Va and continue looping */
587 continue;
588 }
589
590 /* Make the PXE valid */
592 }
593#endif
594#if (_MI_PAGING_LEVELS >= 3)
595 /* Get the PPE and check if it's valid */
598 {
599 /* Check for unmapped range and skip it */
601 {
602 /* There are gaps in the address space */
603 AddressGap = TRUE;
604
605 /* Update Va and continue looping */
607 continue;
608 }
609
610 /* Make the PPE valid */
612 }
613#endif
614 /* Skip invalid PDEs */
617 {
618 /* There are gaps in the address space */
619 AddressGap = TRUE;
620
621 /* Check if all the PDEs are invalid, so there's nothing to free */
623 continue;
624 }
625
626 /* Now check if the PDE is mapped in */
628 {
629 /* It isn't, so map it in */
630 PointerPte = MiPteToAddress(PointerPde);
631 MiMakeSystemAddressValid(PointerPte, CurrentProcess);
632 }
633
634 /* Now we should have a valid PDE, mapped in, and still have some VA */
636 ASSERT(Va <= EndingAddress);
637
638 /* Check if this is a section VAD with gaps in it */
639 if ((AddressGap) && (LastPrototypePte))
640 {
641 /* We need to skip to the next correct prototype PTE */
643
644 /* And we need the subsection to skip to the next last prototype PTE */
646 if (Subsection)
647 {
648 /* Found it! */
650 }
651 else
652 {
653 /* No more subsections, we are done with prototype PTEs */
655 }
656 }
657
658 /* Lock the PFN Database while we delete the PTEs */
659 OldIrql = MiAcquirePfnLock();
660 PointerPte = MiAddressToPte(Va);
661 do
662 {
663 /* Making sure the PDE is still valid */
665
666 /* Capture the PDE and make sure it exists */
667 TempPte = *PointerPte;
669 {
670 /* Check if the PTE is actually mapped in */
672 {
673 /* Are we dealing with section VAD? */
675 {
676 /* We need to skip to the next correct prototype PTE */
678
679 /* And we need the subsection to skip to the next last prototype PTE */
681 if (Subsection)
682 {
683 /* Found it! */
685 }
686 else
687 {
688 /* No more subsections, we are done with prototype PTEs */
690 }
691 }
692
693 /* Check for prototype PTE */
695 (TempPte.u.Soft.Prototype == 1))
696 {
697 /* Just nuke it */
698 MI_ERASE_PTE(PointerPte);
699 }
700 else
701 {
702 /* Delete the PTE proper */
703 MiDeletePte(PointerPte,
704 (PVOID)Va,
705 CurrentProcess,
706 PrototypePte);
707 }
708 }
709 else
710 {
711 /* The PTE was never mapped, just nuke it here */
712 MI_ERASE_PTE(PointerPte);
713 }
714
716 {
718
719 /* Delete the PDE proper */
720 MiDeletePde(PointerPde, CurrentProcess);
721
722 /* Continue with the next PDE */
724
725 /* Use this to detect address gaps */
726 PointerPte++;
727
728 PrototypePte++;
729 break;
730 }
731 }
732
733 /* Update the address and PTE for it */
734 Va += PAGE_SIZE;
735 PointerPte++;
736 PrototypePte++;
738
739 /* Release the lock */
740 MiReleasePfnLock(OldIrql);
741
742 if (Va > EndingAddress) return;
743
744 /* Check if we exited the loop regularly */
745 AddressGap = (PointerPte != MiAddressToPte(Va));
746 }
747}
FORCEINLINE PMMPTE MI_GET_PROTOTYPE_PTE_FOR_VPN(IN PMMVAD Vad, IN ULONG_PTR Vpn)
Definition: miarm.h:1560
FORCEINLINE VOID MiDeletePde(_In_ PMMPDE PointerPde, _In_ PEPROCESS CurrentProcess)
Definition: miarm.h:2535
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:1262
Definition: mmtypes.h:572
Referenced by MiRemoveMappedView(), MmCleanProcessAddressSpace(), MmDeleteTeb(), and NtFreeVirtualMemory().
◆ MiDereferencePfnAndDropLockCount()
| FORCEINLINE VOID MiDereferencePfnAndDropLockCount | ( | IN PMMPFN | Pfn1 | ) |
Definition at line 1618 of file miarm.h.
1619{
1620 USHORT RefCount, OldRefCount;
1621 PFN_NUMBER PageFrameIndex;
1622
1623 /* Loop while we decrement the page successfully */
1624 do
1625 {
1626 /* There should be at least one reference */
1627 OldRefCount = Pfn1->u3.e2.ReferenceCount;
1628 ASSERT(OldRefCount != 0);
1629
1630 /* Are we the last one */
1631 if (OldRefCount == 1)
1632 {
1633 /* The page shoudln't be shared not active at this point */
1634 ASSERT(Pfn1->u3.e2.ReferenceCount == 1);
1636 ASSERT(Pfn1->u2.ShareCount == 0);
1637
1638 /* Is it a prototype PTE? */
1639 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1640 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1641 {
1642 /* FIXME: We should return commit */
1644 }
1645
1646 /* Update the counter, and drop a reference the long way */
1648 PageFrameIndex = MiGetPfnEntryIndex(Pfn1);
1649 MiDecrementReferenceCount(Pfn1, PageFrameIndex);
1650 return;
1651 }
1652
1653 /* Drop a reference the short way, and that's it */
1655 OldRefCount - 1,
1656 OldRefCount);
1657 ASSERT(RefCount != 0);
1658 } while (OldRefCount != RefCount);
1659
1660 /* If we got here, there should be more than one reference */
1661 ASSERT(RefCount > 1);
1662 if (RefCount == 2)
1663 {
1664 /* Is it still being shared? */
1665 if (Pfn1->u2.ShareCount >= 1)
1666 {
1667 /* Then it should be valid */
1669
1670 /* Is it a prototype PTE? */
1671 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1672 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1673 {
1674 /* We don't handle ethis */
1676 }
1677
1678 /* Update the counter */
1680 }
1681 }
1682}
Referenced by MI_UNLOCK_VA(), MiCompleteProtoPteFault(), MiDispatchFault(), and MmUnlockPages().
◆ MiDetermineUserGlobalPteMask()
| FORCEINLINE ULONG_PTR MiDetermineUserGlobalPteMask | ( | IN PVOID | PointerPte | ) |
Definition at line 740 of file miarm.h.
741{
743
744 /* Start fresh */
745 TempPte.u.Long = 0;
746
747 /* Make it valid and accessed */
750
751 /* Is this for user-mode? */
752 if (
754 MiIsUserPxe(PointerPte) ||
755#endif
757 MiIsUserPpe(PointerPte) ||
758#endif
759 MiIsUserPde(PointerPte) ||
760 MiIsUserPte(PointerPte))
761 {
762 /* Set the owner bit */
764 }
765
766 /* FIXME: We should also set the global bit */
767
768 /* Return the protection */
770}
Referenced by MI_MAKE_HARDWARE_PTE(), and MiResolveTransitionFault().
◆ MiDropLockCount()
| FORCEINLINE VOID MiDropLockCount | ( | IN PMMPFN | Pfn1 | ) |
Definition at line 1588 of file miarm.h.
1589{
1590 /* This page shouldn't be locked, but it should be valid */
1591 ASSERT(Pfn1->u3.e2.ReferenceCount != 0);
1592 ASSERT(Pfn1->u2.ShareCount == 0);
1593
1594 /* Is this the last reference to the page */
1595 if (Pfn1->u3.e2.ReferenceCount == 1)
1596 {
1597 /* It better not be valid */
1599
1600 /* Is it a prototype PTE? */
1601 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1602 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1603 {
1604 /* FIXME: We should return commit */
1606 }
1607
1608 /* Update the counter */
1610 }
1611}
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 711 of file vadnode.c.
716{
718 ULONG_PTR LowVpn, BestVpn;
719
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:320
Definition: dlist.c:348
PMMADDRESS_NODE NTAPI MiGetPreviousNode(IN PMMADDRESS_NODE Node)
Definition: vadnode.c:425
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 593 of file vadnode.c.
599{
601 ULONG_PTR LowVpn, HighVpn, AlignmentVpn;
602 PFN_NUMBER PageCount;
603
605
606 /* Sanity checks */
607 ASSERT(BoundaryAddress);
610
611 /* Calculate page numbers for the length and alignment */
615
616 /* Check for kernel mode table (memory areas) */
618 {
620 }
621 else
622 {
624 }
625
626 /* Check if there is enough space below the boundary */
628 {
629 return TableFoundNode;
630 }
631
632 /* Check if the table is empty */
634 {
635 /* Tree is empty, the candidate address is already the best one */
637 return TableEmptyTree;
638 }
639
640 /* Calculate the initial upper margin */
641 HighVpn = (BoundaryAddress + 1) >> PAGE_SHIFT;
642
643 /* Starting from the root, follow the right children until we found a node
644 that ends above the boundary */
648
649 /* Now loop the Vad nodes */
651 {
652 /* Calculate the lower margin */
654
655 /* Check if the current bounds are suitable */
656 if ((HighVpn > LowVpn) && ((HighVpn - LowVpn) >= PageCount))
657 {
658 /* There is enough space to add our node */
659 LowVpn = ALIGN_DOWN_BY(HighVpn - PageCount, AlignmentVpn);
661
662 /* Can we use the current node as parent? */
664 {
665 /* Node has no right child, so use it as parent */
667 return TableInsertAsRight;
668 }
669 else
670 {
671 /* Node has a right child. This means we must have already
672 moved one node left from the right-most node we started
673 with, thus we already have an OldNode! */
675
676 /* The node we had before is the most left grandchild of
677 that right child, use it as parent. */
679 *Parent = OldNode;
680 return TableInsertAsLeft;
681 }
682 }
683
684 /* Update the upper margin if necessary */
686
687 /* Remember the current node and go to the previous node */
688 OldNode = Node;
690 }
691
692 /* Check if there's enough space before the lowest Vad */
694 if ((HighVpn > LowVpn) && ((HighVpn - LowVpn) >= PageCount))
695 {
696 /* There is enough space to add our address */
699 *Parent = OldNode;
700 return TableInsertAsLeft;
701 }
702
703 /* No address space left at all */
704 *Base = 0;
706 return TableFoundNode;
707}
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 496 of file vadnode.c.
501{
503 ULONG_PTR PageCount, AlignmentVpn, LowVpn, HighestVpn;
505
507
508 /* Calculate page numbers for the length, alignment, and starting address */
512
513 /* Check for kernel mode table (memory areas) */
515 {
517 }
518
519 /* Check if the table is empty */
521 {
522 /* Tree is empty, the candidate address is already the best one */
524 return TableEmptyTree;
525 }
526
527 /* Otherwise, follow the leftmost child of the right root node's child */
530
531 /* Start a search to find a gap */
532 PreviousNode = NULL;
534 {
535 /* Check if the gap below the current node is suitable */
537 {
538 /* There is enough space to add our node */
540
541 /* Can we use the current node as parent? */
543 {
544 /* Node has no left child, so use it as parent */
545 *PreviousVad = Node;
546 return TableInsertAsLeft;
547 }
548 else
549 {
550 /* Node has a left child, this means that the previous node is
551 the right-most child of it's left child and can be used as
552 the parent. In case we use the space before the left-most
553 node, it's left child must be NULL. */
556 *PreviousVad = PreviousNode;
557 return TableInsertAsRight;
558 }
559 }
560
561 /* The next candidate is above the current node */
564
565 /* Remember the current node and go to the next node */
566 PreviousNode = Node;
568 }
569
570 /* We're up to the highest VAD, will this allocation fit above it? */
572
573 /* Check for kernel mode table (memory areas) */
575 {
577 }
578
579 if (HighestVpn >= LowVpn + PageCount)
580 {
581 /* Yes! Use this VAD to store the allocation */
582 *PreviousVad = PreviousNode;
584 return TableInsertAsRight;
585 }
586
587 /* Nyet, there's no free address space for this allocation, so we'll fail */
588 return TableFoundNode;
589}
#define BYTES_TO_PAGES(Size)
Referenced by MiInsertVadEx(), MiMapLockedPagesInUserSpace(), and MmFindGap().
◆ MiGetNextNode()
| PMMADDRESS_NODE NTAPI MiGetNextNode | ( | IN PMMADDRESS_NODE | Node | ) |
Definition at line 461 of file vadnode.c.
462{
464
465 /* Get the right child */
467 {
468 /* Get left-most child */
472 }
473
477 {
478 /* The parent should be a left child, return the real predecessor */
480 {
481 /* Return it */
483 }
484
485 /* Keep lopping until we find our parent */
488 }
489
490 /* Nothing found */
492}
Referenced by MiFindEmptyAddressRangeInTree(), and MiQueryMemoryBasicInformation().
◆ MiGetPageProtection()
Definition at line 1356 of file virtual.c.
1357{
1359 PMMPFN Pfn;
1360 PEPROCESS CurrentProcess;
1361 PETHREAD CurrentThread;
1362 BOOLEAN WsSafe, WsShared;
1365 PAGED_CODE();
1366
1367 /* Copy this PTE's contents */
1368 TempPte = *PointerPte;
1369
1370 /* Assure it's not totally zero */
1372
1373 /* Check for a special prototype format */
1375 (TempPte.u.Soft.Prototype == 1))
1376 {
1377 /* Check if the prototype PTE is not yet pointing to a PTE */
1379 {
1380 /* The prototype PTE contains the protection */
1382 }
1383
1384 /* Get a pointer to the underlying shared PTE */
1386
1387 /* Since the PTE we want to read can be paged out at any time, we need
1388 to release the working set lock first, so that it can be paged in */
1389 CurrentThread = PsGetCurrentThread();
1390 CurrentProcess = PsGetCurrentProcess();
1391 MiUnlockProcessWorkingSetForFault(CurrentProcess,
1392 CurrentThread,
1393 &WsSafe,
1394 &WsShared);
1395
1396 /* Now read the PTE value */
1397 TempPte = *PointerPte;
1398
1399 /* Check if that one is invalid */
1401 {
1402 /* We get the protection directly from this PTE */
1404 }
1405 else
1406 {
1407 /* The PTE is valid, so we might need to get the protection from
1408 the PFN. Lock the PFN database */
1409 OldIrql = MiAcquirePfnLock();
1410
1411 /* Check if the PDE is still valid */
1413 {
1414 /* It's not, make it valid */
1416 }
1417
1418 /* Now it's safe to read the PTE value again */
1419 TempPte = *PointerPte;
1421
1422 /* Check again if the PTE is invalid */
1424 {
1425 /* The PTE is not valid, so we can use it's protection field */
1427 }
1428 else
1429 {
1430 /* The PTE is valid, so we can find the protection in the
1431 OriginalPte field of the PFN */
1434 }
1435
1436 /* Release the PFN database */
1437 MiReleasePfnLock(OldIrql);
1438 }
1439
1440 /* Lock the working set again */
1441 MiLockProcessWorkingSetForFault(CurrentProcess,
1442 CurrentThread,
1443 WsSafe,
1444 WsShared);
1445
1447 }
1448
1449 /* In the easy case of transition or demand zero PTE just return its protection */
1451
1452 /* If we get here, the PTE is valid, so look up the page in PFN database */
1455 {
1456 /* Return protection of the original pte */
1459 }
1460
1461 /* This is software PTE */
1467}
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:1471
FORCEINLINE VOID MiLockProcessWorkingSetForFault(IN PEPROCESS Process, IN PETHREAD Thread, IN BOOLEAN Safe, IN BOOLEAN Shared)
Definition: miarm.h:1504
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(), and NtAllocateVirtualMemory().
◆ MiGetPreviousNode()
| PMMADDRESS_NODE NTAPI MiGetPreviousNode | ( | IN PMMADDRESS_NODE | Node | ) |
Definition at line 425 of file vadnode.c.
426{
428
429 /* Get the left child */
431 {
432 /* Get right-most child */
436 }
437
441 {
442 /* The parent should be a right child, return the real predecessor */
444 {
445 /* Return it unless it's the root */
448 }
449
450 /* Keep lopping until we find our parent */
453 }
454
455 /* Nothing found */
457}
Referenced by MiFindEmptyAddressRangeDownBasedTree(), and MiFindEmptyAddressRangeDownTree().
◆ MiIncrementPageTableReferences()
| FORCEINLINE USHORT MiIncrementPageTableReferences | ( | IN PVOID | Address | ) |
Definition at line 2475 of file miarm.h.
2476{
2478 PMMPFN Pfn;
2479
2480 /* We should not tinker with this one. */
2483
2484 /* Make sure we're locked */
2486
2487 /* If we're bumping refcount, then it must be valid! */
2489
2490 /* This lies on the PFN */
2493
2495
2497}
Referenced by MiDecommitPages(), MiMapLockedPagesInUserSpace(), MiProtectVirtualMemory(), MmArmAccessFault(), MmCreatePageFileMapping(), MmCreateVirtualMappingUnsafeEx(), and NtAllocateVirtualMemory().
◆ MiInitializeAndChargePfn()
| NTSTATUS NTAPI MiInitializeAndChargePfn | ( | OUT PPFN_NUMBER | PageFrameIndex, |
| IN PMMPDE | PointerPde, | ||
| IN PFN_NUMBER | ContainingPageFrame, | ||
| IN BOOLEAN | SessionAllocation | ||
| ) |
Definition at line 1101 of file pfnlist.c.
1105{
1108
1109 /* Use either a global or local PDE */
1111
1112 /* Lock the PFN database */
1113 OldIrql = MiAcquirePfnLock();
1114
1115 /* Make sure nobody is racing us */
1116 if (PointerPde->u.Hard.Valid == 1)
1117 {
1118 /* Return special error if that was the case */
1119 MiReleasePfnLock(OldIrql);
1121 }
1122
1123 /* Grab a zero page and set the PFN, then make it valid */
1127
1128 /* Initialize the PFN */
1129 MiInitializePfnForOtherProcess(*PageFrameIndex,
1130 PointerPde,
1131 ContainingPageFrame);
1133
1134 /* Release the lock and return success */
1135 MiReleasePfnLock(OldIrql);
1137}
FORCEINLINE VOID MI_WRITE_VALID_PDE(IN PMMPDE PointerPde, IN MMPDE TempPde)
Definition: miarm.h:1021
VOID NTAPI MiInitializePfnForOtherProcess(IN PFN_NUMBER PageFrameIndex, IN PVOID PteAddress, IN PFN_NUMBER PteFrame)
Definition: pfnlist.c:1301
Referenced by MiInitializeSessionPool().
◆ MiInitializeColorTables()
Definition at line 553 of file mminit.c.
554{
556 PMMPTE PointerPte, LastPte;
558
559 /* The color table starts after the ARM3 PFN database */
561
562 /* Loop the PTEs. We have two color tables for each secondary color */
566 - 1);
567 while (PointerPte <= LastPte)
568 {
569 /* Check for valid PTE */
571 {
572 /* Get a page and map it */
575
576 /* Zero out the page */
578 }
579
580 /* Next */
581 PointerPte++;
582 }
583
584 /* Now set the address of the next list, right after this one */
586
587 /* Now loop the lists to set them up */
589 {
590 /* Set both free and zero lists for each color */
597 }
598}
struct _MMCOLOR_TABLES * PMMCOLOR_TABLES
FORCEINLINE VOID MI_WRITE_VALID_PTE(IN PMMPTE PointerPte, IN MMPTE TempPte)
Definition: miarm.h:963
Definition: miarm.h:434
Referenced by MiBuildPfnDatabase(), and MiInitMachineDependent().
◆ MiInitializeDriverLargePageList()
Definition at line 68 of file largepag.c.
69{
71
72 /* Initialize the list */
74
75 /* Bail out if there's nothing */
77
78 /* Loop from start to finish */
82 {
83 /* Skip whitespaces */
85 {
86 /* Skip the character */
87 p++;
88 continue;
89 }
90
91 /* A star means everything */
93 {
94 /* No need to keep going */
96 break;
97 }
98
101 }
102}
Referenced by MmArmInitSystem().
◆ MiInitializeLargePageSupport()
Definition at line 34 of file largepag.c.
35{
36#if _MI_PAGING_LEVELS > 2
38 //ASSERT(FALSE);
39#else
40 /* Initialize the large-page hyperspace PTE used for initial mapping */
44
45 /* Initialize the process tracking list, and insert the system process */
48#endif
49}
PMMPTE NTAPI MiReserveSystemPtes(IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:246
Referenced by MmArmInitSystem().
◆ MiInitializeMemoryEvents()
Definition at line 1330 of file mminit.c.
1331{
1334 UNICODE_STRING LowPagedPoolString = RTL_CONSTANT_STRING(L"\\KernelObjects\\LowPagedPoolCondition");
1335 UNICODE_STRING HighPagedPoolString = RTL_CONSTANT_STRING(L"\\KernelObjects\\HighPagedPoolCondition");
1336 UNICODE_STRING LowNonPagedPoolString = RTL_CONSTANT_STRING(L"\\KernelObjects\\LowNonPagedPoolCondition");
1337 UNICODE_STRING HighNonPagedPoolString = RTL_CONSTANT_STRING(L"\\KernelObjects\\HighNonPagedPoolCondition");
1339
1340 /* Check if we have a registry setting */
1342 {
1343 /* Convert it to pages */
1345 }
1346 else
1347 {
1348 /* The low memory threshold is hit when we don't consider that we have "plenty" of free pages anymore */
1350
1351 /* More than one GB of memory? */
1353 {
1354 /* Start at 32MB, and add another 16MB for each GB */
1357 }
1359 {
1360 /* For systems with > 128MB RAM, add another 4MB for each 128MB */
1362 }
1363
1364 /* Don't let the minimum threshold go past 64MB */
1366 }
1367
1368 /* Check if we have a registry setting */
1370 {
1371 /* Convert it into pages */
1373 }
1374 else
1375 {
1376 /* Otherwise, the default is three times the low memory threshold */
1379 }
1380
1381 /* Make sure high threshold is actually higher than the low */
1383
1384 /* Create the memory events for all the thresholds */
1397
1398 /* Now setup the pool events */
1399 MiInitializePoolEvents();
1400
1401 /* Set the initial event state */
1402 MiNotifyMemoryEvents();
1404}
NTSTATUS NTAPI MiCreateMemoryEvent(IN PUNICODE_STRING Name, OUT PKEVENT *Event)
Definition: mminit.c:1235
Definition: env_spec_w32.h:368
Referenced by MmInitSystem().
◆ MiInitializeNonPagedPoolThresholds()
Definition at line 186 of file pool.c.
187{
189
190 /* Default low threshold of 8MB or one third of nonpaged pool */
193
194 /* Default high threshold of 20MB or 50% */
198}
Referenced by MiBuildNonPagedPool(), and MiInitMachineDependent().
◆ MiInitializePfn()
| VOID NTAPI MiInitializePfn | ( | IN PFN_NUMBER | PageFrameIndex, |
| IN PMMPTE | PointerPte, | ||
| IN BOOLEAN | Modified | ||
| ) |
Definition at line 970 of file pfnlist.c.
973{
974 PMMPFN Pfn1;
976 PMMPTE PointerPtePte;
977 MI_ASSERT_PFN_LOCK_HELD();
978
979 /* Setup the PTE */
980 Pfn1 = MI_PFN_ELEMENT(PageFrameIndex);
981 Pfn1->PteAddress = PointerPte;
982
984
985 /* Check if this PFN is part of a valid address space */
986 if (PointerPte->u.Hard.Valid == 1)
987 {
988 /* Only valid from MmCreateProcessAddressSpace path */
990
991 /* Make this a demand zero PTE */
993 }
994 else
995 {
996 /* Copy the PTE data */
997 Pfn1->OriginalPte = *PointerPte;
1000 }
1001
1002 /* Otherwise this is a fresh page -- set it up */
1009
1010 /* Get the page table for the PTE */
1011 PointerPtePte = MiAddressToPte(PointerPte);
1013 {
1014 /* Make sure the PDE gets paged in properly */
1017 {
1018 /* Crash */
1019 KeBugCheckEx(MEMORY_MANAGEMENT,
1020 0x61940,
1021 (ULONG_PTR)PointerPte,
1024 }
1025 }
1026
1027 /* Get the PFN for the page table */
1028 PageFrameIndex = PFN_FROM_PTE(PointerPtePte);
1029 ASSERT(PageFrameIndex != 0);
1031
1033
1034 /* Increase its share count so we don't get rid of it */
1035 Pfn1 = MI_PFN_ELEMENT(PageFrameIndex);
1037}
Referenced by MiLoadImageSection(), MiResolveDemandZeroFault(), MiResolvePageFileFault(), MiResolveProtoPteFault(), MmArmAccessFault(), MmCreateKernelStack(), MmGrowKernelStackEx(), and MmInitializeProcessAddressSpace().
◆ MiInitializePfnAndMakePteValid()
| VOID NTAPI MiInitializePfnAndMakePteValid | ( | IN PFN_NUMBER | PageFrameIndex, |
| IN PMMPTE | PointerPte, | ||
| IN MMPTE | TempPte | ||
| ) |
Definition at line 1041 of file pfnlist.c.
1044{
1045 PMMPFN Pfn1;
1047 PMMPTE PointerPtePte;
1048 MI_ASSERT_PFN_LOCK_HELD();
1049
1050 /* PTE must be invalid */
1051 ASSERT(PointerPte->u.Hard.Valid == 0);
1052
1053 /* Setup the PTE */
1054 Pfn1 = MI_PFN_ELEMENT(PageFrameIndex);
1055 Pfn1->PteAddress = PointerPte;
1057
1059
1060 /* Otherwise this is a fresh page -- set it up */
1067
1068 /* Get the page table for the PTE */
1069 PointerPtePte = MiAddressToPte(PointerPte);
1071 {
1072 /* Make sure the PDE gets paged in properly */
1075 {
1076 /* Crash */
1077 KeBugCheckEx(MEMORY_MANAGEMENT,
1078 0x61940,
1079 (ULONG_PTR)PointerPte,
1082 }
1083 }
1084
1085 /* Get the PFN for the page table */
1086 PageFrameIndex = PFN_FROM_PTE(PointerPtePte);
1087 ASSERT(PageFrameIndex != 0);
1089
1090 /* Increase its share count so we don't get rid of it */
1091 Pfn1 = MI_PFN_ELEMENT(PageFrameIndex);
1094
1095 /* Write valid PTE */
1097}
Referenced by GetFreeWsleIndex(), MiSessionCreateInternal(), MiSessionInitializeWorkingSetList(), and MmAllocateSpecialPool().
◆ MiInitializePfnDatabase()
| VOID NTAPI MiInitializePfnDatabase | ( | IN PLOADER_PARAMETER_BLOCK | LoaderBlock | ) |
Definition at line 1065 of file mminit.c.
1066{
1067 /* Scan memory and start setting up PFN entries */
1068 MiBuildPfnDatabaseFromPages(LoaderBlock);
1069
1070 /* Add the zero page */
1071 MiBuildPfnDatabaseZeroPage();
1072
1073 /* Scan the loader block and build the rest of the PFN database */
1074 MiBuildPfnDatabaseFromLoaderBlock(LoaderBlock);
1075
1076 /* Finally add the pages for the PFN database itself */
1077 MiBuildPfnDatabaseSelf();
1078}
VOID NTAPI MiBuildPfnDatabaseFromPages(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:759
VOID NTAPI MiBuildPfnDatabaseFromLoaderBlock(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:891
Referenced by MiInitMachineDependent().
◆ MiInitializePfnForOtherProcess()
| VOID NTAPI MiInitializePfnForOtherProcess | ( | IN PFN_NUMBER | PageFrameIndex, |
| IN PVOID | PteAddress, | ||
| IN PFN_NUMBER | PteFrame | ||
| ) |
Definition at line 1301 of file pfnlist.c.
1304{
1305 PMMPFN Pfn1;
1306
1307 /* Setup the PTE */
1308 Pfn1 = MI_PFN_ELEMENT(PageFrameIndex);
1309 Pfn1->PteAddress = PteAddress;
1310
1311 /* Make this a software PTE */
1313
1315
1316 /* Setup the page */
1323
1324 /* Did we get a PFN for the page table */
1325 if (PteFrame)
1326 {
1327 /* Store it */
1329
1330 /* Increase its share count so we don't get rid of it */
1331 Pfn1 = MI_PFN_ELEMENT(PteFrame);
1332
1335 }
1336}
Referenced by MiAllocatePoolPages(), MiBuildPagedPool(), MiFillSystemPageDirectory(), MiInitializeAndChargePfn(), MiSessionCommitPageTables(), MiSessionCreateInternal(), and MiSessionInitializeWorkingSetList().
◆ MiInitializePoolEvents()
Definition at line 203 of file pool.c.
204{
206 PFN_NUMBER FreePoolInPages;
207
208 /* Lock paged pool */
210
211 /* Total size of the paged pool minus the allocated size, is free */
213
214 /* Check the initial state high state */
216 {
217 /* We have plenty of pool */
219 }
220 else
221 {
222 /* We don't */
224 }
225
226 /* Check the initial low state */
228 {
229 /* We're very low in free pool memory */
231 }
232 else
233 {
234 /* We're not */
236 }
237
238 /* Release the paged pool lock */
240
241 /* Now it's time for the nonpaged pool lock */
243
244 /* Free pages are the maximum minus what's been allocated */
246
247 /* Check if we have plenty */
249 {
250 /* We do, set the event */
252 }
253 else
254 {
255 /* We don't, clear the event */
257 }
258
259 /* Check if we have very little */
261 {
262 /* We do, set the event */
264 }
265 else
266 {
267 /* We don't, clear it */
269 }
270
271 /* We're done, release the nonpaged pool lock */
273}
VOID FASTCALL KeReleaseQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber, IN KIRQL OldIrql)
Definition: spinlock.c:154
KIRQL FASTCALL KeAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
Definition: spinlock.c:108
Referenced by MiInitializeMemoryEvents().
◆ MiInitializeSessionIds()
Definition at line 116 of file session.c.
117{
119 PFN_NUMBER TotalPages;
120
121 /* Setup the total number of data pages needed for the structure */
122 TotalPages = MI_SESSION_DATA_PAGES_MAXIMUM;
125 TotalPages -= MiSessionDataPages;
126
127 /* Setup the number of pages needed for session pool tags */
128 MiSessionTagSizePages = 2;
129 MiSessionBigPoolPages = 1;
133
134 /* Total pages needed for a session (FIXME: Probably different on PAE/x64) */
136
137 /* Initialize the lock */
139
140 /* Allocate the bitmap */
145 TAG_MM);
147 {
148 /* Free all the bits */
151 Size);
153 }
154 else
155 {
156 /* Die if we couldn't allocate the bitmap */
157 KeBugCheckEx(INSTALL_MORE_MEMORY,
159 MmLowestPhysicalPage,
161 0x200);
162 }
163}
Definition: miarm.h:473
Definition: typedefs.h:89
Referenced by MmInitSystem().
◆ MiInitializeSessionPool()
Definition at line 1276 of file pool.c.
1277{
1278 PMMPTE PointerPte, LastPte;
1279 PMMPDE PointerPde, LastPde;
1280 PFN_NUMBER PageFrameIndex, PdeCount;
1281 PPOOL_DESCRIPTOR PoolDescriptor;
1282 PMM_SESSION_SPACE SessionGlobal;
1283 PMM_PAGED_POOL_INFO PagedPoolInfo;
1286 PAGED_CODE();
1287
1288 /* Lock session pool */
1291
1292 /* Setup a valid pool descriptor */
1294 ExInitializePoolDescriptor(PoolDescriptor,
1295 PagedPoolSession,
1296 0,
1297 0,
1298 &SessionGlobal->PagedPoolMutex);
1299
1300 /* Setup the pool addresses */
1305
1306 /* Reset all the counters */
1308 PagedPoolInfo->PagedPoolCommit = 0;
1309 PagedPoolInfo->PagedPoolHint = 0;
1310 PagedPoolInfo->AllocatedPagedPool = 0;
1311
1312 /* Compute PDE and PTE addresses */
1317
1318 /* Write them down */
1320 PagedPoolInfo->FirstPteForPagedPool = PointerPte;
1321 PagedPoolInfo->LastPteForPagedPool = LastPte;
1322 PagedPoolInfo->NextPdeForPagedPoolExpansion = PointerPde + 1;
1323
1324 /* Zero the PDEs */
1325 PdeCount = LastPde - PointerPde;
1327
1328 /* Initialize the PFN for the PDE */
1330 PointerPde,
1332 TRUE);
1334
1335 /* Initialize the first page table */
1337 Index >>= 22;
1338#ifndef _M_AMD64 // FIXME
1341#endif
1342
1343 /* Bump up counters */
1346
1347 /* Compute the size of the pool in pages, and of the bitmap for it */
1350
1351 /* Allocate and initialize the bitmap to track allocations */
1353 BitmapSize,
1354 TAG_MM);
1358 PoolSize);
1359
1360 /* Set all bits, but clear the first page table's worth */
1363
1364 /* Allocate and initialize the bitmap to track free space */
1366 BitmapSize,
1367 TAG_MM);
1371 PoolSize);
1372
1373 /* Clear all the bits and return success */
1376}
NTSTATUS NTAPI MiInitializeAndChargePfn(OUT PPFN_NUMBER PageFrameIndex, IN PMMPDE PointerPde, IN PFN_NUMBER ContainingPageFrame, IN BOOLEAN SessionAllocation)
Definition: pfnlist.c:1101
Definition: mm.h:503
PMMPDE NextPdeForPagedPoolExpansion
Definition: mm.h:508
PFN_NUMBER SessionPageDirectoryIndex
Definition: miarm.h:484
struct _MM_SESSION_SPACE * GlobalVirtualAddress
Definition: miarm.h:474
◆ MiInitializeSessionSpaceLayout()
Definition at line 63 of file init.c.
64{
65 /* This is the entire size */
67
68 /* Start with session space end */
70
71 /* The highest range is the session image range */
76
77 /* Session working set is below the session image range */
79
80 /* Session view is below the session working set */
85
86 /* Session pool is below session view */
91
92 /* And it all begins here */
94
95 /* System view space ends at session space, so now that we know where
96 * this is, we can compute the base address of system view space itself. */
100
101 /* Sanity checks */
105
106 /* Compute the PTE addresses for all the addresses we carved out */
111
112 /* Initialize the pointer to the session space structure */
114}
struct _MM_SESSION_SPACE * PMM_SESSION_SPACE
Referenced by MmArmInitSystem().
◆ MiInitializeSessionWsSupport()
Definition at line 40 of file session.c.
41{
42 /* Initialize the list heads */
44}
Referenced by MmInitSystem().
◆ MiInitializeSystemPtes()
| VOID NTAPI MiInitializeSystemPtes | ( | IN PMMPTE | StartingPte, |
| IN ULONG | NumberOfPtes, | ||
| IN MMSYSTEM_PTE_POOL_TYPE | PoolType | ||
| ) |
Definition at line 388 of file syspte.c.
391{
392 //
393 // Sanity checks
394 //
395 ASSERT(NumberOfPtes >= 1);
396
397 //
398 // Set the starting and ending PTE addresses for this space
399 //
405
406 //
407 // Clear all the PTEs to start with
408 //
410
411 //
412 // Make the first entry free and link it
413 //
414 StartingPte->u.List.NextEntry = MM_EMPTY_PTE_LIST;
417 MmSystemPteBase;
418
419 //
420 // The second entry stores the size of this PTE space
421 //
422 StartingPte++;
424 StartingPte->u.List.NextEntry = NumberOfPtes;
425
426 //
427 // We also keep a global for it
428 //
430
431 //
432 // Check if this is the system PTE space
433 //
435 {
436 //
437 // Remember how many PTEs we have
438 //
439 MmTotalSystemPtes = NumberOfPtes;
440 }
441}
Referenced by MiBuildSystemPteSpace(), MiInitializeNonPagedPool(), and MiInitMachineDependent().
◆ MiInitializeSystemSpaceMap()
| BOOLEAN NTAPI MiInitializeSystemSpaceMap | ( | IN PMMSESSION InputSession | OPTIONAL | ) |
Definition at line 222 of file section.c.
223{
225 PVOID ViewStart;
226 PMMSESSION Session;
227
228 /* Check if this a session or system space */
229 if (InputSession)
230 {
231 /* Use the input session */
232 Session = InputSession;
233 ViewStart = MiSessionViewStart;
235 }
236 else
237 {
238 /* Use the system space "session" */
239 Session = &MmSession;
240 ViewStart = MiSystemViewStart;
242 }
243
244 /* Initialize the system space lock */
247
248 /* Set the start address */
249 Session->SystemSpaceViewStart = ViewStart;
250
251 /* Create a bitmap to describe system space */
252 BitmapSize = sizeof(RTL_BITMAP) + ((((Size / MI_SYSTEM_VIEW_BUCKET_SIZE) + 31) / 32) * sizeof(ULONG));
254 BitmapSize,
255 TAG_MM);
260
261 /* Set system space fully empty to begin with */
263
264 /* Set default hash flags */
265 Session->SystemSpaceHashSize = 31;
267 Session->SystemSpaceHashEntries = 0;
268
269 /* Calculate how much space for the hash views we'll need */
272
273 /* Allocate and zero the view table */
275 NonPagedPool :
276 PagedPool,
277 AllocSize,
278 TAG_MM);
281
282 /* Success */
284}
struct _MMVIEW MMVIEW
Definition: miarm.h:453
PKGUARDED_MUTEX SystemSpaceViewLockPointer
Definition: miarm.h:455
Referenced by MiBuildPagedPool(), and MiSessionCreateInternal().
◆ MiInitMachineDependent()
| NTSTATUS NTAPI MiInitMachineDependent | ( | IN PLOADER_PARAMETER_BLOCK | LoaderBlock | ) |
Definition at line 697 of file init.c.
698{
701
703
704 /* Set some hardcoded addresses */
709
710
711// PrototypePte.u.Proto.Valid = 1
712// PrototypePte.u.ReadOnly
713// PrototypePte.u.Prototype
714// PrototypePte.u.Protection = MM_READWRITE;
715// PrototypePte.u.ProtoAddress
717
718 MiInitializePageTable();
719
720 MiBuildNonPagedPool();
721
722 MiBuildSystemPteSpace();
723
724 /* Map the PFN database pages */
725 MiBuildPfnDatabase(LoaderBlock);
726
727 /* Reset the ref/share count so that MmInitializeProcessAddressSpace works */
731
735
739
743
747
748 /* Initialize the nonpaged pool */
750
751 /* Initialize the bogus address space */
752 Flags = 0;
755 {
758 }
759
760 /* Initialize the balancer */
762
763 /* Make sure we have everything we need */
774
776}
VOID NTAPI InitializePool(IN POOL_TYPE PoolType, IN ULONG Threshold)
Definition: expool.c:1020
NTSTATUS NTAPI MmInitializeProcessAddressSpace(IN PEPROCESS Process, IN PEPROCESS Clone OPTIONAL, IN PVOID Section OPTIONAL, IN OUT PULONG Flags, IN POBJECT_NAME_INFORMATION *AuditName OPTIONAL)
VOID NTAPI MmInitializeBalancer(ULONG NrAvailablePages, ULONG NrSystemPages)
Definition: balance.c:44
VOID NTAPI MiBuildPfnDatabase(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:617
Referenced by MmArmInitSystem().
◆ MiInsertBasedSection()
Definition at line 386 of file vadnode.c.
387{
390 ASSERT(Section->Address.EndingVpn >= Section->Address.StartingVpn);
391
393
394 /* Find the parent VAD and where this child should be inserted */
395 Result = RtlpFindAvlTableNodeOrParent(&MmSectionBasedRoot, (PVOID)Section->Address.StartingVpn, &Parent);
399}
VOID NTAPI MiInsertNode(IN PMM_AVL_TABLE Table, IN PMMADDRESS_NODE NewNode, IN PMMADDRESS_NODE Parent, IN TABLE_SEARCH_RESULT Result)
Definition: vadnode.c:209
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
Referenced by MmCreateArm3Section().
◆ MiInsertNode()
| VOID NTAPI MiInsertNode | ( | IN PMM_AVL_TABLE | Table, |
| IN PMMADDRESS_NODE | NewNode, | ||
| PMMADDRESS_NODE | Parent, | ||
| TABLE_SEARCH_RESULT | Result | ||
| ) |
◆ MiInsertPageInFreeList()
| VOID NTAPI MiInsertPageInFreeList | ( | IN PFN_NUMBER | PageFrameIndex | ) |
Definition at line 611 of file pfnlist.c.
612{
613 PMMPFNLIST ListHead;
614 PFN_NUMBER LastPage;
615 PMMPFN Pfn1;
617 PMMPFN Blink;
618 PMMCOLOR_TABLES ColorTable;
619
620 /* Make sure the page index is valid */
621 MI_ASSERT_PFN_LOCK_HELD();
622 ASSERT((PageFrameIndex != 0) &&
623 (PageFrameIndex <= MmHighestPhysicalPage) &&
624 (PageFrameIndex >= MmLowestPhysicalPage));
625
626 /* Get the PFN entry */
627 Pfn1 = MI_PFN_ELEMENT(PageFrameIndex);
628
629 /* Sanity checks that a right kind of page is being inserted here */
635
636 /* Get the free page list and increment its count */
637 ListHead = &MmFreePageListHead;
638 ASSERT_LIST_INVARIANT(ListHead);
639 ListHead->Total++;
640
641 /* Get the last page on the list */
642 LastPage = ListHead->Blink;
644 {
645 /* Link us with the previous page, so we're at the end now */
647 }
648 else
649 {
650 /* The list is empty, so we are the first page */
651 ListHead->Flink = PageFrameIndex;
652 }
653
654 /* Now make the list head point back to us (since we go at the end) */
655 ListHead->Blink = PageFrameIndex;
656 ASSERT_LIST_INVARIANT(ListHead);
657
658 /* And initialize our own list pointers */
661
662 /* Set the list name and default priority */
665
666 /* Clear some status fields */
669
670 /* Increment number of available pages */
671 MiIncrementAvailablePages();
672
673 /* Get the page color */
675
676 /* Get the first page on the color list */
679 {
680 /* The list is empty, so we are the first page */
682 ColorTable->Flink = PageFrameIndex;
683 }
684 else
685 {
686 /* Get the previous page */
688
689 /* Make it link to us, and link back to it */
692 }
693
694 /* Now initialize our own list pointers */
695 ColorTable->Blink = Pfn1;
696
697 /* This page is now the last */
699
700 /* And increase the count in the colored list */
701 ColorTable->Count++;
702
703 /* Notify zero page thread if enough pages are on the free list now */
705 {
706 /* Set the event */
708 }
709
710#if MI_TRACE_PFNS
711 Pfn1->PfnUsage = MI_USAGE_FREE_PAGE;
712 RtlZeroMemory(Pfn1->ProcessName, 16);
713 Pfn1->CallSite = NULL;
714#endif
715}
struct _MMPFN * PMMPFN
Definition: gdipluscolor.h:301
Definition: mm.h:460
Referenced by MiAddDescriptorToDatabase(), MiBuildPfnDatabaseFromLoaderBlock(), MiDecrementReferenceCount(), MiDecrementShareCount(), MiSegmentDelete(), MmCreateProcessAddressSpace(), MmDereferencePage(), and MmFreeLoaderBlock().
◆ MiInsertPageInList()
| VOID NTAPI MiInsertPageInList | ( | IN PMMPFNLIST | ListHead, |
| IN PFN_NUMBER | PageFrameIndex | ||
| ) |
Definition at line 779 of file pfnlist.c.
781{
782 PFN_NUMBER Flink, LastPage;
783 PMMPFN Pfn1, Pfn2;
784 MMLISTS ListName;
785 PMMCOLOR_TABLES ColorHead;
787
788 /* For free pages, use MiInsertPageInFreeList */
790
791 /* Make sure the lock is held */
792 MI_ASSERT_PFN_LOCK_HELD();
793
794 /* Make sure the PFN is valid */
795 ASSERT((PageFrameIndex) &&
796 (PageFrameIndex <= MmHighestPhysicalPage) &&
797 (PageFrameIndex >= MmLowestPhysicalPage));
798
799 /* Page should be unused */
800 Pfn1 = MI_PFN_ELEMENT(PageFrameIndex);
803
804 /* Is a standby or modified page being inserted? */
805 ListName = ListHead->ListName;
807 {
808 /* If the page is in transition, it must also be a prototype page */
811 {
812 /* Crash the system on inconsistency */
813 KeBugCheckEx(MEMORY_MANAGEMENT, 0x8888, 0, 0, 0);
814 }
815 }
816
817 /* Standby pages are prioritized, so we need to get the real head */
819 {
820 /* Obviously the prioritized list should still have the same name */
822 ASSERT(ListHead->ListName == ListName);
823 }
824
825 /* Increment the list count */
826 ListHead->Total++;
827
828 /* Is a modified page being inserted? */
830 {
831 /* For now, only single-prototype pages should end up in this path */
834
835 /* Modified pages are colored when they are selected for page file */
836 ListHead = &MmModifiedPageListByColor[0];
837 ASSERT (ListHead->ListName == ListName);
838 ListHead->Total++;
839
840 /* Increment the number of paging file modified pages */
841 MmTotalPagesForPagingFile++;
842 }
843
844 /* Don't handle bad pages yet yet */
846
847 /* Zero pages go to the head, all other pages go to the end */
849 {
850 /* Make the head of the list point to this page now */
851 Flink = ListHead->Flink;
852 ListHead->Flink = PageFrameIndex;
853
854 /* Make the page point to the previous head, and back to the list */
857
858 /* Was the list empty? */
860 {
861 /* It wasn't, so update the backlink of the previous head page */
862 Pfn2 = MI_PFN_ELEMENT(Flink);
864 }
865 else
866 {
867 /* It was empty, so have it loop back around to this new page */
868 ListHead->Blink = PageFrameIndex;
869 }
870 }
871 else
872 {
873 /* Get the last page on the list */
874 LastPage = ListHead->Blink;
876 {
877 /* Link us with the previous page, so we're at the end now */
879 }
880 else
881 {
882 /* The list is empty, so we are the first page */
883 ListHead->Flink = PageFrameIndex;
884 }
885
886 /* Now make the list head point back to us (since we go at the end) */
887 ListHead->Blink = PageFrameIndex;
888 ASSERT_LIST_INVARIANT(ListHead);
889
890 /* And initialize our own list pointers */
893 }
894
895 /* Move the page onto its new location */
897
898 /* For zero/free pages, we also have to handle the colored lists */
900 {
901 /* Increment number of available pages */
902 MiIncrementAvailablePages();
903
904 /* Sanity checks */
907
908 /* Get the page color */
910
911 /* Get the list for this color */
913
914 /* Get the old head */
915 Flink = ColorHead->Flink;
916
917 /* Make this page point back to the list, and point forwards to the old head */
920
921 /* Set the new head */
922 ColorHead->Flink = PageFrameIndex;
923
924 /* Was the head empty? */
926 {
927 /* No, so make the old head point to this page */
928 Pfn2 = MI_PFN_ELEMENT(Flink);
930 }
931 else
932 {
933 /* Yes, make it loop back to this page */
935 }
936
937 /* One more paged on the colored list */
938 ColorHead->Count++;
939
940#if MI_TRACE_PFNS
942 Pfn1->PfnUsage = MI_USAGE_FREE_PAGE;
943 RtlZeroMemory(Pfn1->ProcessName, 16);
944 Pfn1->CallSite = NULL;
945#endif
946 }
948 {
949 /* In ARM3, page must be destined for page file, and not yet written out */
952
953 /* One more transition page */
954 MmTransitionSharedPages++;
955
956 /* Increment the number of per-process modified pages */
957 PsGetCurrentProcess()->ModifiedPageCount++;
958
959 /* FIXME: Wake up modified page writer if there are not enough free pages */
960 }
962 {
963 /* This list is not yet implemented */
965 }
966}
enum _MMLISTS MMLISTS
Referenced by MiDecrementReferenceCount(), and MmZeroPageThread().
◆ MiInsertVad()
Referenced by MiMapLockedPagesInUserSpace(), and NtFreeVirtualMemory().
◆ MiInsertVadEx()
| NTSTATUS NTAPI MiInsertVadEx | ( | _Inout_ PMMVAD | Vad, |
| _In_ ULONG_PTR * | BaseAddress, | ||
| _In_ SIZE_T | ViewSize, | ||
| _In_ ULONG_PTR | HighestAddress, | ||
| _In_ ULONG_PTR | Alignment, | ||
| _In_ ULONG | AllocationType | ||
| ) |
Definition at line 245 of file vadnode.c.
252{
253 ULONG_PTR StartingAddress, EndingAddress;
254 PEPROCESS CurrentProcess;
255 PETHREAD CurrentThread;
258
259 /* Align the view size to pages */
261
262 /* Get the current process */
263 CurrentProcess = PsGetCurrentProcess();
264
265 /* Acquire the address creation lock and make sure the process is alive */
268 {
272 }
273
274 /* Did the caller specify an address? */
276 {
277 /* Make sure HighestAddress is not too large */
279
280 /* Which way should we search? */
282 {
283 /* Find an address top-down */
285 HighestAddress,
286 Alignment,
287 &CurrentProcess->VadRoot,
288 &StartingAddress,
289 &Parent);
290 }
291 else
292 {
293 /* Find an address bottom-up */
295 Alignment,
296 &CurrentProcess->VadRoot,
297 &Parent,
298 &StartingAddress);
299 }
300
301 /* Get the ending address, which is the last piece we need for the VAD */
302 EndingAddress = StartingAddress + ViewSize - 1;
303
304 /* Check if we found a suitable location */
306 {
310 }
311
312 ASSERT(StartingAddress != 0);
314 ASSERT(EndingAddress > StartingAddress);
315 }
316 else
317 {
318 /* Calculate the starting and ending address */
320 EndingAddress = StartingAddress + ViewSize - 1;
321
322 /* Make sure it doesn't conflict with an existing allocation */
324 EndingAddress >> PAGE_SHIFT,
325 &CurrentProcess->VadRoot,
326 &Parent);
328 {
332 }
333 }
334
335 /* Now set the VAD address */
336 Vad->StartingVpn = StartingAddress >> PAGE_SHIFT;
337 Vad->EndingVpn = EndingAddress >> PAGE_SHIFT;
338
339 /* Check if we already need to charge for the pages */
340 if ((Vad->u.VadFlags.PrivateMemory && Vad->u.VadFlags.MemCommit) ||
341 (!Vad->u.VadFlags.PrivateMemory &&
342 (Vad->u.VadFlags.Protection & PAGE_WRITECOPY)))
343 {
344 /* Set the commit charge */
346 }
347
348 /* Check if the VAD is to be secured */
349 if (Vad->u2.VadFlags2.OneSecured)
350 {
351 /* This *must* be a long VAD! */
352 ASSERT(Vad->u2.VadFlags2.LongVad);
353
354 /* Yeah this is retarded, I didn't invent it! */
355 ((PMMVAD_LONG)Vad)->u3.Secured.StartVpn = StartingAddress;
356 ((PMMVAD_LONG)Vad)->u3.Secured.EndVpn = EndingAddress;
357 }
358
359 /* Lock the working set */
360 CurrentThread = PsGetCurrentThread();
361 MiLockProcessWorkingSetUnsafe(CurrentProcess, CurrentThread);
362
363 /* Insert the VAD */
366
367 /* Release the working set */
368 MiUnlockProcessWorkingSetUnsafe(CurrentProcess, CurrentThread);
369
370 /* Update the process' virtual size, and peak virtual size */
373 {
375 }
376
377 /* Unlock the address space */
379
380 *BaseAddress = StartingAddress;
382}
FORCEINLINE VOID MiUnlockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1242
FORCEINLINE VOID MiLockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1172
_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 AllocationType
Definition: mmfuncs.h:410
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T ViewSize
Definition: mmfuncs.h:408
struct _MMVAD_LONG * PMMVAD_LONG
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: vadnode.c:593
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: vadnode.c:496
TABLE_SEARCH_RESULT NTAPI MiCheckForConflictingNode(IN ULONG_PTR StartVpn, IN ULONG_PTR EndVpn, IN PMM_AVL_TABLE Table, OUT PMMADDRESS_NODE *NodeOrParent)
Definition: vadnode.c:157
Referenced by MiCreatePebOrTeb(), MiMapViewOfDataSection(), and NtAllocateVirtualMemory().
◆ MiIsMemoryTypeFree()
| FORCEINLINE BOOLEAN MiIsMemoryTypeFree | ( | TYPE_OF_MEMORY | MemoryType | ) |
Definition at line 672 of file miarm.h.
673{
675 (MemoryType == LoaderLoadedProgram) ||
676 (MemoryType == LoaderFirmwareTemporary) ||
677 (MemoryType == LoaderOsloaderStack));
678}
Referenced by MiAddDescriptorToDatabase(), and MiScanMemoryDescriptors().
◆ MiIsMemoryTypeInvisible()
| FORCEINLINE BOOLEAN MiIsMemoryTypeInvisible | ( | TYPE_OF_MEMORY | MemoryType | ) |
Definition at line 682 of file miarm.h.
683{
685 (MemoryType == LoaderSpecialMemory) ||
686 (MemoryType == LoaderHALCachedMemory) ||
687 (MemoryType == LoaderBBTMemory));
688}
Referenced by KdpGetMemorySizeInMBs(), MiAddDescriptorToDatabase(), MiBuildPfnDatabase(), and MiScanMemoryDescriptors().
◆ MiIsPfnInUse()
Definition at line 174 of file freelist.c.
175{
176 /* Standby list or higher, unlinked, and with references */
178}
Referenced by MiAllocatePagesForMdl(), MiFindContiguousPages(), MmGetRmapListHeadPage(), MmIsPageInUse(), and MmSetRmapListHeadPage().
◆ MiIsRosSectionObject()
| FORCEINLINE BOOLEAN MiIsRosSectionObject | ( | IN PSECTION | Section | ) |
Definition at line 1101 of file miarm.h.
1102{
1103 return Section->u.Flags.filler;
1104}
Referenced by MmExtendSection(), MmGetFileObjectForSection(), MmGetImageInformation(), MmMapViewInSessionSpace(), MmMapViewInSystemSpaceEx(), MmMapViewOfSection(), MmpDeleteSection(), and NtQuerySection().
◆ MiIsUserPde()
| FORCEINLINE BOOLEAN MiIsUserPde | ( | PVOID | Address | ) |
Definition at line 721 of file miarm.h.
722{
725}
Referenced by MiDeletePde(), MiDetermineUserGlobalPteMask(), and MmArmAccessFault().
◆ MiIsUserPte()
| FORCEINLINE BOOLEAN MiIsUserPte | ( | PVOID | Address | ) |
Definition at line 729 of file miarm.h.
730{
732}
Referenced by MiDetermineUserGlobalPteMask(), and MmArmAccessFault().
◆ MiLocateAddress()
◆ MiLocateSubsection()
Definition at line 556 of file section.c.
558{
559 PSUBSECTION Subsection;
560 PCONTROL_AREA ControlArea;
561 ULONG_PTR PteOffset;
562
563 /* Get the control area */
564 ControlArea = Vad->ControlArea;
568
569 /* Get the subsection */
570 Subsection = (PSUBSECTION)(ControlArea + 1);
571
572 /* We only support single-subsection segments */
576
577 /* Compute the PTE offset */
578 PteOffset = Vpn - Vad->StartingVpn;
579 PteOffset += Vad->FirstPrototypePte - Subsection->SubsectionBase;
580
581 /* Again, we only support single-subsection segments */
582 ASSERT(PteOffset < 0xF0000000);
583 ASSERT(PteOffset < Subsection->PtesInSubsection);
584
585 /* Return the subsection */
586 return Subsection;
587}
struct _SUBSECTION * PSUBSECTION
Referenced by MiDeleteVirtualAddresses().
◆ MiLocateVad()
Definition at line 116 of file vadnode.c.
117{
118 PMMVAD FoundVad;
119 ULONG_PTR Vpn;
120 TABLE_SEARCH_RESULT SearchResult;
121
123
124 /* Start with the the hint */
127
128 /* Check if this VPN is in the hint, if so, use it */
131
132 /* VAD hint didn't work, go look for it */
134 (PVOID)Vpn,
135 (PMMADDRESS_NODE*)&FoundVad);
137
138 /* We found it, update the hint */
141
142 /* We allow this (atomic) update without exclusive lock, because it's a hint only */
143 Table->NodeHint = FoundVad;
144 return FoundVad;
145}
struct _MMVAD * PMMVAD
Definition: mmtypes.h:721
Referenced by MiLocateAddress(), MiUnmapViewOfSection(), and MmAccessFault().
◆ MiLockProcessWorkingSet()
Definition at line 1127 of file miarm.h.
1129{
1130 /* Shouldn't already be owning the process working set */
1133
1134 /* Block APCs, make sure that still nothing is already held */
1135 KeEnterGuardedRegion();
1137
1138 /* Lock the working set */
1140
1141 /* Now claim that we own the lock */
1145}
FORCEINLINE VOID ExAcquirePushLockExclusive(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1039
FORCEINLINE BOOLEAN MM_ANY_WS_LOCK_HELD(IN PETHREAD Thread)
Definition: miarm.h:1055
Referenced by MiLockProcessWorkingSetForFault(), MiLockVirtualMemory(), MiUnlockVirtualMemory(), MmArmAccessFault(), MmFreeMemoryArea(), MmInitializeProcessAddressSpace(), MmProbeAndLockPages(), and MmTrimUserMemory().
◆ MiLockProcessWorkingSetForFault()
| FORCEINLINE VOID MiLockProcessWorkingSetForFault | ( | IN PEPROCESS | Process, |
| IN PETHREAD | Thread, | ||
| IN BOOLEAN | Safe, | ||
| IN BOOLEAN | Shared | ||
| ) |
Definition at line 1504 of file miarm.h.
1508{
1509 /* Check if this was a safe lock or not */
1510 if (Safe)
1511 {
1512 if (Shared)
1513 {
1514 /* Reacquire safely & shared */
1516 }
1517 else
1518 {
1519 /* Reacquire safely */
1521 }
1522 }
1523 else
1524 {
1525 /* Unsafe lock cannot be shared */
1527 /* Reacquire unsafely */
1529 }
1530}
FORCEINLINE VOID MiLockProcessWorkingSetShared(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1149
FORCEINLINE VOID MiLockProcessWorkingSet(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1127
Referenced by MiGetPageProtection(), and MiMakeSystemAddressValid().
◆ MiLockProcessWorkingSetShared()
Definition at line 1149 of file miarm.h.
1151{
1152 /* Shouldn't already be owning the process working set */
1155
1156 /* Block APCs, make sure that still nothing is already held */
1157 KeEnterGuardedRegion();
1159
1160 /* Lock the working set */
1162
1163 /* Now claim that we own the lock */
1168}
FORCEINLINE VOID ExAcquirePushLockShared(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1108
Referenced by MiLockProcessWorkingSetForFault(), MiQueryMemoryBasicInformation(), MmAccessFault(), MmGetPageFileMapping(), MmGetPageProtect(), MmGetPfnForProcess(), MmIsDisabledPage(), MmIsPagePresent(), and MmIsPageSwapEntry().
◆ MiLockProcessWorkingSetUnsafe()
Definition at line 1172 of file miarm.h.
1174{
1175 /* Shouldn't already be owning the process working set */
1177
1178 /* APCs must be blocked, make sure that still nothing is already held */
1181
1182 /* Lock the working set */
1184
1185 /* Now claim that we own the lock */
1187 Process->Vm.Flags.AcquiredUnsafe = 1;
1190}
Referenced by _Success_(), MiDecommitPages(), MiInsertVadEx(), MiLockProcessWorkingSetForFault(), MiMapLockedPagesInUserSpace(), MiProtectVirtualMemory(), MiUnmapLockedPagesInUserSpace(), MiUnmapViewOfSection(), MmCleanProcessAddressSpace(), MmCreatePageFileMapping(), MmCreateVirtualMappingUnsafeEx(), MmDeletePageFileMapping(), MmDeleteTeb(), MmInsertMemoryArea(), MmSetDirtyBit(), MmSetPageProtect(), NtAllocateVirtualMemory(), and NtFreeVirtualMemory().
◆ MiLockWorkingSet()
| FORCEINLINE VOID MiLockWorkingSet | ( | IN PETHREAD | Thread, |
| IN PMMSUPPORT | WorkingSet | ||
| ) |
Definition at line 1268 of file miarm.h.
1270{
1271 /* Block APCs */
1272 KeEnterGuardedRegion();
1273
1274 /* Working set should be in global memory */
1276
1277 /* Thread shouldn't already be owning something */
1279
1280 /* Lock this working set */
1281 ExAcquirePushLockExclusive(&WorkingSet->WorkingSetMutex);
1282
1283 /* Which working set is this? */
1285 {
1286 /* Own the system working set */
1290 }
1291 else if (WorkingSet->Flags.SessionSpace)
1292 {
1293 /* Own the session working set */
1297 }
1298 else
1299 {
1300 /* Own the process working set */
1304 }
1305}
Referenced by MiDeleteSystemPageableVm(), MiSetPagingOfDriver(), MmAdjustWorkingSetSize(), MmArmAccessFault(), MmFreeMemoryArea(), and MmInsertMemoryArea().
◆ MiLockWorkingSetShared()
| FORCEINLINE VOID MiLockWorkingSetShared | ( | _In_ PETHREAD | Thread, |
| _In_ PMMSUPPORT | WorkingSet | ||
| ) |
Definition at line 1309 of file miarm.h.
1312{
1313 /* Block APCs */
1314 KeEnterGuardedRegion();
1315
1316 /* Working set should be in global memory */
1318
1319 /* Thread shouldn't already be owning something */
1321
1322 /* Lock this working set */
1323 ExAcquirePushLockShared(&WorkingSet->WorkingSetMutex);
1324
1325 /* Which working set is this? */
1327 {
1328 /* Own the system working set */
1332 }
1333 else if (WorkingSet->Flags.SessionSpace)
1334 {
1335 /* Own the session working set */
1339 }
1340 else
1341 {
1342 /* Own the process working set */
1346 }
1347}
Referenced by MmAccessFault(), and MmWorkingSetManager().
◆ MiLookupDataTableEntry()
| PLDR_DATA_TABLE_ENTRY NTAPI MiLookupDataTableEntry | ( | IN PVOID | Address | ) |
Definition at line 3528 of file sysldr.c.
3529{
3531 PLIST_ENTRY NextEntry;
3532 PAGED_CODE();
3533
3534 /* Loop entries */
3536 do
3537 {
3538 /* Get the loader entry */
3539 LdrEntry = CONTAINING_RECORD(NextEntry,
3540 LDR_DATA_TABLE_ENTRY,
3541 InLoadOrderLinks);
3542
3543 /* Check if the address matches */
3546 LdrEntry->SizeOfImage)))
3547 {
3548 /* Found a match */
3549 FoundEntry = LdrEntry;
3550 break;
3551 }
3552
3553 /* Move on */
3554 NextEntry = NextEntry->Flink;
3556
3557 /* Return the entry */
3558 return FoundEntry;
3559}
Definition: btrfs_drv.h:1876
Referenced by ExAllocatePool(), MmAddVerifierThunks(), and MmPageEntireDriver().
◆ MiMakePdeExistAndMakeValid()
| VOID NTAPI MiMakePdeExistAndMakeValid | ( | IN PMMPDE | PointerPde, |
| IN PEPROCESS | TargetProcess, | ||
| IN KIRQL | OldIrql | ||
| ) |
Definition at line 2441 of file virtual.c.
2444{
2445 PMMPTE PointerPte;
2446#if _MI_PAGING_LEVELS >= 3
2448#if _MI_PAGING_LEVELS == 4
2450#endif
2451#endif
2452
2453 //
2454 // Sanity checks. The latter is because we only use this function with the
2455 // PFN lock not held, so it may go away in the future.
2456 //
2459
2460 //
2461 // If everything is already valid, there is nothing to do.
2462 //
2463 if (
2466#endif
2469#endif
2470 (PointerPde->u.Hard.Valid))
2471 {
2472 return;
2473 }
2474
2475 //
2476 // At least something is invalid, so begin by getting the PTE for the PDE itself
2477 // and then lookup each additional level. We must do it in this precise order
2478 // because the pagfault.c code (as well as in Windows) depends that the next
2479 // level up (higher) must be valid when faulting a lower level
2480 //
2481 PointerPte = MiPteToAddress(PointerPde);
2482 do
2483 {
2484 //
2485 // Make sure APCs continued to be disabled
2486 //
2488
2489#if _MI_PAGING_LEVELS == 4
2490 //
2491 // First, make the PXE valid if needed
2492 //
2494 {
2495 MiMakeSystemAddressValid(PointerPpe, TargetProcess);
2497 }
2498#endif
2499
2500#if _MI_PAGING_LEVELS >= 3
2501 //
2502 // Next, the PPE
2503 //
2505 {
2506 MiMakeSystemAddressValid(PointerPde, TargetProcess);
2508 }
2509#endif
2510
2511 //
2512 // And finally, make the PDE itself valid.
2513 //
2514 MiMakeSystemAddressValid(PointerPte, TargetProcess);
2515
2516 /* Do not increment Page table refcount here for the PDE, this must be managed by caller */
2517
2518 //
2519 // This should've worked the first time so the loop is really just for
2520 // show -- ASSERT that we're actually NOT going to be looping.
2521 //
2522 ASSERT(PointerPde->u.Hard.Valid == 1);
2523 } while (
2526#endif
2529#endif
2530 !PointerPde->u.Hard.Valid);
2531}
Referenced by _Success_(), MiDecommitPages(), MiMapLockedPagesInUserSpace(), MiProtectVirtualMemory(), MmCreatePageFileMapping(), MmCreateVirtualMappingUnsafeEx(), MmDeletePageFileMapping(), MmGetPageFileMapping(), MmGetPageProtect(), MmGetPfnForProcess(), MmIsDisabledPage(), MmIsPagePresent(), MmIsPageSwapEntry(), MmSetDirtyBit(), MmSetPageProtect(), and NtAllocateVirtualMemory().
◆ MiMakeProtectionMask()
Definition at line 140 of file section.c.
141{
142 ULONG Mask1, Mask2, ProtectMask;
143
144 /* PAGE_EXECUTE_WRITECOMBINE is theoretically the maximum */
146
147 /*
148 * Windows API protection mask can be understood as two bitfields, differing
149 * by whether or not execute rights are being requested
150 */
151 Mask1 = Protect & 0xF;
152 Mask2 = (Protect >> 4) & 0xF;
153
154 /* Check which field is there */
155 if (!Mask1)
156 {
157 /* Mask2 must be there, use it to determine the PTE protection */
159 ProtectMask = MmUserProtectionToMask2[Mask2];
160 }
161 else
162 {
163 /* Mask2 should not be there, use Mask1 to determine the PTE mask */
165 ProtectMask = MmUserProtectionToMask1[Mask1];
166 }
167
168 /* Make sure the final mask is a valid one */
170
171 /* Check for PAGE_GUARD option */
173 {
174 /* It's not valid on no-access, nocache, or writecombine pages */
177 {
178 /* Fail such requests */
180 }
181
182 /* This actually turns on guard page in this scenario! */
183 ProtectMask |= MM_GUARDPAGE;
184 }
185
186 /* Check for nocache option */
188 {
189 /* The earlier check should've eliminated this possibility */
191
192 /* Check for no-access page or write combine page */
194 {
195 /* Such a request is invalid */
197 }
198
199 /* Add the PTE flag */
200 ProtectMask |= MM_NOCACHE;
201 }
202
203 /* Check for write combine option */
205 {
206 /* The two earlier scenarios should've caught this */
208
209 /* Don't allow on no-access pages */
211
212 /* This actually turns on write-combine in this scenario! */
213 ProtectMask |= MM_NOACCESS;
214 }
215
216 /* Return the final MM PTE protection mask */
217 return ProtectMask;
218}
Referenced by MiProtectVirtualMemory(), MmCreateVirtualMappingUnsafeEx(), MmSetPageProtect(), and NtAllocateVirtualMemory().
◆ MiMakeSystemAddressValid()
| ULONG NTAPI MiMakeSystemAddressValid | ( | IN PVOID | PageTableVirtualAddress, |
| IN PEPROCESS | CurrentProcess | ||
| ) |
Definition at line 183 of file virtual.c.
185{
189
190 /* Must be a non-pool page table, since those are double-mapped already */
193 (PageTableVirtualAddress > MmPagedPoolEnd));
194
195 /* Working set lock or PFN lock should be held */
197
198 /* Check if the page table is valid */
200 {
201 /* Release the working set lock */
202 MiUnlockProcessWorkingSetForFault(CurrentProcess,
203 CurrentThread,
204 &WsSafe,
205 &WsShared);
206
207 /* Fault it in */
210 {
211 /* This should not fail */
212 KeBugCheckEx(KERNEL_DATA_INPAGE_ERROR,
213 1,
214 Status,
215 (ULONG_PTR)CurrentProcess,
216 (ULONG_PTR)PageTableVirtualAddress);
217 }
218
219 /* Lock the working set again */
220 MiLockProcessWorkingSetForFault(CurrentProcess,
221 CurrentThread,
222 WsSafe,
223 WsShared);
224
225 /* This flag will be useful later when we do better locking */
226 LockChange = TRUE;
227 }
228
229 /* Let caller know what the lock state is */
230 return LockChange;
231}
NTSTATUS NTAPI MmAccessFault(IN ULONG FaultCode, IN PVOID Address, IN KPROCESSOR_MODE Mode, IN PVOID TrapInformation)
Definition: mmfault.c:220
Referenced by MiCalculatePageCommitment(), MiDeleteVirtualAddresses(), MiIsEntireRangeCommitted(), MiIsPageTablePresent(), MiMakePdeExistAndMakeValid(), and MiQueryAddressState().
◆ MiMakeSystemAddressValidPfn()
Definition at line 235 of file virtual.c.
237{
240
241 /* Must be e kernel address */
243
244 /* Check if the page is valid */
246 {
247 /* Release the PFN database */
248 MiReleasePfnLock(OldIrql);
249
250 /* Fault it in */
253 {
254 /* This should not fail */
255 KeBugCheckEx(KERNEL_DATA_INPAGE_ERROR,
256 3,
257 Status,
258 0,
260 }
261
262 /* This flag will be useful later when we do better locking */
263 LockChange = TRUE;
264
265 /* Lock the PFN database */
266 OldIrql = MiAcquirePfnLock();
267 }
268
269 /* Let caller know what the lock state is */
270 return LockChange;
271}
Referenced by MiGetPageProtection(), and MiSegmentDelete().
◆ MiMapPfnDatabase()
| VOID NTAPI MiMapPfnDatabase | ( | IN PLOADER_PARAMETER_BLOCK | LoaderBlock | ) |
Definition at line 663 of file mminit.c.
664{
666 PLIST_ENTRY NextEntry;
667 PMEMORY_ALLOCATION_DESCRIPTOR MdBlock;
668 PMMPTE PointerPte, LastPte;
670
671 /* Get current page data, since we won't be using MxGetNextPage as it would corrupt our state */
674 PagesLeft = 0;
675
676 /* Loop the memory descriptors */
677 NextEntry = LoaderBlock->MemoryDescriptorListHead.Flink;
678 while (NextEntry != &LoaderBlock->MemoryDescriptorListHead)
679 {
680 /* Get the descriptor */
681 MdBlock = CONTAINING_RECORD(NextEntry,
683 ListEntry);
687 {
688 /* These pages are not part of the PFN database */
690 continue;
691 }
692
693 /* Next, check if this is our special free descriptor we've found */
695 {
696 /* Use the real numbers instead */
699 }
700 else
701 {
702 /* Use the descriptor's numbers */
703 BasePage = MdBlock->BasePage;
704 PageCount = MdBlock->PageCount;
705 }
706
707 /* Get the PTEs for this range */
711
712 /* Loop them */
713 while (PointerPte <= LastPte)
714 {
715 /* We'll only touch PTEs that aren't already valid */
717 {
718 /* Use the next free page */
720 ASSERT(FreePageCount != 0);
721
722 /* Consume free pages */
723 FreePage++;
724 FreePageCount--;
725 if (!FreePageCount)
726 {
727 /* Out of memory */
728 KeBugCheckEx(INSTALL_MORE_MEMORY,
730 FreePageCount,
732 1);
733 }
734
735 /* Write out this PTE */
736 PagesLeft++;
738
739 /* Zero this page */
741 }
742
743 /* Next! */
744 PointerPte++;
745 }
746
747 /* Do the next address range */
749 }
750
751 /* Now update the free descriptors to consume the pages we used up during the PFN allocation loop */
754}
Definition: arc.h:238
Referenced by MiInitMachineDependent().
◆ MiPagesInLoaderBlock()
| PFN_NUMBER NTAPI MiPagesInLoaderBlock | ( | IN PLOADER_PARAMETER_BLOCK | LoaderBlock, |
| IN PBOOLEAN | IncludeType | ||
| ) |
◆ MiQueryMemorySectionName()
| NTSTATUS NTAPI MiQueryMemorySectionName | ( | IN HANDLE | ProcessHandle, |
| IN PVOID | BaseAddress, | ||
| OUT PVOID | MemoryInformation, | ||
| IN SIZE_T | MemoryInformationLength, | ||
| OUT PSIZE_T | ReturnLength | ||
| ) |
Definition at line 1754 of file section.c.
1759{
1765
1768 NULL,
1769 PreviousMode,
1771 NULL);
1772
1774 {
1777 }
1778
1780
1782 {
1783 SectionName = MemoryInformation;
1785 {
1786 _SEH2_TRY
1787 {
1788 RtlInitEmptyUnicodeString(&SectionName->SectionFileName,
1789 (PWSTR)(SectionName + 1),
1792
1794
1795 }
1797 {
1799 }
1800 _SEH2_END;
1801 }
1802 else
1803 {
1804 RtlInitEmptyUnicodeString(&SectionName->SectionFileName,
1805 (PWSTR)(SectionName + 1),
1808
1810
1811 }
1812
1814 }
1817}
NTSTATUS NTAPI MmGetFileNameForAddress(IN PVOID Address, OUT PUNICODE_STRING ModuleName)
Definition: section.c:1691
_In_ PVOID _In_ ULONG _Out_ PVOID _In_ ULONG _Inout_ PULONG ReturnLength
Definition: KdSystemDebugControl.c:34
_In_ PVOID _In_ ULONG _Out_ PVOID _In_ ULONG _Inout_ PULONG _In_ KPROCESSOR_MODE PreviousMode
Definition: KdSystemDebugControl.c:35
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
Definition: mmtypes.h:325
Referenced by NtQueryVirtualMemory().
◆ MiReferenceProbedPageAndBumpLockCount()
| FORCEINLINE VOID MiReferenceProbedPageAndBumpLockCount | ( | IN PMMPFN | Pfn1 | ) |
Definition at line 1690 of file miarm.h.
1691{
1692 USHORT RefCount, OldRefCount;
1693
1694 /* Sanity check */
1695 ASSERT(Pfn1->u3.e2.ReferenceCount != 0);
1696
1697 /* Does ARM3 own the page? */
1699 {
1700 /* ReactOS Mm doesn't track share count */
1702 }
1703 else
1704 {
1705 /* On ARM3 pages, we should see a valid share count */
1707
1708 /* Is it a prototype PTE? */
1709 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1710 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1711 {
1712 /* FIXME: We should charge commit */
1714 }
1715 }
1716
1717 /* More locked pages! */
1719
1720 /* Loop trying to update the reference count */
1721 do
1722 {
1723 /* Get the current reference count, make sure it's valid */
1724 OldRefCount = Pfn1->u3.e2.ReferenceCount;
1725 ASSERT(OldRefCount != 0);
1726 ASSERT(OldRefCount < 2500);
1727
1728 /* Bump it up by one */
1730 OldRefCount + 1,
1731 OldRefCount);
1732 ASSERT(RefCount != 0);
1733 } while (OldRefCount != RefCount);
1734
1735 /* Was this the first lock attempt? If not, undo our bump */
1737}
Referenced by MI_LOCK_VA(), and MmProbeAndLockPages().
◆ MiReferenceUnusedPageAndBumpLockCount()
| FORCEINLINE VOID MiReferenceUnusedPageAndBumpLockCount | ( | IN PMMPFN | Pfn1 | ) |
Definition at line 1790 of file miarm.h.
1791{
1792 USHORT NewRefCount;
1793
1794 /* Make sure the page isn't used yet */
1795 ASSERT(Pfn1->u2.ShareCount == 0);
1797
1798 /* Is it a prototype PTE? */
1799 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1800 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1801 {
1802 /* FIXME: We should charge commit */
1804 }
1805
1806 /* More locked pages! */
1808
1809 /* Update the reference count */
1811 if (NewRefCount != 1)
1812 {
1813 /* Someone had already locked the page, so undo our bump */
1814 ASSERT(NewRefCount < 2500);
1816 }
1817}
Referenced by MiResolveTransitionFault().
◆ MiReferenceUsedPageAndBumpLockCount()
| FORCEINLINE VOID MiReferenceUsedPageAndBumpLockCount | ( | IN PMMPFN | Pfn1 | ) |
Definition at line 1745 of file miarm.h.
1746{
1747 USHORT NewRefCount;
1748
1749 /* Is it a prototype PTE? */
1750 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1751 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1752 {
1753 /* FIXME: We should charge commit */
1755 }
1756
1757 /* More locked pages! */
1759
1760 /* Update the reference count */
1762 if (NewRefCount == 2)
1763 {
1764 /* Is it locked or shared? */
1765 if (Pfn1->u2.ShareCount)
1766 {
1767 /* It's shared, so make sure it's active */
1769 }
1770 else
1771 {
1772 /* It's locked, so we shouldn't lock again */
1774 }
1775 }
1776 else
1777 {
1778 /* Someone had already locked the page, so undo our bump */
1779 ASSERT(NewRefCount < 2500);
1781 }
1782}
Referenced by MiDispatchFault().
◆ MiReleaseExpansionLock()
| FORCEINLINE VOID MiReleaseExpansionLock | ( | KIRQL | OldIrql | ) |
Definition at line 1547 of file miarm.h.
1548{
1553}
Referenced by MiArchCreateProcessAddressSpace(), MiDereferenceSessionFinal(), MiSessionAddProcess(), MiSessionInitializeWorkingSetList(), MiSessionLeader(), MiSessionRemoveProcess(), MmDeleteProcessAddressSpace(), MmGetSessionById(), and MmWorkingSetManager().
◆ MiReleaseProcessReferenceToSessionDataPage()
| VOID NTAPI MiReleaseProcessReferenceToSessionDataPage | ( | IN PMM_SESSION_SPACE | SessionGlobal | ) |
Definition at line 209 of file session.c.
210{
212 PMMPTE PointerPte;
214 PMMPFN Pfn1;
216
217 /* Is there more than just this reference? If so, bail out */
219
220 /* Get the session ID */
221 SessionId = SessionGlobal->SessionId;
223
224 /* Free the session page tables */
225#ifndef _M_AMD64
227#endif
229
230 /* Capture the data page PFNs */
231 PointerPte = MiAddressToPte(SessionGlobal);
233 {
235 }
236
237 /* Release them */
239
240 /* Mark them as deleted */
242 {
244 MI_SET_PFN_DELETED(Pfn1);
245 }
246
247 /* Loop every data page and drop a reference count */
248 OldIrql = MiAcquirePfnLock();
250 {
251 /* Sanity check that the page is correct, then decrement it */
256 }
257
258 /* Done playing with pages, release the lock */
259 MiReleasePfnLock(OldIrql);
260
261 /* Decrement the number of data pages */
263
264 /* Free this session ID from the session bitmap */
269}
FORCEINLINE BOOLEAN MI_IS_PHYSICAL_ADDRESS(IN PVOID Address)
Definition: miarm.h:949
VOID NTAPI MiReleaseSystemPtes(IN PMMPTE StartingPte, IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:264
Referenced by MiDereferenceSession(), and MmDeleteProcessAddressSpace().
◆ MiReleaseSystemPtes()
| VOID NTAPI MiReleaseSystemPtes | ( | IN PMMPTE | StartingPte, |
| IN ULONG | NumberOfPtes, | ||
| IN MMSYSTEM_PTE_POOL_TYPE | SystemPtePoolType | ||
| ) |
Definition at line 264 of file syspte.c.
267{
270 PMMPTE PreviousPte, NextPte, InsertPte;
271
272 //
273 // Check to make sure the PTE address is within bounds
274 //
275 ASSERT(NumberOfPtes != 0);
278
279 //
280 // Zero PTEs
281 //
283
284 //
285 // Acquire the System PTE lock
286 //
288
289 //
290 // Increase availability
291 //
292 MmTotalFreeSystemPtes[SystemPtePoolType] += NumberOfPtes;
293
294 //
295 // Step through the cluster list to find where to insert the PTEs
296 //
297 PreviousPte = &MmFirstFreeSystemPte[SystemPtePoolType];
298 InsertPte = NULL;
299
301 {
302 //
303 // Get the next cluster and its size
304 //
307
308 //
309 // Check if this cluster is adjacent to the PTEs being released
310 //
312 (StartingPte + NumberOfPtes == NextPte))
313 {
314 //
315 // Add the PTEs in the cluster to the PTEs being released
316 //
317 NumberOfPtes += ClusterSize;
318
319 if (NextPte < StartingPte)
320 StartingPte = NextPte;
321
322 //
323 // Unlink this cluster and zero it
324 //
326
328 {
330 NextPte++;
331 }
333
334 //
335 // Invalidate the previously found insertion location, if any
336 //
337 InsertPte = NULL;
338 }
339 else
340 {
341 //
342 // Check if the insertion location is right before this cluster
343 //
345 InsertPte = PreviousPte;
346
347 //
348 // On to the next cluster
349 //
350 PreviousPte = NextPte;
351 }
352 }
353
354 //
355 // If no insertion location was found, use the tail of the list
356 //
358 InsertPte = PreviousPte;
359
360 //
361 // Create a new cluster using the PTEs being released
362 //
363 if (NumberOfPtes != 1)
364 {
366
367 NextPte = StartingPte + 1;
369 }
370 else
371 StartingPte->u.List.OneEntry = 1;
372
373 //
374 // Link the new cluster into the cluster list at the insertion location
375 //
378
379 //
380 // Release the System PTE lock
381 //
383}
Referenced by MiAllocatePoolPages(), MiArchCreateProcessAddressSpace(), MiCopyPfn(), MiReleaseProcessReferenceToSessionDataPage(), MiZeroPfn(), MmDeleteKernelStack(), MmFreeNonCachedMemory(), MmUnmapIoSpace(), and MmUnmapLockedPages().
◆ MiRemoveAnyPage()
| PFN_NUMBER NTAPI MiRemoveAnyPage | ( | IN ULONG | Color | ) |
Definition at line 477 of file pfnlist.c.
478{
479 PFN_NUMBER PageIndex;
480 PMMPFN Pfn1;
481
482 /* Make sure PFN lock is held and we have pages */
483 MI_ASSERT_PFN_LOCK_HELD();
486 {
487 return 0;
488 }
489
490 /* Check the colored free list */
493 {
494 /* Check the colored zero list */
497 {
498 /* Check the free list */
503 {
504 /* Check the zero list */
510 {
511 /* FIXME: Should check the standby list */
513 }
514 }
515 }
516 }
517
518 /* Remove the page from its list */
520 ASSERT(PageIndex != 0);
521
522 /* Sanity checks */
523 Pfn1 = MI_PFN_ELEMENT(PageIndex);
530
531 /* Return the page */
532 return PageIndex;
533}
PFN_NUMBER NTAPI MiRemovePageByColor(IN PFN_NUMBER PageIndex, IN ULONG Color)
Definition: pfnlist.c:364
Referenced by GetFreeWsleIndex(), MiAllocatePagesForMdl(), MiAllocatePoolPages(), MiArchCreateProcessAddressSpace(), MiInitMachineDependent(), MiLoadImageSection(), MiResolveDemandZeroFault(), MiResolvePageFileFault(), MiResolveProtoPteFault(), MiSessionCreateInternal(), MiSessionInitializeWorkingSetList(), MmAllocateSpecialPool(), MmArmAccessFault(), MmCreateKernelStack(), MmCreateProcessAddressSpace(), MmGrowKernelStackEx(), and MmZeroPageThread().
◆ MiRemoveMappedView()
Definition at line 766 of file section.c.
768{
770 PCONTROL_AREA ControlArea;
772
773 /* Get the control area */
774 ControlArea = Vad->ControlArea;
775
776 /* We only support non-extendable, non-image, pagefile-backed regular sections */
779 ASSERT(ControlArea);
782
783 /* Delete the actual virtual memory pages */
786 Vad);
787
788 /* Release the working set */
789 MiUnlockProcessWorkingSetUnsafe(CurrentProcess, CurrentThread);
790
791 /* Lock the PFN database */
792 OldIrql = MiAcquirePfnLock();
793
794 /* Remove references */
795 ControlArea->NumberOfMappedViews--;
796 ControlArea->NumberOfUserReferences--;
797
798 /* Check if it should be destroyed */
800}
VOID NTAPI MiDeleteVirtualAddresses(_In_ ULONG_PTR Va, _In_ ULONG_PTR EndingAddress, _In_opt_ PMMVAD Vad)
Definition: virtual.c:530
Referenced by MiUnmapViewOfSection(), and MmCleanProcessAddressSpace().
◆ MiRemoveNode()
| VOID NTAPI MiRemoveNode | ( | IN PMMADDRESS_NODE | Node, |
| IN PMM_AVL_TABLE | Table | ||
| ) |
Definition at line 403 of file vadnode.c.
405{
407
408 /* Call the AVL code */
410
411 /* Decrease element count */
412 Table->NumberGenericTableElements--;
413
414 /* Check if this node was the hint */
416 {
417 /* Get a new hint, unless we're empty now, in which case nothing */
420 }
421}
Referenced by MiDeleteARM3Section(), MiUnmapLockedPagesInUserSpace(), MiUnmapViewOfSection(), MmCleanProcessAddressSpace(), MmDeleteTeb(), and NtFreeVirtualMemory().
◆ MiRemoveZeroPage()
| PFN_NUMBER NTAPI MiRemoveZeroPage | ( | IN ULONG | Color | ) |
Definition at line 537 of file pfnlist.c.
538{
539 PFN_NUMBER PageIndex;
540 PMMPFN Pfn1;
542
543 /* Make sure PFN lock is held and we have pages */
544 MI_ASSERT_PFN_LOCK_HELD();
547 {
548 return 0;
549 }
550
551 /* Check the colored zero list */
554 {
555 /* Check the zero list */
559 {
560 /* This means there's no zero pages, we have to look for free ones */
563
564 /* Check the colored free list */
567 {
568 /* Check the free list */
574 {
575 /* FIXME: Should check the standby list */
577 }
578 }
579 }
580 else
581 {
583 }
584 }
585
586 /* Sanity checks */
587 Pfn1 = MI_PFN_ELEMENT(PageIndex);
590
591 /* Remove the page from its list */
593 ASSERT(PageIndex != 0);
595
596 /* Zero it, if needed */
598
599 /* Sanity checks */
604
605 /* Return the page */
606 return PageIndex;
607}
VOID NTAPI MiZeroPhysicalPage(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:122
Referenced by MiBuildPagedPool(), MiFillSystemPageDirectory(), MiInitializeAndChargePfn(), MiRemoveZeroPageSafe(), MiResolveDemandZeroFault(), MiSessionCommitPageTables(), and MmAllocPage().
◆ MiRemoveZeroPageSafe()
| FORCEINLINE PFN_NUMBER MiRemoveZeroPageSafe | ( | IN ULONG | Color | ) |
Definition at line 2409 of file miarm.h.
2410{
2411 if (MmFreePagesByColor[ZeroedPageList][Color].Flink != LIST_HEAD) return MiRemoveZeroPage(Color);
2412 return 0;
2413}
Referenced by MiArchCreateProcessAddressSpace(), MiResolveDemandZeroFault(), MiSessionCreateInternal(), MiSessionInitializeWorkingSetList(), MmArmAccessFault(), and MmCreateProcessAddressSpace().
◆ MiReserveSystemPtes()
| PMMPTE NTAPI MiReserveSystemPtes | ( | IN ULONG | NumberOfPtes, |
| IN MMSYSTEM_PTE_POOL_TYPE | SystemPtePoolType | ||
| ) |
Definition at line 246 of file syspte.c.
248{
249 PMMPTE PointerPte;
250
251 //
252 // Use the extended function
253 //
254 PointerPte = MiReserveAlignedSystemPtes(NumberOfPtes, SystemPtePoolType, 0);
255
256 //
257 // Return the PTE Pointer
258 //
259 return PointerPte;
260}
PMMPTE NTAPI MiReserveAlignedSystemPtes(IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType, IN ULONG Alignment)
Definition: syspte.c:88
Referenced by _IRQL_requires_max_(), MiAllocatePoolPages(), MiArchCreateProcessAddressSpace(), MiBuildPagedPool(), MiBuildSystemPteSpace(), MiCopyPfn(), MiInitializeLargePageSupport(), MiInitMachineDependent(), MiLoadImageSection(), MiReloadBootLoadedDrivers(), MiSessionCreateInternal(), MiZeroPfn(), MmAllocateNonCachedMemory(), MmCreateKernelStack(), MmMapIoSpace(), and MmMapLockedPagesSpecifyCache().
◆ MiRosProtectVirtualMemory()
| NTSTATUS NTAPI MiRosProtectVirtualMemory | ( | IN PEPROCESS | Process, |
| IN OUT PVOID * | BaseAddress, | ||
| IN OUT PSIZE_T | NumberOfBytesToProtect, | ||
| IN ULONG | NewAccessProtection, | ||
| OUT PULONG OldAccessProtection | OPTIONAL | ||
| ) |
◆ MiRosUnmapViewInSystemSpace()
Definition at line 4608 of file section.c.
4609{
4611
4613}
static NTSTATUS MmUnmapViewOfSegment(PMMSUPPORT AddressSpace, PVOID BaseAddress)
Definition: section.c:3562
_Must_inspect_result_ _Outptr_result_bytebuffer_ ViewSize PVOID * MappedBase
Definition: mmfuncs.h:492
Referenced by MmUnmapViewInSystemSpace().
◆ MiRosUnmapViewOfSection()
| NTSTATUS NTAPI MiRosUnmapViewOfSection | ( | _In_ PEPROCESS | Process, |
| _In_ PMEMORY_AREA | MemoryArea, | ||
| _In_ PVOID | BaseAddress, | ||
| _In_ BOOLEAN | SkipDebuggerNotify | ||
| ) |
Definition at line 3626 of file section.c.
3631{
3634 PVOID ImageBaseAddress = 0;
3635
3638
3641
3643
3645#ifdef NEWCC
3647#else
3649#endif
3651
3652 {
3654
3657 }
3658
3660 {
3662 ULONG NrSegments;
3663 PMM_IMAGE_SECTION_OBJECT ImageSectionObject;
3664 PMM_SECTION_SEGMENT SectionSegments;
3666
3669 SectionSegments = ImageSectionObject->Segments;
3670 NrSegments = ImageSectionObject->NrSegments;
3671
3673
3674 /* Search for the current segment within the section segments
3675 * and calculate the image base address */
3677 {
3679 {
3681 break;
3682 }
3683 }
3685 {
3686 KeBugCheck(MEMORY_MANAGEMENT);
3687 }
3688
3690 {
3693
3696 {
3700 }
3701 }
3704 }
3705 else
3706 {
3712 LARGE_INTEGER ViewOffset;
3714
3716
3718
3721 {
3725 }
3726
3727 /* These might be deleted now */
3728 Vad = NULL;
3730
3732 {
3733 /* Don't bother */
3734 MmDereferenceSegment(Segment);
3736 }
3738
3741
3742 /* Don't bother for auto-delete closed file. */
3743 if (FlagOn(FileObject->Flags, FO_DELETE_ON_CLOSE) && FlagOn(FileObject->Flags, FO_CLEANUP_COMPLETE))
3744 {
3746 MmDereferenceSegment(Segment);
3748 }
3749
3750 /*
3751 * Flush only when last mapping is deleted.
3752 * FIXME: Why ControlArea == NULL? Or rather: is ControlArea ever not NULL here?
3753 */
3755 {
3757 {
3760 &ViewOffset,
3761 FlushSize,
3762 NULL);
3763 ViewSize -= FlushSize;
3764 ViewOffset.QuadPart += FlushSize;
3765 }
3766 }
3767
3769 MmDereferenceSegment(Segment);
3770 }
3771
3772 /* Notify debugger */
3774
3776}
Definition: gdiplusheaders.h:23
VOID NTAPI DbgkUnMapViewOfSection(IN PVOID BaseAddress)
Definition: dbgkutil.c:436
VOID NTAPI FsRtlAcquireFileExclusive(IN PFILE_OBJECT FileObject)
Definition: fastio.c:1640
PMM_IMAGE_SECTION_OBJECT ImageSectionObjectFromSegment(PMM_SECTION_SEGMENT Segment)
Definition: section.c:118
NTSTATUS NTAPI MmFlushSegment(_In_ PSECTION_OBJECT_POINTERS SectionObjectPointer, _In_opt_ PLARGE_INTEGER Offset, _In_ ULONG Length, _Out_opt_ PIO_STATUS_BLOCK Iosb)
Definition: section.c:5113
struct _MEMORY_AREA::@1927 SectionData
Definition: mmtypes.h:923
union _MMVAD::@2798 u
Definition: mm.h:229
Definition: mm.h:200
struct _MM_SECTION_SEGMENT::@1926 Image
Definition: typedefs.h:103
Referenced by MiRosCleanupMemoryArea(), and MiUnmapViewOfSection().
◆ MiSessionAddProcess()
Definition at line 423 of file session.c.
424{
425 PMM_SESSION_SPACE SessionGlobal;
427
428 /* The current process must already be in a session */
430
431 /* Sanity check */
433
434 /* Get the global session */
436
437 /* Increment counters */
441
442 /* Set the session pointer */
444 NewProcess->Session = SessionGlobal;
445
446 /* Acquire the expansion lock while touching the session */
448
449 /* Insert it into the process list */
451
452 /* Release the lock again */
454
455 /* Set the flag */
457}
FORCEINLINE VOID MiReleaseExpansionLock(KIRQL OldIrql)
Definition: miarm.h:1547
Referenced by MmCreateProcessAddressSpace().
◆ MiSessionRemoveProcess()
Definition at line 392 of file session.c.
393{
396
397 /* If the process isn't already in a session, or if it's the leader... */
400 {
401 /* Then there's nothing to do */
402 return;
403 }
404
405 /* Sanity check */
407
408 /* Acquire the expansion lock while touching the session */
410
411 /* Remove the process from the list */
413
414 /* Release the lock again */
416
417 /* Dereference the session */
418 MiDereferenceSession();
419}
Referenced by MmCleanProcessAddressSpace().
◆ MiSyncARM3WithROS()
◆ MiSyncCachedRanges()
Definition at line 54 of file largepag.c.
55{
57
58 /* Scan every range */
60 {
62 }
63}
Referenced by MmArmInitSystem().
◆ MiUnlinkFreeOrZeroedPage()
Definition at line 137 of file pfnlist.c.
138{
139 PFN_NUMBER OldFlink, OldBlink;
140 PMMPFNLIST ListHead;
141 MMLISTS ListName;
143 PMMCOLOR_TABLES ColorTable;
144 PMMPFN Pfn1;
145
146 /* Make sure the PFN lock is held */
147 MI_ASSERT_PFN_LOCK_HELD();
148
149 /* Make sure the PFN entry isn't in-use */
152
153 /* Find the list for this entry, make sure it's the free or zero list */
155 ListName = ListHead->ListName;
158 ASSERT_LIST_INVARIANT(ListHead);
159
160 /* Remove one count */
162 ListHead->Total--;
163
164 /* Get the forward and back pointers */
165 OldFlink = Entry->u1.Flink;
166 OldBlink = Entry->u2.Blink;
167
168 /* Check if the next entry is the list head */
170 {
171 /* It is not, so set the backlink of the actual entry, to our backlink */
173 }
174 else
175 {
176 /* Set the list head's backlink instead */
177 ListHead->Blink = OldBlink;
178 }
179
180 /* Check if the back entry is the list head */
182 {
183 /* It is not, so set the backlink of the actual entry, to our backlink */
185 }
186 else
187 {
188 /* Set the list head's backlink instead */
189 ListHead->Flink = OldFlink;
190 }
191
192 /* Get the page color */
195
196 /* Get the first page on the color list */
198
199 /* Check if this was was actually the head */
200 OldFlink = ColorTable->Flink;
201 if (OldFlink == OldBlink)
202 {
203 /* Make the table point to the next page this page was linking to */
206 {
207 /* And make the previous link point to the head now */
209 }
210 else
211 {
212 /* And if that page was the head, loop the list back around */
214 }
215 }
216 else
217 {
218 /* This page shouldn't be pointing back to the head */
220
221 /* Make the back link point to whoever the next page is */
224
225 /* Check if this page was pointing to the head */
227 {
228 /* Make the back link point to the head */
231 }
232 else
233 {
234 /* Then the table is directly back pointing to this page now */
235 ColorTable->Blink = Pfn1;
236 }
237 }
238
239 /* One less colored page */
241 ColorTable->Count--;
242
243 /* ReactOS Hack */
244 Entry->OriginalPte.u.Long = 0;
245
246 /* We are not on a list anymore */
248 ASSERT_LIST_INVARIANT(ListHead);
249
250 /* Decrement number of available pages */
251 MiDecrementAvailablePages();
252
253#if MI_TRACE_PFNS
260#endif
261}
Referenced by MiAllocatePagesForMdl(), and MiFindContiguousPages().
◆ MiUnlinkPageFromList()
Definition at line 265 of file pfnlist.c.
266{
267 PMMPFNLIST ListHead;
268 PFN_NUMBER OldFlink, OldBlink;
269
270 /* Make sure the PFN lock is held */
271 MI_ASSERT_PFN_LOCK_HELD();
272
273 /* ARM3 should only call this for dead pages */
274 ASSERT(Pfn->u3.e2.ReferenceCount == 0);
275
276 /* Transition pages are supposed to be standby/modified/nowrite */
277 ListHead = MmPageLocationList[Pfn->u3.e1.PageLocation];
279
280 /* Check if this was standby, or modified */
282 {
283 /* Should not be a ROM page */
284 ASSERT(Pfn->u3.e1.Rom == 0);
285
286 /* Get the exact list */
287 ListHead = &MmStandbyPageListByPriority[Pfn->u4.Priority];
288
289 /* Decrement number of available pages */
290 MiDecrementAvailablePages();
291
292 /* Decrease transition page counter */
294 MmTransitionSharedPages--;
295 }
297 {
298 /* Only shared memory (page-file backed) modified pages are supported */
299 ASSERT(Pfn->OriginalPte.u.Soft.Prototype == 0);
300
301 /* Decrement the counters */
302 ListHead->Total--;
303 MmTotalPagesForPagingFile--;
304
305 /* Pick the correct colored list */
306 ListHead = &MmModifiedPageListByColor[0];
307
308 /* Decrease transition page counter */
309 MmTransitionSharedPages--;
310 }
312 {
313 /* List not yet supported */
315 }
316
317 /* Nothing should be in progress and the list should not be empty */
318 ASSERT(Pfn->u3.e1.WriteInProgress == 0);
319 ASSERT(Pfn->u3.e1.ReadInProgress == 0);
321
322 /* Get the forward and back pointers */
323 OldFlink = Pfn->u1.Flink;
324 OldBlink = Pfn->u2.Blink;
325
326 /* Check if the next entry is the list head */
328 {
329 /* It is not, so set the backlink of the actual entry, to our backlink */
331 }
332 else
333 {
334 /* Set the list head's backlink instead */
335 ListHead->Blink = OldBlink;
336 }
337
338 /* Check if the back entry is the list head */
340 {
341 /* It is not, so set the backlink of the actual entry, to our backlink */
343 }
344 else
345 {
346 /* Set the list head's backlink instead */
347 ListHead->Flink = OldFlink;
348 }
349
350 /* ReactOS Hack */
351 Pfn->OriginalPte.u.Long = 0;
352
353 /* We are not on a list anymore */
354 Pfn->u1.Flink = Pfn->u2.Blink = 0;
355
356 /* Remove one entry from the list */
357 ListHead->Total--;
358
359 ASSERT_LIST_INVARIANT(ListHead);
360}
Referenced by MiDeletePte(), MiDispatchFault(), MiResolveTransitionFault(), and MiSegmentDelete().
◆ MiUnlockProcessWorkingSet()
Definition at line 1197 of file miarm.h.
1199{
1200 /* Make sure we are the owner of a safe acquisition */
1203
1204 /* The thread doesn't own it anymore */
1207
1208 /* Release the lock and re-enable APCs */
1210 KeLeaveGuardedRegion();
1211}
FORCEINLINE VOID ExReleasePushLockExclusive(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1255
Referenced by MiLockVirtualMemory(), MiUnlockProcessWorkingSetForFault(), MiUnlockVirtualMemory(), MmArmAccessFault(), MmFreeMemoryArea(), MmInitializeProcessAddressSpace(), MmProbeAndLockPages(), and MmTrimUserMemory().
◆ MiUnlockProcessWorkingSetForFault()
| FORCEINLINE VOID MiUnlockProcessWorkingSetForFault | ( | IN PEPROCESS | Process, |
| IN PETHREAD | Thread, | ||
| OUT PBOOLEAN | Safe, | ||
| OUT PBOOLEAN | Shared | ||
| ) |
Definition at line 1471 of file miarm.h.
1475{
1477
1478 /* Check if the current owner is unsafe */
1480 {
1481 /* Release unsafely */
1483 *Safe = FALSE;
1484 *Shared = FALSE;
1485 }
1487 {
1488 /* Owner is safe and exclusive, release normally */
1490 *Safe = TRUE;
1491 *Shared = FALSE;
1492 }
1493 else
1494 {
1495 /* Owner is shared (implies safe), release normally */
1497 *Safe = TRUE;
1498 *Shared = TRUE;
1499 }
1500}
FORCEINLINE VOID MiUnlockProcessWorkingSetShared(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1218
FORCEINLINE VOID MiUnlockProcessWorkingSet(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1197
Referenced by MiGetPageProtection(), and MiMakeSystemAddressValid().
◆ MiUnlockProcessWorkingSetShared()
Definition at line 1218 of file miarm.h.
1220{
1221 /* Make sure we are the owner of a safe acquisition (because shared) */
1224
1225 /* Ensure we are in a shared acquisition */
1228
1229 /* Don't claim the lock anylonger */
1231
1232 /* Release the lock and re-enable APCs */
1234 KeLeaveGuardedRegion();
1235}
FORCEINLINE VOID ExReleasePushLockShared(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1216
Referenced by MiQueryMemoryBasicInformation(), MiUnlockProcessWorkingSetForFault(), MmAccessFault(), MmGetPageFileMapping(), MmGetPageProtect(), MmGetPfnForProcess(), MmIsDisabledPage(), MmIsPagePresent(), and MmIsPageSwapEntry().
◆ MiUnlockProcessWorkingSetUnsafe()
Definition at line 1242 of file miarm.h.
1244{
1245 /* Make sure we are the owner of an unsafe acquisition */
1250
1251 /* No longer unsafe */
1252 Process->Vm.Flags.AcquiredUnsafe = 0;
1253
1254 /* The thread doesn't own it anymore */
1257
1258 /* Release the lock but don't touch APC state */
1261}
Referenced by _Success_(), MiDecommitPages(), MiInsertVadEx(), MiMapLockedPagesInUserSpace(), MiProtectVirtualMemory(), MiRemoveMappedView(), MiUnlockProcessWorkingSetForFault(), MiUnmapLockedPagesInUserSpace(), MmCleanProcessAddressSpace(), MmCreatePageFileMapping(), MmCreateVirtualMappingUnsafeEx(), MmDeletePageFileMapping(), MmDeleteTeb(), MmInsertMemoryArea(), MmSetDirtyBit(), MmSetPageProtect(), NtAllocateVirtualMemory(), and NtFreeVirtualMemory().
◆ MiUnlockWorkingSet()
| FORCEINLINE VOID MiUnlockWorkingSet | ( | IN PETHREAD | Thread, |
| IN PMMSUPPORT | WorkingSet | ||
| ) |
Definition at line 1354 of file miarm.h.
1356{
1357 /* Working set should be in global memory */
1359
1360 /* Which working set is this? */
1362 {
1363 /* Release the system working set */
1367 }
1368 else if (WorkingSet->Flags.SessionSpace)
1369 {
1370 /* Release the session working set */
1374 }
1375 else
1376 {
1377 /* Release the process working set */
1381 }
1382
1383 /* Release the working set lock */
1384 ExReleasePushLockExclusive(&WorkingSet->WorkingSetMutex);
1385
1386 /* Unblock APCs */
1387 KeLeaveGuardedRegion();
1388}
Referenced by MiDeleteSystemPageableVm(), MiSetPagingOfDriver(), MmAdjustWorkingSetSize(), MmArmAccessFault(), MmFreeMemoryArea(), MmInsertMemoryArea(), and MmWorkingSetManager().
◆ MiUnlockWorkingSetShared()
| FORCEINLINE VOID MiUnlockWorkingSetShared | ( | _In_ PETHREAD | Thread, |
| _In_ PMMSUPPORT | WorkingSet | ||
| ) |
Definition at line 1392 of file miarm.h.
1395{
1396 /* Working set should be in global memory */
1398
1399 /* Which working set is this? */
1401 {
1402 /* Release the system working set */
1406 }
1407 else if (WorkingSet->Flags.SessionSpace)
1408 {
1409 /* Release the session working set */
1413 }
1414 else
1415 {
1416 /* Release the process working set */
1420 }
1421
1422 /* Release the working set lock */
1423 ExReleasePushLockShared(&WorkingSet->WorkingSetMutex);
1424
1425 /* Unblock APCs */
1426 KeLeaveGuardedRegion();
1427}
Referenced by MmAccessFault(), and MmWorkingSetManager().
◆ MiWriteProtectSystemImage()
Definition at line 2481 of file sysldr.c.
2483{
2484 PIMAGE_NT_HEADERS NtHeaders;
2485 PIMAGE_SECTION_HEADER SectionHeaders, Section;
2487 PVOID SectionBase, SectionEnd;
2488 ULONG SectionSize;
2489 ULONG Protection;
2490 PMMPTE FirstPte, LastPte;
2491
2492 /* Check if the registry setting is on or not */
2494 {
2495 /* Ignore section protection */
2496 return;
2497 }
2498
2499 /* Large page mapped images are not supported */
2501
2502 /* Session images are not yet supported */
2504
2505 /* Get the NT headers */
2506 NtHeaders = RtlImageNtHeader(ImageBase);
2508 {
2510 return;
2511 }
2512
2513 /* Don't touch NT4 drivers */
2516 {
2518 return;
2519 }
2520
2521 /* Get the section headers */
2522 SectionHeaders = IMAGE_FIRST_SECTION(NtHeaders);
2523
2524 /* Get the base address of the first section */
2526
2527 /* Start protecting the image header as R/W */
2528 FirstPte = MiAddressToPte(ImageBase);
2529 LastPte = MiAddressToPte(SectionBase) - 1;
2531 if (LastPte >= FirstPte)
2532 {
2533 MiSetSystemCodeProtection(FirstPte, LastPte, Protection);
2534 }
2535
2536 /* Loop the sections */
2538 {
2539 /* Get the section base address and size */
2540 Section = &SectionHeaders[i];
2543
2544 /* Get the first PTE of this section */
2545 FirstPte = MiAddressToPte(SectionBase);
2546
2547 /* Check for overlap with the previous range */
2548 if (FirstPte == LastPte)
2549 {
2550 /* Combine the old and new protection by ORing them */
2552
2553 /* Update the protection for this PTE */
2554 MiSetSystemCodeProtection(FirstPte, FirstPte, Protection);
2555
2556 /* Skip this PTE */
2557 FirstPte++;
2558 }
2559
2560 /* There can not be gaps! */
2561 NT_ASSERT(FirstPte == (LastPte + 1));
2562
2563 /* Get the end of the section and the last PTE */
2564 SectionEnd = Add2Ptr(SectionBase, SectionSize - 1);
2566 LastPte = MiAddressToPte(SectionEnd);
2567
2568 /* If there are no more pages (after an overlap), skip this section */
2569 if (LastPte < FirstPte)
2570 {
2571 NT_ASSERT(FirstPte == (LastPte + 1));
2572 continue;
2573 }
2574
2575 /* Get the section protection */
2577
2578 /* Update the protection for this section */
2579 MiSetSystemCodeProtection(FirstPte, LastPte, Protection);
2580 }
2581
2582 /* Image should end with the last section */
2585 {
2587 ImageBase,
2589 i,
2590 Section->VirtualAddress,
2591 Section->SizeOfRawData,
2593 }
2594}
Definition: ntddk_ex.h:181
WORD MajorOperatingSystemVersion
Definition: ntddk_ex.h:160
Definition: pedump.c:280
union _IMAGE_SECTION_HEADER::@1693 Misc
VOID NTAPI MiSetSystemCodeProtection(_In_ PMMPTE FirstPte, _In_ PMMPTE LastPte, _In_ ULONG Protection)
Definition: sysldr.c:2442
Referenced by MmInitSystem(), and MmLoadSystemImage().
◆ MiZeroPhysicalPage()
| VOID NTAPI MiZeroPhysicalPage | ( | IN PFN_NUMBER | PageFrameIndex | ) |
Definition at line 122 of file pfnlist.c.
123{
127
128 /* Map in hyperspace, then wipe it using XMMI or MEMSET */
133}
VOID NTAPI MiUnmapPageInHyperSpace(IN PEPROCESS Process, IN PVOID Address, IN KIRQL OldIrql)
Definition: hypermap.c:91
PVOID NTAPI MiMapPageInHyperSpace(IN PEPROCESS Process, IN PFN_NUMBER Page, IN PKIRQL OldIrql)
Definition: hypermap.c:28
◆ MM_ANY_WS_LOCK_HELD()
| FORCEINLINE BOOLEAN MM_ANY_WS_LOCK_HELD | ( | IN PETHREAD | Thread | ) |
Definition at line 1055 of file miarm.h.
1056{
1057 /* If any of these are held, return TRUE */
1064}
Referenced by MiLockProcessWorkingSet(), MiLockProcessWorkingSetShared(), MiLockProcessWorkingSetUnsafe(), MiLockWorkingSet(), MiLockWorkingSetShared(), MmRebalanceMemoryConsumersAndWait(), and TrimWsList().
◆ MM_ANY_WS_LOCK_HELD_EXCLUSIVE()
| FORCEINLINE BOOLEAN MM_ANY_WS_LOCK_HELD_EXCLUSIVE | ( | _In_ PETHREAD | Thread | ) |
Definition at line 1068 of file miarm.h.
1069{
1073}
Referenced by MiDeletePte(), MiInsertInWorkingSetList(), and RemoveFromWsList().
◆ MmArmAccessFault()
| NTSTATUS NTAPI MmArmAccessFault | ( | IN ULONG | FaultCode, |
| IN PVOID | Address, | ||
| IN KPROCESSOR_MODE | Mode, | ||
| IN PVOID | TrapInformation | ||
| ) |
Definition at line 1698 of file pagfault.c.
1702{
1707#if (_MI_PAGING_LEVELS >= 3)
1709#if (_MI_PAGING_LEVELS == 4)
1711#endif
1712#endif
1714 PETHREAD CurrentThread;
1715 PEPROCESS CurrentProcess;
1717 PMMSUPPORT WorkingSet;
1718 ULONG ProtectionCode;
1720 PFN_NUMBER PageFrameIndex;
1722 BOOLEAN IsSessionAddress;
1723 PMMPFN Pfn1;
1725
1726 /* Check for page fault on high IRQL */
1728 {
1729#if (_MI_PAGING_LEVELS < 3)
1730 /* Could be a page table for paged pool, which we'll allow */
1733#endif
1734 /* Check if any of the top-level pages are invalid */
1735 if (
1738#endif
1741#endif
1744 {
1745 /* This fault is not valid, print out some debugging help */
1747 Address,
1748 OldIrql);
1749 if (TrapInformation)
1750 {
1751 PKTRAP_FRAME TrapFrame = TrapInformation;
1752#ifdef _M_IX86
1756#elif defined(_M_AMD64)
1760#elif defined(_M_ARM)
1762 DbgPrint("MM:***R0 %p, R1 %p R2 %p, R3 %p\n", TrapFrame->R0, TrapFrame->R1, TrapFrame->R2, TrapFrame->R3);
1763 DbgPrint("MM:***R11 %p, R12 %p SP %p, LR %p\n", TrapFrame->R11, TrapFrame->R12, TrapFrame->Sp, TrapFrame->Lr);
1764#endif
1765 }
1766
1767 /* Tell the trap handler to fail */
1769 }
1770
1771 /* Not yet implemented in ReactOS */
1773 ASSERT((!MI_IS_NOT_PRESENT_FAULT(FaultCode) && MI_IS_PAGE_COPY_ON_WRITE(PointerPte)) == FALSE);
1774
1775 /* Check if this was a write */
1777 {
1778 /* Was it to a read-only page? */
1782 {
1783 /* Crash with distinguished bugcheck code */
1784 KeBugCheckEx(ATTEMPTED_WRITE_TO_READONLY_MEMORY,
1787 (ULONG_PTR)TrapInformation,
1788 10);
1789 }
1790 }
1791
1792 /* Nothing is actually wrong */
1795 }
1796
1797 /* Check for kernel fault address */
1799 {
1800 /* Bail out, if the fault came from user mode */
1802
1803#if (_MI_PAGING_LEVELS == 2)
1806#endif
1807
1808 /* Check if the higher page table entries are invalid */
1809 if (
1811 /* AMD64 system, check if PXE is invalid */
1813#endif
1815 /* PAE/AMD64 system, check if PPE is invalid */
1817#endif
1818 /* Always check if the PDE is valid */
1820 {
1821 /* PXE/PPE/PDE (still) not valid, kill the system */
1822 KeBugCheckEx(PAGE_FAULT_IN_NONPAGED_AREA,
1824 FaultCode,
1825 (ULONG_PTR)TrapInformation,
1826 2);
1827 }
1828
1829 /* Not handling session faults yet */
1831
1832 /* The PDE is valid, so read the PTE */
1833 TempPte = *PointerPte;
1835 {
1836 /* Check if this was system space or session space */
1837 if (!IsSessionAddress)
1838 {
1839 /* Check if the PTE is still valid under PFN lock */
1840 OldIrql = MiAcquirePfnLock();
1841 TempPte = *PointerPte;
1843 {
1844 /* Check if this was a write */
1846 {
1847 /* Was it to a read-only page? */
1851 {
1852 /* Crash with distinguished bugcheck code */
1853 KeBugCheckEx(ATTEMPTED_WRITE_TO_READONLY_MEMORY,
1856 (ULONG_PTR)TrapInformation,
1857 11);
1858 }
1859 }
1860
1861 /* Check for execution of non-executable memory */
1864 {
1865 KeBugCheckEx(ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY,
1868 (ULONG_PTR)TrapInformation,
1869 1);
1870 }
1871 }
1872
1873 /* Release PFN lock and return all good */
1874 MiReleasePfnLock(OldIrql);
1876 }
1877 }
1878#if (_MI_PAGING_LEVELS == 2)
1879 /* Check if this was a session PTE that needs to remap the session PDE */
1881 {
1882 /* Do the remapping */
1885 {
1886 /* It failed, this address is invalid */
1887 KeBugCheckEx(PAGE_FAULT_IN_NONPAGED_AREA,
1889 FaultCode,
1890 (ULONG_PTR)TrapInformation,
1891 6);
1892 }
1893 }
1894#else
1895
1897
1898#endif
1899
1900 /* Check for a fault on the page table or hyperspace */
1902 {
1903#if (_MI_PAGING_LEVELS < 3)
1904 /* Windows does this check but I don't understand why -- it's done above! */
1906#endif
1907 /* Handle this as a user mode fault */
1908 goto UserFault;
1909 }
1910
1911 /* Get the current thread */
1912 CurrentThread = PsGetCurrentThread();
1913
1914 /* What kind of address is this */
1915 if (!IsSessionAddress)
1916 {
1917 /* Use the system working set */
1918 WorkingSet = &MmSystemCacheWs;
1919 CurrentProcess = NULL;
1920
1921 /* Make sure we don't have a recursive working set lock */
1923 (CurrentThread->OwnsProcessWorkingSetShared) ||
1924 (CurrentThread->OwnsSystemWorkingSetExclusive) ||
1925 (CurrentThread->OwnsSystemWorkingSetShared) ||
1926 (CurrentThread->OwnsSessionWorkingSetExclusive) ||
1927 (CurrentThread->OwnsSessionWorkingSetShared))
1928 {
1929 /* Fail */
1931 }
1932 }
1933 else
1934 {
1935 /* Use the session process and working set */
1936 CurrentProcess = HYDRA_PROCESS;
1938
1939 /* Make sure we don't have a recursive working set lock */
1941 (CurrentThread->OwnsSessionWorkingSetShared))
1942 {
1943 /* Fail */
1945 }
1946 }
1947RetryKernel:
1948 /* Acquire the working set lock */
1950 MiLockWorkingSet(CurrentThread, WorkingSet);
1951
1952 /* Re-read PTE now that we own the lock */
1953 TempPte = *PointerPte;
1955 {
1956 /* Check if this was a write */
1958 {
1959 /* Was it to a read-only page that is not copy on write? */
1964 {
1965 /* Case not yet handled */
1966 ASSERT(!IsSessionAddress);
1967
1968 /* Crash with distinguished bugcheck code */
1969 KeBugCheckEx(ATTEMPTED_WRITE_TO_READONLY_MEMORY,
1971 TempPte.u.Long,
1972 (ULONG_PTR)TrapInformation,
1973 12);
1974 }
1975 }
1976
1977 /* Check for execution of non-executable memory */
1980 {
1981 KeBugCheckEx(ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY,
1984 (ULONG_PTR)TrapInformation,
1985 2);
1986 }
1987
1988 /* Check for read-only write in session space */
1989 if ((IsSessionAddress) &&
1990 MI_IS_WRITE_ACCESS(FaultCode) &&
1992 {
1993 /* Sanity check */
1995
1996 /* Was this COW? */
1998 {
1999 /* Then this is not allowed */
2000 KeBugCheckEx(ATTEMPTED_WRITE_TO_READONLY_MEMORY,
2003 (ULONG_PTR)TrapInformation,
2004 13);
2005 }
2006
2007 /* Otherwise, handle COW */
2009 }
2010
2011 /* Release the working set */
2012 MiUnlockWorkingSet(CurrentThread, WorkingSet);
2013 KeLowerIrql(LockIrql);
2014
2015 /* Otherwise, the PDE was probably invalid, and all is good now */
2017 }
2018
2019 /* Check one kind of prototype PTE */
2021 {
2022 /* Make sure protected pool is on, and that this is a pool address */
2026 MmSizeOfNonPagedPoolInBytes))) ||
2029 {
2030 /* Bad boy, bad boy, whatcha gonna do, whatcha gonna do when ARM3 comes for you! */
2031 KeBugCheckEx(DRIVER_CAUGHT_MODIFYING_FREED_POOL,
2033 FaultCode,
2034 Mode,
2035 4);
2036 }
2037
2038 /* Get the prototype PTE! */
2040
2041 /* Do we need to locate the prototype PTE in session space? */
2042 if ((IsSessionAddress) &&
2044 {
2045 /* Yep, go find it as well as the VAD for it */
2047 &ProtectionCode,
2048 &Vad);
2050 }
2051 }
2052 else
2053 {
2054 /* We don't implement transition PTEs */
2056
2057 /* Check for no-access PTE */
2059 {
2060 /* Bugcheck the system! */
2061 KeBugCheckEx(PAGE_FAULT_IN_NONPAGED_AREA,
2063 FaultCode,
2064 (ULONG_PTR)TrapInformation,
2065 1);
2066 }
2067
2068 /* Check for no protecton at all */
2070 {
2071 /* Bugcheck the system! */
2072 KeBugCheckEx(PAGE_FAULT_IN_NONPAGED_AREA,
2074 FaultCode,
2075 (ULONG_PTR)TrapInformation,
2076 0);
2077 }
2078 }
2079
2080 /* Check for demand page */
2082 !(ProtoPte) &&
2083 !(IsSessionAddress) &&
2085 {
2086 /* Get the protection code */
2089 {
2090 /* Bugcheck the system! */
2091 KeBugCheckEx(ATTEMPTED_WRITE_TO_READONLY_MEMORY,
2093 TempPte.u.Long,
2094 (ULONG_PTR)TrapInformation,
2095 14);
2096 }
2097 }
2098
2099 /* Now do the real fault handling */
2101 Address,
2102 PointerPte,
2103 ProtoPte,
2104 FALSE,
2105 CurrentProcess,
2106 TrapInformation,
2107 NULL);
2108
2109 /* Release the working set */
2111 MiUnlockWorkingSet(CurrentThread, WorkingSet);
2112 KeLowerIrql(LockIrql);
2113
2115 {
2117 goto RetryKernel;
2118 }
2119
2120 /* We are done! */
2123 }
2124
2125 /* This is a user fault */
2126UserFault:
2127 CurrentThread = PsGetCurrentThread();
2129
2130 /* Lock the working set */
2131 MiLockProcessWorkingSet(CurrentProcess, CurrentThread);
2132
2133 ProtectionCode = MM_INVALID_PROTECTION;
2134
2135#if (_MI_PAGING_LEVELS == 4)
2136 /* Check if the PXE is valid */
2138 {
2139 /* Right now, we only handle scenarios where the PXE is totally empty */
2141
2142 /* This is only possible for user mode addresses! */
2144
2145 /* Check if we have a VAD */
2148 {
2149 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2151 }
2152
2153 /* Resolve a demand zero fault */
2155 PointerPxe,
2156 MM_EXECUTE_READWRITE,
2157 CurrentProcess,
2158 MM_NOIRQL);
2160 {
2161 goto ExitUser;
2162 }
2163
2164 /* We should come back with a valid PXE */
2166 }
2167#endif
2168
2169#if (_MI_PAGING_LEVELS >= 3)
2170 /* Check if the PPE is valid */
2172 {
2173 /* Right now, we only handle scenarios where the PPE is totally empty */
2175
2176 /* This is only possible for user mode addresses! */
2178
2179 /* Check if we have a VAD, unless we did this already */
2181 {
2183 }
2184
2186 {
2187 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2189 }
2190
2191 /* Resolve a demand zero fault */
2193 PointerPpe,
2194 MM_EXECUTE_READWRITE,
2195 CurrentProcess,
2196 MM_NOIRQL);
2198 {
2199 goto ExitUser;
2200 }
2201
2202 /* We should come back with a valid PPE */
2204 MiIncrementPageTableReferences(PointerPde);
2205 }
2206#endif
2207
2208 /* Check if the PDE is invalid */
2210 {
2211 /* Right now, we only handle scenarios where the PDE is totally empty */
2213
2214 /* And go dispatch the fault on the PDE. This should handle the demand-zero */
2215#if MI_TRACE_PFNS
2216 UserPdeFault = TRUE;
2217#endif
2218 /* Check if we have a VAD, unless we did this already */
2220 {
2222 }
2223
2225 {
2226#if (_MI_PAGING_LEVELS == 2)
2227 /* Could be a page table for paged pool */
2229#endif
2230 /* Has the code above changed anything -- is this now a valid PTE? */
2232
2233 /* Either this was a bogus VA or we've fixed up a paged pool PDE */
2234 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2236 }
2237
2238 /* Resolve a demand zero fault */
2240 PointerPde,
2241 MM_EXECUTE_READWRITE,
2242 CurrentProcess,
2243 MM_NOIRQL);
2245 {
2246 goto ExitUser;
2247 }
2248
2249#if _MI_PAGING_LEVELS >= 3
2250 MiIncrementPageTableReferences(PointerPte);
2251#endif
2252
2253#if MI_TRACE_PFNS
2254 UserPdeFault = FALSE;
2255 /* Update debug info */
2256 if (TrapInformation)
2257 MiGetPfnEntry(PointerPde->u.Hard.PageFrameNumber)->CallSite = (PVOID)((PKTRAP_FRAME)TrapInformation)->Eip;
2258 else
2260#endif
2261 /* We should come back with APCs enabled, and with a valid PDE */
2264 }
2265 else
2266 {
2267 /* Not yet implemented in ReactOS */
2269 }
2270
2271 /* Now capture the PTE. */
2272 TempPte = *PointerPte;
2273
2274 /* Check if the PTE is valid */
2276 {
2277 /* Check if this is a write on a readonly PTE */
2279 {
2280 /* Is this a copy on write PTE? */
2282 {
2283 PFN_NUMBER PageFrameIndex, OldPageFrameIndex;
2284 PMMPFN Pfn1;
2285
2286 LockIrql = MiAcquirePfnLock();
2287
2289
2291 MI_SET_PROCESS(CurrentProcess);
2292
2293 /* Allocate a new page and copy it */
2295 if (PageFrameIndex == 0)
2296 {
2297 MiReleasePfnLock(LockIrql);
2299 goto ExitUser;
2300 }
2302
2303 MiCopyPfn(PageFrameIndex, OldPageFrameIndex);
2304
2305 /* Dereference whatever this PTE is referencing */
2306 Pfn1 = MI_PFN_ELEMENT(OldPageFrameIndex);
2309 ProtoPte = Pfn1->PteAddress;
2311
2312 /* And make a new shiny one with our page */
2315 TempPte.u.Hard.Write = 1;
2316 TempPte.u.Hard.CopyOnWrite = 0;
2317
2319
2320 MiReleasePfnLock(LockIrql);
2321
2322 /* Return the status */
2323 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2325 }
2326
2327 /* Is this a read-only PTE? */
2329 {
2330 /* Return the status */
2331 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2333 }
2334 }
2335
2336#if _MI_HAS_NO_EXECUTE
2337 /* Check for execution of non-executable memory */
2340 {
2341 /* Check if execute enable was set */
2343 {
2344 /* Fix up the PTE to be executable */
2347 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2349 }
2350
2351 /* Return the status */
2352 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2354 }
2355#endif
2356
2357 /* The fault has already been resolved by a different thread */
2358 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2360 }
2361
2362 /* Quick check for demand-zero */
2365 {
2366 /* Resolve the fault */
2368 PointerPte,
2369 TempPte.u.Soft.Protection,
2370 CurrentProcess,
2371 MM_NOIRQL);
2373 {
2374 goto ExitUser;
2375 }
2376
2377#if MI_TRACE_PFNS
2378 /* Update debug info */
2379 if (TrapInformation)
2380 MiGetPfnEntry(PointerPte->u.Hard.PageFrameNumber)->CallSite = (PVOID)((PKTRAP_FRAME)TrapInformation)->Eip;
2381 else
2383#endif
2384
2385 /* Return the status */
2386 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2388 }
2389
2390 /* Check for zero PTE */
2392 {
2393 /* Check if this address range belongs to a valid allocation (VAD) */
2396 {
2397#if (_MI_PAGING_LEVELS == 2)
2398 /* Could be a page table for paged pool */
2400#endif
2401 /* Has the code above changed anything -- is this now a valid PTE? */
2403
2404 /* Either this was a bogus VA or we've fixed up a paged pool PDE */
2405 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2407 }
2408
2409 /*
2410 * Check if this is a real user-mode address or actually a kernel-mode
2411 * page table for a user mode address
2412 */
2418#endif
2419#endif
2420 )
2421 {
2422 /* Add an additional page table reference */
2424 }
2425
2426 /* Is this a guard page? */
2428 {
2429 /* The VAD protection cannot be MM_DECOMMIT! */
2431
2432 /* Remove the bit */
2433 TempPte.u.Soft.Protection = ProtectionCode & ~MM_GUARDPAGE;
2435
2436 /* Not supported */
2438 ASSERT(CurrentThread->ApcNeeded == 0);
2439
2440 /* Drop the working set lock */
2441 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2443
2444 /* Handle stack expansion */
2446 }
2447
2448 /* Did we get a prototype PTE back? */
2449 if (!ProtoPte)
2450 {
2451 /* Is this PTE actually part of the PDE-PTE self-mapping directory? */
2453 {
2454 /* Then it's really a demand-zero PDE (on behalf of user-mode) */
2455#ifdef _M_ARM
2458#else
2460#endif
2461 }
2462 else
2463 {
2464 /* No, create a new PTE. First, write the protection */
2465 TempPte.u.Soft.Protection = ProtectionCode;
2467 }
2468
2469 /* Lock the PFN database since we're going to grab a page */
2470 OldIrql = MiAcquirePfnLock();
2471
2472 /* Make sure we have enough pages */
2473 //ASSERT(MmAvailablePages >= 32);
2474
2475 /* Try to get a zero page */
2480 if (!PageFrameIndex)
2481 {
2482 /* Grab a page out of there. Later we should grab a colored zero page */
2484
2485 /* Release the lock since we need to do some zeroing */
2486 MiReleasePfnLock(OldIrql);
2487
2488 if (PageFrameIndex == 0)
2489 {
2491 goto ExitUser;
2492 }
2493
2494 /* Zero out the page, since it's for user-mode */
2495 MiZeroPfn(PageFrameIndex);
2496
2497 /* Grab the lock again so we can initialize the PFN entry */
2498 OldIrql = MiAcquirePfnLock();
2499 }
2500
2501 /* Initialize the PFN entry now */
2502 MiInitializePfn(PageFrameIndex, PointerPte, 1);
2503
2504 /* Increment the count of pages in the process */
2505 CurrentProcess->NumberOfPrivatePages++;
2506
2507 /* One more demand-zero fault */
2508 KeGetCurrentPrcb()->MmDemandZeroCount++;
2509
2510 /* And we're done with the lock */
2511 MiReleasePfnLock(OldIrql);
2512
2513 /* Fault on user PDE, or fault on user PTE? */
2515 {
2516 /* User fault, build a user PTE */
2518 PointerPte,
2520 PageFrameIndex);
2521 }
2522 else
2523 {
2524 /* This is a user-mode PDE, create a kernel PTE for it */
2526 PointerPte,
2528 PageFrameIndex);
2529 }
2530
2531 /* Write the dirty bit for writeable pages */
2533
2534 /* And now write down the PTE, making the address valid */
2536 Pfn1 = MI_PFN_ELEMENT(PageFrameIndex);
2538
2539 /* Demand zero */
2541 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2543 }
2544
2545 /* We should have a valid protection here */
2546 ASSERT(ProtectionCode != 0x100);
2547
2548 /* Write the prototype PTE */
2550 TempPte.u.Soft.Protection = ProtectionCode;
2553 }
2554 else
2555 {
2556 /* Get the protection code and check if this is a proto PTE */
2559 {
2560 /* Do we need to go find the real PTE? */
2562 {
2563 /* Get the prototype pte and VAD for it */
2565 &ProtectionCode,
2566 &Vad);
2567 if (!ProtoPte)
2568 {
2570 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2572 }
2573 }
2574 else
2575 {
2576 /* Get the prototype PTE! */
2578
2579 /* Is it read-only */
2581 {
2582 /* Set read-only code */
2583 ProtectionCode = MM_READONLY;
2584 }
2585 else
2586 {
2587 /* Set unknown protection */
2588 ProtectionCode = 0x100;
2590 }
2591 }
2592 }
2593 }
2594
2595 /* Do we have a valid protection code? */
2596 if (ProtectionCode != 0x100)
2597 {
2598 /* Run a software access check first, including to detect guard pages */
2600 !MI_IS_NOT_PRESENT_FAULT(FaultCode),
2601 Mode,
2602 ProtectionCode,
2603 TrapInformation,
2604 FALSE);
2606 {
2607 /* Not supported */
2608 ASSERT(CurrentThread->ApcNeeded == 0);
2609
2610 /* Drop the working set lock */
2611 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2613
2614 /* Did we hit a guard page? */
2616 {
2617 /* Handle stack expansion */
2619 }
2620
2621 /* Otherwise, fail back to the caller directly */
2623 }
2624 }
2625
2626 /* Dispatch the fault */
2628 Address,
2629 PointerPte,
2630 ProtoPte,
2631 FALSE,
2632 CurrentProcess,
2633 TrapInformation,
2634 Vad);
2635
2636ExitUser:
2637
2638 /* Return the status */
2640 MiUnlockProcessWorkingSet(CurrentProcess, CurrentThread);
2641
2643 {
2645 goto UserFault;
2646 }
2647
2649}
#define MI_IS_SYSTEM_PAGE_TABLE_ADDRESS(Address)
Definition: miarm.h:194
FORCEINLINE VOID MI_MAKE_HARDWARE_PTE_USER(IN PMMPTE NewPte, IN PMMPTE MappingPte, IN ULONG_PTR ProtectionMask, IN PFN_NUMBER PageFrameNumber)
Definition: miarm.h:831
FORCEINLINE VOID MI_WRITE_INVALID_PDE(IN PMMPDE PointerPde, IN MMPDE InvalidPde)
Definition: miarm.h:1038
FORCEINLINE VOID MI_MAKE_HARDWARE_PTE(IN PMMPTE NewPte, IN PMMPTE MappingPte, IN ULONG_PTR ProtectionMask, IN PFN_NUMBER PageFrameNumber)
Definition: miarm.h:811
FORCEINLINE VOID MI_UPDATE_VALID_PTE(IN PMMPTE PointerPte, IN MMPTE TempPte)
Definition: miarm.h:981
VOID NTAPI MiInitializePfn(IN PFN_NUMBER PageFrameIndex, IN PMMPTE PointerPte, IN BOOLEAN Modified)
Definition: pfnlist.c:970
#define MI_IS_PAGE_TABLE_OR_HYPER_ADDRESS(Address)
Definition: miarm.h:197
FORCEINLINE USHORT MiIncrementPageTableReferences(IN PVOID Address)
Definition: miarm.h:2475
FORCEINLINE PFN_NUMBER MiRemoveZeroPageSafe(IN ULONG Color)
Definition: miarm.h:2409
VOID NTAPI MiCopyPfn(_In_ PFN_NUMBER DestPage, _In_ PFN_NUMBER SrcPage)
Definition: pagfault.c:533
static NTSTATUS NTAPI MiAccessCheck(IN PMMPTE PointerPte, IN BOOLEAN StoreInstruction, IN KPROCESSOR_MODE PreviousMode, IN ULONG_PTR ProtectionMask, IN PVOID TrapFrame, IN BOOLEAN LockHeld)
Definition: pagfault.c:172
static NTSTATUS NTAPI MiResolveDemandZeroFault(IN PVOID Address, IN PMMPTE PointerPte, IN ULONG Protection, IN PEPROCESS Process, IN KIRQL OldIrql)
Definition: pagfault.c:599
static PMMPTE NTAPI MiCheckVirtualAddress(IN PVOID VirtualAddress, OUT PULONG ProtectCode, OUT PMMVAD *ProtoVad)
Definition: pagfault.c:241
VOID NTAPI MmRebalanceMemoryConsumersAndWait(VOID)
Definition: balance.c:300
NTSTATUS FASTCALL MiCheckPdeForPagedPool(IN PVOID Address)
Definition: pagfault.c:479
static NTSTATUS NTAPI MiCheckForUserStackOverflow(IN PVOID Address, IN PVOID TrapInformation)
Definition: pagfault.c:34
NTSTATUS NTAPI MiDispatchFault(IN ULONG FaultCode, IN PVOID Address, IN PMMPTE PointerPte, IN PMMPTE PointerProtoPte, IN BOOLEAN Recursive, IN PEPROCESS Process, IN PVOID TrapInformation, IN PMMVAD Vad)
Definition: pagfault.c:1338
Definition: ketypes.h:406
Referenced by MmAccessFault().
◆ MmArmInitSystem()
Definition at line 2037 of file mminit.c.
2039{
2044 PFN_NUMBER PageCount;
2045#if DBG
2047 PMMPTE PointerPte, TestPte;
2049#endif
2050
2051 /* Dump memory descriptors */
2053
2054 //
2055 // Instantiate memory that we don't consider RAM/usable
2056 // We use the same exclusions that Windows does, in order to try to be
2057 // compatible with WinLDR-style booting
2058 //
2064 if (Phase == 0)
2065 {
2066 /* Count physical pages on the system */
2067 MiScanMemoryDescriptors(LoaderBlock);
2068
2069 /* Initialize the phase 0 temporary event */
2071
2072 /* Set all the events to use the temporary event for now */
2079
2080 //
2081 // Default throttling limits for Cc
2082 // May be ajusted later on depending on system type
2083 //
2084 MmThrottleTop = 450;
2085 MmThrottleBottom = 127;
2086
2087 //
2088 // Define the basic user vs. kernel address space separation
2089 //
2093
2094 /* Highest PTE and PDE based on the addresses above */
2097#if (_MI_PAGING_LEVELS >= 3)
2099#if (_MI_PAGING_LEVELS >= 4)
2101#endif
2102#endif
2103 //
2104 // Get the size of the boot loader's image allocations and then round
2105 // that region up to a PDE size, so that any PDEs we might create for
2106 // whatever follows are separate from the PDEs that boot loader might've
2107 // already created (and later, we can blow all that away if we want to).
2108 //
2113
2114 /* Initialize session space address layout */
2115 MiInitializeSessionSpaceLayout();
2116
2117 /* Set the based section highest address */
2119
2120 /* Loop all 8 standby lists */
2122 {
2123 /* Initialize them */
2128 }
2129
2130 /* Initialize the user mode image list */
2132
2133 /* Initalize the Working set list */
2135
2136 /* Initialize critical section timeout value (relative time is negative) */
2138
2139 /* Initialize the paged pool mutex and the section commit mutex */
2143
2144 /* Initialize the Loader Lock */
2146
2147 /* Set up the zero page event */
2149
2150 /* Initialize the dead stack S-LIST */
2152
2153 //
2154 // Check if this is a machine with less than 19MB of RAM
2155 //
2156 PageCount = MmNumberOfPhysicalPages;
2158 {
2159 //
2160 // Use the very minimum of system PTEs
2161 //
2162 MmNumberOfSystemPtes = 7000;
2163 }
2164 else
2165 {
2166 //
2167 // Use the default
2168 //
2169 MmNumberOfSystemPtes = 11000;
2171 {
2172 //
2173 // Double the amount of system PTEs
2174 //
2175 MmNumberOfSystemPtes <<= 1;
2176 }
2178 {
2179 //
2180 // Double the amount of system PTEs
2181 //
2182 MmNumberOfSystemPtes <<= 1;
2183 }
2185 {
2186 //
2187 // Add some extra PTEs for special pool
2188 //
2189 MmNumberOfSystemPtes += 0x6000;
2190 }
2191 }
2192
2195
2196 /* Check if no values are set for the heap limits */
2198 {
2200 }
2201
2203 {
2205 }
2206
2208 {
2210 }
2211
2213 {
2215 }
2216
2217 /* Initialize the working set lock */
2219
2220 /* Set commit limit */
2223
2224 /* Has the allocation fragment been setup? */
2226 {
2227 /* Use the default value */
2230 {
2231 /* On memory systems with less than 256MB, divide by 4 */
2233 }
2235 {
2236 /* On systems with less than 1GB, divide by 2 */
2238 }
2239 }
2240 else
2241 {
2242 /* Convert from 1KB fragments to pages */
2245
2246 /* Don't let it past the maximum */
2248 MI_MAX_ALLOCATION_FRAGMENT);
2249
2250 /* Don't let it too small either */
2252 MI_MIN_ALLOCATION_FRAGMENT);
2253 }
2254
2255 /* Check for kernel stack size that's too big */
2257 {
2258 /* Sanitize to default value */
2260 }
2261 else
2262 {
2263 /* Take the registry setting, and convert it into bytes */
2265
2266 /* Now align it to a page boundary */
2268
2269 /* Sanity checks */
2272
2273 /* Make sure it's not too low */
2275 }
2276
2277 /* Compute color information (L2 cache-separated paging lists) */
2278 MiComputeColorInformation();
2279
2280 // Calculate the number of bytes for the PFN database
2281 // then add the color tables and convert to pages
2285
2286 // We have to add one to the count here, because in the process of
2287 // shifting down to the page size, we actually ended up getting the
2288 // lower aligned size (so say, 0x5FFFF bytes is now 0x5F pages).
2289 // Later on, we'll shift this number back into bytes, which would cause
2290 // us to end up with only 0x5F000 bytes -- when we actually want to have
2291 // 0x60000 bytes.
2292 MxPfnAllocation++;
2293
2294 /* Initialize the platform-specific parts */
2295 MiInitMachineDependent(LoaderBlock);
2296
2297#if DBG
2298 /* Prototype PTEs are assumed to be in paged pool, so check if the math works */
2302 ASSERT(PointerPte == TestPte);
2303
2304 /* Try the last nonpaged pool address */
2308 ASSERT(PointerPte == TestPte);
2309
2310 /* Try a bunch of random addresses near the end of the address space */
2313 {
2316 ASSERT(PointerPte == TestPte);
2317 PointerPte++;
2318 }
2319
2320 /* Subsection PTEs are always in nonpaged pool, pick a random address to try */
2324 ASSERT(PointerPte == TestPte);
2325#endif
2326
2327 //
2328 // Build the physical memory block
2329 //
2331 IncludeType);
2332
2333 //
2334 // Allocate enough buffer for the PFN bitmap
2335 // Align it up to a 32-bit boundary
2336 //
2338 (((MmHighestPhysicalPage + 1) + 31) / 32) * 4,
2339 TAG_MM);
2341 {
2342 //
2343 // This is critical
2344 //
2345 KeBugCheckEx(INSTALL_MORE_MEMORY,
2346 MmNumberOfPhysicalPages,
2347 MmLowestPhysicalPage,
2348 MmHighestPhysicalPage,
2349 0x101);
2350 }
2351
2352 //
2353 // Initialize it and clear all the bits to begin with
2354 //
2356 Bitmap,
2359
2360 //
2361 // Loop physical memory runs
2362 //
2364 {
2365 //
2366 // Get the run
2367 //
2372
2373 //
2374 // Make sure it has pages inside it
2375 //
2377 {
2378 //
2379 // Set the bits in the PFN bitmap
2380 //
2382 }
2383 }
2384
2385 /* Look for large page cache entries that need caching */
2386 MiSyncCachedRanges();
2387
2388 /* Loop for HAL Heap I/O device mappings that need coherency tracking */
2389 MiAddHalIoMappings();
2390
2391 /* Set the initial resident page count */
2393
2394 /* Initialize large page structures on PAE/x64, and MmProcessList on x86 */
2395 MiInitializeLargePageSupport();
2396
2397 /* Check if the registry says any drivers should be loaded with large pages */
2398 MiInitializeDriverLargePageList();
2399
2400 /* Relocate the boot drivers into system PTE space and fixup their PFNs */
2401 MiReloadBootLoadedDrivers(LoaderBlock);
2402
2403 /* FIXME: Call out into Driver Verifier for initialization */
2404
2405 /* Check how many pages the system has */
2407 {
2408 /* Set small system */
2410 MmMaximumDeadKernelStacks = 0;
2411 }
2413 {
2414 /* Set small system and add 100 pages for the cache */
2416 MmSystemCacheWsMinimum += 100;
2417 MmMaximumDeadKernelStacks = 2;
2418 }
2419 else
2420 {
2421 /* Set medium system and add 400 pages for the cache */
2423 MmSystemCacheWsMinimum += 400;
2424 MmMaximumDeadKernelStacks = 5;
2425 }
2426
2427 /* Check for less than 24MB */
2429 {
2430 /* No more than 32 pages */
2431 MmSystemCacheWsMinimum = 32;
2432 }
2433
2434 /* Check for more than 32MB */
2436 {
2437 /* Check for product type being "Wi" for WinNT */
2439 {
2440 /* Then this is a large system */
2442 }
2443 else
2444 {
2445 /* For servers, we need 64MB to consider this as being large */
2447 {
2448 /* Set it as large */
2450 }
2451 }
2452 }
2453
2454 /* Check for more than 33 MB */
2456 {
2457 /* Add another 500 pages to the cache */
2458 MmSystemCacheWsMinimum += 500;
2459 }
2460
2461 /* Now setup the shared user data fields */
2464 SharedUserData->LargePageMinimum = 0;
2465
2466 /* Check for workstation (Wi for WinNT) */
2468 {
2469 /* Set Windows NT Workstation product type */
2471 MmProductType = 0;
2472
2473 /* For this product, we wait till the last moment to throttle */
2474 MmThrottleTop = 250;
2475 MmThrottleBottom = 30;
2476 }
2477 else
2478 {
2479 /* Check for LanMan server (La for LanmanNT) */
2481 {
2482 /* This is a domain controller */
2484 }
2485 else
2486 {
2487 /* Otherwise it must be a normal server (Se for ServerNT) */
2489 }
2490
2491 /* Set the product type, and make the system more aggressive with low memory */
2492 MmProductType = 1;
2493 MmMinimumFreePages = 81;
2494
2495 /* We will throttle earlier to preserve memory */
2496 MmThrottleTop = 450;
2497 MmThrottleBottom = 80;
2498 }
2499
2500 /* Update working set tuning parameters */
2502
2503 /* Finetune the page count by removing working set and NP expansion */
2508 {
2509 /* This should not happen */
2512 }
2513
2514 /* Define limits for system cache */
2515#ifdef _M_AMD64
2517#else
2518 MmSizeOfSystemCacheInPages = ((ULONG_PTR)MI_PAGED_POOL_START - (ULONG_PTR)MI_SYSTEM_CACHE_START) / PAGE_SIZE;
2519#endif
2520 MmSystemCacheEnd = (PVOID)((ULONG_PTR)MmSystemCacheStart + (MmSizeOfSystemCacheInPages * PAGE_SIZE) - 1);
2521#ifdef _M_AMD64
2523#else
2525#endif
2526
2527 /* Initialize the system cache */
2528 //MiInitializeSystemCache(MmSystemCacheWsMinimum, MmAvailablePages);
2529
2530 /* Update the commit limit */
2534
2535 /* Size up paged pool and build the shadow system page directory */
2536 MiBuildPagedPool();
2537
2538 /* Debugger physical memory support is now ready to be used */
2540
2541 /* Initialize the loaded module list */
2542 MiInitializeLoadedModuleList(LoaderBlock);
2543 }
2544
2545 //
2546 // Always return success for now
2547 //
2549}
VOID NTAPI MiAdjustWorkingSetManagerParameters(IN BOOLEAN Client)
Definition: mminit.c:1194
VOID NTAPI MiScanMemoryDescriptors(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:403
PPHYSICAL_MEMORY_DESCRIPTOR NTAPI MmInitializeMemoryLimits(IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN PBOOLEAN IncludeType)
Definition: mminit.c:1613
Definition: gdiplusheaders.h:379
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 GLint GLint j
Definition: glfuncs.h:250
VOID NTAPI MiInitializeDriverLargePageList(VOID)
Definition: largepag.c:68
struct _MMCOLOR_TABLES MMCOLOR_TABLES
struct _MMPTE * PMMPTE
FORCEINLINE VOID MI_MAKE_PROTOTYPE_PTE(IN PMMPTE NewPte, IN PMMPTE PointerPte)
Definition: mm.h:342
FORCEINLINE VOID MI_MAKE_SUBSECTION_PTE(_Out_ PMMPTE NewPte, _In_ PVOID Segment)
Definition: mm.h:328
BOOLEAN NTAPI MiInitializeLoadedModuleList(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: sysldr.c:2242
VOID NTAPI MiReloadBootLoadedDrivers(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: sysldr.c:1731
VOID NTAPI KeInitializeMutant(IN PKMUTANT Mutant, IN BOOLEAN InitialOwner)
Definition: mutex.c:22
NTSTATUS NTAPI MiInitMachineDependent(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:697
#define KERNEL_LARGE_STACK_SIZE
#define KERNEL_STACK_SIZE
#define SharedUserData
Definition: miarm.h:421
Definition: bidi.c:434
struct tagRun Run
FORCEINLINE VOID InitializeSListHead(_Out_ PSLIST_HEADER SListHead)
Definition: rtlfuncs.h:3368
◆ MmInitializeMemoryLimits()
| PPHYSICAL_MEMORY_DESCRIPTOR NTAPI MmInitializeMemoryLimits | ( | IN PLOADER_PARAMETER_BLOCK | LoaderBlock, |
| IN PBOOLEAN | IncludeType | ||
| ) |
Definition at line 1613 of file mminit.c.
1615{
1616 PLIST_ENTRY NextEntry;
1618 PFN_NUMBER NextPage = -1, PageCount = 0;
1620 PMEMORY_ALLOCATION_DESCRIPTOR MdBlock;
1621
1622 //
1623 // Start with the maximum we might need
1624 //
1625 InitialRuns = MiNumberDescriptors;
1626
1627 //
1628 // Allocate the maximum we'll ever need
1629 //
1633 (InitialRuns - 1),
1634 'lMmM');
1636
1637 //
1638 // For now that's how many runs we have
1639 //
1640 Buffer->NumberOfRuns = InitialRuns;
1641
1642 //
1643 // Now loop through the descriptors again
1644 //
1645 NextEntry = LoaderBlock->MemoryDescriptorListHead.Flink;
1646 while (NextEntry != &LoaderBlock->MemoryDescriptorListHead)
1647 {
1648 //
1649 // Grab each one, and check if it's one we should include
1650 //
1651 MdBlock = CONTAINING_RECORD(NextEntry,
1653 ListEntry);
1655 (IncludeType[MdBlock->MemoryType]))
1656 {
1657 //
1658 // Add this to our running total
1659 //
1660 PageCount += MdBlock->PageCount;
1661
1662 //
1663 // Check if the next page is described by the next descriptor
1664 //
1666 {
1667 //
1668 // Combine it into the same physical run
1669 //
1672 NextPage += MdBlock->PageCount;
1673 }
1674 else
1675 {
1676 //
1677 // Otherwise just duplicate the descriptor's contents
1678 //
1682
1683 //
1684 // And in this case, increase the number of runs
1685 //
1686 Run++;
1687 }
1688 }
1689
1690 //
1691 // Try the next descriptor
1692 //
1694 }
1695
1696 //
1697 // We should not have been able to go past our initial estimate
1698 //
1699 ASSERT(Run <= Buffer->NumberOfRuns);
1700
1701 //
1702 // Our guess was probably exaggerated...
1703 //
1705 {
1706 //
1707 // Allocate a more accurately sized buffer
1708 //
1712 (Run - 1),
1713 'lMmM');
1714 if (NewBuffer)
1715 {
1716 //
1717 // Copy the old buffer into the new, then free it
1718 //
1720 Buffer->Run,
1723
1724 //
1725 // Now use the new buffer
1726 //
1727 Buffer = NewBuffer;
1728 }
1729 }
1730
1731 //
1732 // Write the final numbers, and return it
1733 //
1735 Buffer->NumberOfPages = PageCount;
1737}
Definition: bufpool.h:45
Definition: miarm.h:427
Referenced by MmArmInitSystem().
◆ MxGetNextPage()
| PFN_NUMBER NTAPI MxGetNextPage | ( | IN PFN_NUMBER | PageCount | ) |
Definition at line 474 of file mminit.c.
475{
476 PFN_NUMBER Pfn;
477
478 /* Make sure we have enough pages */
480 {
481 /* Crash the system */
482 KeBugCheckEx(INSTALL_MORE_MEMORY,
486 PageCount);
487 }
488
489 /* Use our lowest usable free pages */
493 return Pfn;
494}
Referenced by MiInitializeColorTables(), MiInitializePageTable(), MiInitMachineDependent(), MiMapPDEs(), MiMapPPEs(), and MiMapPTEs().
Variable Documentation
◆ DemandZeroPde
|
extern |
Definition at line 36 of file init.c.
Referenced by MmArmAccessFault().
◆ DemandZeroPte
|
extern |
Definition at line 37 of file init.c.
Referenced by MiInitializePfnAndMakePteValid(), and MiQueryAddressState().
◆ ExpNumberOfPagedPools
|
extern |
Definition at line 41 of file expool.c.
Referenced by ExQueryPoolUsage().
◆ ExpPagedPoolDescriptor
|
extern |
Definition at line 43 of file expool.c.
Referenced by ExQueryPoolUsage(), and InitializePool().
◆ HyperTemplatePte
|
extern |
Definition at line 22 of file hypermap.c.
Referenced by MiInitializePageTable().
◆ MiExpansionLockOwner
|
extern |
Definition at line 33 of file session.c.
Referenced by MiAcquireExpansionLock(), and MiReleaseExpansionLock().
◆ MiExpansionPoolPagesInitialCharge
|
extern |
Definition at line 21 of file pool.c.
Referenced by MiInitializeNonPagedPool(), and MmArmInitSystem().
◆ MiFirstReservedZeroingPte
|
extern |
Definition at line 21 of file hypermap.c.
Referenced by MiBuildSystemPteSpace(), MiInitMachineDependent(), and MiMapPagesInZeroSpace().
◆ MiHighestUserPde
|
extern |
Definition at line 234 of file mminit.c.
Referenced by MiIsUserPde(), and MmArmInitSystem().
◆ MiHighestUserPte
|
extern |
Definition at line 233 of file mminit.c.
Referenced by MI_MAKE_HARDWARE_PTE_KERNEL(), MI_MAKE_HARDWARE_PTE_USER(), MiAccessCheck(), MiDeletePte(), MiIsUserPte(), MiResolveDemandZeroFault(), MiResolveProtoPteFault(), MmArmAccessFault(), and MmArmInitSystem().
◆ MiHighMemoryEvent
|
extern |
Definition at line 293 of file mminit.c.
Referenced by MiDecrementAvailablePages(), MiIncrementAvailablePages(), MiInitializeMemoryEvents(), MiNotifyMemoryEvents(), and MmArmInitSystem().
◆ MiHighNonPagedPoolEvent
|
extern |
Definition at line 297 of file mminit.c.
Referenced by MiInitializeMemoryEvents(), MiInitializePoolEvents(), and MmArmInitSystem().
◆ MiHighNonPagedPoolThreshold
|
extern |
Definition at line 305 of file mminit.c.
Referenced by MiInitializeNonPagedPoolThresholds(), and MiInitializePoolEvents().
◆ MiHighPagedPoolEvent
|
extern |
Definition at line 295 of file mminit.c.
Referenced by MiInitializeMemoryEvents(), MiInitializePoolEvents(), and MmArmInitSystem().
◆ MiHighPagedPoolThreshold
|
extern |
Definition at line 303 of file mminit.c.
Referenced by MiBuildPagedPool(), and MiInitializePoolEvents().
◆ MiLargePageAllDrivers
|
extern |
Definition at line 27 of file largepag.c.
Referenced by MiInitializeDriverLargePageList(), and MiUseLargeDriverPage().
◆ MiLargePageDriverList
|
extern |
Definition at line 26 of file largepag.c.
Referenced by MiInitializeDriverLargePageList(), and MiUseLargeDriverPage().
◆ MiLowMemoryEvent
|
extern |
Definition at line 292 of file mminit.c.
Referenced by MiDecrementAvailablePages(), MiIncrementAvailablePages(), MiInitializeMemoryEvents(), MiNotifyMemoryEvents(), and MmArmInitSystem().
◆ MiLowNonPagedPoolEvent
|
extern |
Definition at line 296 of file mminit.c.
Referenced by MiInitializeMemoryEvents(), MiInitializePoolEvents(), and MmArmInitSystem().
◆ MiLowNonPagedPoolThreshold
|
extern |
Definition at line 304 of file mminit.c.
Referenced by MiInitializeNonPagedPoolThresholds(), and MiInitializePoolEvents().
◆ MiLowPagedPoolEvent
|
extern |
Definition at line 294 of file mminit.c.
Referenced by MiInitializeMemoryEvents(), MiInitializePoolEvents(), and MmArmInitSystem().
◆ MiLowPagedPoolThreshold
|
extern |
Definition at line 302 of file mminit.c.
Referenced by MiBuildPagedPool(), and MiInitializePoolEvents().
◆ MiNumberOfFreePages
|
extern |
Definition at line 384 of file mminit.c.
Referenced by MiInitMachineDependent(), and MiScanMemoryDescriptors().
◆ MiPlatformCacheAttributes
|
extern |
Definition at line 27 of file iosup.c.
Referenced by MiAllocateContiguousMemory(), MiMapLockedPagesInUserSpace(), MmAllocateNonCachedMemory(), MmAllocatePagesForMdlEx(), MmMapIoSpace(), MmMapLockedPagesSpecifyCache(), and MmMapLockedPagesWithReservedMapping().
◆ MiSessionBasePte
|
extern |
Definition at line 145 of file mminit.c.
Referenced by MiInitializeSessionSpaceLayout().
◆ MiSessionImageEnd
|
extern |
Definition at line 28 of file init.c.
Referenced by MiInitializeSessionSpaceLayout().
◆ MiSessionImagePteEnd
|
extern |
Definition at line 144 of file mminit.c.
Referenced by MiInitializeSessionSpaceLayout().
◆ MiSessionImagePteStart
|
extern |
Definition at line 143 of file mminit.c.
Referenced by MiInitializeSessionSpaceLayout().
◆ MiSessionImageStart
|
extern |
Definition at line 29 of file init.c.
Referenced by MiInitializeSessionSpaceLayout().
◆ MiSessionLastPte
|
extern |
Definition at line 146 of file mminit.c.
Referenced by MiInitializeSessionSpaceLayout().
◆ MiSessionPoolEnd
|
extern |
Definition at line 31 of file init.c.
Referenced by MiInitializeSessionPool(), and MiInitializeSessionSpaceLayout().
◆ MiSessionPoolStart
|
extern |
Definition at line 32 of file init.c.
Referenced by MiInitializeSessionPool(), and MiInitializeSessionSpaceLayout().
◆ MiSessionSpaceEnd
|
extern |
Definition at line 27 of file init.c.
Referenced by MiDbgDumpAddressSpace(), MiInitializeSessionSpaceLayout(), MiInitSystemMemoryAreas(), and MiSessionCommitPageTables().
◆ MiSessionSpaceWs
|
extern |
Definition at line 130 of file mminit.c.
Referenced by MiInitializeSessionSpaceLayout(), MiResolveDemandZeroFault(), and MiSessionInitializeWorkingSetList().
◆ MiSessionViewStart
|
extern |
Definition at line 30 of file init.c.
Referenced by MiInitializeSessionSpaceLayout(), MiInitializeSystemSpaceMap(), MiResolveDemandZeroFault(), and MmCommitSessionMappedView().
◆ MiSystemViewStart
|
extern |
Definition at line 646 of file miarm.h.
Referenced by MiDbgDumpAddressSpace(), MiInitializePageTable(), MiInitializeSessionSpaceLayout(), MiInitializeSystemSpaceMap(), and MiInitSystemMemoryAreas().
◆ MmAllocatedNonPagedPool
|
extern |
Definition at line 26 of file pool.c.
Referenced by _Requires_lock_held_(), and MiInitializePoolEvents().
◆ MmAllocationFragment
|
extern |
Definition at line 352 of file mminit.c.
Referenced by MmArmInitSystem().
◆ MmBootImageSize
|
extern |
Definition at line 49 of file init.c.
Referenced by MiDbgDumpAddressSpace(), MiInitSystemMemoryAreas(), MmAddVerifierThunks(), and MmArmInitSystem().
◆ MmConsumedPoolPercentage
◆ MmCriticalSectionTimeout
|
extern |
Definition at line 388 of file mminit.c.
Referenced by MmArmInitSystem(), and MmCreatePeb().
◆ MmCritsectTimeoutSeconds
|
extern |
Definition at line 387 of file mminit.c.
Referenced by MmArmInitSystem().
◆ MmDeadStackSListHead
|
extern |
Definition at line 22 of file procsup.c.
Referenced by MmArmInitSystem(), MmCreateKernelStack(), and MmDeleteKernelStack().
◆ MmDecommittedPte
|
extern |
Definition at line 44 of file init.c.
Referenced by MiDecommitPages(), MiProcessValidPteList(), MiResolveProtoPteFault(), and NtAllocateVirtualMemory().
◆ MmDefaultMaximumNonPagedPool
|
extern |
Definition at line 41 of file mminit.c.
Referenced by MiBuildNonPagedPool(), and MiComputeNonPagedPoolVa().
◆ MmDynamicPfn
◆ MmEnforceWriteProtection
|
extern |
Definition at line 34 of file sysldr.c.
Referenced by MiWriteProtectSystemImage().
◆ MmExpansionLock
|
extern |
Definition at line 32 of file session.c.
Referenced by MiAcquireExpansionLock(), MiInitializeWorkingSetList(), and MiReleaseExpansionLock().
◆ MmFirstReservedMappingPte
|
extern |
Definition at line 20 of file hypermap.c.
Referenced by MiInitializePageTable(), MiInitMachineDependent(), and MiMapPageInHyperSpace().
◆ MmFreePagesByColor
|
extern |
Definition at line 286 of file mminit.c.
Referenced by MiInitializeColorTables(), MiInitMachineDependent(), MiInsertPageInFreeList(), MiInsertPageInList(), MiRemoveAnyPage(), MiRemovePageByColor(), MiRemoveZeroPage(), MiRemoveZeroPageSafe(), and MiUnlinkFreeOrZeroedPage().
◆ MmHighMemoryThreshold
|
extern |
Definition at line 301 of file mminit.c.
Referenced by MiDecrementAvailablePages(), MiIncrementAvailablePages(), MiInitializeMemoryEvents(), and MiNotifyMemoryEvents().
◆ MmHighSectionBase
|
extern |
Definition at line 111 of file section.c.
Referenced by MmArmInitSystem(), and MmCreateArm3Section().
◆ MmHyperSpaceEnd
|
extern |
Definition at line 56 of file init.c.
Referenced by MiArchCreateProcessAddressSpace(), MiComputeNonPagedPoolVa(), and MiInitMachineDependent().
◆ MmLargePageDriverBuffer
|
extern |
Definition at line 24 of file largepag.c.
Referenced by MiInitializeDriverLargePageList().
◆ MmLargePageDriverBufferLength
|
extern |
Definition at line 25 of file largepag.c.
Referenced by MiInitializeDriverLargePageList().
◆ MmLargeStackSize
|
extern |
Definition at line 262 of file mminit.c.
Referenced by MmArmInitSystem(), MmCreateKernelStack(), MmDeleteKernelStack(), and MmGrowKernelStackEx().
◆ MmLargeSystemCache
◆ MmLastReservedMappingPte
◆ MmLowMemoryThreshold
|
extern |
Definition at line 300 of file mminit.c.
Referenced by MiDecrementAvailablePages(), MiIncrementAvailablePages(), MiInitializeMemoryEvents(), and MiNotifyMemoryEvents().
◆ MmMakeLowMemory
◆ MmMaxAdditionNonPagedPoolPerMb
|
extern |
Definition at line 42 of file mminit.c.
Referenced by MiBuildNonPagedPool(), and MiComputeNonPagedPoolVa().
◆ MmMaximumDeadKernelStacks
|
extern |
Definition at line 21 of file procsup.c.
Referenced by MmArmInitSystem(), and MmDeleteKernelStack().
◆ MmMaximumNonPagedPoolInBytes
|
extern |
Definition at line 22 of file init.c.
Referenced by MiBuildNonPagedPool(), MiBuildPagedPool(), MiComputeNonPagedPoolVa(), MiInitializeNonPagedPool(), and MiInitMachineDependent().
◆ MmMaximumNonPagedPoolInPages
|
extern |
Definition at line 30 of file mminit.c.
Referenced by _Requires_lock_held_(), MiBuildNonPagedPool(), MiInitializeNonPagedPoolThresholds(), MiInitializePoolEvents(), and MiInitMachineDependent().
◆ MmMaximumNonPagedPoolPercent
|
extern |
Definition at line 20 of file init.c.
Referenced by MiBuildNonPagedPool(), and MiComputeNonPagedPoolVa().
◆ MmMinAdditionNonPagedPoolPerMb
|
extern |
Definition at line 40 of file mminit.c.
Referenced by MiBuildNonPagedPool(), and MiComputeNonPagedPoolVa().
◆ MmMinimumFreePages
|
extern |
Definition at line 314 of file mminit.c.
Referenced by MiDecrementAvailablePages(), MmArmInitSystem(), and MmWorkingSetManager().
◆ MmMinimumNonPagedPoolSize
|
extern |
Definition at line 39 of file mminit.c.
Referenced by MiBuildNonPagedPool(), and MiComputeNonPagedPoolVa().
◆ MmMinimumStackCommitInBytes
|
extern |
Definition at line 370 of file mminit.c.
Referenced by MmCreatePeb().
◆ MmMirroring
◆ MmNonPagedPoolEnd
|
extern |
Definition at line 99 of file mminit.c.
Referenced by MI_MAKE_SUBSECTION_PTE(), MiBuildNonPagedPool(), MiDbgDumpAddressSpace(), MiFreeContiguousMemory(), MiFreePoolPages(), MiInitMachineDependent(), MiInitSystemMemoryAreas(), MmArmAccessFault(), and MmDeterminePoolType().
◆ MmNonPagedPoolExpansionStart
|
extern |
Definition at line 25 of file init.c.
Referenced by MiBuildNonPagedPool(), MiDbgDumpAddressSpace(), MiFreeContiguousMemory(), MiInitializeNonPagedPool(), MiInitMachineDependent(), MiInitSystemMemoryAreas(), and MmArmAccessFault().
◆ MmNonPagedPoolStart
|
extern |
Definition at line 24 of file init.c.
Referenced by MiBuildNonPagedPool(), MiBuildPfnDatabaseFromPages(), MiDbgDumpAddressSpace(), MiFreeContiguousMemory(), MiInitializeNonPagedPool(), MiInitMachineDependent(), MiInitSystemMemoryAreas(), MmArmAccessFault(), MmArmInitSystem(), and MmDeterminePoolType().
◆ MmNonPagedSystemStart
|
extern |
Definition at line 580 of file miarm.h.
Referenced by MiBuildPagedPool(), MiBuildSystemPteSpace(), MiDbgDumpAddressSpace(), MiInitMachineDependent(), and MiInitSystemMemoryAreas().
◆ MmNumberOfSystemPtes
|
extern |
Definition at line 42 of file init.c.
Referenced by MiBuildSystemPteSpace(), MiInitializeSpecialPool(), MiInitMachineDependent(), MiInitSystemMemoryAreas(), and MmArmInitSystem().
◆ MmPagedPoolEnd
|
extern |
Definition at line 579 of file miarm.h.
Referenced by MiBuildPagedPool(), MiDecrementShareCount(), MiFreePoolPages(), MiInitializePageTable(), MiMakeSystemAddressValid(), MiResolveTransitionFault(), MmAccessFault(), and MmDeterminePoolType().
◆ MmPagedPoolInfo
|
extern |
Definition at line 25 of file pool.c.
Referenced by _Requires_lock_held_(), MiAllocatePoolPages(), MiBuildPagedPool(), MiCheckVirtualAddress(), MiFreePoolPages(), and MiInitializePoolEvents().
◆ MmPagedPoolMutex
|
extern |
Definition at line 24 of file pool.c.
Referenced by MiAllocatePoolPages(), MiFreePoolPages(), MiInitializePoolEvents(), and MmArmInitSystem().
◆ MmPagedPoolStart
|
extern |
Definition at line 578 of file miarm.h.
Referenced by MI_MAKE_PROTOTYPE_PTE(), MiAllocatePoolPages(), MiBuildPagedPool(), MiCheckVirtualAddress(), MiDbgDumpAddressSpace(), MiDecrementShareCount(), MiFreePoolPages(), MiInitializePageTable(), MiInitMachineDependent(), MiInitSystemMemoryAreas(), MiMakeSystemAddressValid(), MiResolveTransitionFault(), MmAccessFault(), MmArmInitSystem(), and MmDeterminePoolType().
◆ MmPhysicalMemoryBlock
|
extern |
Definition at line 45 of file init.c.
Referenced by MiFindContiguousPages(), MmArmInitSystem(), and MmGetPhysicalMemoryRanges().
◆ MmPlentyFreePages
|
extern |
Definition at line 322 of file mminit.c.
Referenced by MiAdjustWorkingSetManagerParameters(), MiInitializeMemoryEvents(), and MmWorkingSetManager().
◆ MmProcessColorSeed
|
extern |
Definition at line 20 of file procsup.c.
Referenced by MmCreateProcessAddressSpace().
◆ MmProcessList
|
extern |
Definition at line 20 of file largepag.c.
Referenced by MiArchCreateProcessAddressSpace(), and MiInitializeLargePageSupport().
◆ MmProductType
|
extern |
Definition at line 325 of file mminit.c.
Referenced by MmArmInitSystem().
◆ MmProtectFreedNonPagedPool
|
extern |
Definition at line 31 of file pool.c.
Referenced by MiAllocatePoolPages(), MiFreePoolPages(), MiInitializeNonPagedPool(), and MmArmAccessFault().
◆ MmProtectToPteMask
Definition at line 22 of file page.c.
Referenced by MI_MAKE_HARDWARE_PTE(), MI_MAKE_HARDWARE_PTE_KERNEL(), MI_MAKE_HARDWARE_PTE_USER(), MiDispatchFault(), MiResolveTransitionFault(), and MmSetPageProtect().
◆ MmProtectToValue
Definition at line 71 of file page.c.
Referenced by MiGetPageProtection(), MiProtectVirtualMemory(), MiQueryAddressState(), MiQueryMemoryBasicInformation(), and MmQuerySectionView().
◆ MmResidentAvailableAtInit
|
extern |
Definition at line 28 of file freelist.c.
Referenced by MmArmInitSystem().
◆ MmSecondaryColorMask
|
extern |
Definition at line 257 of file mminit.c.
Referenced by MiComputeColorInformation(), MiInsertPageInFreeList(), MiInsertPageInList(), MiRemoveAnyPage(), MiRemoveZeroPage(), MiSessionCommitPageTables(), and MiUnlinkFreeOrZeroedPage().
◆ MmSecondaryColors
|
extern |
Definition at line 256 of file mminit.c.
Referenced by MiComputeColorInformation(), MiInitializeColorTables(), MiInitMachineDependent(), MiRemoveAnyPage(), MiRemovePageByColor(), MiRemoveZeroPage(), and MmArmInitSystem().
◆ MmSectionBasedMutex
|
extern |
Definition at line 110 of file section.c.
Referenced by MiDeleteARM3Section(), MmArmInitSystem(), and MmCreateArm3Section().
◆ MmSectionBasedRoot
|
extern |
Definition at line 109 of file section.c.
Referenced by MiDeleteARM3Section(), MiFindEmptyAddressRangeDownBasedTree(), MiInsertBasedSection(), MmCreateArm3Section(), and MmInitSectionImplementation().
◆ MmSectionCommitMutex
|
extern |
Definition at line 108 of file section.c.
Referenced by MiMapViewOfDataSection(), MmArmInitSystem(), MmCommitSessionMappedView(), and NtAllocateVirtualMemory().
◆ MmSessionBase
|
extern |
Definition at line 583 of file miarm.h.
Referenced by MiDbgDumpAddressSpace(), MiInitializeSessionPool(), MiInitializeSessionSpaceLayout(), MiInitSystemMemoryAreas(), MiSessionCommitPageTables(), MiSessionCreateInternal(), and MiSessionInitializeWorkingSetList().
◆ MmSessionImageSize
|
extern |
Definition at line 37 of file init.c.
Referenced by MiInitializeSessionSpaceLayout().
◆ MmSessionPoolSize
|
extern |
Definition at line 36 of file init.c.
Referenced by MiInitializeSessionPool(), and MiInitializeSessionSpaceLayout().
◆ MmSessionSize
|
extern |
Definition at line 34 of file init.c.
Referenced by MiInitializeSessionSpaceLayout().
◆ MmSessionSpace
|
extern |
Definition at line 21 of file session.c.
Referenced by MiCheckVirtualAddress(), MiDereferenceSession(), MiDereferenceSessionFinal(), MiInitializeSessionPool(), MiInitializeSessionSpaceLayout(), MiSessionAddProcess(), MiSessionCommitPageTables(), MiSessionCreateInternal(), MiSessionInitializeWorkingSetList(), MiSessionRemoveProcess(), MmArmAccessFault(), MmCommitSessionMappedView(), MmMapViewInSessionSpace(), MmSessionCreate(), and MmUnmapViewInSessionSpace().
◆ MmSessionViewSize
|
extern |
Definition at line 35 of file init.c.
Referenced by MiInitializeSessionSpaceLayout(), MiInitializeSystemSpaceMap(), and MmCommitSessionMappedView().
◆ MmSharedUserDataPte
|
extern |
Definition at line 26 of file mminit.c.
Referenced by MiCheckVirtualAddress(), and MmInitSystem().
◆ MmSizeOfNonPagedPoolInBytes
|
extern |
Definition at line 21 of file init.c.
Referenced by InitializePool(), MiBuildNonPagedPool(), MiBuildPfnDatabaseFromPages(), MiComputeNonPagedPoolVa(), MiDbgDumpAddressSpace(), MiFreeContiguousMemory(), MiInitializeNonPagedPool(), MiInitMachineDependent(), MiInitSystemMemoryAreas(), MmArmAccessFault(), and MmArmInitSystem().
◆ MmSizeOfPagedPoolInBytes
|
extern |
Definition at line 589 of file miarm.h.
Referenced by MiBuildPagedPool(), MiCreatePagingFileMap(), MiDbgDumpAddressSpace(), MiInitMachineDependent(), and MiInitSystemMemoryAreas().
◆ MmSizeOfPagedPoolInPages
|
extern |
Definition at line 111 of file mminit.c.
Referenced by _Requires_lock_held_(), MiBuildPagedPool(), and MiInitializePoolEvents().
◆ MmSpecialPoolTag
|
extern |
Definition at line 29 of file pool.c.
Referenced by MiInitializeSpecialPool(), MmArmInitSystem(), and MmUseSpecialPool().
◆ MmStandbyPageListByPriority
|
extern |
Definition at line 44 of file pfnlist.c.
Referenced by MiInsertPageInList(), MiInsertStandbyListAtFront(), MiUnlinkPageFromList(), and MmArmInitSystem().
◆ MmSubsectionBase
|
extern |
Definition at line 194 of file section.c.
Referenced by MI_MAKE_SUBSECTION_PTE(), and MiInitMachineDependent().
◆ MmSystemCacheEnd
|
extern |
Definition at line 54 of file init.c.
Referenced by MiDbgDumpAddressSpace(), and MmArmInitSystem().
◆ MmSystemCacheStart
|
extern |
Definition at line 53 of file init.c.
Referenced by MiDbgDumpAddressSpace(), and MmArmInitSystem().
◆ MmSystemCacheWorkingSetList
|
extern |
Definition at line 174 of file mminit.c.
Referenced by GetNextPageColorForWsList(), GetPteTemplateForWsList(), and MiComputeNonPagedPoolVa().
◆ MmSystemCacheWs
|
extern |
Definition at line 55 of file init.c.
Referenced by MI_IS_PROCESS_WORKING_SET(), MiConvertSharedWorkingSetLockToExclusive(), MiDeleteSystemPageableVm(), MiLockWorkingSet(), MiLockWorkingSetShared(), MiSetPagingOfDriver(), MiUnlockWorkingSet(), MiUnlockWorkingSetShared(), MmAccessFault(), MmArmAccessFault(), MmArmInitSystem(), MmFreeMemoryArea(), and MmInsertMemoryArea().
◆ MmSystemLockPagesCount
|
extern |
Definition at line 22 of file mdlsup.c.
Referenced by MiDereferencePfnAndDropLockCount(), MiDropLockCount(), MiReferenceProbedPageAndBumpLockCount(), MiReferenceUnusedPageAndBumpLockCount(), MiReferenceUsedPageAndBumpLockCount(), and MmAdjustWorkingSetSize().
◆ MmSystemPageColor
◆ MmSystemPageDirectory
|
extern |
Definition at line 40 of file init.c.
Referenced by MiAllocatePoolPages(), MiBuildPagedPool(), and MiFillSystemPageDirectory().
◆ MmSystemPagePtes
|
extern |
Definition at line 41 of file init.c.
Referenced by MiAllocatePoolPages(), MiBuildPagedPool(), MiFillSystemPageDirectory(), and MiRemoveMappedPtes().
◆ MmSystemPtesEnd
|
extern |
Definition at line 23 of file syspte.c.
Referenced by MiInitializeSystemPtes(), MiReleaseSystemPtes(), MmUnmapLockedPages(), and MmUnmapReservedMapping().
◆ MmSystemPtesStart
|
extern |
Definition at line 22 of file syspte.c.
Referenced by MiInitializeSystemPtes(), MiReleaseSystemPtes(), MmUnmapLockedPages(), and MmUnmapReservedMapping().
◆ MmSystemSize
|
extern |
Definition at line 326 of file mminit.c.
Referenced by MmArmInitSystem(), MmQuerySystemSize(), and MmSetMemoryPriorityProcess().
◆ MmSystemViewSize
|
extern |
Definition at line 39 of file init.c.
Referenced by MiDbgDumpAddressSpace(), MiInitializePageTable(), MiInitializeSessionSpaceLayout(), MiInitializeSystemSpaceMap(), and MiInitSystemMemoryAreas().
◆ MmTotalFreeSystemPtes
|
extern |
Definition at line 25 of file syspte.c.
Referenced by MiInitializeSystemPtes(), MiReleaseSystemPtes(), MiReserveAlignedSystemPtes(), and MiUseLargeDriverPage().
◆ MmTotalSystemDriverPages
|
extern |
Definition at line 28 of file sysldr.c.
Referenced by MiSetPagingOfDriver().
◆ MmTrackLockedPages
◆ MmTrackPtes
◆ MmVerifyDriverBuffer
◆ MmVerifyDriverBufferLength
◆ MmVerifyDriverBufferType
◆ MmVerifyDriverLevel
◆ MmWorkingSetExpansionHead
|
extern |
Definition at line 30 of file session.c.
Referenced by MiInitializeWorkingSetList(), MiSessionInitializeWorkingSetList(), MmArmInitSystem(), and MmWorkingSetManager().
◆ MmWorkingSetList
|
extern |
Definition at line 19 of file wslist.cpp.
Referenced by MiInitializeWorkingSetList().
◆ MmZeroingPageEvent
|
extern |
Definition at line 20 of file zeropage.c.
Referenced by MiInsertPageInFreeList(), MmArmInitSystem(), and MmZeroPageThread().
◆ MmZeroPageFile
|
extern |
Definition at line 71 of file pagefile.c.
◆ MxFreeDescriptor
|
extern |
Definition at line 46 of file init.c.
Referenced by MiBuildPfnDatabase(), MiInitMachineDependent(), MiMapPfnDatabase(), MiScanMemoryDescriptors(), and MxGetNextPage().
◆ MxOldFreeDescriptor
|
extern |
Definition at line 47 of file init.c.
Referenced by MiBuildPfnDatabase(), MiInitMachineDependent(), MiIsRegularMemory(), MiMapPfnDatabase(), MiScanMemoryDescriptors(), and MxGetNextPage().
◆ MxPfnAllocation
|
extern |
Definition at line 43 of file init.c.
Referenced by MiBuildNonPagedPool(), MiBuildPfnDatabase(), MiDbgDumpAddressSpace(), MiInitMachineDependent(), MiInitSystemMemoryAreas(), and MmArmInitSystem().
◆ NonPagedPoolDescriptor
|
extern |
Definition at line 42 of file expool.c.
Referenced by ExAllocatePoolWithTag(), ExQueryPoolUsage(), and InitializePool().
◆ PoolTrackTable
|
extern |
Definition at line 49 of file expool.c.
Referenced by ExpGetPoolTagInfoTarget(), ExpInsertPoolTracker(), ExpRemovePoolTracker(), ExpSeedHotTags(), and InitializePool().
◆ PrototypePte
|
extern |
Definition at line 40 of file init.c.
Referenced by MiDeletePte(), MiDeleteVirtualAddresses(), MiInitMachineDependent(), and MmArmAccessFault().
◆ ValidKernelPde
|
extern |
Definition at line 28 of file init.c.
Referenced by MiAllocatePoolPages(), MiBuildPagedPool(), MiFillSystemPageDirectory(), MiInitializeAndChargePfn(), MiInitMachineDependent(), MiMapPDEs(), and MiMapPPEs().
◆ ValidKernelPdeLocal
|
extern |
Definition at line 32 of file init.c.
Referenced by MiInitializeAndChargePfn(), MiInitMachineDependent(), MiSessionCommitPageTables(), MiSessionCreateInternal(), and MiSessionInitializeWorkingSetList().
◆ ValidKernelPte
|
extern |
Definition at line 29 of file init.c.
Referenced by GetPteTemplateForWsList(), MiAllocatePoolPages(), MiArchCreateProcessAddressSpace(), MiBuildPagedPool(), MiCopyPfn(), MiDbgTranslatePhysicalAddress(), MiInitializeColorTables(), MiInitMachineDependent(), MiLoadImageSection(), MiMapPagesInZeroSpace(), MiMapPfnDatabase(), MiMapPTEs(), MiReloadBootLoadedDrivers(), MiSessionCreateInternal(), MiZeroPfn(), MmAllocateNonCachedMemory(), MmAllocateSpecialPool(), MmInitSystem(), MmMapIoSpace(), MmMapLockedPagesSpecifyCache(), and MmMapLockedPagesWithReservedMapping().
◆ ValidKernelPteLocal
|
extern |
Definition at line 33 of file init.c.
Referenced by GetPteTemplateForWsList(), MiArchCreateProcessAddressSpace(), MiInitMachineDependent(), MiMapPageInHyperSpace(), MiSessionCreateInternal(), and MiSessionInitializeWorkingSetList().
