ReactOS 0.4.16-dev-1151-g3842b59
miarm.h
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: BSD - See COPYING.ARM in the top level directory
4 * FILE: ntoskrnl/mm/ARM3/miarm.h
5 * PURPOSE: ARM Memory Manager Header
6 * PROGRAMMERS: ReactOS Portable Systems Group
7 */
8
9#pragma once
10
11#ifdef __cplusplus
12extern "C" {
13#endif
14
15#define MI_LOWEST_VAD_ADDRESS (PVOID)MM_LOWEST_USER_ADDRESS
16
17/* Make the code cleaner with some definitions for size multiples */
18#define _1KB (1024u)
19#define _1MB (1024 * _1KB)
20#define _1GB (1024 * _1MB)
21
22/* Everyone loves 64K */
23#define _64K (64 * _1KB)
24
25/* Size of a page table */
26#define PT_SIZE (PTE_PER_PAGE * sizeof(MMPTE))
27
28/* Size of a page directory */
29#define PD_SIZE (PDE_PER_PAGE * sizeof(MMPDE))
30
31/* Size of all page directories for a process */
32#define SYSTEM_PD_SIZE (PPE_PER_PAGE * PD_SIZE)
33#ifdef _M_IX86
35#endif
36
37//
38// Protection Bits part of the internal memory manager Protection Mask, from:
39// http://reactos.org/wiki/Techwiki:Memory_management_in_the_Windows_XP_kernel
40// https://www.reactos.org/wiki/Techwiki:Memory_Protection_constants
41// and public assertions.
42//
43#define MM_ZERO_ACCESS 0
44#define MM_READONLY 1
45#define MM_EXECUTE 2
46#define MM_EXECUTE_READ 3
47#define MM_READWRITE 4
48#define MM_WRITECOPY 5
49#define MM_EXECUTE_READWRITE 6
50#define MM_EXECUTE_WRITECOPY 7
51#define MM_PROTECT_ACCESS 7
52
53//
54// These are flags on top of the actual protection mask
55//
56#define MM_NOCACHE 0x08
57#define MM_GUARDPAGE 0x10
58#define MM_WRITECOMBINE 0x18
59#define MM_PROTECT_SPECIAL 0x18
60
61//
62// These are special cases
63//
64#define MM_DECOMMIT (MM_ZERO_ACCESS | MM_GUARDPAGE)
65#define MM_NOACCESS (MM_ZERO_ACCESS | MM_WRITECOMBINE)
66#define MM_OUTSWAPPED_KSTACK (MM_EXECUTE_WRITECOPY | MM_WRITECOMBINE)
67#define MM_INVALID_PROTECTION 0xFFFFFFFF
68
69//
70// Specific PTE Definitions that map to the Memory Manager's Protection Mask Bits
71// The Memory Manager's definition define the attributes that must be preserved
72// and these PTE definitions describe the attributes in the hardware sense. This
73// helps deal with hardware differences between the actual boolean expression of
74// the argument.
75//
76// For example, in the logical attributes, we want to express read-only as a flag
77// but on x86, it is writability that must be set. On the other hand, on x86, just
78// like in the kernel, it is disabling the caches that requires a special flag,
79// while on certain architectures such as ARM, it is enabling the cache which
80// requires a flag.
81//
82#if defined(_M_IX86)
83//
84// Access Flags
85//
86#define PTE_READONLY 0 // Doesn't exist on x86
87#define PTE_EXECUTE 0 // Not worrying about NX yet
88#define PTE_EXECUTE_READ 0 // Not worrying about NX yet
89#define PTE_READWRITE 0x2
90#define PTE_WRITECOPY 0x200
91#define PTE_EXECUTE_READWRITE 0x2 // Not worrying about NX yet
92#define PTE_EXECUTE_WRITECOPY 0x200
93#define PTE_PROTOTYPE 0x400
94
95//
96// State Flags
97//
98#define PTE_VALID 0x1
99#define PTE_ACCESSED 0x20
100#define PTE_DIRTY 0x40
101
102//
103// Cache flags
104//
105#define PTE_ENABLE_CACHE 0
106#define PTE_DISABLE_CACHE 0x10
107#define PTE_WRITECOMBINED_CACHE 0x10
108#define PTE_PROTECT_MASK 0x612
109#elif defined(_M_AMD64)
110//
111// Access Flags
112//
113#define PTE_READONLY 0x8000000000000000ULL
114#define PTE_EXECUTE 0x0000000000000000ULL
115#define PTE_EXECUTE_READ PTE_EXECUTE /* EXECUTE implies READ on x64 */
116#define PTE_READWRITE 0x8000000000000002ULL
117#define PTE_WRITECOPY 0x8000000000000200ULL
118#define PTE_EXECUTE_READWRITE 0x0000000000000002ULL
119#define PTE_EXECUTE_WRITECOPY 0x0000000000000200ULL
120#define PTE_PROTOTYPE 0x0000000000000400ULL
121
122//
123// State Flags
124//
125#define PTE_VALID 0x0000000000000001ULL
126#define PTE_ACCESSED 0x0000000000000020ULL
127#define PTE_DIRTY 0x0000000000000040ULL
128
129//
130// Cache flags
131//
132#define PTE_ENABLE_CACHE 0x0000000000000000ULL
133#define PTE_DISABLE_CACHE 0x0000000000000010ULL
134#define PTE_WRITECOMBINED_CACHE 0x0000000000000010ULL
135#define PTE_PROTECT_MASK 0x8000000000000612ULL
136#elif defined(_M_ARM)
137#define PTE_READONLY 0x200
138#define PTE_EXECUTE 0 // Not worrying about NX yet
139#define PTE_EXECUTE_READ 0 // Not worrying about NX yet
140#define PTE_READWRITE 0 // Doesn't exist on ARM
141#define PTE_WRITECOPY 0 // Doesn't exist on ARM
142#define PTE_EXECUTE_READWRITE 0 // Not worrying about NX yet
143#define PTE_EXECUTE_WRITECOPY 0 // Not worrying about NX yet
144#define PTE_PROTOTYPE 0x400 // Using the Shared bit
145
146//
147// Cache flags
148//
149#define PTE_ENABLE_CACHE 0
150#define PTE_DISABLE_CACHE 0x10
151#define PTE_WRITECOMBINED_CACHE 0x10
152#define PTE_PROTECT_MASK 0x610
153#else
154#error Define these please!
155#endif
156
157//
158// Some internal SYSTEM_PTE_MISUSE bugcheck subcodes
159// These names were created by Oleg Dubinskiy and Doug Lyons for ReactOS. For reference, see
160// https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/bug-check-0xda--system-pte-misuse
161//
162#define PTE_MAPPING_NONE 0x100
163#define PTE_MAPPING_NOT_OWNED 0x101
164#define PTE_MAPPING_EMPTY 0x102
165#define PTE_MAPPING_RESERVED 0x103
166#define PTE_MAPPING_ADDRESS_NOT_OWNED 0x104
167#define PTE_MAPPING_ADDRESS_INVALID 0x105
168#define PTE_UNMAPPING_ADDRESS_NOT_OWNED 0x108
169#define PTE_MAPPING_ADDRESS_EMPTY 0x109
170
171//
172// Mask for image section page protection
173//
174#define IMAGE_SCN_PROTECTION_MASK (IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE)
175
176extern const ULONG_PTR MmProtectToPteMask[32];
177extern const ULONG MmProtectToValue[32];
178
179//
180// Assertions for session images, addresses, and PTEs
181//
182#define MI_IS_SESSION_IMAGE_ADDRESS(Address) \
183 (((Address) >= MiSessionImageStart) && ((Address) < MiSessionImageEnd))
184
185#define MI_IS_SESSION_ADDRESS(Address) \
186 (((Address) >= MmSessionBase) && ((Address) < MiSessionSpaceEnd))
187
188#define MI_IS_SESSION_PTE(Pte) \
189 ((((PMMPTE)Pte) >= MiSessionBasePte) && (((PMMPTE)Pte) < MiSessionLastPte))
190
191#define MI_IS_PAGE_TABLE_ADDRESS(Address) \
192 (((PVOID)(Address) >= (PVOID)PTE_BASE) && ((PVOID)(Address) <= (PVOID)PTE_TOP))
193
194#define MI_IS_SYSTEM_PAGE_TABLE_ADDRESS(Address) \
195 (((Address) >= (PVOID)MiAddressToPte(MmSystemRangeStart)) && ((Address) <= (PVOID)PTE_TOP))
196
197#define MI_IS_PAGE_TABLE_OR_HYPER_ADDRESS(Address) \
198 (((PVOID)(Address) >= (PVOID)PTE_BASE) && ((PVOID)(Address) <= (PVOID)MmHyperSpaceEnd))
199
200//
201// Creates a software PTE with the given protection
202//
203#define MI_MAKE_SOFTWARE_PTE(p, x) ((p)->u.Long = (x << MM_PTE_SOFTWARE_PROTECTION_BITS))
204
205//
206// Marks a PTE as deleted
207//
208#define MI_SET_PFN_DELETED(x) ((x)->PteAddress = (PMMPTE)((ULONG_PTR)(x)->PteAddress | 1))
209#define MI_IS_PFN_DELETED(x) ((ULONG_PTR)((x)->PteAddress) & 1)
210
211//
212// Special values for LoadedImports
213//
214#define MM_SYSLDR_NO_IMPORTS ((PVOID)(ULONG_PTR)-2)
215#define MM_SYSLDR_BOOT_LOADED ((PVOID)(ULONG_PTR)-1)
216#define MM_SYSLDR_SINGLE_ENTRY 0x1
217
218//
219// Number of initial session IDs
220//
221#define MI_INITIAL_SESSION_IDS 64
222
223#define LIST_HEAD ULONG_PTR_MAX
224
225//
226// Because GCC cannot automatically downcast 0xFFFFFFFF to lesser-width bits,
227// we need a manual definition suited to the number of bits in the PteFrame.
228// This is used as a LIST_HEAD for the colored list
229//
230#define COLORED_LIST_HEAD (((ULONG_PTR)1 << MI_PTE_FRAME_BITS) - 1)
231
232//
233// Returns the color of a page
234//
235#define MI_GET_PAGE_COLOR(x) ((x) & MmSecondaryColorMask)
236#define MI_GET_NEXT_COLOR() (MI_GET_PAGE_COLOR(++MmSystemPageColor))
237#define MI_GET_NEXT_PROCESS_COLOR(x) (MI_GET_PAGE_COLOR(++(x)->NextPageColor))
238
239//
240// Prototype PTEs that don't yet have a pagefile association
241//
242#ifdef _WIN64
243#define MI_PTE_LOOKUP_NEEDED 0xffffffffULL
244#else
245#define MI_PTE_LOOKUP_NEEDED 0xFFFFF
246#endif
247
248//
249// Number of session data and tag pages
250//
251#define MI_SESSION_DATA_PAGES_MAXIMUM (MM_ALLOCATION_GRANULARITY / PAGE_SIZE)
252#define MI_SESSION_TAG_PAGES_MAXIMUM (MM_ALLOCATION_GRANULARITY / PAGE_SIZE)
253
254//
255// Used by MiCheckSecuredVad
256//
257#define MM_READ_WRITE_ALLOWED 11
258#define MM_READ_ONLY_ALLOWED 10
259#define MM_NO_ACCESS_ALLOWED 01
260#define MM_DELETE_CHECK 85
261
262//
263// System views are binned into 64K chunks
264//
265#define MI_SYSTEM_VIEW_BUCKET_SIZE _64K
266
267//
268// FIXFIX: These should go in ex.h after the pool merge
269//
270#ifdef _WIN64
271#define POOL_BLOCK_SIZE 16
272#else
273#define POOL_BLOCK_SIZE 8
274#endif
275#define POOL_LISTS_PER_PAGE (PAGE_SIZE / POOL_BLOCK_SIZE)
276#define BASE_POOL_TYPE_MASK 1
277#define POOL_MAX_ALLOC (PAGE_SIZE - (sizeof(POOL_HEADER) + POOL_BLOCK_SIZE))
278
279//
280// Pool debugging/analysis/tracing flags
281//
282#define POOL_FLAG_CHECK_TIMERS 0x1
283#define POOL_FLAG_CHECK_WORKERS 0x2
284#define POOL_FLAG_CHECK_RESOURCES 0x4
285#define POOL_FLAG_VERIFIER 0x8
286#define POOL_FLAG_CHECK_DEADLOCK 0x10
287#define POOL_FLAG_SPECIAL_POOL 0x20
288#define POOL_FLAG_DBGPRINT_ON_FAILURE 0x40
289#define POOL_FLAG_CRASH_ON_FAILURE 0x80
290
291//
292// BAD_POOL_HEADER codes during pool bugcheck
293//
294#define POOL_CORRUPTED_LIST 3
295#define POOL_SIZE_OR_INDEX_MISMATCH 5
296#define POOL_ENTRIES_NOT_ALIGNED_PREVIOUS 6
297#define POOL_HEADER_NOT_ALIGNED 7
298#define POOL_HEADER_IS_ZERO 8
299#define POOL_ENTRIES_NOT_ALIGNED_NEXT 9
300#define POOL_ENTRY_NOT_FOUND 10
301
302//
303// BAD_POOL_CALLER codes during pool bugcheck
304//
305#define POOL_ENTRY_CORRUPTED 1
306#define POOL_ENTRY_ALREADY_FREE 6
307#define POOL_ENTRY_NOT_ALLOCATED 7
308#define POOL_ALLOC_IRQL_INVALID 8
309#define POOL_FREE_IRQL_INVALID 9
310#define POOL_BILLED_PROCESS_INVALID 13
311#define POOL_HEADER_SIZE_INVALID 32
312
313typedef struct _POOL_DESCRIPTOR
314{
329
330typedef struct _POOL_HEADER
331{
332 union
333 {
334 struct
335 {
336#ifdef _WIN64
341#else
346#endif
347 };
349 };
350#ifdef _WIN64
352#endif
353 union
354 {
355#ifdef _WIN64
356 PEPROCESS ProcessBilled;
357#else
359#endif
360 struct
361 {
364 };
365 };
367
370
372{
381
383{
389
394
395//
396// END FIXFIX
397//
398
400{
404
406{
411
413{
419
421{
425
427{
432
433typedef struct _MMCOLOR_TABLES
434{
439
441{
445
446typedef struct _MMVIEW
447{
451
452typedef struct _MMSESSION
453{
464
466{
471
472typedef struct _MM_SESSION_SPACE
473{
476 union
477 {
480 } u;
508#if defined (_M_AMD64)
509 MMPDE PageDirectory;
510#else
512#endif
513#if defined (_M_AMD64)
514 PMMPTE SpecialPoolFirstPte;
515 PMMPTE SpecialPoolLastPte;
516 PMMPTE NextPdeForSpecialPoolExpansion;
517 PMMPTE LastPdeForSpecialPoolExpansion;
518 PFN_NUMBER SpecialPagesInUse;
519#endif
522
525extern MMPDE ValidKernelPde;
526extern MMPTE ValidKernelPte;
529extern MMPDE DemandZeroPde;
530extern MMPTE DemandZeroPte;
531extern MMPTE PrototypePte;
537extern BOOLEAN MmTrackPtes;
538extern BOOLEAN MmDynamicPfn;
539extern BOOLEAN MmMirroring;
546extern WCHAR MmVerifyDriverBuffer[512];
562extern PVOID MmPagedPoolEnd;
563extern PVOID MmSessionBase;
564extern SIZE_T MmSessionSize;
609extern ULONG MmProductType;
647extern PVOID MiSessionPoolEnd; // 0xBE000000
648extern PVOID MiSessionPoolStart; // 0xBD000000
649extern PVOID MiSessionViewStart; // 0xBE000000
662
666{
667 return (WorkingSet != &MmSystemCacheWs) && !WorkingSet->Flags.SessionSpace;
668}
669
673{
674 return ((MemoryType == LoaderFree) ||
675 (MemoryType == LoaderLoadedProgram) ||
676 (MemoryType == LoaderFirmwareTemporary) ||
677 (MemoryType == LoaderOsloaderStack));
678}
679
683{
684 return ((MemoryType == LoaderFirmwarePermanent) ||
685 (MemoryType == LoaderSpecialMemory) ||
686 (MemoryType == LoaderHALCachedMemory) ||
687 (MemoryType == LoaderBBTMemory));
688}
689
690#ifdef _M_AMD64
693MiIsUserPxe(PVOID Address)
694{
695 return ((ULONG_PTR)Address >> 7) == 0x1FFFFEDF6FB7DA0ULL;
696}
697
700MiIsUserPpe(PVOID Address)
701{
702 return ((ULONG_PTR)Address >> 16) == 0xFFFFF6FB7DA0ULL;
703}
704
708{
709 return ((ULONG_PTR)Address >> 25) == 0x7FFFFB7DA0ULL;
710}
711
715{
716 return ((ULONG_PTR)Address >> 34) == 0x3FFFFDA0ULL;
717}
718#else
722{
723 return ((Address >= (PVOID)MiAddressToPde(NULL)) &&
725}
726
730{
731 return (Address >= (PVOID)PTE_BASE) && (Address <= (PVOID)MiHighestUserPte);
732}
733#endif
734
735//
736// Figures out the hardware bits for a PTE
737//
741{
743
744 /* Start fresh */
745 TempPte.u.Long = 0;
746
747 /* Make it valid and accessed */
748 TempPte.u.Hard.Valid = TRUE;
750
751 /* Is this for user-mode? */
752 if (
753#if (_MI_PAGING_LEVELS == 4)
754 MiIsUserPxe(PointerPte) ||
755#endif
756#if (_MI_PAGING_LEVELS >= 3)
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 */
769 return TempPte.u.Long;
770}
771
772//
773// Creates a valid kernel PTE with the given protection
774//
776VOID
778 IN PMMPTE MappingPte,
779 IN ULONG_PTR ProtectionMask,
780 IN PFN_NUMBER PageFrameNumber)
781{
782 /* Only valid for kernel, non-session PTEs */
783 ASSERT(MappingPte > MiHighestUserPte);
784 ASSERT(!MI_IS_SESSION_PTE(MappingPte));
785 ASSERT((MappingPte < (PMMPTE)PDE_BASE) || (MappingPte > (PMMPTE)PDE_TOP));
786
787 /* Check that we are not setting valid a page that should not be */
788 ASSERT(ProtectionMask & MM_PROTECT_ACCESS);
789 ASSERT((ProtectionMask & MM_GUARDPAGE) == 0);
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}
805
806//
807// Creates a valid PTE with the given protection
808//
810VOID
812 IN PMMPTE MappingPte,
813 IN ULONG_PTR ProtectionMask,
814 IN PFN_NUMBER PageFrameNumber)
815{
816 /* Check that we are not setting valid a page that should not be */
817 ASSERT(ProtectionMask & MM_PROTECT_ACCESS);
818 ASSERT((ProtectionMask & MM_GUARDPAGE) == 0);
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}
825
826//
827// Creates a valid user PTE with the given protection
828//
830VOID
832 IN PMMPTE MappingPte,
833 IN ULONG_PTR ProtectionMask,
834 IN PFN_NUMBER PageFrameNumber)
835{
836 /* Only valid for kernel, non-session PTEs */
837 ASSERT(MappingPte <= MiHighestUserPte);
838
839 /* Start fresh */
840 NewPte->u.Long = 0;
841
842 /* Check that we are not setting valid a page that should not be */
843 ASSERT(ProtectionMask & MM_PROTECT_ACCESS);
844 ASSERT((ProtectionMask & MM_GUARDPAGE) == 0);
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}
851
852#ifndef _M_AMD64
853//
854// Builds a Prototype PTE for the address of the PTE
855//
857VOID
859 IN PMMPTE PointerPte)
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}
881
882//
883// Builds a Subsection PTE for the address of the Segment
884//
886VOID
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 */
902 if ((ULONG_PTR)Segment < ((ULONG_PTR)MmSubsectionBase + (128 * _1MB)))
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}
920
924{
926 return ((PointerPte->u.Long & 0xFFFFFC01) != 0);
927}
928
929#endif
930
932VOID
935 _In_ ULONG Protection)
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}
942
943//
944// Returns if the page is physically resident (ie: a large page)
945// FIXFIX: CISC/x86 only?
946//
950{
951 PMMPDE PointerPde;
952
953 /* Large pages are never paged out, always physically resident */
954 PointerPde = MiAddressToPde(Address);
955 return ((PointerPde->u.Hard.LargePage) && (PointerPde->u.Hard.Valid));
956}
957
958//
959// Writes a valid PTE
960//
962VOID
965{
966 /* Write the valid PTE */
967 ASSERT(PointerPte->u.Hard.Valid == 0);
968 ASSERT(TempPte.u.Hard.Valid == 1);
969#if _M_AMD64
971 (TempPte.u.Hard.NoExecute == 0));
972#endif
973 *PointerPte = TempPte;
974}
975
976//
977// Updates a valid PTE
978//
980VOID
983{
984 /* Write the valid PTE */
985 ASSERT(PointerPte->u.Hard.Valid == 1);
986 ASSERT(TempPte.u.Hard.Valid == 1);
987 ASSERT(PointerPte->u.Hard.PageFrameNumber == TempPte.u.Hard.PageFrameNumber);
988 *PointerPte = TempPte;
989}
990
991//
992// Writes an invalid PTE
993//
995VOID
997 IN MMPTE InvalidPte)
998{
999 /* Write the invalid PTE */
1000 ASSERT(InvalidPte.u.Hard.Valid == 0);
1001 *PointerPte = InvalidPte;
1002}
1003
1004//
1005// Erase the PTE completely
1006//
1008VOID
1010{
1011 /* Zero out the PTE */
1012 ASSERT(PointerPte->u.Long != 0);
1013 PointerPte->u.Long = 0;
1014}
1015
1016//
1017// Writes a valid PDE
1018//
1020VOID
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
1029 ASSERT(TempPde.u.Hard.Valid == 1);
1030 *PointerPde = TempPde;
1031}
1032
1033//
1034// Writes an invalid PDE
1035//
1037VOID
1039 IN MMPDE InvalidPde)
1040{
1041 /* Write the invalid PDE */
1042 ASSERT(InvalidPde.u.Hard.Valid == 0);
1043 ASSERT(InvalidPde.u.Long != 0);
1044#ifdef _M_AMD64
1045 ASSERT(InvalidPde.u.Soft.Protection == MM_EXECUTE_READWRITE);
1046#endif
1047 *PointerPde = InvalidPde;
1048}
1049
1050//
1051// Checks if the thread already owns a working set
1052//
1054BOOLEAN
1056{
1057 /* If any of these are held, return TRUE */
1064}
1065
1067BOOLEAN
1069{
1073}
1074
1075//
1076// Checks if the process owns the working set lock
1077//
1079BOOLEAN
1081{
1082 /* Check if this process is the owner, and that the thread owns the WS */
1083 if (PsGetCurrentThread()->OwnsProcessWorkingSetExclusive == 0)
1084 {
1085 DPRINT("Thread: %p is not an owner\n", PsGetCurrentThread());
1086 }
1087 if (KeGetCurrentThread()->ApcState.Process != &Process->Pcb)
1088 {
1089 DPRINT("Current thread %p is attached to another process %p\n", PsGetCurrentThread(), Process);
1090 }
1091 return ((KeGetCurrentThread()->ApcState.Process == &Process->Pcb) &&
1092 ((PsGetCurrentThread()->OwnsProcessWorkingSetExclusive) ||
1093 (PsGetCurrentThread()->OwnsProcessWorkingSetShared)));
1094}
1095
1096//
1097// New ARM3<->RosMM PAGE Architecture
1098//
1100BOOLEAN
1102{
1103 return Section->u.Flags.filler;
1104}
1105
1106#define MI_IS_ROS_PFN(x) ((x)->u4.AweAllocation == TRUE)
1107
1108VOID
1109NTAPI
1111 IN PMMPFN Pfn1,
1112 IN PFN_NUMBER PageFrameIndex
1113);
1114
1116BOOLEAN
1118{
1119 return (Process->Vm.Flags.AcquiredUnsafe == TRUE);
1120}
1121
1122//
1123// Locks the working set for the given process
1124//
1126VOID
1129{
1130 /* Shouldn't already be owning the process working set */
1133
1134 /* Block APCs, make sure that still nothing is already held */
1137
1138 /* Lock the working set */
1139 ExAcquirePushLockExclusive(&Process->Vm.WorkingSetMutex);
1140
1141 /* Now claim that we own the lock */
1145}
1146
1148VOID
1151{
1152 /* Shouldn't already be owning the process working set */
1155
1156 /* Block APCs, make sure that still nothing is already held */
1159
1160 /* Lock the working set */
1161 ExAcquirePushLockShared(&Process->Vm.WorkingSetMutex);
1162
1163 /* Now claim that we own the lock */
1168}
1169
1171VOID
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 */
1183 ExAcquirePushLockExclusive(&Process->Vm.WorkingSetMutex);
1184
1185 /* Now claim that we own the lock */
1187 Process->Vm.Flags.AcquiredUnsafe = 1;
1190}
1191
1192//
1193// Unlocks the working set for the given process
1194//
1196VOID
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 */
1209 ExReleasePushLockExclusive(&Process->Vm.WorkingSetMutex);
1211}
1212
1213//
1214// Unlocks the working set for the given process
1215//
1217VOID
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 */
1233 ExReleasePushLockShared(&Process->Vm.WorkingSetMutex);
1235}
1236
1237//
1238// Unlocks the working set for the given process
1239//
1241VOID
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 */
1259 ExReleasePushLockExclusive(&Process->Vm.WorkingSetMutex);
1261}
1262
1263//
1264// Locks the working set
1265//
1267VOID
1269 IN PMMSUPPORT WorkingSet)
1270{
1271 /* Block APCs */
1273
1274 /* Working set should be in global memory */
1275 ASSERT(MI_IS_SESSION_ADDRESS((PVOID)WorkingSet) == FALSE);
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? */
1284 if (WorkingSet == &MmSystemCacheWs)
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}
1306
1308VOID
1311 _In_ PMMSUPPORT WorkingSet)
1312{
1313 /* Block APCs */
1315
1316 /* Working set should be in global memory */
1317 ASSERT(MI_IS_SESSION_ADDRESS((PVOID)WorkingSet) == FALSE);
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? */
1326 if (WorkingSet == &MmSystemCacheWs)
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}
1348
1349//
1350// Unlocks the working set
1351//
1353VOID
1355 IN PMMSUPPORT WorkingSet)
1356{
1357 /* Working set should be in global memory */
1358 ASSERT(MI_IS_SESSION_ADDRESS((PVOID)WorkingSet) == FALSE);
1359
1360 /* Which working set is this? */
1361 if (WorkingSet == &MmSystemCacheWs)
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 */
1388}
1389
1391VOID
1394 _In_ PMMSUPPORT WorkingSet)
1395{
1396 /* Working set should be in global memory */
1397 ASSERT(MI_IS_SESSION_ADDRESS((PVOID)WorkingSet) == FALSE);
1398
1399 /* Which working set is this? */
1400 if (WorkingSet == &MmSystemCacheWs)
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 */
1427}
1428
1430BOOLEAN
1434{
1435 /* Sanity check: No exclusive lock. */
1439
1440 /* And it should have one and only one shared lock */
1442
1443 /* Try. */
1445 return FALSE;
1446
1447 if (Vm == &MmSystemCacheWs)
1448 {
1452 }
1453 else if (Vm->Flags.SessionSpace)
1454 {
1458 }
1459 else
1460 {
1464 }
1465
1466 return TRUE;
1467}
1468
1470VOID
1473 OUT PBOOLEAN Safe,
1474 OUT PBOOLEAN Shared)
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}
1501
1503VOID
1506 IN BOOLEAN Safe,
1507 IN BOOLEAN Shared)
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 */
1526 ASSERT(Shared == FALSE);
1527 /* Reacquire unsafely */
1529 }
1530}
1531
1533KIRQL
1535{
1536 KIRQL OldIrql;
1537
1542 return OldIrql;
1543}
1544
1546VOID
1548{
1553}
1554
1555//
1556// Returns the ProtoPTE inside a VAD for the given VPN
1557//
1559PMMPTE
1561 IN ULONG_PTR Vpn)
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}
1570
1571//
1572// Returns the PFN Database entry for the given page number
1573// Warning: This is not necessarily a valid PFN database entry!
1574//
1576PMMPFN
1578{
1579 /* Get the entry */
1580 return &MmPfnDatabase[Pfn];
1581};
1582
1583//
1584// Drops a locked page without dereferencing it
1585//
1587VOID
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 */
1598 ASSERT(Pfn1->u3.e1.PageLocation != ActiveAndValid);
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 */
1605 DPRINT1("Not returning commit for prototype PTE\n");
1606 }
1607
1608 /* Update the counter */
1610 }
1611}
1612
1613//
1614// Drops a locked page and dereferences it
1615//
1617VOID
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);
1635 ASSERT(Pfn1->u3.e1.PageLocation != ActiveAndValid);
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 */
1643 DPRINT1("Not returning commit for prototype PTE\n");
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 */
1654 RefCount = InterlockedCompareExchange16((PSHORT)&Pfn1->u3.e2.ReferenceCount,
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 */
1668 ASSERT(Pfn1->u3.e1.PageLocation == ActiveAndValid);
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 */
1675 ASSERT(FALSE);
1676 }
1677
1678 /* Update the counter */
1680 }
1681 }
1682}
1683
1684//
1685// References a locked page and updates the counter
1686// Used in MmProbeAndLockPages to handle different edge cases
1687//
1689VOID
1691{
1692 USHORT RefCount, OldRefCount;
1693
1694 /* Sanity check */
1695 ASSERT(Pfn1->u3.e2.ReferenceCount != 0);
1696
1697 /* Does ARM3 own the page? */
1698 if (MI_IS_ROS_PFN(Pfn1))
1699 {
1700 /* ReactOS Mm doesn't track share count */
1701 ASSERT(Pfn1->u3.e1.PageLocation == ActiveAndValid);
1702 }
1703 else
1704 {
1705 /* On ARM3 pages, we should see a valid share count */
1706 ASSERT((Pfn1->u2.ShareCount != 0) && (Pfn1->u3.e1.PageLocation == ActiveAndValid));
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 */
1713 DPRINT1("Not charging commit for prototype PTE\n");
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 */
1729 RefCount = InterlockedCompareExchange16((PSHORT)&Pfn1->u3.e2.ReferenceCount,
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 */
1736 if (OldRefCount != 1) InterlockedDecrementSizeT(&MmSystemLockPagesCount);
1737}
1738
1739//
1740// References a locked page and updates the counter
1741// Used in all other cases except MmProbeAndLockPages
1742//
1744VOID
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 */
1754 DPRINT1("Not charging commit for prototype PTE\n");
1755 }
1756
1757 /* More locked pages! */
1759
1760 /* Update the reference count */
1761 NewRefCount = InterlockedIncrement16((PSHORT)&Pfn1->u3.e2.ReferenceCount);
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 */
1768 ASSERT(Pfn1->u3.e1.PageLocation == ActiveAndValid);
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}
1783
1784//
1785// References a locked page and updates the counter
1786// Used in all other cases except MmProbeAndLockPages
1787//
1789VOID
1791{
1792 USHORT NewRefCount;
1793
1794 /* Make sure the page isn't used yet */
1795 ASSERT(Pfn1->u2.ShareCount == 0);
1796 ASSERT(Pfn1->u3.e1.PageLocation != ActiveAndValid);
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 */
1803 DPRINT1("Not charging commit for prototype PTE\n");
1804 }
1805
1806 /* More locked pages! */
1808
1809 /* Update the reference count */
1810 NewRefCount = InterlockedIncrement16((PSHORT)&Pfn1->u3.e2.ReferenceCount);
1811 if (NewRefCount != 1)
1812 {
1813 /* Someone had already locked the page, so undo our bump */
1814 ASSERT(NewRefCount < 2500);
1816 }
1817}
1818
1819
1820
1821CODE_SEG("INIT")
1822BOOLEAN
1823NTAPI
1825 IN ULONG Phase,
1826 IN PLOADER_PARAMETER_BLOCK LoaderBlock
1827);
1828
1829CODE_SEG("INIT")
1830VOID
1831NTAPI
1833
1834CODE_SEG("INIT")
1836NTAPI
1838 IN PLOADER_PARAMETER_BLOCK LoaderBlock
1839);
1840
1841CODE_SEG("INIT")
1842VOID
1843NTAPI
1845 VOID
1846);
1847
1848CODE_SEG("INIT")
1849VOID
1850NTAPI
1852 IN PLOADER_PARAMETER_BLOCK LoaderBlock
1853);
1854
1855CODE_SEG("INIT")
1856VOID
1857NTAPI
1859 VOID
1860);
1861
1862CODE_SEG("INIT")
1863VOID
1864NTAPI
1866 IN PLOADER_PARAMETER_BLOCK LoaderBlock
1867);
1868
1869VOID
1870NTAPI
1872 VOID
1873);
1874
1875VOID
1876NTAPI
1878 VOID
1879);
1880
1881CODE_SEG("INIT")
1882BOOLEAN
1883NTAPI
1885 VOID
1886);
1887
1888CODE_SEG("INIT")
1890NTAPI
1892 IN PFN_NUMBER PageCount
1893);
1894
1895CODE_SEG("INIT")
1897NTAPI
1899 IN PLOADER_PARAMETER_BLOCK LoaderBlock,
1900 IN PBOOLEAN IncludeType
1901);
1902
1904NTAPI
1906 IN PLOADER_PARAMETER_BLOCK LoaderBlock,
1907 IN PBOOLEAN IncludeType
1908);
1909
1910VOID
1913 IN PVOID AddressStart,
1914 IN PVOID AddressEnd
1915);
1916
1918NTAPI
1922 IN OUT PSIZE_T NumberOfBytesToProtect,
1923 IN ULONG NewAccessProtection,
1924 OUT PULONG OldAccessProtection OPTIONAL
1925);
1926
1928NTAPI
1930 IN ULONG FaultCode,
1933 IN PVOID TrapInformation
1934);
1935
1940);
1941
1942CODE_SEG("INIT")
1943VOID
1944NTAPI
1946 VOID
1947);
1948
1949CODE_SEG("INIT")
1950VOID
1951NTAPI
1953 VOID
1954);
1955
1956CODE_SEG("INIT")
1957VOID //
1958NTAPI //
1960 IN POOL_TYPE PoolType,// FIXFIX: This should go in ex.h after the pool merge
1961 IN ULONG Threshold //
1962); //
1963
1964// FIXFIX: THIS ONE TOO
1965CODE_SEG("INIT")
1966VOID
1967NTAPI
1969 IN PPOOL_DESCRIPTOR PoolDescriptor,
1971 IN ULONG PoolIndex,
1972 IN ULONG Threshold,
1973 IN PVOID PoolLock
1974);
1975
1977NTAPI
1979 VOID
1980);
1981
1982CODE_SEG("INIT")
1983VOID
1984NTAPI
1986 IN PMMPTE StartingPte,
1987 IN ULONG NumberOfPtes,
1989);
1990
1991PMMPTE
1992NTAPI
1994 IN ULONG NumberOfPtes,
1995 IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType
1996);
1997
1998VOID
1999NTAPI
2001 IN PMMPTE StartingPte,
2002 IN ULONG NumberOfPtes,
2003 IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType
2004);
2005
2006
2008NTAPI
2010 IN PFN_NUMBER LowestPfn,
2011 IN PFN_NUMBER HighestPfn,
2012 IN PFN_NUMBER BoundaryPfn,
2013 IN PFN_NUMBER SizeInPages,
2015);
2016
2017PVOID
2018NTAPI
2021 IN PFN_NUMBER BaseAddressPages,
2022 IN PFN_NUMBER SizeInPages,
2023 IN PFN_NUMBER LowestPfn,
2024 IN PFN_NUMBER HighestPfn,
2025 IN PFN_NUMBER BoundaryPfn,
2026 IN MI_PFN_CACHE_ATTRIBUTE CacheAttribute
2027);
2028
2029PMDL
2030NTAPI
2032 IN PHYSICAL_ADDRESS LowAddress,
2036 IN MI_PFN_CACHE_ATTRIBUTE CacheAttribute,
2037 IN ULONG Flags
2038);
2039
2040VOID
2041NTAPI
2043 IN PMMPFNLIST ListHead,
2044 IN PFN_NUMBER PageFrameIndex
2045);
2046
2047VOID
2048NTAPI
2051);
2052
2053VOID
2054NTAPI
2056 IN PMMPFN Pfn
2057);
2058
2059VOID
2060NTAPI
2062 IN PFN_NUMBER PageFrameIndex,
2063 IN PMMPTE PointerPte,
2064 IN BOOLEAN Modified
2065);
2066
2068NTAPI
2070 OUT PPFN_NUMBER PageFrameIndex,
2071 IN PMMPDE PointerPde,
2072 IN PFN_NUMBER ContainingPageFrame,
2073 IN BOOLEAN SessionAllocation
2074);
2075
2076VOID
2077NTAPI
2079 IN PFN_NUMBER PageFrameIndex,
2080 IN PMMPTE PointerPte,
2082);
2083
2084VOID
2085NTAPI
2087 IN PFN_NUMBER PageFrameIndex,
2088 IN PVOID PteAddress,
2089 IN PFN_NUMBER PteFrame
2090);
2091
2092VOID
2093NTAPI
2095 IN PMMPFN Pfn1,
2096 IN PFN_NUMBER PageFrameIndex
2097);
2098
2100NTAPI
2102 IN ULONG Color
2103);
2104
2106NTAPI
2108 IN ULONG Color
2109);
2110
2111VOID
2112NTAPI
2114 IN PFN_NUMBER PageFrameIndex
2115);
2116
2117VOID
2118NTAPI
2120 IN PFN_NUMBER PageFrameIndex
2121);
2122
2124NTAPI
2126 IN PMMPTE PointerPte,
2127 IN PFN_NUMBER PageCount,
2128 IN ULONG Flags,
2129 OUT PPFN_NUMBER ValidPages
2130);
2131
2132ULONG
2133NTAPI
2135 IN PMMPTE PointerPte
2136);
2137
2139NTAPI
2142);
2143
2144CODE_SEG("INIT")
2145VOID
2146NTAPI
2148 VOID
2149);
2150
2151CODE_SEG("INIT")
2152VOID
2153NTAPI
2155 VOID
2156);
2157
2158CODE_SEG("INIT")
2159VOID
2160NTAPI
2162 VOID
2163);
2164
2165BOOLEAN
2166NTAPI
2168 IN PMMPFN Pfn1
2169);
2170
2171PMMVAD
2172NTAPI
2176
2177PMMVAD
2178NTAPI
2181);
2182
2184NTAPI
2186 IN ULONG_PTR StartVpn,
2187 IN ULONG_PTR EndVpn,
2189 OUT PMMADDRESS_NODE *NodeOrParent
2190);
2191
2193NTAPI
2196 IN ULONG_PTR BoundaryAddress,
2201);
2202
2204NTAPI
2207 IN ULONG_PTR BoundaryAddress,
2211);
2212
2214NTAPI
2219 OUT PMMADDRESS_NODE *PreviousVad,
2221);
2222
2224NTAPI
2226 IN PMMVAD Vad,
2227 IN PVOID Base,
2228 IN SIZE_T Size,
2229 IN ULONG ProtectionMask
2230);
2231
2232VOID
2233NTAPI
2235 _Inout_ PMMVAD Vad,
2236 _Inout_ PMM_AVL_TABLE VadRoot);
2237
2239NTAPI
2241 _Inout_ PMMVAD Vad,
2244 _In_ ULONG_PTR HighestAddress,
2247
2248VOID
2249NTAPI
2251 IN PSECTION Section
2252);
2253
2255NTAPI
2260 _In_ BOOLEAN SkipDebuggerNotify);
2261
2262VOID
2263NTAPI
2266 IN PMMADDRESS_NODE NewNode,
2269);
2270
2271VOID
2272NTAPI
2276);
2277
2279NTAPI
2282);
2283
2285NTAPI
2288);
2289
2290BOOLEAN
2291NTAPI
2293 IN PMMSESSION InputSession OPTIONAL
2294);
2295
2296VOID
2297NTAPI
2299 VOID
2300);
2301
2302VOID
2303NTAPI
2305 IN PMM_SESSION_SPACE SessionGlobal
2306);
2307
2308VOID
2309NTAPI
2311 IN PEPROCESS NewProcess
2312);
2313
2314ULONG
2315NTAPI
2318);
2319
2320VOID
2321NTAPI
2323 _In_ ULONG_PTR Va,
2324 _In_ ULONG_PTR EndingAddress,
2325 _In_opt_ PMMVAD Vad
2326);
2327
2328VOID
2329NTAPI
2331 IN PMMPTE PointerPte,
2333 IN PEPROCESS CurrentProcess,
2335);
2336
2337ULONG
2338NTAPI
2340 IN PVOID PageTableVirtualAddress,
2341 IN PEPROCESS CurrentProcess
2342);
2343
2344ULONG
2345NTAPI
2349);
2350
2351VOID
2352NTAPI
2354 IN PEPROCESS CurrentProcess,
2355 IN PMMVAD Vad
2356);
2357
2359NTAPI
2361 IN PMMVAD Vad,
2362 IN ULONG_PTR Vpn
2363);
2364
2365VOID
2366NTAPI
2368 PVOID ObjectBody
2369);
2370
2372NTAPI
2376 OUT PVOID MemoryInformation,
2377 IN SIZE_T MemoryInformationLength,
2379);
2380
2382NTAPI
2385);
2386
2387VOID
2388NTAPI
2390 IN PMMPDE PointerPde,
2391 IN PEPROCESS TargetProcess,
2393);
2394
2395VOID
2396NTAPI
2398 _In_ PVOID ImageBase);
2399
2400//
2401// MiRemoveZeroPage will use inline code to zero out the page manually if only
2402// free pages are available. In some scenarios, we don't/can't run that piece of
2403// code and would rather only have a real zero page. If we can't have a zero page,
2404// then we'd like to have our own code to grab a free page and zero it out, by
2405// using MiRemoveAnyPage. This macro implements this.
2406//
2410{
2412 return 0;
2413}
2414
2415#if (_MI_PAGING_LEVELS == 2)
2417BOOLEAN
2418MiSynchronizeSystemPde(PMMPDE PointerPde)
2419{
2420 ULONG Index;
2421
2422 /* Get the Index from the PDE */
2423 Index = ((ULONG_PTR)PointerPde & (SYSTEM_PD_SIZE - 1)) / sizeof(MMPTE);
2424 if (PointerPde->u.Hard.Valid != 0)
2425 {
2426 NT_ASSERT(PointerPde->u.Long == MmSystemPagePtes[Index].u.Long);
2427 return TRUE;
2428 }
2429
2430 if (MmSystemPagePtes[Index].u.Hard.Valid == 0)
2431 {
2432 return FALSE;
2433 }
2434
2435 /* Copy the PDE from the double-mapped system page directory */
2437
2438 /* Make sure we re-read the PDE and PTE */
2440
2441 /* Return success */
2442 return TRUE;
2443}
2444#endif
2445
2446#if _MI_PAGING_LEVELS == 2
2448USHORT
2450{
2451 PUSHORT RefCount;
2452
2454
2455 *RefCount += 1;
2456 ASSERT(*RefCount <= PTE_PER_PAGE);
2457 return *RefCount;
2458}
2459
2461USHORT
2463{
2464 PUSHORT RefCount;
2465
2467
2468 *RefCount -= 1;
2469 ASSERT(*RefCount < PTE_PER_PAGE);
2470 return *RefCount;
2471}
2472#else
2474USHORT
2476{
2477 PMMPDE PointerPde = MiAddressToPde(Address);
2478 PMMPFN Pfn;
2479
2480 /* We should not tinker with this one. */
2481 ASSERT(PointerPde != (PMMPDE)PXE_SELFMAP);
2482 DPRINT("Incrementing %p from %p\n", Address, _ReturnAddress());
2483
2484 /* Make sure we're locked */
2485 ASSERT(PsGetCurrentThread()->OwnsProcessWorkingSetExclusive);
2486
2487 /* If we're bumping refcount, then it must be valid! */
2488 ASSERT(PointerPde->u.Hard.Valid == 1);
2489
2490 /* This lies on the PFN */
2491 Pfn = MiGetPfnEntry(PFN_FROM_PDE(PointerPde));
2493
2495
2497}
2498
2500USHORT
2502{
2503 PMMPDE PointerPde = MiAddressToPde(Address);
2504 PMMPFN Pfn;
2505
2506 /* We should not tinker with this one. */
2507 ASSERT(PointerPde != (PMMPDE)PXE_SELFMAP);
2508
2509 DPRINT("Decrementing %p from %p\n", PointerPde, _ReturnAddress());
2510
2511 /* Make sure we're locked */
2512 ASSERT(PsGetCurrentThread()->OwnsProcessWorkingSetExclusive);
2513
2514 /* If we're decreasing refcount, then it must be valid! */
2515 ASSERT(PointerPde->u.Hard.Valid == 1);
2516
2517 /* This lies on the PFN */
2518 Pfn = MiGetPfnEntry(PFN_FROM_PDE(PointerPde));
2519
2522
2524
2526}
2527#endif
2528
2529#ifdef __cplusplus
2530} // extern "C"
2531#endif
2532
2534VOID
2536 _In_ PMMPDE PointerPde,
2537 _In_ PEPROCESS CurrentProcess)
2538{
2539 /* Only for user-mode ones */
2540 ASSERT(MiIsUserPde(PointerPde));
2541
2542 /* Kill this one as a PTE */
2543 MiDeletePte((PMMPTE)PointerPde, MiPdeToPte(PointerPde), CurrentProcess, NULL);
2544#if _MI_PAGING_LEVELS >= 3
2545 /* Cascade down */
2546 if (MiDecrementPageTableReferences(MiPdeToPte(PointerPde)) == 0)
2547 {
2548 MiDeletePte(MiPdeToPpe(PointerPde), PointerPde, CurrentProcess, NULL);
2549#if _MI_PAGING_LEVELS == 4
2550 if (MiDecrementPageTableReferences(PointerPde) == 0)
2551 {
2552 MiDeletePte(MiPdeToPxe(PointerPde), MiPdeToPpe(PointerPde), CurrentProcess, NULL);
2553 }
2554#endif
2555 }
2556#endif
2557}
2558
2559/* EOF */
#define CODE_SEG(...)
_In_ PVOID _In_ ULONG _Out_ PVOID _In_ ULONG _Inout_ PULONG ReturnLength
ULONG_PTR PFN_NUMBER
unsigned char BOOLEAN
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
HARDWARE_PTE_ARMV6 TempPte
Definition: winldr.c:76
#define PDE_BASE
Definition: winldr.c:21
HARDWARE_PDE_ARMV6 TempPde
Definition: winldr.c:78
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define ULONG_PTR
Definition: config.h:101
UCHAR KIRQL
Definition: env_spec_w32.h:591
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
#define PsGetCurrentThread()
Definition: env_spec_w32.h:81
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
#define APC_LEVEL
Definition: env_spec_w32.h:695
#define PAGE_SIZE
Definition: env_spec_w32.h:49
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
#define NonPagedPool
Definition: env_spec_w32.h:307
#define PagedPool
Definition: env_spec_w32.h:308
FORCEINLINE VOID ExAcquirePushLockExclusive(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1039
FORCEINLINE VOID ExAcquirePushLockShared(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1108
FORCEINLINE VOID ExReleasePushLockShared(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1216
FORCEINLINE BOOLEAN ExConvertPushLockSharedToExclusive(IN PEX_PUSH_LOCK PushLock)
Definition: ex.h:1142
FORCEINLINE VOID ExReleasePushLockExclusive(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1255
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
ASMGENDATA Table[]
Definition: genincdata.c:61
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
#define KeGetCurrentThread
Definition: hal.h:55
_In_ ULONG Mode
Definition: hubbusif.h:303
#define InterlockedCompareExchange16
Definition: interlocked.h:109
#define InterlockedDecrementSizeT(a)
Definition: interlocked.h:153
#define InterlockedIncrement16
Definition: interlocked.h:206
#define InterlockedIncrementSizeT(a)
Definition: interlocked.h:220
#define _ReturnAddress()
Definition: intrin_arm.h:35
#define C_ASSERT(e)
Definition: intsafe.h:73
#define KeLeaveGuardedRegion()
Definition: ke_x.h:68
#define KeEnterGuardedRegion()
Definition: ke_x.h:39
PMMVAD NTAPI MiLocateAddress(IN PVOID VirtualAddress)
MMPTE ValidKernelPte
Definition: init.c:29
_MMSYSTEM_PTE_POOL_TYPE
Definition: miarm.h:406
@ SystemPteSpace
Definition: miarm.h:407
@ MaximumPtePoolTypes
Definition: miarm.h:409
@ NonPagedPoolExpansion
Definition: miarm.h:408
FORCEINLINE VOID MI_MAKE_SUBSECTION_PTE(IN PMMPTE NewPte, IN PVOID Segment)
Definition: miarm.h:887
VOID NTAPI MiInitializeSystemPtes(IN PMMPTE StartingPte, IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE PoolType)
Definition: syspte.c:388
SIZE_T MmMinimumNonPagedPoolSize
Definition: mminit.c:39
BOOLEAN MmTrackLockedPages
Definition: mdlsup.c:21
PMMPTE MiHighestUserPte
Definition: mminit.c:233
PETHREAD MiExpansionLockOwner
Definition: session.c:33
PMMWSL MmWorkingSetList
Definition: wslist.cpp:19
#define MI_IS_ROS_PFN(x)
Definition: miarm.h:1106
ULONG MmMaximumNonPagedPoolPercent
Definition: init.c:20
FORCEINLINE KIRQL MiAcquireExpansionLock(VOID)
Definition: miarm.h:1534
PMMPTE MmSharedUserDataPte
Definition: mminit.c:26
PFN_COUNT MiExpansionPoolPagesInitialCharge
Definition: pool.c:21
KGUARDED_MUTEX MmSectionBasedMutex
Definition: section.c:110
NTSTATUS NTAPI MiQueryMemorySectionName(IN HANDLE ProcessHandle, IN PVOID BaseAddress, OUT PVOID MemoryInformation, IN SIZE_T MemoryInformationLength, OUT PSIZE_T ReturnLength)
Definition: section.c:1754
PFN_NUMBER MiNumberOfFreePages
Definition: mminit.c:384
PVOID MmNonPagedSystemStart
Definition: miarm.h:580
VOID NTAPI MiInsertNode(IN PMM_AVL_TABLE Table, IN PMMADDRESS_NODE NewNode, PMMADDRESS_NODE Parent, TABLE_SEARCH_RESULT Result)
FORCEINLINE PMMPTE MI_GET_PROTOTYPE_PTE_FOR_VPN(IN PMMVAD Vad, IN ULONG_PTR Vpn)
Definition: miarm.h:1560
PMMPTE MiSessionBasePte
Definition: mminit.c:145
FORCEINLINE BOOLEAN MM_ANY_WS_LOCK_HELD_EXCLUSIVE(_In_ PETHREAD Thread)
Definition: miarm.h:1068
FORCEINLINE BOOLEAN MI_IS_PHYSICAL_ADDRESS(IN PVOID Address)
Definition: miarm.h:949
struct _POOL_TRACKER_TABLE POOL_TRACKER_TABLE
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: freelist.c:182
FORCEINLINE VOID MiLockProcessWorkingSetShared(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1149
PMMPTE MmSystemPtesStart[MaximumPtePoolTypes]
Definition: syspte.c:22
FORCEINLINE BOOLEAN MiIsMemoryTypeInvisible(TYPE_OF_MEMORY MemoryType)
Definition: miarm.h:682
FORCEINLINE VOID MiDeletePde(_In_ PMMPDE PointerPde, _In_ PEPROCESS CurrentProcess)
Definition: miarm.h:2535
PMMPTE MmLastReservedMappingPte
Definition: miarm.h:565
PVOID MmPagedPoolStart
Definition: miarm.h:578
PMEMORY_ALLOCATION_DESCRIPTOR MxFreeDescriptor
Definition: init.c:46
PFN_NUMBER NTAPI MiRemoveZeroPage(IN ULONG Color)
Definition: pfnlist.c:537
FORCEINLINE VOID MiLockWorkingSet(IN PETHREAD Thread, IN PMMSUPPORT WorkingSet)
Definition: miarm.h:1268
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
ULONG MmProcessColorSeed
Definition: procsup.c:20
struct _MMSESSION MMSESSION
struct _MM_SESSION_SPACE * PMM_SESSION_SPACE
PFN_NUMBER MmLowMemoryThreshold
Definition: mminit.c:300
ULONG MmVerifyDriverBufferType
Definition: drvmgmt.c:25
VOID NTAPI MiInitializePfnDatabase(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:1065
SIZE_T MmMinimumStackCommitInBytes
Definition: mminit.c:370
VOID NTAPI ExInitializePoolDescriptor(IN PPOOL_DESCRIPTOR PoolDescriptor, IN POOL_TYPE PoolType, IN ULONG PoolIndex, IN ULONG Threshold, IN PVOID PoolLock)
Definition: expool.c:969
ULONG NTAPI MiGetPageProtection(IN PMMPTE PointerPte)
Definition: virtual.c:1356
VOID NTAPI MiInsertBasedSection(IN PSECTION Section)
Definition: vadnode.c:386
VOID NTAPI MiRemoveNode(IN PMMADDRESS_NODE Node, IN PMM_AVL_TABLE Table)
Definition: vadnode.c:403
PMMPTE MmSystemPtesEnd[MaximumPtePoolTypes]
Definition: syspte.c:23
VOID NTAPI MiInitializePoolEvents(VOID)
Definition: pool.c:203
FORCEINLINE VOID MiUnlockProcessWorkingSetForFault(IN PEPROCESS Process, IN PETHREAD Thread, OUT PBOOLEAN Safe, OUT PBOOLEAN Shared)
Definition: miarm.h:1471
SLIST_HEADER MmDeadStackSListHead
Definition: procsup.c:22
MM_SYSTEMSIZE MmSystemSize
Definition: mminit.c:326
BOOLEAN MmDynamicPfn
Definition: pfnlist.c:34
struct _MI_LARGE_PAGE_RANGES MI_LARGE_PAGE_RANGES
ULONG MmSecondaryColorMask
Definition: mminit.c:257
FORCEINLINE BOOLEAN MI_IS_WS_UNSAFE(IN PEPROCESS Process)
Definition: miarm.h:1117
ULONG_PTR MmSubsectionBase
Definition: section.c:196
VOID NTAPI InitializePool(IN POOL_TYPE PoolType, IN ULONG Threshold)
Definition: expool.c:1020
SIZE_T MmBootImageSize
Definition: init.c:49
VOID NTAPI MiDeletePte(IN PMMPTE PointerPte, IN PVOID VirtualAddress, IN PEPROCESS CurrentProcess, IN PMMPTE PrototypePte)
Definition: virtual.c:369
VOID NTAPI MiReleaseProcessReferenceToSessionDataPage(IN PMM_SESSION_SPACE SessionGlobal)
Definition: session.c:209
PMMPDE MmSystemPagePtes
Definition: init.c:41
FORCEINLINE BOOLEAN MiIsRosSectionObject(IN PSECTION Section)
Definition: miarm.h:1101
#define MM_GUARDPAGE
Definition: miarm.h:57
FORCEINLINE VOID MiLockProcessWorkingSetForFault(IN PEPROCESS Process, IN PETHREAD Thread, IN BOOLEAN Safe, IN BOOLEAN Shared)
Definition: miarm.h:1504
struct _PHYSICAL_MEMORY_RUN * PPHYSICAL_MEMORY_RUN
PMMVAD NTAPI MiLocateVad(_In_ PMM_AVL_TABLE Table, _In_ PVOID VirtualAddress)
Definition: vadnode.c:116
PVOID MmNonPagedPoolEnd
Definition: mminit.c:99
PMMPDE MiHighestUserPde
Definition: mminit.c:234
VOID NTAPI MiUnlinkFreeOrZeroedPage(IN PMMPFN Entry)
Definition: pfnlist.c:137
MI_PFN_CACHE_ATTRIBUTE MiPlatformCacheAttributes[2][MmMaximumCacheType]
Definition: iosup.c:27
struct _MMCOLOR_TABLES MMCOLOR_TABLES
VOID NTAPI MiZeroPhysicalPage(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:122
ULONG NTAPI MiMakeSystemAddressValidPfn(IN PVOID VirtualAddress, IN KIRQL OldIrql)
Definition: virtual.c:235
struct _MI_LARGE_PAGE_DRIVER_ENTRY MI_LARGE_PAGE_DRIVER_ENTRY
ULONG_PTR MxPfnAllocation
Definition: init.c:43
SIZE_T MmSessionViewSize
Definition: init.c:35
BOOLEAN NTAPI MiInitializeMemoryEvents(VOID)
Definition: mminit.c:1330
FORCEINLINE BOOLEAN MI_IS_PROCESS_WORKING_SET(PMMSUPPORT WorkingSet)
Definition: miarm.h:665
#define POOL_LISTS_PER_PAGE
Definition: miarm.h:275
PFN_NUMBER MmMinimumFreePages
Definition: mminit.c:314
SIZE_T MmSizeOfNonPagedPoolInBytes
Definition: init.c:21
VOID NTAPI MiSessionAddProcess(IN PEPROCESS NewProcess)
Definition: session.c:423
PFN_NUMBER MiLowPagedPoolThreshold
Definition: mminit.c:302
MMPTE ValidKernelPteLocal
Definition: init.c:33
FORCEINLINE VOID MI_MAKE_PROTOTYPE_PTE(IN PMMPTE NewPte, IN PMMPTE PointerPte)
Definition: miarm.h:858
PMM_SESSION_SPACE MmSessionSpace
Definition: session.c:21
VOID NTAPI MiInitializeColorTables(VOID)
Definition: mminit.c:553
FORCEINLINE VOID MiReferenceUsedPageAndBumpLockCount(IN PMMPFN Pfn1)
Definition: miarm.h:1745
struct _MI_LARGE_PAGE_RANGES * PMI_LARGE_PAGE_RANGES
PFN_NUMBER NTAPI MxGetNextPage(IN PFN_NUMBER PageCount)
Definition: mminit.c:474
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: vadnode.c:711
#define MI_IS_SESSION_ADDRESS(Address)
Definition: miarm.h:185
SIZE_T MmSessionImageSize
Definition: init.c:37
struct _PHYSICAL_MEMORY_DESCRIPTOR * PPHYSICAL_MEMORY_DESCRIPTOR
BOOLEAN MmProtectFreedNonPagedPool
Definition: pool.c:31
BOOLEAN MmEnforceWriteProtection
Definition: sysldr.c:34
ULONG MmVerifyDriverLevel
Definition: drvmgmt.c:26
ULONG MmSecondaryColors
Definition: mminit.c:256
PMMPTE MiFirstReservedZeroingPte
Definition: hypermap.c:21
PVOID MiSessionViewStart
Definition: init.c:30
PMMPTE MiSessionImagePteEnd
Definition: mminit.c:144
VOID NTAPI MiInsertPageInFreeList(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:611
PFN_NUMBER NTAPI MiRemoveAnyPage(IN ULONG Color)
Definition: pfnlist.c:477
KGUARDED_MUTEX MmPagedPoolMutex
Definition: pool.c:24
LIST_ENTRY MmProcessList
Definition: largepag.c:20
MMPDE DemandZeroPde
Definition: init.c:36
#define POOL_BLOCK_SIZE
Definition: miarm.h:273
VOID NTAPI MiReleaseSystemPtes(IN PMMPTE StartingPte, IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:264
enum _MI_PFN_CACHE_ATTRIBUTE MI_PFN_CACHE_ATTRIBUTE
BOOLEAN NTAPI MmArmInitSystem(IN ULONG Phase, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:2037
MMPTE HyperTemplatePte
Definition: hypermap.c:22
VOID NTAPI MiRemoveMappedView(IN PEPROCESS CurrentProcess, IN PMMVAD Vad)
Definition: section.c:766
#define MM_EXECUTE_READWRITE
Definition: miarm.h:49
#define LIST_HEAD
Definition: miarm.h:223
PFN_NUMBER MmResidentAvailableAtInit
Definition: freelist.c:28
struct _POOL_TRACKER_TABLE * PPOOL_TRACKER_TABLE
struct _POOL_DESCRIPTOR POOL_DESCRIPTOR
PFN_NUMBER MmMaximumNonPagedPoolInPages
Definition: mminit.c:30
ULONG ExpNumberOfPagedPools
Definition: expool.c:41
VOID NTAPI MiInitializeSessionIds(VOID)
Definition: session.c:116
FORCEINLINE BOOLEAN MiIsUserPte(PVOID Address)
Definition: miarm.h:729
MMPDE ValidKernelPdeLocal
Definition: init.c:32
PMMADDRESS_NODE NTAPI MiGetPreviousNode(IN PMMADDRESS_NODE Node)
Definition: vadnode.c:425
FORCEINLINE VOID MiUnlockProcessWorkingSetShared(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1218
VOID NTAPI MiInitializePfnAndMakePteValid(IN PFN_NUMBER PageFrameIndex, IN PMMPTE PointerPte, IN MMPTE TempPte)
Definition: pfnlist.c:1041
PVOID MiSessionImageStart
Definition: init.c:29
MMPTE MmDecommittedPte
Definition: init.c:44
struct _POOL_TRACKER_BIG_PAGES * PPOOL_TRACKER_BIG_PAGES
VOID NTAPI MiWriteProtectSystemImage(_In_ PVOID ImageBase)
Definition: sysldr.c:2481
FORCEINLINE VOID MI_MAKE_HARDWARE_PTE_KERNEL(IN PMMPTE NewPte, IN PMMPTE MappingPte, IN ULONG_PTR ProtectionMask, IN PFN_NUMBER PageFrameNumber)
Definition: miarm.h:777
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: contmem.c:214
PFN_NUMBER MmPlentyFreePages
Definition: mminit.c:322
ULONG MmVerifyDriverBufferLength
Definition: drvmgmt.c:24
PMMWSL MmSystemCacheWorkingSetList
Definition: mminit.c:174
BOOLEAN MmMakeLowMemory
Definition: sysldr.c:33
MM_PAGED_POOL_INFO MmPagedPoolInfo
Definition: pool.c:25
WCHAR MmVerifyDriverBuffer[512]
Definition: drvmgmt.c:23
VOID NTAPI MiDeleteARM3Section(PVOID ObjectBody)
Definition: section.c:2951
KSPIN_LOCK MmExpansionLock
Definition: session.c:32
NTSTATUS NTAPI MiInitializeAndChargePfn(OUT PPFN_NUMBER PageFrameIndex, IN PMMPDE PointerPde, IN PFN_NUMBER ContainingPageFrame, IN BOOLEAN SessionAllocation)
Definition: pfnlist.c:1101
SIZE_T MmSessionSize
Definition: init.c:34
FORCEINLINE VOID MiReleaseExpansionLock(KIRQL OldIrql)
Definition: miarm.h:1547
PFN_NUMBER MiHighPagedPoolThreshold
Definition: mminit.c:303
PMMPTE MiSessionLastPte
Definition: mminit.c:146
FORCEINLINE VOID MI_ERASE_PTE(IN PMMPTE PointerPte)
Definition: miarm.h:1009
#define MI_IS_SESSION_PTE(Pte)
Definition: miarm.h:188
#define MI_IS_PAGE_TABLE_ADDRESS(Address)
Definition: miarm.h:191
VOID NTAPI MiInitializeNonPagedPoolThresholds(VOID)
Definition: pool.c:186
VOID NTAPI MiInitializeSessionSpaceLayout(VOID)
Definition: init.c:63
SIZE_T MmSessionPoolSize
Definition: init.c:36
VOID NTAPI MiInitializePfnForOtherProcess(IN PFN_NUMBER PageFrameIndex, IN PVOID PteAddress, IN PFN_NUMBER PteFrame)
Definition: pfnlist.c:1301
PMMPTE MiSessionImagePteStart
Definition: mminit.c:143
FORCEINLINE USHORT MiDecrementPageTableReferences(IN PVOID Address)
Definition: miarm.h:2501
PVOID MiSessionPoolStart
Definition: init.c:32
ULONG MmNumberOfSystemPtes
Definition: init.c:42
struct _POOL_DESCRIPTOR * PPOOL_DESCRIPTOR
NTSTATUS NTAPI MmArmAccessFault(IN ULONG FaultCode, IN PVOID Address, IN KPROCESSOR_MODE Mode, IN PVOID TrapInformation)
Definition: pagfault.c:1698
BOOLEAN MmLargeSystemCache
Definition: mminit.c:340
FORCEINLINE VOID MI_WRITE_VALID_PDE(IN PMMPDE PointerPde, IN MMPDE TempPde)
Definition: miarm.h:1021
VOID NTAPI MiDecrementShareCount(IN PMMPFN Pfn1, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:1141
FORCEINLINE VOID MiUnlockProcessWorkingSet(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1197
struct _MMVIEW * PMMVIEW
PKEVENT MiLowNonPagedPoolEvent
Definition: mminit.c:296
FORCEINLINE VOID MiUnlockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1242
struct _MMCOLOR_TABLES * PMMCOLOR_TABLES
const ULONG MmProtectToValue[32]
Definition: page.c:71
VOID NTAPI MiInitializeDriverLargePageList(VOID)
Definition: largepag.c:68
#define _1MB
Definition: miarm.h:19
ULONG MmTotalFreeSystemPtes[MaximumPtePoolTypes]
Definition: syspte.c:25
PKEVENT MiHighMemoryEvent
Definition: mminit.c:293
PKEVENT MiLowMemoryEvent
Definition: mminit.c:292
struct _MI_LARGE_PAGE_DRIVER_ENTRY * PMI_LARGE_PAGE_DRIVER_ENTRY
ULONG MmProductType
Definition: mminit.c:325
VOID FASTCALL MiSyncARM3WithROS(IN PVOID AddressStart, IN PVOID AddressEnd)
FORCEINLINE VOID MiReferenceUnusedPageAndBumpLockCount(IN PMMPFN Pfn1)
Definition: miarm.h:1790
_MI_PFN_CACHE_ATTRIBUTE
Definition: miarm.h:413
@ MiWriteCombined
Definition: miarm.h:416
@ MiCached
Definition: miarm.h:415
@ MiNotMapped
Definition: miarm.h:417
@ MiNonCached
Definition: miarm.h:414
FORCEINLINE VOID MI_WRITE_INVALID_PTE(IN PMMPTE PointerPte, IN MMPTE InvalidPte)
Definition: miarm.h:996
BOOLEAN MmZeroPageFile
Definition: pagefile.c:71
enum _MI_PFN_CACHE_ATTRIBUTE * PMI_PFN_CACHE_ATTRIBUTE
PPHYSICAL_MEMORY_DESCRIPTOR NTAPI MmInitializeMemoryLimits(IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN PBOOLEAN IncludeType)
Definition: mminit.c:1613
FORCEINLINE VOID MiUnlockWorkingSet(IN PETHREAD Thread, IN PMMSUPPORT WorkingSet)
Definition: miarm.h:1354
VOID NTAPI MiMakePdeExistAndMakeValid(IN PMMPDE PointerPde, IN PEPROCESS TargetProcess, IN KIRQL OldIrql)
Definition: virtual.c:2441
ULONG NTAPI MiMakeSystemAddressValid(IN PVOID PageTableVirtualAddress, IN PEPROCESS CurrentProcess)
Definition: virtual.c:183
VOID NTAPI MiSessionRemoveProcess(VOID)
Definition: session.c:392
FORCEINLINE VOID MiDereferencePfnAndDropLockCount(IN PMMPFN Pfn1)
Definition: miarm.h:1618
MMPFNLIST MmStandbyPageListByPriority[8]
Definition: pfnlist.c:44
PFN_NUMBER MmTotalSystemDriverPages
Definition: sysldr.c:28
struct _PHYSICAL_MEMORY_RUN PHYSICAL_MEMORY_RUN
ULONG MmLargePageDriverBufferLength
Definition: largepag.c:25
NTSTATUS NTAPI MiRosUnmapViewInSystemSpace(IN PVOID MappedBase)
Definition: section.c:4569
SIZE_T MmMaximumNonPagedPoolInBytes
Definition: init.c:22
ULONG MmMaxAdditionNonPagedPoolPerMb
Definition: mminit.c:42
PVOID MmNonPagedPoolExpansionStart
Definition: init.c:25
PMMPTE NTAPI MiReserveSystemPtes(IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:246
VOID NTAPI MiUnlinkPageFromList(IN PMMPFN Pfn)
Definition: pfnlist.c:265
PVOID MmHighSectionBase
Definition: section.c:111
PVOID MmSessionBase
Definition: miarm.h:583
FORCEINLINE VOID MiReferenceProbedPageAndBumpLockCount(IN PMMPFN Pfn1)
Definition: miarm.h:1690
MMPTE PrototypePte
Definition: init.c:40
PSUBSECTION NTAPI MiLocateSubsection(IN PMMVAD Vad, IN ULONG_PTR Vpn)
Definition: section.c:556
BOOLEAN MiLargePageAllDrivers
Definition: largepag.c:27
PFN_NUMBER NTAPI MiPagesInLoaderBlock(IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN PBOOLEAN IncludeType)
MMPTE DemandZeroPte
Definition: init.c:37
FORCEINLINE BOOLEAN MI_IS_MAPPED_PTE(PMMPTE PointerPte)
Definition: miarm.h:923
POOL_DESCRIPTOR NonPagedPoolDescriptor
Definition: expool.c:42
FORCEINLINE BOOLEAN MM_ANY_WS_LOCK_HELD(IN PETHREAD Thread)
Definition: miarm.h:1055
#define SYSTEM_PD_SIZE
Definition: miarm.h:32
BOOLEAN NTAPI MiIsPfnInUse(IN PMMPFN Pfn1)
Definition: freelist.c:174
PPOOL_TRACKER_TABLE PoolTrackTable
Definition: expool.c:49
SIZE_T MmAllocatedNonPagedPool
Definition: pool.c:26
PPOOL_DESCRIPTOR ExpPagedPoolDescriptor[16+1]
Definition: expool.c:43
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: vadnode.c:245
PVOID MiSystemViewStart
Definition: miarm.h:646
ULONG MmMinAdditionNonPagedPoolPerMb
Definition: mminit.c:40
LIST_ENTRY MiLargePageDriverList
Definition: largepag.c:26
ULONG MmSpecialPoolTag
Definition: pool.c:29
PVOID MmHyperSpaceEnd
Definition: init.c:56
struct _PHYSICAL_MEMORY_DESCRIPTOR PHYSICAL_MEMORY_DESCRIPTOR
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
VOID NTAPI MiMapPfnDatabase(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:663
FORCEINLINE BOOLEAN MiIsMemoryTypeFree(TYPE_OF_MEMORY MemoryType)
Definition: miarm.h:672
VOID NTAPI MiDeleteVirtualAddresses(_In_ ULONG_PTR Va, _In_ ULONG_PTR EndingAddress, _In_opt_ PMMVAD Vad)
Definition: virtual.c:530
struct _MMVIEW MMVIEW
KGUARDED_MUTEX MmSectionCommitMutex
Definition: section.c:108
BOOLEAN NTAPI MiInitializeSystemSpaceMap(IN PMMSESSION InputSession OPTIONAL)
Definition: section.c:222
PFN_NUMBER MiLowNonPagedPoolThreshold
Definition: mminit.c:304
FORCEINLINE VOID MiLockWorkingSetShared(_In_ PETHREAD Thread, _In_ PMMSUPPORT WorkingSet)
Definition: miarm.h:1309
MMSUPPORT MmSystemCacheWs
Definition: init.c:55
FORCEINLINE VOID MI_WRITE_INVALID_PDE(IN PMMPDE PointerPde, IN MMPDE InvalidPde)
Definition: miarm.h:1038
PFN_NUMBER MiHighNonPagedPoolThreshold
Definition: mminit.c:305
MEMORY_ALLOCATION_DESCRIPTOR MxOldFreeDescriptor
Definition: init.c:47
BOOLEAN MmMirroring
Definition: pfnlist.c:35
struct _MM_SESSION_SPACE_FLAGS MM_SESSION_SPACE_FLAGS
ULONG MmLargeStackSize
Definition: mminit.c:262
VOID NTAPI MiComputeColorInformation(VOID)
Definition: mminit.c:499
FORCEINLINE VOID MI_MAKE_HARDWARE_PTE(IN PMMPTE NewPte, IN PMMPTE MappingPte, IN ULONG_PTR ProtectionMask, IN PFN_NUMBER PageFrameNumber)
Definition: miarm.h:811
struct _POOL_HEADER POOL_HEADER
VOID NTAPI MiInsertPageInList(IN PMMPFNLIST ListHead, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:779
NTSTATUS NTAPI MiCheckSecuredVad(IN PMMVAD Vad, IN PVOID Base, IN SIZE_T Size, IN ULONG ProtectionMask)
Definition: vadnode.c:815
PKEVENT MiHighPagedPoolEvent
Definition: mminit.c:295
FORCEINLINE BOOLEAN MI_WS_OWNER(IN PEPROCESS Process)
Definition: miarm.h:1080
FORCEINLINE BOOLEAN MiIsUserPde(PVOID Address)
Definition: miarm.h:721
PVOID MmNonPagedPoolStart
Definition: init.c:24
PVOID MiSessionImageEnd
Definition: init.c:28
FORCEINLINE VOID MI_UPDATE_VALID_PTE(IN PMMPTE PointerPte, IN MMPTE TempPte)
Definition: miarm.h:981
VOID NTAPI MiInitializeLargePageSupport(VOID)
Definition: largepag.c:34
SIZE_T MmSystemLockPagesCount
Definition: mdlsup.c:22
NTSTATUS FASTCALL MiCheckPdeForPagedPool(IN PVOID Address)
Definition: pagfault.c:479
VOID NTAPI MiDecrementReferenceCount(IN PMMPFN Pfn1, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:1236
WCHAR MmLargePageDriverBuffer[512]
Definition: largepag.c:24
MM_AVL_TABLE MmSectionBasedRoot
Definition: section.c:109
FORCEINLINE BOOLEAN MiConvertSharedWorkingSetLockToExclusive(_In_ PETHREAD Thread, _In_ PMMSUPPORT Vm)
Definition: miarm.h:1431
enum _MMSYSTEM_PTE_POOL_TYPE MMSYSTEM_PTE_POOL_TYPE
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
FORCEINLINE VOID MI_MAKE_TRANSITION_PTE(_Out_ PMMPTE NewPte, _In_ PFN_NUMBER Page, _In_ ULONG Protection)
Definition: miarm.h:933
FORCEINLINE VOID MI_WRITE_VALID_PTE(IN PMMPTE PointerPte, IN MMPTE TempPte)
Definition: miarm.h:963
FORCEINLINE VOID MiDropLockCount(IN PMMPFN Pfn1)
Definition: miarm.h:1588
PMMPTE MmFirstReservedMappingPte
Definition: hypermap.c:20
FORCEINLINE ULONG_PTR MiDetermineUserGlobalPteMask(IN PVOID PointerPte)
Definition: miarm.h:740
KEVENT MmZeroingPageEvent
Definition: zeropage.c:20
SIZE_T MmDefaultMaximumNonPagedPool
Definition: mminit.c:41
NTSTATUS NTAPI MiInitializeSessionPool(VOID)
Definition: pool.c:1276
VOID NTAPI MiInitializePfn(IN PFN_NUMBER PageFrameIndex, IN PMMPTE PointerPte, IN BOOLEAN Modified)
Definition: pfnlist.c:970
SIZE_T MmAllocationFragment
Definition: mminit.c:352
struct _POOL_TRACKER_BIG_PAGES POOL_TRACKER_BIG_PAGES
PFN_COUNT NTAPI MiDeleteSystemPageableVm(IN PMMPTE PointerPte, IN PFN_NUMBER PageCount, IN ULONG Flags, OUT PPFN_NUMBER ValidPages)
Definition: virtual.c:275
PKEVENT MiLowPagedPoolEvent
Definition: mminit.c:294
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
PFN_NUMBER MmSizeOfPagedPoolInPages
Definition: mminit.c:111
ULONG NTAPI MiMakeProtectionMask(IN ULONG Protect)
Definition: section.c:140
FORCEINLINE USHORT MiIncrementPageTableReferences(IN PVOID Address)
Definition: miarm.h:2475
LIST_ENTRY MmWorkingSetExpansionHead
Definition: session.c:30
LARGE_INTEGER MmCriticalSectionTimeout
Definition: mminit.c:388
#define MM_PROTECT_ACCESS
Definition: miarm.h:51
PVOID MiSessionSpaceWs
Definition: mminit.c:130
struct _MMSESSION * PMMSESSION
PMMADDRESS_NODE NTAPI MiGetNextNode(IN PMMADDRESS_NODE Node)
Definition: vadnode.c:461
VOID NTAPI MiInsertVad(_Inout_ PMMVAD Vad, _Inout_ PMM_AVL_TABLE VadRoot)
NTSTATUS NTAPI MiRosUnmapViewOfSection(_In_ PEPROCESS Process, _In_ PMEMORY_AREA MemoryArea, _In_ PVOID BaseAddress, _In_ BOOLEAN SkipDebuggerNotify)
Definition: section.c:3602
PPHYSICAL_MEMORY_DESCRIPTOR MmPhysicalMemoryBlock
Definition: init.c:45
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: contmem.c:22
NTSTATUS NTAPI MiInitMachineDependent(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:697
ULONG MmConsumedPoolPercentage
Definition: pool.c:30
BOOLEAN MmTrackPtes
Definition: mdlsup.c:20
FORCEINLINE PMMPFN MI_PFN_ELEMENT(IN PFN_NUMBER Pfn)
Definition: miarm.h:1577
SIZE_T MmSystemViewSize
Definition: init.c:39
PVOID MiSessionSpaceEnd
Definition: init.c:27
VOID NTAPI MiSyncCachedRanges(VOID)
Definition: largepag.c:54
const ULONG_PTR MmProtectToPteMask[32]
Definition: page.c:22
SIZE_T MmSizeOfPagedPoolInBytes
Definition: miarm.h:589
MMPDE ValidKernelPde
Definition: init.c:28
FORCEINLINE VOID MiLockProcessWorkingSet(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1127
PMMCOLOR_TABLES MmFreePagesByColor[FreePageList+1]
Definition: mminit.c:286
struct _MM_SESSION_SPACE MM_SESSION_SPACE
PVOID MmSystemCacheStart
Definition: init.c:53
ULONG MmSystemPageColor
Definition: pfnlist.c:36
FORCEINLINE PFN_NUMBER MiRemoveZeroPageSafe(IN ULONG Color)
Definition: miarm.h:2409
PFN_NUMBER MmHighMemoryThreshold
Definition: mminit.c:301
PVOID MiSessionPoolEnd
Definition: init.c:31
NTSTATUS NTAPI MiRosProtectVirtualMemory(IN PEPROCESS Process, IN OUT PVOID *BaseAddress, IN OUT PSIZE_T NumberOfBytesToProtect, IN ULONG NewAccessProtection, OUT PULONG OldAccessProtection OPTIONAL)
struct _POOL_HEADER * PPOOL_HEADER
ULONG MmMaximumDeadKernelStacks
Definition: procsup.c:21
VOID NTAPI MiInitializeSessionWsSupport(VOID)
Definition: session.c:40
PVOID MmSystemCacheEnd
Definition: init.c:54
PLDR_DATA_TABLE_ENTRY NTAPI MiLookupDataTableEntry(IN PVOID Address)
Definition: sysldr.c:3528
PKEVENT MiHighNonPagedPoolEvent
Definition: mminit.c:297
PFN_NUMBER MmSystemPageDirectory[PPE_PER_PAGE]
Definition: init.c:40
FORCEINLINE VOID MiLockProcessWorkingSetUnsafe(IN PEPROCESS Process, IN PETHREAD Thread)
Definition: miarm.h:1172
PVOID MmPagedPoolEnd
Definition: miarm.h:579
FORCEINLINE VOID MiUnlockWorkingSetShared(_In_ PETHREAD Thread, _In_ PMMSUPPORT WorkingSet)
Definition: miarm.h:1392
ULONG MmCritsectTimeoutSeconds
Definition: mminit.c:387
#define PTE_BASE
Definition: mmx86.c:14
#define MiAddressToPde(x)
Definition: mmx86.c:20
#define ASSERT(a)
Definition: mode.c:44
#define KF_GLOBAL_PAGE
Definition: ketypes.h:35
_In_ HANDLE ProcessHandle
Definition: mmfuncs.h:403
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
_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
@ ZeroedPageList
Definition: mmtypes.h:153
@ FreePageList
Definition: mmtypes.h:154
@ ActiveAndValid
Definition: mmtypes.h:159
_In_opt_ ULONG Base
Definition: rtlfuncs.h:2478
_In_ PMEMORY_AREA MemoryArea
Definition: newmm.h:207
#define _Inout_
Definition: no_sal2.h:162
#define _Out_
Definition: no_sal2.h:160
#define _In_
Definition: no_sal2.h:158
#define _In_opt_
Definition: no_sal2.h:212
#define FASTCALL
Definition: nt_native.h:50
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
FORCEINLINE PMMPXE MiPdeToPxe(PMMPDE PointerPde)
Definition: mm.h:300
#define MI_MAKE_OWNER_PAGE(x)
Definition: mm.h:113
FORCEINLINE PMMPDE MiPdeToPpe(PMMPDE PointerPde)
Definition: mm.h:292
#define MiGetPdeOffset(x)
Definition: mm.h:195
#define MI_MAKE_ACCESSED_PAGE(x)
Definition: mm.h:100
#define _MI_PAGING_LEVELS
Definition: mm.h:6
#define SESSION_POOL_LOOKASIDES
Definition: mm.h:84
#define PFN_FROM_PDE(v)
Definition: mm.h:93
#define PTE_PER_PAGE
Definition: mm.h:20
#define PPE_PER_PAGE
Definition: mm.h:22
#define MiPteToAddress(_Pte)
Definition: mm.h:116
#define MiPdeToPte(_Pde)
Definition: mm.h:120
#define PDE_TOP
Definition: mm.h:168
ULONG64 KeFeatureBits
Definition: krnlinit.c:22
FORCEINLINE PMMPFN MiGetPfnEntry(IN PFN_NUMBER Pfn)
Definition: mm.h:1047
FORCEINLINE PFN_NUMBER MiGetPfnEntryIndex(IN PMMPFN Pfn1)
Definition: mm.h:1067
PMMPFN MmPfnDatabase
Definition: freelist.c:24
_In_ PVOID _Out_opt_ BOOLEAN _Out_opt_ PPFN_NUMBER Page
Definition: mm.h:1306
_Out_ PKAPC_STATE ApcState
Definition: mm.h:1770
BOOLEAN NTAPI KeAreAllApcsDisabled(VOID)
Definition: apc.c:985
long LONG
Definition: pedump.c:60
unsigned short USHORT
Definition: pedump.c:61
static WCHAR Address[46]
Definition: ping.c:68
DWORD LCID
Definition: nls.h:13
@ LoaderFree
Definition: arc.h:176
@ LoaderFirmwareTemporary
Definition: arc.h:179
@ LoaderLoadedProgram
Definition: arc.h:178
@ LoaderHALCachedMemory
Definition: arc.h:200
@ LoaderFirmwarePermanent
Definition: arc.h:180
@ LoaderOsloaderStack
Definition: arc.h:182
@ LoaderSpecialMemory
Definition: arc.h:196
@ LoaderBBTMemory
Definition: arc.h:197
enum _TYPE_OF_MEMORY TYPE_OF_MEMORY
#define KeMemoryBarrierWithoutFence()
Definition: ke.h:66
#define PXE_SELFMAP
ULONG * PPFN_NUMBER
Definition: ke.h:9
#define DPRINT
Definition: sndvol32.h:73
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
base of all file and directory entries
Definition: entries.h:83
ULONG OwnsSessionWorkingSetExclusive
Definition: pstypes.h:1226
ULONG OwnsSessionWorkingSetShared
Definition: pstypes.h:1227
ULONG OwnsSystemWorkingSetShared
Definition: pstypes.h:1225
ULONG OwnsProcessWorkingSetShared
Definition: pstypes.h:1223
ULONG OwnsProcessWorkingSetExclusive
Definition: pstypes.h:1222
ULONG OwnsSystemWorkingSetExclusive
Definition: pstypes.h:1224
ULONG PageFrameNumber
Definition: mmtypes.h:109
Definition: btrfs_drv.h:1876
Definition: typedefs.h:120
Definition: miarm.h:400
LIST_ENTRY Links
Definition: miarm.h:401
UNICODE_STRING BaseName
Definition: miarm.h:402
PFN_NUMBER LastFrame
Definition: miarm.h:443
PFN_NUMBER StartFrame
Definition: miarm.h:442
PFN_NUMBER Count
Definition: miarm.h:437
PVOID Blink
Definition: miarm.h:436
PFN_NUMBER Flink
Definition: miarm.h:435
Definition: mm.h:462
Definition: mm.h:391
MMPTE OriginalPte
Definition: mm.h:427
ULONG64 LargePage
Definition: mmtypes.h:165
ULONG64 Valid
Definition: mmtypes.h:150
ULONG64 UsedPageTableEntries
Definition: mmtypes.h:91
MMPTE_SOFTWARE Soft
Definition: mmtypes.h:219
union _MMPTE::@2422 u
MMPTE_HARDWARE Hard
Definition: mmtypes.h:217
ULONG_PTR Long
Definition: mmtypes.h:215
ULONG SystemSpaceHashKey
Definition: miarm.h:460
ULONG SystemSpaceHashEntries
Definition: miarm.h:459
ULONG BitmapFailures
Definition: miarm.h:461
PKGUARDED_MUTEX SystemSpaceViewLockPointer
Definition: miarm.h:455
PRTL_BITMAP SystemSpaceBitMap
Definition: miarm.h:462
PCHAR SystemSpaceViewStart
Definition: miarm.h:456
ULONG SystemSpaceHashSize
Definition: miarm.h:458
PMMVIEW SystemSpaceViewTable
Definition: miarm.h:457
KGUARDED_MUTEX SystemSpaceViewLock
Definition: miarm.h:454
ULONG SessionSpace
Definition: mmtypes.h:905
EX_PUSH_LOCK WorkingSetMutex
Definition: mmtypes.h:961
MMSUPPORT_FLAGS Flags
Definition: mmtypes.h:933
Definition: miarm.h:447
PCONTROL_AREA ControlArea
Definition: miarm.h:449
ULONG_PTR Entry
Definition: miarm.h:448
USHORT UsedPageTableEntries[768]
Definition: mmtypes.h:886
ULONG SessionId
Definition: miarm.h:481
ULONG LongFlags
Definition: miarm.h:478
PFN_NUMBER SessionPageDirectoryIndex
Definition: miarm.h:484
PMMPDE PageTables
Definition: miarm.h:511
LONG ResidentProcessCount
Definition: miarm.h:491
KGUARDED_MUTEX PagedPoolMutex
Definition: miarm.h:502
LARGE_INTEGER LastProcessSwappedOutTime
Definition: miarm.h:483
PVOID PagedPoolStart
Definition: miarm.h:487
MM_PAGED_POOL_INFO PagedPoolInfo
Definition: miarm.h:503
struct _MM_SESSION_SPACE * GlobalVirtualAddress
Definition: miarm.h:474
MM_SESSION_SPACE_FLAGS Flags
Definition: miarm.h:479
ULONG SessionPoolAllocationFailures[4]
Definition: miarm.h:492
PVOID PagedPoolEnd
Definition: miarm.h:488
MMSESSION Session
Definition: miarm.h:501
LONG ImageLoadingCount
Definition: miarm.h:520
LONG ProcessReferenceToSession
Definition: miarm.h:498
ULONG AttachCount
Definition: miarm.h:495
KEVENT AttachEvent
Definition: miarm.h:496
MMSUPPORT Vm
Definition: miarm.h:504
SIZE_T CommittedPages
Definition: miarm.h:486
LIST_ENTRY WsListEntry
Definition: miarm.h:499
LIST_ENTRY ProcessList
Definition: miarm.h:482
union _MM_SESSION_SPACE::@1880 u
SIZE_T NonPageablePages
Definition: miarm.h:485
POOL_DESCRIPTOR PagedPool
Definition: miarm.h:507
LONG ReferenceCount
Definition: miarm.h:475
PEPROCESS LastProcess
Definition: miarm.h:497
PMMWSLE Wsle
Definition: miarm.h:505
PDRIVER_UNLOAD Win32KDriverUnload
Definition: miarm.h:506
LIST_ENTRY ImageList
Definition: miarm.h:493
PMMPDE PagedPoolBasePde
Definition: miarm.h:489
PFN_NUMBER NumberOfPages
Definition: miarm.h:429
PFN_NUMBER PageCount
Definition: miarm.h:423
PFN_NUMBER BasePage
Definition: miarm.h:422
LIST_ENTRY ListHeads[POOL_LISTS_PER_PAGE]
Definition: miarm.h:327
POOL_TYPE PoolType
Definition: miarm.h:315
ULONG Threshold
Definition: miarm.h:321
ULONG RunningAllocs
Definition: miarm.h:317
ULONG TotalPages
Definition: miarm.h:319
SIZE_T TotalBytes
Definition: miarm.h:325
LONG PendingFreeDepth
Definition: miarm.h:324
ULONG PoolIndex
Definition: miarm.h:316
PVOID PendingFrees
Definition: miarm.h:323
ULONG RunningDeAllocs
Definition: miarm.h:318
SIZE_T Spare0
Definition: miarm.h:326
ULONG TotalBigPages
Definition: miarm.h:320
PVOID LockAddress
Definition: miarm.h:322
USHORT PoolTagHash
USHORT AllocatorBackTraceIndex
USHORT PreviousSize
LONG NonPagedAllocs
Definition: miarm.h:374
SIZE_T NonPagedBytes
Definition: miarm.h:376
LONG NonPagedFrees
Definition: miarm.h:375
SIZE_T PagedBytes
Definition: miarm.h:379
Definition: bidi.c:434
ULONG_PTR * PSIZE_T
Definition: typedefs.h:80
uint32_t * PULONG_PTR
Definition: typedefs.h:65
uint32_t * PULONG
Definition: typedefs.h:59
unsigned char * PBOOLEAN
Definition: typedefs.h:53
INT POOL_TYPE
Definition: typedefs.h:78
int16_t * PSHORT
Definition: typedefs.h:55
#define NTAPI
Definition: typedefs.h:36
void * PVOID
Definition: typedefs.h:50
ULONG_PTR SIZE_T
Definition: typedefs.h:80
uint16_t * PUSHORT
Definition: typedefs.h:56
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
char * PCHAR
Definition: typedefs.h:51
Definition: dlist.c:348
_In_ WDFCOLLECTION _In_ ULONG Index
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ _Strict_type_match_ POOL_TYPE PoolType
Definition: wdfdevice.h:3815
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
_Must_inspect_result_ _In_ WDFDMATRANSACTION _In_ PFN_WDF_PROGRAM_DMA _In_ WDF_DMA_DIRECTION _In_ PMDL _In_ PVOID VirtualAddress
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _In_ _In_ _Strict_type_match_ POOL_TYPE _In_opt_ PWDF_OBJECT_ATTRIBUTES _In_opt_ ULONG _Out_ WDFLOOKASIDE * Lookaside
Definition: wdfmemory.h:414
#define FORCEINLINE
Definition: wdftypes.h:67
_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
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
_Inout_ PVOID Segment
Definition: exfuncs.h:1101
struct LOOKASIDE_ALIGN _GENERAL_LOOKASIDE GENERAL_LOOKASIDE
DRIVER_UNLOAD * PDRIVER_UNLOAD
Definition: iotypes.h:2253
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
_Must_inspect_result_ _Outptr_result_bytebuffer_ ViewSize PVOID * MappedBase
Definition: mmfuncs.h:492
_Must_inspect_result_ _In_ PHYSICAL_ADDRESS HighAddress
Definition: mmfuncs.h:226
_Must_inspect_result_ _In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS SkipBytes
Definition: mmfuncs.h:227
_Must_inspect_result_ _In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS _In_opt_ PHYSICAL_ADDRESS _In_ MEMORY_CACHING_TYPE CacheType
Definition: mmfuncs.h:217
_Must_inspect_result_ _In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS _In_ SIZE_T TotalBytes
Definition: mmfuncs.h:228
enum _MM_SYSTEM_SIZE MM_SYSTEMSIZE
enum _MEMORY_CACHING_TYPE MEMORY_CACHING_TYPE
@ MmMaximumCacheType
Definition: mmtypes.h:135
ULONG PFN_COUNT
Definition: mmtypes.h:102
#define NT_ASSERT
Definition: rtlfuncs.h:3327
TABLE_SEARCH_RESULT
Definition: rtltypes.h:386
__wchar_t WCHAR
Definition: xmlstorage.h:180
_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