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
9 #define MI_LOWEST_VAD_ADDRESS (PVOID)MM_LOWEST_USER_ADDRESS
11 /* Make the code cleaner with some definitions for size multiples */
13 #define _1MB (1024 * _1KB)
14 #define _1GB (1024 * _1MB)
16 /* Everyone loves 64K */
17 #define _64K (64 * _1KB)
19 /* Area mapped by a PDE */
20 #define PDE_MAPPED_VA (PTE_COUNT * PAGE_SIZE)
22 /* Size of a page table */
23 #define PT_SIZE (PTE_COUNT * sizeof(MMPTE))
25 /* Size of a page directory */
26 #define PD_SIZE (PDE_COUNT * sizeof(MMPDE))
28 /* Stop using these! */
29 #define PD_COUNT PPE_PER_PAGE
30 #define PDE_COUNT PDE_PER_PAGE
31 #define PTE_COUNT PTE_PER_PAGE
33 /* Size of all page directories for a process */
34 #define SYSTEM_PD_SIZE (PD_COUNT * PD_SIZE)
36 C_ASSERT(SYSTEM_PD_SIZE
== PAGE_SIZE
);
40 // Protection Bits part of the internal memory manager Protection Mask, from:
41 // http://reactos.org/wiki/Techwiki:Memory_management_in_the_Windows_XP_kernel
42 // https://www.reactos.org/wiki/Techwiki:Memory_Protection_constants
43 // and public assertions.
45 #define MM_ZERO_ACCESS 0
48 #define MM_EXECUTE_READ 3
49 #define MM_READWRITE 4
50 #define MM_WRITECOPY 5
51 #define MM_EXECUTE_READWRITE 6
52 #define MM_EXECUTE_WRITECOPY 7
53 #define MM_PROTECT_ACCESS 7
56 // These are flags on top of the actual protection mask
58 #define MM_NOCACHE 0x08
59 #define MM_GUARDPAGE 0x10
60 #define MM_WRITECOMBINE 0x18
61 #define MM_PROTECT_SPECIAL 0x18
64 // These are special cases
66 #define MM_DECOMMIT (MM_ZERO_ACCESS | MM_GUARDPAGE)
67 #define MM_NOACCESS (MM_ZERO_ACCESS | MM_WRITECOMBINE)
68 #define MM_OUTSWAPPED_KSTACK (MM_EXECUTE_WRITECOPY | MM_WRITECOMBINE)
69 #define MM_INVALID_PROTECTION 0xFFFFFFFF
72 // Specific PTE Definitions that map to the Memory Manager's Protection Mask Bits
73 // The Memory Manager's definition define the attributes that must be preserved
74 // and these PTE definitions describe the attributes in the hardware sense. This
75 // helps deal with hardware differences between the actual boolean expression of
78 // For example, in the logical attributes, we want to express read-only as a flag
79 // but on x86, it is writability that must be set. On the other hand, on x86, just
80 // like in the kernel, it is disabling the caches that requires a special flag,
81 // while on certain architectures such as ARM, it is enabling the cache which
84 #if defined(_M_IX86) || defined(_M_AMD64)
88 #define PTE_READONLY 0 // Doesn't exist on x86
89 #define PTE_EXECUTE 0 // Not worrying about NX yet
90 #define PTE_EXECUTE_READ 0 // Not worrying about NX yet
91 #define PTE_READWRITE 0x2
92 #define PTE_WRITECOPY 0x200
93 #define PTE_EXECUTE_READWRITE 0x2 // Not worrying about NX yet
94 #define PTE_EXECUTE_WRITECOPY 0x200
95 #define PTE_PROTOTYPE 0x400
100 #define PTE_VALID 0x1
101 #define PTE_ACCESSED 0x20
102 #define PTE_DIRTY 0x40
107 #define PTE_ENABLE_CACHE 0
108 #define PTE_DISABLE_CACHE 0x10
109 #define PTE_WRITECOMBINED_CACHE 0x10
110 #elif defined(_M_ARM)
111 #define PTE_READONLY 0x200
112 #define PTE_EXECUTE 0 // Not worrying about NX yet
113 #define PTE_EXECUTE_READ 0 // Not worrying about NX yet
114 #define PTE_READWRITE 0 // Doesn't exist on ARM
115 #define PTE_WRITECOPY 0 // Doesn't exist on ARM
116 #define PTE_EXECUTE_READWRITE 0 // Not worrying about NX yet
117 #define PTE_EXECUTE_WRITECOPY 0 // Not worrying about NX yet
118 #define PTE_PROTOTYPE 0x400 // Using the Shared bit
122 #define PTE_ENABLE_CACHE 0
123 #define PTE_DISABLE_CACHE 0x10
124 #define PTE_WRITECOMBINED_CACHE 0x10
126 #error Define these please!
129 extern const ULONG_PTR MmProtectToPteMask
[32];
130 extern const ULONG MmProtectToValue
[32];
133 // Assertions for session images, addresses, and PTEs
135 #define MI_IS_SESSION_IMAGE_ADDRESS(Address) \
136 (((Address) >= MiSessionImageStart) && ((Address) < MiSessionImageEnd))
138 #define MI_IS_SESSION_ADDRESS(Address) \
139 (((Address) >= MmSessionBase) && ((Address) < MiSessionSpaceEnd))
141 #define MI_IS_SESSION_PTE(Pte) \
142 ((((PMMPTE)Pte) >= MiSessionBasePte) && (((PMMPTE)Pte) < MiSessionLastPte))
144 #define MI_IS_PAGE_TABLE_ADDRESS(Address) \
145 (((PVOID)(Address) >= (PVOID)PTE_BASE) && ((PVOID)(Address) <= (PVOID)PTE_TOP))
147 #define MI_IS_SYSTEM_PAGE_TABLE_ADDRESS(Address) \
148 (((Address) >= (PVOID)MiAddressToPte(MmSystemRangeStart)) && ((Address) <= (PVOID)PTE_TOP))
150 #define MI_IS_PAGE_TABLE_OR_HYPER_ADDRESS(Address) \
151 (((PVOID)(Address) >= (PVOID)PTE_BASE) && ((PVOID)(Address) <= (PVOID)MmHyperSpaceEnd))
154 // Creates a software PTE with the given protection
156 #define MI_MAKE_SOFTWARE_PTE(p, x) ((p)->u.Long = (x << MM_PTE_SOFTWARE_PROTECTION_BITS))
159 // Marks a PTE as deleted
161 #define MI_SET_PFN_DELETED(x) ((x)->PteAddress = (PMMPTE)((ULONG_PTR)(x)->PteAddress | 1))
162 #define MI_IS_PFN_DELETED(x) ((ULONG_PTR)((x)->PteAddress) & 1)
165 // Special values for LoadedImports
168 #define MM_SYSLDR_NO_IMPORTS (PVOID)0xFFFFFFFFFFFFFFFEULL
169 #define MM_SYSLDR_BOOT_LOADED (PVOID)0xFFFFFFFFFFFFFFFFULL
171 #define MM_SYSLDR_NO_IMPORTS (PVOID)0xFFFFFFFE
172 #define MM_SYSLDR_BOOT_LOADED (PVOID)0xFFFFFFFF
174 #define MM_SYSLDR_SINGLE_ENTRY 0x1
177 // Number of initial session IDs
179 #define MI_INITIAL_SESSION_IDS 64
181 #if defined(_M_IX86) || defined(_M_ARM)
185 #define LIST_HEAD 0xFFFFFFFF
188 // Because GCC cannot automatically downcast 0xFFFFFFFF to lesser-width bits,
189 // we need a manual definition suited to the number of bits in the PteFrame.
190 // This is used as a LIST_HEAD for the colored list
192 #define COLORED_LIST_HEAD ((1 << 25) - 1) // 0x1FFFFFF
193 #elif defined(_M_AMD64)
194 #define LIST_HEAD 0xFFFFFFFFFFFFFFFFLL
195 #define COLORED_LIST_HEAD ((1ULL << 57) - 1) // 0x1FFFFFFFFFFFFFFLL
197 #error Define these please!
201 // Special IRQL value (found in assertions)
203 #define MM_NOIRQL (KIRQL)0xFFFFFFFF
206 // Returns the color of a page
208 #define MI_GET_PAGE_COLOR(x) ((x) & MmSecondaryColorMask)
209 #define MI_GET_NEXT_COLOR() (MI_GET_PAGE_COLOR(++MmSystemPageColor))
210 #define MI_GET_NEXT_PROCESS_COLOR(x) (MI_GET_PAGE_COLOR(++(x)->NextPageColor))
213 // Prototype PTEs that don't yet have a pagefile association
216 #define MI_PTE_LOOKUP_NEEDED 0xffffffffULL
218 #define MI_PTE_LOOKUP_NEEDED 0xFFFFF
222 // Number of session data and tag pages
224 #define MI_SESSION_DATA_PAGES_MAXIMUM (MM_ALLOCATION_GRANULARITY / PAGE_SIZE)
225 #define MI_SESSION_TAG_PAGES_MAXIMUM (MM_ALLOCATION_GRANULARITY / PAGE_SIZE)
228 // Used by MiCheckSecuredVad
230 #define MM_READ_WRITE_ALLOWED 11
231 #define MM_READ_ONLY_ALLOWED 10
232 #define MM_NO_ACCESS_ALLOWED 01
233 #define MM_DELETE_CHECK 85
236 // System views are binned into 64K chunks
238 #define MI_SYSTEM_VIEW_BUCKET_SIZE _64K
241 // FIXFIX: These should go in ex.h after the pool merge
244 #define POOL_BLOCK_SIZE 16
246 #define POOL_BLOCK_SIZE 8
248 #define POOL_LISTS_PER_PAGE (PAGE_SIZE / POOL_BLOCK_SIZE)
249 #define BASE_POOL_TYPE_MASK 1
250 #define POOL_MAX_ALLOC (PAGE_SIZE - (sizeof(POOL_HEADER) + POOL_BLOCK_SIZE))
253 // Pool debugging/analysis/tracing flags
255 #define POOL_FLAG_CHECK_TIMERS 0x1
256 #define POOL_FLAG_CHECK_WORKERS 0x2
257 #define POOL_FLAG_CHECK_RESOURCES 0x4
258 #define POOL_FLAG_VERIFIER 0x8
259 #define POOL_FLAG_CHECK_DEADLOCK 0x10
260 #define POOL_FLAG_SPECIAL_POOL 0x20
261 #define POOL_FLAG_DBGPRINT_ON_FAILURE 0x40
262 #define POOL_FLAG_CRASH_ON_FAILURE 0x80
265 // BAD_POOL_HEADER codes during pool bugcheck
267 #define POOL_CORRUPTED_LIST 3
268 #define POOL_SIZE_OR_INDEX_MISMATCH 5
269 #define POOL_ENTRIES_NOT_ALIGNED_PREVIOUS 6
270 #define POOL_HEADER_NOT_ALIGNED 7
271 #define POOL_HEADER_IS_ZERO 8
272 #define POOL_ENTRIES_NOT_ALIGNED_NEXT 9
273 #define POOL_ENTRY_NOT_FOUND 10
276 // BAD_POOL_CALLER codes during pool bugcheck
278 #define POOL_ENTRY_CORRUPTED 1
279 #define POOL_ENTRY_ALREADY_FREE 6
280 #define POOL_ENTRY_NOT_ALLOCATED 7
281 #define POOL_ALLOC_IRQL_INVALID 8
282 #define POOL_FREE_IRQL_INVALID 9
283 #define POOL_BILLED_PROCESS_INVALID 13
284 #define POOL_HEADER_SIZE_INVALID 32
286 typedef struct _POOL_DESCRIPTOR
291 ULONG RunningDeAllocs
;
297 LONG PendingFreeDepth
;
300 LIST_ENTRY ListHeads
[POOL_LISTS_PER_PAGE
];
301 } POOL_DESCRIPTOR
, *PPOOL_DESCRIPTOR
;
303 typedef struct _POOL_HEADER
310 USHORT PreviousSize
:8;
315 USHORT PreviousSize
:9;
329 PEPROCESS ProcessBilled
;
335 USHORT AllocatorBackTraceIndex
;
339 } POOL_HEADER
, *PPOOL_HEADER
;
341 C_ASSERT(sizeof(POOL_HEADER
) == POOL_BLOCK_SIZE
);
342 C_ASSERT(POOL_BLOCK_SIZE
== sizeof(LIST_ENTRY
));
344 typedef struct _POOL_TRACKER_TABLE
349 SIZE_T NonPagedBytes
;
353 } POOL_TRACKER_TABLE
, *PPOOL_TRACKER_TABLE
;
355 typedef struct _POOL_TRACKER_BIG_PAGES
361 } POOL_TRACKER_BIG_PAGES
, *PPOOL_TRACKER_BIG_PAGES
;
363 extern ULONG ExpNumberOfPagedPools
;
364 extern POOL_DESCRIPTOR NonPagedPoolDescriptor
;
365 extern PPOOL_DESCRIPTOR ExpPagedPoolDescriptor
[16 + 1];
366 extern PPOOL_TRACKER_TABLE PoolTrackTable
;
372 typedef struct _MI_LARGE_PAGE_DRIVER_ENTRY
375 UNICODE_STRING BaseName
;
376 } MI_LARGE_PAGE_DRIVER_ENTRY
, *PMI_LARGE_PAGE_DRIVER_ENTRY
;
378 typedef enum _MMSYSTEM_PTE_POOL_TYPE
381 NonPagedPoolExpansion
,
383 } MMSYSTEM_PTE_POOL_TYPE
;
385 typedef enum _MI_PFN_CACHE_ATTRIBUTE
391 } MI_PFN_CACHE_ATTRIBUTE
, *PMI_PFN_CACHE_ATTRIBUTE
;
393 typedef struct _PHYSICAL_MEMORY_RUN
396 PFN_NUMBER PageCount
;
397 } PHYSICAL_MEMORY_RUN
, *PPHYSICAL_MEMORY_RUN
;
399 typedef struct _PHYSICAL_MEMORY_DESCRIPTOR
402 PFN_NUMBER NumberOfPages
;
403 PHYSICAL_MEMORY_RUN Run
[1];
404 } PHYSICAL_MEMORY_DESCRIPTOR
, *PPHYSICAL_MEMORY_DESCRIPTOR
;
406 typedef struct _MMCOLOR_TABLES
411 } MMCOLOR_TABLES
, *PMMCOLOR_TABLES
;
413 typedef struct _MI_LARGE_PAGE_RANGES
415 PFN_NUMBER StartFrame
;
416 PFN_NUMBER LastFrame
;
417 } MI_LARGE_PAGE_RANGES
, *PMI_LARGE_PAGE_RANGES
;
419 typedef struct _MMVIEW
422 PCONTROL_AREA ControlArea
;
425 typedef struct _MMSESSION
427 KGUARDED_MUTEX SystemSpaceViewLock
;
428 PKGUARDED_MUTEX SystemSpaceViewLockPointer
;
429 PCHAR SystemSpaceViewStart
;
430 PMMVIEW SystemSpaceViewTable
;
431 ULONG SystemSpaceHashSize
;
432 ULONG SystemSpaceHashEntries
;
433 ULONG SystemSpaceHashKey
;
434 ULONG BitmapFailures
;
435 PRTL_BITMAP SystemSpaceBitMap
;
436 } MMSESSION
, *PMMSESSION
;
438 typedef struct _MM_SESSION_SPACE_FLAGS
441 ULONG DeletePending
:1;
443 } MM_SESSION_SPACE_FLAGS
;
445 typedef struct _MM_SESSION_SPACE
447 struct _MM_SESSION_SPACE
*GlobalVirtualAddress
;
452 MM_SESSION_SPACE_FLAGS Flags
;
455 LIST_ENTRY ProcessList
;
456 LARGE_INTEGER LastProcessSwappedOutTime
;
457 PFN_NUMBER SessionPageDirectoryIndex
;
458 SIZE_T NonPageablePages
;
459 SIZE_T CommittedPages
;
460 PVOID PagedPoolStart
;
462 PMMPDE PagedPoolBasePde
;
464 LONG ResidentProcessCount
;
465 ULONG SessionPoolAllocationFailures
[4];
466 LIST_ENTRY ImageList
;
470 PEPROCESS LastProcess
;
471 LONG ProcessReferenceToSession
;
472 LIST_ENTRY WsListEntry
;
473 GENERAL_LOOKASIDE Lookaside
[SESSION_POOL_LOOKASIDES
];
475 KGUARDED_MUTEX PagedPoolMutex
;
476 MM_PAGED_POOL_INFO PagedPoolInfo
;
479 PDRIVER_UNLOAD Win32KDriverUnload
;
480 POOL_DESCRIPTOR PagedPool
;
481 #if defined (_M_AMD64)
486 #if defined (_M_AMD64)
487 PMMPTE SpecialPoolFirstPte
;
488 PMMPTE SpecialPoolLastPte
;
489 PMMPTE NextPdeForSpecialPoolExpansion
;
490 PMMPTE LastPdeForSpecialPoolExpansion
;
491 PFN_NUMBER SpecialPagesInUse
;
493 LONG ImageLoadingCount
;
494 } MM_SESSION_SPACE
, *PMM_SESSION_SPACE
;
496 extern PMM_SESSION_SPACE MmSessionSpace
;
497 extern MMPTE HyperTemplatePte
;
498 extern MMPDE ValidKernelPde
;
499 extern MMPTE ValidKernelPte
;
500 extern MMPDE ValidKernelPdeLocal
;
501 extern MMPTE ValidKernelPteLocal
;
502 extern MMPDE DemandZeroPde
;
503 extern MMPTE DemandZeroPte
;
504 extern MMPTE PrototypePte
;
505 extern MMPTE MmDecommittedPte
;
506 extern BOOLEAN MmLargeSystemCache
;
507 extern BOOLEAN MmZeroPageFile
;
508 extern BOOLEAN MmProtectFreedNonPagedPool
;
509 extern BOOLEAN MmTrackLockedPages
;
510 extern BOOLEAN MmTrackPtes
;
511 extern BOOLEAN MmDynamicPfn
;
512 extern BOOLEAN MmMirroring
;
513 extern BOOLEAN MmMakeLowMemory
;
514 extern BOOLEAN MmEnforceWriteProtection
;
515 extern SIZE_T MmAllocationFragment
;
516 extern ULONG MmConsumedPoolPercentage
;
517 extern ULONG MmVerifyDriverBufferType
;
518 extern ULONG MmVerifyDriverLevel
;
519 extern WCHAR MmVerifyDriverBuffer
[512];
520 extern WCHAR MmLargePageDriverBuffer
[512];
521 extern LIST_ENTRY MiLargePageDriverList
;
522 extern BOOLEAN MiLargePageAllDrivers
;
523 extern ULONG MmVerifyDriverBufferLength
;
524 extern ULONG MmLargePageDriverBufferLength
;
525 extern SIZE_T MmSizeOfNonPagedPoolInBytes
;
526 extern SIZE_T MmMaximumNonPagedPoolInBytes
;
527 extern PFN_NUMBER MmMaximumNonPagedPoolInPages
;
528 extern PFN_NUMBER MmSizeOfPagedPoolInPages
;
529 extern PVOID MmNonPagedSystemStart
;
530 extern PVOID MmNonPagedPoolStart
;
531 extern PVOID MmNonPagedPoolExpansionStart
;
532 extern PVOID MmNonPagedPoolEnd
;
533 extern SIZE_T MmSizeOfPagedPoolInBytes
;
534 extern PVOID MmPagedPoolStart
;
535 extern PVOID MmPagedPoolEnd
;
536 extern PVOID MmSessionBase
;
537 extern SIZE_T MmSessionSize
;
538 extern PMMPTE MmFirstReservedMappingPte
, MmLastReservedMappingPte
;
539 extern PMMPTE MiFirstReservedZeroingPte
;
540 extern MI_PFN_CACHE_ATTRIBUTE MiPlatformCacheAttributes
[2][MmMaximumCacheType
];
541 extern PPHYSICAL_MEMORY_DESCRIPTOR MmPhysicalMemoryBlock
;
542 extern SIZE_T MmBootImageSize
;
543 extern PMMPTE MmSystemPtesStart
[MaximumPtePoolTypes
];
544 extern PMMPTE MmSystemPtesEnd
[MaximumPtePoolTypes
];
545 extern PMEMORY_ALLOCATION_DESCRIPTOR MxFreeDescriptor
;
546 extern MEMORY_ALLOCATION_DESCRIPTOR MxOldFreeDescriptor
;
547 extern ULONG_PTR MxPfnAllocation
;
548 extern MM_PAGED_POOL_INFO MmPagedPoolInfo
;
549 extern RTL_BITMAP MiPfnBitMap
;
550 extern KGUARDED_MUTEX MmPagedPoolMutex
;
551 extern KGUARDED_MUTEX MmSectionCommitMutex
;
552 extern PVOID MmPagedPoolStart
;
553 extern PVOID MmPagedPoolEnd
;
554 extern PVOID MmNonPagedSystemStart
;
555 extern PVOID MiSystemViewStart
;
556 extern SIZE_T MmSystemViewSize
;
557 extern PVOID MmSessionBase
;
558 extern PVOID MiSessionSpaceEnd
;
559 extern PMMPTE MiSessionImagePteStart
;
560 extern PMMPTE MiSessionImagePteEnd
;
561 extern PMMPTE MiSessionBasePte
;
562 extern PMMPTE MiSessionLastPte
;
563 extern SIZE_T MmSizeOfPagedPoolInBytes
;
564 extern PMMPDE MmSystemPagePtes
;
565 extern PVOID MmSystemCacheStart
;
566 extern PVOID MmSystemCacheEnd
;
567 extern MMSUPPORT MmSystemCacheWs
;
568 extern SIZE_T MmAllocatedNonPagedPool
;
569 extern ULONG MmSpecialPoolTag
;
570 extern PVOID MmHyperSpaceEnd
;
571 extern PMMWSL MmSystemCacheWorkingSetList
;
572 extern SIZE_T MmMinimumNonPagedPoolSize
;
573 extern ULONG MmMinAdditionNonPagedPoolPerMb
;
574 extern SIZE_T MmDefaultMaximumNonPagedPool
;
575 extern ULONG MmMaxAdditionNonPagedPoolPerMb
;
576 extern ULONG MmSecondaryColors
;
577 extern ULONG MmSecondaryColorMask
;
578 extern ULONG MmNumberOfSystemPtes
;
579 extern ULONG MmMaximumNonPagedPoolPercent
;
580 extern ULONG MmLargeStackSize
;
581 extern PMMCOLOR_TABLES MmFreePagesByColor
[FreePageList
+ 1];
582 extern MMPFNLIST MmStandbyPageListByPriority
[8];
583 extern ULONG MmProductType
;
584 extern MM_SYSTEMSIZE MmSystemSize
;
585 extern PKEVENT MiLowMemoryEvent
;
586 extern PKEVENT MiHighMemoryEvent
;
587 extern PKEVENT MiLowPagedPoolEvent
;
588 extern PKEVENT MiHighPagedPoolEvent
;
589 extern PKEVENT MiLowNonPagedPoolEvent
;
590 extern PKEVENT MiHighNonPagedPoolEvent
;
591 extern PFN_NUMBER MmLowMemoryThreshold
;
592 extern PFN_NUMBER MmHighMemoryThreshold
;
593 extern PFN_NUMBER MiLowPagedPoolThreshold
;
594 extern PFN_NUMBER MiHighPagedPoolThreshold
;
595 extern PFN_NUMBER MiLowNonPagedPoolThreshold
;
596 extern PFN_NUMBER MiHighNonPagedPoolThreshold
;
597 extern PFN_NUMBER MmMinimumFreePages
;
598 extern PFN_NUMBER MmPlentyFreePages
;
599 extern SIZE_T MmMinimumStackCommitInBytes
;
600 extern PFN_COUNT MiExpansionPoolPagesInitialCharge
;
601 extern PFN_NUMBER MmResidentAvailablePages
;
602 extern PFN_NUMBER MmResidentAvailableAtInit
;
603 extern ULONG MmTotalFreeSystemPtes
[MaximumPtePoolTypes
];
604 extern PFN_NUMBER MmTotalSystemDriverPages
;
605 extern ULONG MmCritsectTimeoutSeconds
;
606 extern PVOID MiSessionImageStart
;
607 extern PVOID MiSessionImageEnd
;
608 extern PMMPTE MiHighestUserPte
;
609 extern PMMPDE MiHighestUserPde
;
610 extern PFN_NUMBER MmSystemPageDirectory
[PD_COUNT
];
611 extern PMMPTE MmSharedUserDataPte
;
612 extern LIST_ENTRY MmProcessList
;
613 extern BOOLEAN MmZeroingPageThreadActive
;
614 extern KEVENT MmZeroingPageEvent
;
615 extern ULONG MmSystemPageColor
;
616 extern ULONG MmProcessColorSeed
;
617 extern PMMWSL MmWorkingSetList
;
618 extern PFN_NUMBER MiNumberOfFreePages
;
619 extern SIZE_T MmSessionViewSize
;
620 extern SIZE_T MmSessionPoolSize
;
621 extern SIZE_T MmSessionImageSize
;
622 extern PVOID MiSystemViewStart
;
623 extern PVOID MiSessionPoolEnd
; // 0xBE000000
624 extern PVOID MiSessionPoolStart
; // 0xBD000000
625 extern PVOID MiSessionViewStart
; // 0xBE000000
626 extern PVOID MiSessionSpaceWs
;
627 extern ULONG MmMaximumDeadKernelStacks
;
628 extern SLIST_HEADER MmDeadStackSListHead
;
629 extern MM_AVL_TABLE MmSectionBasedRoot
;
630 extern KGUARDED_MUTEX MmSectionBasedMutex
;
631 extern PVOID MmHighSectionBase
;
632 extern SIZE_T MmSystemLockPagesCount
;
633 extern ULONG_PTR MmSubsectionBase
;
634 extern LARGE_INTEGER MmCriticalSectionTimeout
;
635 extern LIST_ENTRY MmWorkingSetExpansionHead
;
636 extern KSPIN_LOCK MmExpansionLock
;
637 extern PETHREAD MiExpansionLockOwner
;
641 MiIsMemoryTypeFree(TYPE_OF_MEMORY MemoryType
)
643 return ((MemoryType
== LoaderFree
) ||
644 (MemoryType
== LoaderLoadedProgram
) ||
645 (MemoryType
== LoaderFirmwareTemporary
) ||
646 (MemoryType
== LoaderOsloaderStack
));
651 MiIsMemoryTypeInvisible(TYPE_OF_MEMORY MemoryType
)
653 return ((MemoryType
== LoaderFirmwarePermanent
) ||
654 (MemoryType
== LoaderSpecialMemory
) ||
655 (MemoryType
== LoaderHALCachedMemory
) ||
656 (MemoryType
== LoaderBBTMemory
));
662 MiIsUserPxe(PVOID Address
)
664 return ((ULONG_PTR
)Address
>> 7) == 0x1FFFFEDF6FB7DA0ULL
;
669 MiIsUserPpe(PVOID Address
)
671 return ((ULONG_PTR
)Address
>> 16) == 0xFFFFF6FB7DA0ULL
;
676 MiIsUserPde(PVOID Address
)
678 return ((ULONG_PTR
)Address
>> 25) == 0x7FFFFB7DA0ULL
;
683 MiIsUserPte(PVOID Address
)
685 return ((ULONG_PTR
)Address
>> 34) == 0x3FFFFDA0ULL
;
690 MiIsUserPde(PVOID Address
)
692 return ((Address
>= (PVOID
)MiAddressToPde(NULL
)) &&
693 (Address
<= (PVOID
)MiHighestUserPde
));
698 MiIsUserPte(PVOID Address
)
700 return (Address
<= (PVOID
)MiHighestUserPte
);
705 // Figures out the hardware bits for a PTE
709 MiDetermineUserGlobalPteMask(IN PVOID PointerPte
)
716 /* Make it valid and accessed */
717 TempPte
.u
.Hard
.Valid
= TRUE
;
718 MI_MAKE_ACCESSED_PAGE(&TempPte
);
720 /* Is this for user-mode? */
722 #if (_MI_PAGING_LEVELS == 4)
723 MiIsUserPxe(PointerPte
) ||
725 #if (_MI_PAGING_LEVELS >= 3)
726 MiIsUserPpe(PointerPte
) ||
728 MiIsUserPde(PointerPte
) ||
729 MiIsUserPte(PointerPte
))
731 /* Set the owner bit */
732 MI_MAKE_OWNER_PAGE(&TempPte
);
735 /* FIXME: We should also set the global bit */
737 /* Return the protection */
738 return TempPte
.u
.Long
;
742 // Creates a valid kernel PTE with the given protection
746 MI_MAKE_HARDWARE_PTE_KERNEL(IN PMMPTE NewPte
,
747 IN PMMPTE MappingPte
,
748 IN ULONG_PTR ProtectionMask
,
749 IN PFN_NUMBER PageFrameNumber
)
751 /* Only valid for kernel, non-session PTEs */
752 ASSERT(MappingPte
> MiHighestUserPte
);
753 ASSERT(!MI_IS_SESSION_PTE(MappingPte
));
754 ASSERT((MappingPte
< (PMMPTE
)PDE_BASE
) || (MappingPte
> (PMMPTE
)PDE_TOP
));
757 *NewPte
= ValidKernelPte
;
759 /* Set the protection and page */
760 NewPte
->u
.Hard
.PageFrameNumber
= PageFrameNumber
;
761 NewPte
->u
.Long
|= MmProtectToPteMask
[ProtectionMask
];
765 // Creates a valid PTE with the given protection
769 MI_MAKE_HARDWARE_PTE(IN PMMPTE NewPte
,
770 IN PMMPTE MappingPte
,
771 IN ULONG_PTR ProtectionMask
,
772 IN PFN_NUMBER PageFrameNumber
)
774 /* Set the protection and page */
775 NewPte
->u
.Long
= MiDetermineUserGlobalPteMask(MappingPte
);
776 NewPte
->u
.Long
|= MmProtectToPteMask
[ProtectionMask
];
777 NewPte
->u
.Hard
.PageFrameNumber
= PageFrameNumber
;
781 // Creates a valid user PTE with the given protection
785 MI_MAKE_HARDWARE_PTE_USER(IN PMMPTE NewPte
,
786 IN PMMPTE MappingPte
,
787 IN ULONG_PTR ProtectionMask
,
788 IN PFN_NUMBER PageFrameNumber
)
790 /* Only valid for kernel, non-session PTEs */
791 ASSERT(MappingPte
<= MiHighestUserPte
);
796 /* Set the protection and page */
797 NewPte
->u
.Hard
.Valid
= TRUE
;
798 NewPte
->u
.Hard
.Owner
= TRUE
;
799 NewPte
->u
.Hard
.PageFrameNumber
= PageFrameNumber
;
800 NewPte
->u
.Long
|= MmProtectToPteMask
[ProtectionMask
];
805 // Builds a Prototype PTE for the address of the PTE
809 MI_MAKE_PROTOTYPE_PTE(IN PMMPTE NewPte
,
810 IN PMMPTE PointerPte
)
814 /* Mark this as a prototype */
816 NewPte
->u
.Proto
.Prototype
= 1;
819 * Prototype PTEs are only valid in paged pool by design, this little trick
820 * lets us only use 30 bits for the adress of the PTE, as long as the area
821 * stays 1024MB At most.
823 Offset
= (ULONG_PTR
)PointerPte
- (ULONG_PTR
)MmPagedPoolStart
;
826 * 7 bits go in the "low" (but we assume the bottom 2 are zero)
827 * and the other 21 bits go in the "high"
829 NewPte
->u
.Proto
.ProtoAddressLow
= (Offset
& 0x1FC) >> 2;
830 NewPte
->u
.Proto
.ProtoAddressHigh
= (Offset
& 0x3FFFFE00) >> 9;
834 // Builds a Subsection PTE for the address of the Segment
838 MI_MAKE_SUBSECTION_PTE(IN PMMPTE NewPte
,
843 /* Mark this as a prototype */
845 NewPte
->u
.Subsect
.Prototype
= 1;
848 * Segments are only valid either in nonpaged pool. We store the 20 bit
849 * difference either from the top or bottom of nonpaged pool, giving a
850 * maximum of 128MB to each delta, meaning nonpaged pool cannot exceed
853 if ((ULONG_PTR
)Segment
< ((ULONG_PTR
)MmSubsectionBase
+ (128 * _1MB
)))
855 Offset
= (ULONG_PTR
)Segment
- (ULONG_PTR
)MmSubsectionBase
;
856 NewPte
->u
.Subsect
.WhichPool
= PagedPool
;
860 Offset
= (ULONG_PTR
)MmNonPagedPoolEnd
- (ULONG_PTR
)Segment
;
861 NewPte
->u
.Subsect
.WhichPool
= NonPagedPool
;
865 * 4 bits go in the "low" (but we assume the bottom 3 are zero)
866 * and the other 20 bits go in the "high"
868 NewPte
->u
.Subsect
.SubsectionAddressLow
= (Offset
& 0x78) >> 3;
869 NewPte
->u
.Subsect
.SubsectionAddressHigh
= (Offset
& 0xFFFFF80) >> 7;
874 MI_IS_MAPPED_PTE(PMMPTE PointerPte
)
876 /// \todo Make this reasonable code, this is UGLY!
877 return ((PointerPte
->u
.Long
& 0xFFFFFC01) != 0);
884 MI_MAKE_TRANSITION_PTE(_Out_ PMMPTE NewPte
,
885 _In_ PFN_NUMBER Page
,
886 _In_ ULONG Protection
)
889 NewPte
->u
.Trans
.Transition
= 1;
890 NewPte
->u
.Trans
.Protection
= Protection
;
891 NewPte
->u
.Trans
.PageFrameNumber
= Page
;
895 // Returns if the page is physically resident (ie: a large page)
896 // FIXFIX: CISC/x86 only?
900 MI_IS_PHYSICAL_ADDRESS(IN PVOID Address
)
904 /* Large pages are never paged out, always physically resident */
905 PointerPde
= MiAddressToPde(Address
);
906 return ((PointerPde
->u
.Hard
.LargePage
) && (PointerPde
->u
.Hard
.Valid
));
910 // Writes a valid PTE
914 MI_WRITE_VALID_PTE(IN PMMPTE PointerPte
,
917 /* Write the valid PTE */
918 ASSERT(PointerPte
->u
.Hard
.Valid
== 0);
919 ASSERT(TempPte
.u
.Hard
.Valid
== 1);
920 *PointerPte
= TempPte
;
924 // Updates a valid PTE
928 MI_UPDATE_VALID_PTE(IN PMMPTE PointerPte
,
931 /* Write the valid PTE */
932 ASSERT(PointerPte
->u
.Hard
.Valid
== 1);
933 ASSERT(TempPte
.u
.Hard
.Valid
== 1);
934 ASSERT(PointerPte
->u
.Hard
.PageFrameNumber
== TempPte
.u
.Hard
.PageFrameNumber
);
935 *PointerPte
= TempPte
;
939 // Writes an invalid PTE
943 MI_WRITE_INVALID_PTE(IN PMMPTE PointerPte
,
946 /* Write the invalid PTE */
947 ASSERT(InvalidPte
.u
.Hard
.Valid
== 0);
948 ASSERT(InvalidPte
.u
.Long
!= 0);
949 *PointerPte
= InvalidPte
;
953 // Erase the PTE completely
957 MI_ERASE_PTE(IN PMMPTE PointerPte
)
959 /* Zero out the PTE */
960 ASSERT(PointerPte
->u
.Long
!= 0);
961 PointerPte
->u
.Long
= 0;
965 // Writes a valid PDE
969 MI_WRITE_VALID_PDE(IN PMMPDE PointerPde
,
972 /* Write the valid PDE */
973 ASSERT(PointerPde
->u
.Hard
.Valid
== 0);
974 ASSERT(TempPde
.u
.Hard
.Valid
== 1);
975 *PointerPde
= TempPde
;
979 // Writes an invalid PDE
983 MI_WRITE_INVALID_PDE(IN PMMPDE PointerPde
,
986 /* Write the invalid PDE */
987 ASSERT(InvalidPde
.u
.Hard
.Valid
== 0);
988 ASSERT(InvalidPde
.u
.Long
!= 0);
989 *PointerPde
= InvalidPde
;
993 // Checks if the thread already owns a working set
997 MM_ANY_WS_LOCK_HELD(IN PETHREAD Thread
)
999 /* If any of these are held, return TRUE */
1000 return ((Thread
->OwnsProcessWorkingSetExclusive
) ||
1001 (Thread
->OwnsProcessWorkingSetShared
) ||
1002 (Thread
->OwnsSystemWorkingSetExclusive
) ||
1003 (Thread
->OwnsSystemWorkingSetShared
) ||
1004 (Thread
->OwnsSessionWorkingSetExclusive
) ||
1005 (Thread
->OwnsSessionWorkingSetShared
));
1009 // Checks if the process owns the working set lock
1013 MI_WS_OWNER(IN PEPROCESS Process
)
1015 /* Check if this process is the owner, and that the thread owns the WS */
1016 if (PsGetCurrentThread()->OwnsProcessWorkingSetExclusive
== 0)
1018 DPRINT("Thread: %p is not an owner\n", PsGetCurrentThread());
1020 if (KeGetCurrentThread()->ApcState
.Process
!= &Process
->Pcb
)
1022 DPRINT("Current thread %p is attached to another process %p\n", PsGetCurrentThread(), Process
);
1024 return ((KeGetCurrentThread()->ApcState
.Process
== &Process
->Pcb
) &&
1025 ((PsGetCurrentThread()->OwnsProcessWorkingSetExclusive
) ||
1026 (PsGetCurrentThread()->OwnsProcessWorkingSetShared
)));
1030 // New ARM3<->RosMM PAGE Architecture
1034 MiIsRosSectionObject(IN PVOID Section
)
1036 PROS_SECTION_OBJECT RosSection
= Section
;
1037 if ((RosSection
->Type
== 'SC') && (RosSection
->Size
== 'TN')) return TRUE
;
1041 #define MI_IS_ROS_PFN(x) ((x)->u4.AweAllocation == TRUE)
1045 MiDecrementReferenceCount(
1047 IN PFN_NUMBER PageFrameIndex
1052 MI_IS_WS_UNSAFE(IN PEPROCESS Process
)
1054 return (Process
->Vm
.Flags
.AcquiredUnsafe
== TRUE
);
1058 // Locks the working set for the given process
1062 MiLockProcessWorkingSet(IN PEPROCESS Process
,
1065 /* Shouldn't already be owning the process working set */
1066 ASSERT(Thread
->OwnsProcessWorkingSetShared
== FALSE
);
1067 ASSERT(Thread
->OwnsProcessWorkingSetExclusive
== FALSE
);
1069 /* Block APCs, make sure that still nothing is already held */
1070 KeEnterGuardedRegion();
1071 ASSERT(!MM_ANY_WS_LOCK_HELD(Thread
));
1073 /* Lock the working set */
1074 ExAcquirePushLockExclusive(&Process
->Vm
.WorkingSetMutex
);
1076 /* Now claim that we own the lock */
1077 ASSERT(!MI_IS_WS_UNSAFE(Process
));
1078 ASSERT(Thread
->OwnsProcessWorkingSetExclusive
== FALSE
);
1079 Thread
->OwnsProcessWorkingSetExclusive
= TRUE
;
1084 MiLockProcessWorkingSetShared(IN PEPROCESS Process
,
1087 /* Shouldn't already be owning the process working set */
1088 ASSERT(Thread
->OwnsProcessWorkingSetShared
== FALSE
);
1089 ASSERT(Thread
->OwnsProcessWorkingSetExclusive
== FALSE
);
1091 /* Block APCs, make sure that still nothing is already held */
1092 KeEnterGuardedRegion();
1093 ASSERT(!MM_ANY_WS_LOCK_HELD(Thread
));
1095 /* Lock the working set */
1096 ExAcquirePushLockShared(&Process
->Vm
.WorkingSetMutex
);
1098 /* Now claim that we own the lock */
1099 ASSERT(!MI_IS_WS_UNSAFE(Process
));
1100 ASSERT(Thread
->OwnsProcessWorkingSetShared
== FALSE
);
1101 ASSERT(Thread
->OwnsProcessWorkingSetExclusive
== FALSE
);
1102 Thread
->OwnsProcessWorkingSetShared
= TRUE
;
1107 MiLockProcessWorkingSetUnsafe(IN PEPROCESS Process
,
1110 /* Shouldn't already be owning the process working set */
1111 ASSERT(Thread
->OwnsProcessWorkingSetExclusive
== FALSE
);
1113 /* APCs must be blocked, make sure that still nothing is already held */
1114 ASSERT(KeAreAllApcsDisabled() == TRUE
);
1115 ASSERT(!MM_ANY_WS_LOCK_HELD(Thread
));
1117 /* Lock the working set */
1118 ExAcquirePushLockExclusive(&Process
->Vm
.WorkingSetMutex
);
1120 /* Now claim that we own the lock */
1121 ASSERT(!MI_IS_WS_UNSAFE(Process
));
1122 Process
->Vm
.Flags
.AcquiredUnsafe
= 1;
1123 ASSERT(Thread
->OwnsProcessWorkingSetExclusive
== FALSE
);
1124 Thread
->OwnsProcessWorkingSetExclusive
= TRUE
;
1128 // Unlocks the working set for the given process
1132 MiUnlockProcessWorkingSet(IN PEPROCESS Process
,
1135 /* Make sure we are the owner of a safe acquisition */
1136 ASSERT(MI_WS_OWNER(Process
));
1137 ASSERT(!MI_IS_WS_UNSAFE(Process
));
1139 /* The thread doesn't own it anymore */
1140 ASSERT(Thread
->OwnsProcessWorkingSetExclusive
== TRUE
);
1141 Thread
->OwnsProcessWorkingSetExclusive
= FALSE
;
1143 /* Release the lock and re-enable APCs */
1144 ExReleasePushLockExclusive(&Process
->Vm
.WorkingSetMutex
);
1145 KeLeaveGuardedRegion();
1149 // Unlocks the working set for the given process
1153 MiUnlockProcessWorkingSetShared(IN PEPROCESS Process
,
1156 /* Make sure we are the owner of a safe acquisition (because shared) */
1157 ASSERT(MI_WS_OWNER(Process
));
1158 ASSERT(!MI_IS_WS_UNSAFE(Process
));
1160 /* Ensure we are in a shared acquisition */
1161 ASSERT(Thread
->OwnsProcessWorkingSetShared
== TRUE
);
1162 ASSERT(Thread
->OwnsProcessWorkingSetExclusive
== FALSE
);
1164 /* Don't claim the lock anylonger */
1165 Thread
->OwnsProcessWorkingSetShared
= FALSE
;
1167 /* Release the lock and re-enable APCs */
1168 ExReleasePushLockShared(&Process
->Vm
.WorkingSetMutex
);
1169 KeLeaveGuardedRegion();
1173 // Unlocks the working set for the given process
1177 MiUnlockProcessWorkingSetUnsafe(IN PEPROCESS Process
,
1180 /* Make sure we are the owner of an unsafe acquisition */
1181 ASSERT(KeGetCurrentIrql() <= APC_LEVEL
);
1182 ASSERT(KeAreAllApcsDisabled() == TRUE
);
1183 ASSERT(MI_WS_OWNER(Process
));
1184 ASSERT(MI_IS_WS_UNSAFE(Process
));
1186 /* No longer unsafe */
1187 Process
->Vm
.Flags
.AcquiredUnsafe
= 0;
1189 /* The thread doesn't own it anymore */
1190 ASSERT(Thread
->OwnsProcessWorkingSetExclusive
== TRUE
);
1191 Thread
->OwnsProcessWorkingSetExclusive
= FALSE
;
1193 /* Release the lock but don't touch APC state */
1194 ExReleasePushLockExclusive(&Process
->Vm
.WorkingSetMutex
);
1195 ASSERT(KeGetCurrentIrql() <= APC_LEVEL
);
1199 // Locks the working set
1203 MiLockWorkingSet(IN PETHREAD Thread
,
1204 IN PMMSUPPORT WorkingSet
)
1207 KeEnterGuardedRegion();
1209 /* Working set should be in global memory */
1210 ASSERT(MI_IS_SESSION_ADDRESS((PVOID
)WorkingSet
) == FALSE
);
1212 /* Thread shouldn't already be owning something */
1213 ASSERT(!MM_ANY_WS_LOCK_HELD(Thread
));
1215 /* Lock this working set */
1216 ExAcquirePushLockExclusive(&WorkingSet
->WorkingSetMutex
);
1218 /* Which working set is this? */
1219 if (WorkingSet
== &MmSystemCacheWs
)
1221 /* Own the system working set */
1222 ASSERT((Thread
->OwnsSystemWorkingSetExclusive
== FALSE
) &&
1223 (Thread
->OwnsSystemWorkingSetShared
== FALSE
));
1224 Thread
->OwnsSystemWorkingSetExclusive
= TRUE
;
1226 else if (WorkingSet
->Flags
.SessionSpace
)
1228 /* Own the session working set */
1229 ASSERT((Thread
->OwnsSessionWorkingSetExclusive
== FALSE
) &&
1230 (Thread
->OwnsSessionWorkingSetShared
== FALSE
));
1231 Thread
->OwnsSessionWorkingSetExclusive
= TRUE
;
1235 /* Own the process working set */
1236 ASSERT((Thread
->OwnsProcessWorkingSetExclusive
== FALSE
) &&
1237 (Thread
->OwnsProcessWorkingSetShared
== FALSE
));
1238 Thread
->OwnsProcessWorkingSetExclusive
= TRUE
;
1243 // Unlocks the working set
1247 MiUnlockWorkingSet(IN PETHREAD Thread
,
1248 IN PMMSUPPORT WorkingSet
)
1250 /* Working set should be in global memory */
1251 ASSERT(MI_IS_SESSION_ADDRESS((PVOID
)WorkingSet
) == FALSE
);
1253 /* Which working set is this? */
1254 if (WorkingSet
== &MmSystemCacheWs
)
1256 /* Release the system working set */
1257 ASSERT((Thread
->OwnsSystemWorkingSetExclusive
== TRUE
) ||
1258 (Thread
->OwnsSystemWorkingSetShared
== TRUE
));
1259 Thread
->OwnsSystemWorkingSetExclusive
= FALSE
;
1261 else if (WorkingSet
->Flags
.SessionSpace
)
1263 /* Release the session working set */
1264 ASSERT((Thread
->OwnsSessionWorkingSetExclusive
== TRUE
) ||
1265 (Thread
->OwnsSessionWorkingSetShared
== TRUE
));
1266 Thread
->OwnsSessionWorkingSetExclusive
= 0;
1270 /* Release the process working set */
1271 ASSERT((Thread
->OwnsProcessWorkingSetExclusive
) ||
1272 (Thread
->OwnsProcessWorkingSetShared
));
1273 Thread
->OwnsProcessWorkingSetExclusive
= FALSE
;
1276 /* Release the working set lock */
1277 ExReleasePushLockExclusive(&WorkingSet
->WorkingSetMutex
);
1280 KeLeaveGuardedRegion();
1285 MiUnlockProcessWorkingSetForFault(IN PEPROCESS Process
,
1288 OUT PBOOLEAN Shared
)
1290 ASSERT(MI_WS_OWNER(Process
));
1292 /* Check if the current owner is unsafe */
1293 if (MI_IS_WS_UNSAFE(Process
))
1295 /* Release unsafely */
1296 MiUnlockProcessWorkingSetUnsafe(Process
, Thread
);
1300 else if (Thread
->OwnsProcessWorkingSetExclusive
== 1)
1302 /* Owner is safe and exclusive, release normally */
1303 MiUnlockProcessWorkingSet(Process
, Thread
);
1309 /* Owner is shared (implies safe), release normally */
1310 MiUnlockProcessWorkingSetShared(Process
, Thread
);
1318 MiLockProcessWorkingSetForFault(IN PEPROCESS Process
,
1323 /* Check if this was a safe lock or not */
1328 /* Reacquire safely & shared */
1329 MiLockProcessWorkingSetShared(Process
, Thread
);
1333 /* Reacquire safely */
1334 MiLockProcessWorkingSet(Process
, Thread
);
1339 /* Unsafe lock cannot be shared */
1340 ASSERT(Shared
== FALSE
);
1341 /* Reacquire unsafely */
1342 MiLockProcessWorkingSetUnsafe(Process
, Thread
);
1348 MiAcquireExpansionLock(VOID
)
1352 ASSERT(KeGetCurrentIrql() <= APC_LEVEL
);
1353 KeAcquireSpinLock(&MmExpansionLock
, &OldIrql
);
1354 ASSERT(MiExpansionLockOwner
== NULL
);
1355 MiExpansionLockOwner
= PsGetCurrentThread();
1361 MiReleaseExpansionLock(KIRQL OldIrql
)
1363 ASSERT(MiExpansionLockOwner
== PsGetCurrentThread());
1364 MiExpansionLockOwner
= NULL
;
1365 KeReleaseSpinLock(&MmExpansionLock
, OldIrql
);
1366 ASSERT(KeGetCurrentIrql() <= APC_LEVEL
);
1370 // Returns the ProtoPTE inside a VAD for the given VPN
1374 MI_GET_PROTOTYPE_PTE_FOR_VPN(IN PMMVAD Vad
,
1379 /* Find the offset within the VAD's prototype PTEs */
1380 ProtoPte
= Vad
->FirstPrototypePte
+ (Vpn
- Vad
->StartingVpn
);
1381 ASSERT(ProtoPte
<= Vad
->LastContiguousPte
);
1386 // Returns the PFN Database entry for the given page number
1387 // Warning: This is not necessarily a valid PFN database entry!
1391 MI_PFN_ELEMENT(IN PFN_NUMBER Pfn
)
1394 return &MmPfnDatabase
[Pfn
];
1398 // Drops a locked page without dereferencing it
1402 MiDropLockCount(IN PMMPFN Pfn1
)
1404 /* This page shouldn't be locked, but it should be valid */
1405 ASSERT(Pfn1
->u3
.e2
.ReferenceCount
!= 0);
1406 ASSERT(Pfn1
->u2
.ShareCount
== 0);
1408 /* Is this the last reference to the page */
1409 if (Pfn1
->u3
.e2
.ReferenceCount
== 1)
1411 /* It better not be valid */
1412 ASSERT(Pfn1
->u3
.e1
.PageLocation
!= ActiveAndValid
);
1414 /* Is it a prototype PTE? */
1415 if ((Pfn1
->u3
.e1
.PrototypePte
== 1) &&
1416 (Pfn1
->OriginalPte
.u
.Soft
.Prototype
== 1))
1418 /* FIXME: We should return commit */
1419 DPRINT1("Not returning commit for prototype PTE\n");
1422 /* Update the counter */
1423 InterlockedDecrementSizeT(&MmSystemLockPagesCount
);
1428 // Drops a locked page and dereferences it
1432 MiDereferencePfnAndDropLockCount(IN PMMPFN Pfn1
)
1434 USHORT RefCount
, OldRefCount
;
1435 PFN_NUMBER PageFrameIndex
;
1437 /* Loop while we decrement the page successfully */
1440 /* There should be at least one reference */
1441 OldRefCount
= Pfn1
->u3
.e2
.ReferenceCount
;
1442 ASSERT(OldRefCount
!= 0);
1444 /* Are we the last one */
1445 if (OldRefCount
== 1)
1447 /* The page shoudln't be shared not active at this point */
1448 ASSERT(Pfn1
->u3
.e2
.ReferenceCount
== 1);
1449 ASSERT(Pfn1
->u3
.e1
.PageLocation
!= ActiveAndValid
);
1450 ASSERT(Pfn1
->u2
.ShareCount
== 0);
1452 /* Is it a prototype PTE? */
1453 if ((Pfn1
->u3
.e1
.PrototypePte
== 1) &&
1454 (Pfn1
->OriginalPte
.u
.Soft
.Prototype
== 1))
1456 /* FIXME: We should return commit */
1457 DPRINT1("Not returning commit for prototype PTE\n");
1460 /* Update the counter, and drop a reference the long way */
1461 InterlockedDecrementSizeT(&MmSystemLockPagesCount
);
1462 PageFrameIndex
= MiGetPfnEntryIndex(Pfn1
);
1463 MiDecrementReferenceCount(Pfn1
, PageFrameIndex
);
1467 /* Drop a reference the short way, and that's it */
1468 RefCount
= InterlockedCompareExchange16((PSHORT
)&Pfn1
->u3
.e2
.ReferenceCount
,
1471 ASSERT(RefCount
!= 0);
1472 } while (OldRefCount
!= RefCount
);
1474 /* If we got here, there should be more than one reference */
1475 ASSERT(RefCount
> 1);
1478 /* Is it still being shared? */
1479 if (Pfn1
->u2
.ShareCount
>= 1)
1481 /* Then it should be valid */
1482 ASSERT(Pfn1
->u3
.e1
.PageLocation
== ActiveAndValid
);
1484 /* Is it a prototype PTE? */
1485 if ((Pfn1
->u3
.e1
.PrototypePte
== 1) &&
1486 (Pfn1
->OriginalPte
.u
.Soft
.Prototype
== 1))
1488 /* We don't handle ethis */
1492 /* Update the counter */
1493 InterlockedDecrementSizeT(&MmSystemLockPagesCount
);
1499 // References a locked page and updates the counter
1500 // Used in MmProbeAndLockPages to handle different edge cases
1504 MiReferenceProbedPageAndBumpLockCount(IN PMMPFN Pfn1
)
1506 USHORT RefCount
, OldRefCount
;
1509 ASSERT(Pfn1
->u3
.e2
.ReferenceCount
!= 0);
1511 /* Does ARM3 own the page? */
1512 if (MI_IS_ROS_PFN(Pfn1
))
1514 /* ReactOS Mm doesn't track share count */
1515 ASSERT(Pfn1
->u3
.e1
.PageLocation
== ActiveAndValid
);
1519 /* On ARM3 pages, we should see a valid share count */
1520 ASSERT((Pfn1
->u2
.ShareCount
!= 0) && (Pfn1
->u3
.e1
.PageLocation
== ActiveAndValid
));
1522 /* Is it a prototype PTE? */
1523 if ((Pfn1
->u3
.e1
.PrototypePte
== 1) &&
1524 (Pfn1
->OriginalPte
.u
.Soft
.Prototype
== 1))
1526 /* FIXME: We should charge commit */
1527 DPRINT1("Not charging commit for prototype PTE\n");
1531 /* More locked pages! */
1532 InterlockedIncrementSizeT(&MmSystemLockPagesCount
);
1534 /* Loop trying to update the reference count */
1537 /* Get the current reference count, make sure it's valid */
1538 OldRefCount
= Pfn1
->u3
.e2
.ReferenceCount
;
1539 ASSERT(OldRefCount
!= 0);
1540 ASSERT(OldRefCount
< 2500);
1542 /* Bump it up by one */
1543 RefCount
= InterlockedCompareExchange16((PSHORT
)&Pfn1
->u3
.e2
.ReferenceCount
,
1546 ASSERT(RefCount
!= 0);
1547 } while (OldRefCount
!= RefCount
);
1549 /* Was this the first lock attempt? If not, undo our bump */
1550 if (OldRefCount
!= 1) InterlockedDecrementSizeT(&MmSystemLockPagesCount
);
1554 // References a locked page and updates the counter
1555 // Used in all other cases except MmProbeAndLockPages
1559 MiReferenceUsedPageAndBumpLockCount(IN PMMPFN Pfn1
)
1563 /* Is it a prototype PTE? */
1564 if ((Pfn1
->u3
.e1
.PrototypePte
== 1) &&
1565 (Pfn1
->OriginalPte
.u
.Soft
.Prototype
== 1))
1567 /* FIXME: We should charge commit */
1568 DPRINT1("Not charging commit for prototype PTE\n");
1571 /* More locked pages! */
1572 InterlockedIncrementSizeT(&MmSystemLockPagesCount
);
1574 /* Update the reference count */
1575 NewRefCount
= InterlockedIncrement16((PSHORT
)&Pfn1
->u3
.e2
.ReferenceCount
);
1576 if (NewRefCount
== 2)
1578 /* Is it locked or shared? */
1579 if (Pfn1
->u2
.ShareCount
)
1581 /* It's shared, so make sure it's active */
1582 ASSERT(Pfn1
->u3
.e1
.PageLocation
== ActiveAndValid
);
1586 /* It's locked, so we shouldn't lock again */
1587 InterlockedDecrementSizeT(&MmSystemLockPagesCount
);
1592 /* Someone had already locked the page, so undo our bump */
1593 ASSERT(NewRefCount
< 2500);
1594 InterlockedDecrementSizeT(&MmSystemLockPagesCount
);
1599 // References a locked page and updates the counter
1600 // Used in all other cases except MmProbeAndLockPages
1604 MiReferenceUnusedPageAndBumpLockCount(IN PMMPFN Pfn1
)
1608 /* Make sure the page isn't used yet */
1609 ASSERT(Pfn1
->u2
.ShareCount
== 0);
1610 ASSERT(Pfn1
->u3
.e1
.PageLocation
!= ActiveAndValid
);
1612 /* Is it a prototype PTE? */
1613 if ((Pfn1
->u3
.e1
.PrototypePte
== 1) &&
1614 (Pfn1
->OriginalPte
.u
.Soft
.Prototype
== 1))
1616 /* FIXME: We should charge commit */
1617 DPRINT1("Not charging commit for prototype PTE\n");
1620 /* More locked pages! */
1621 InterlockedIncrementSizeT(&MmSystemLockPagesCount
);
1623 /* Update the reference count */
1624 NewRefCount
= InterlockedIncrement16((PSHORT
)&Pfn1
->u3
.e2
.ReferenceCount
);
1625 if (NewRefCount
!= 1)
1627 /* Someone had already locked the page, so undo our bump */
1628 ASSERT(NewRefCount
< 2500);
1629 InterlockedDecrementSizeT(&MmSystemLockPagesCount
);
1635 MiIncrementPageTableReferences(IN PVOID Address
)
1639 RefCount
= &MmWorkingSetList
->UsedPageTableEntries
[MiGetPdeOffset(Address
)];
1642 ASSERT(*RefCount
<= PTE_PER_PAGE
);
1647 MiDecrementPageTableReferences(IN PVOID Address
)
1651 RefCount
= &MmWorkingSetList
->UsedPageTableEntries
[MiGetPdeOffset(Address
)];
1654 ASSERT(*RefCount
< PTE_PER_PAGE
);
1659 MiQueryPageTableReferences(IN PVOID Address
)
1663 RefCount
= &MmWorkingSetList
->UsedPageTableEntries
[MiGetPdeOffset(Address
)];
1672 IN PLOADER_PARAMETER_BLOCK LoaderBlock
1677 MiInitializeSessionSpaceLayout(VOID
);
1681 MiInitMachineDependent(
1682 IN PLOADER_PARAMETER_BLOCK LoaderBlock
1687 MiComputeColorInformation(
1694 IN PLOADER_PARAMETER_BLOCK LoaderBlock
1699 MiInitializeColorTables(
1705 MiInitializePfnDatabase(
1706 IN PLOADER_PARAMETER_BLOCK LoaderBlock
1711 MiInitializeSessionWsSupport(
1717 MiInitializeSessionIds(
1723 MiInitializeMemoryEvents(
1730 IN PFN_NUMBER PageCount
1733 PPHYSICAL_MEMORY_DESCRIPTOR
1735 MmInitializeMemoryLimits(
1736 IN PLOADER_PARAMETER_BLOCK LoaderBlock
,
1737 IN PBOOLEAN IncludeType
1742 MiPagesInLoaderBlock(
1743 IN PLOADER_PARAMETER_BLOCK LoaderBlock
,
1744 IN PBOOLEAN IncludeType
1750 IN PVOID AddressStart
,
1756 MiRosProtectVirtualMemory(
1757 IN PEPROCESS Process
,
1758 IN OUT PVOID
*BaseAddress
,
1759 IN OUT PSIZE_T NumberOfBytesToProtect
,
1760 IN ULONG NewAccessProtection
,
1761 OUT PULONG OldAccessProtection OPTIONAL
1767 IN BOOLEAN StoreInstruction
,
1769 IN KPROCESSOR_MODE Mode
,
1770 IN PVOID TrapInformation
1775 MiCheckPdeForPagedPool(
1781 MiInitializeNonPagedPool(
1787 MiInitializeNonPagedPoolThresholds(
1793 MiInitializePoolEvents(
1800 IN POOL_TYPE PoolType
,// FIXFIX: This should go in ex.h after the pool merge
1801 IN ULONG Threshold
//
1804 // FIXFIX: THIS ONE TOO
1808 ExInitializePoolDescriptor(
1809 IN PPOOL_DESCRIPTOR PoolDescriptor
,
1810 IN POOL_TYPE PoolType
,
1818 MiInitializeSessionPool(
1824 MiInitializeSystemPtes(
1825 IN PMMPTE StartingPte
,
1826 IN ULONG NumberOfPtes
,
1827 IN MMSYSTEM_PTE_POOL_TYPE PoolType
1832 MiReserveSystemPtes(
1833 IN ULONG NumberOfPtes
,
1834 IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType
1839 MiReleaseSystemPtes(
1840 IN PMMPTE StartingPte
,
1841 IN ULONG NumberOfPtes
,
1842 IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType
1848 MiFindContiguousPages(
1849 IN PFN_NUMBER LowestPfn
,
1850 IN PFN_NUMBER HighestPfn
,
1851 IN PFN_NUMBER BoundaryPfn
,
1852 IN PFN_NUMBER SizeInPages
,
1853 IN MEMORY_CACHING_TYPE CacheType
1858 MiCheckForContiguousMemory(
1859 IN PVOID BaseAddress
,
1860 IN PFN_NUMBER BaseAddressPages
,
1861 IN PFN_NUMBER SizeInPages
,
1862 IN PFN_NUMBER LowestPfn
,
1863 IN PFN_NUMBER HighestPfn
,
1864 IN PFN_NUMBER BoundaryPfn
,
1865 IN MI_PFN_CACHE_ATTRIBUTE CacheAttribute
1870 MiAllocatePagesForMdl(
1871 IN PHYSICAL_ADDRESS LowAddress
,
1872 IN PHYSICAL_ADDRESS HighAddress
,
1873 IN PHYSICAL_ADDRESS SkipBytes
,
1874 IN SIZE_T TotalBytes
,
1875 IN MI_PFN_CACHE_ATTRIBUTE CacheAttribute
,
1882 IN PMMPFNLIST ListHead
,
1883 IN PFN_NUMBER PageFrameIndex
1888 MiUnlinkFreeOrZeroedPage(
1894 MiUnlinkPageFromList(
1901 IN PFN_NUMBER PageFrameIndex
,
1902 IN PMMPTE PointerPte
,
1908 MiInitializeAndChargePfn(
1909 OUT PPFN_NUMBER PageFrameIndex
,
1910 IN PMMPDE PointerPde
,
1911 IN PFN_NUMBER ContainingPageFrame
,
1912 IN BOOLEAN SessionAllocation
1917 MiInitializePfnAndMakePteValid(
1918 IN PFN_NUMBER PageFrameIndex
,
1919 IN PMMPTE PointerPte
,
1925 MiInitializePfnForOtherProcess(
1926 IN PFN_NUMBER PageFrameIndex
,
1927 IN PVOID PteAddress
,
1928 IN PFN_NUMBER PteFrame
1933 MiDecrementShareCount(
1935 IN PFN_NUMBER PageFrameIndex
1953 IN PFN_NUMBER PageFrameIndex
1958 MiInsertPageInFreeList(
1959 IN PFN_NUMBER PageFrameIndex
1964 MiDeleteSystemPageableVm(
1965 IN PMMPTE PointerPte
,
1966 IN PFN_NUMBER PageCount
,
1968 OUT PPFN_NUMBER ValidPages
1973 MiGetPageProtection(
1974 IN PMMPTE PointerPte
1977 PLDR_DATA_TABLE_ENTRY
1979 MiLookupDataTableEntry(
1985 MiInitializeDriverLargePageList(
1991 MiInitializeLargePageSupport(
2010 IN PVOID VirtualAddress
2015 MiCheckForConflictingNode(
2016 IN ULONG_PTR StartVpn
,
2017 IN ULONG_PTR EndVpn
,
2018 IN PMM_AVL_TABLE Table
,
2019 OUT PMMADDRESS_NODE
*NodeOrParent
2024 MiFindEmptyAddressRangeDownTree(
2026 IN ULONG_PTR BoundaryAddress
,
2027 IN ULONG_PTR Alignment
,
2028 IN PMM_AVL_TABLE Table
,
2029 OUT PULONG_PTR Base
,
2030 OUT PMMADDRESS_NODE
*Parent
2035 MiFindEmptyAddressRangeDownBasedTree(
2037 IN ULONG_PTR BoundaryAddress
,
2038 IN ULONG_PTR Alignment
,
2039 IN PMM_AVL_TABLE Table
,
2045 MiFindEmptyAddressRangeInTree(
2047 IN ULONG_PTR Alignment
,
2048 IN PMM_AVL_TABLE Table
,
2049 OUT PMMADDRESS_NODE
*PreviousVad
,
2059 IN ULONG ProtectionMask
2066 _Inout_ PMM_AVL_TABLE VadRoot
);
2072 _In_ ULONG_PTR
*BaseAddress
,
2073 _In_ SIZE_T ViewSize
,
2074 _In_ ULONG_PTR HighestAddress
,
2075 _In_ ULONG_PTR Alignment
,
2076 _In_ ULONG AllocationType
);
2080 MiInsertBasedSection(
2086 MiUnmapViewOfSection(
2087 IN PEPROCESS Process
,
2088 IN PVOID BaseAddress
,
2094 MiRosUnmapViewOfSection(
2095 IN PEPROCESS Process
,
2096 IN PVOID BaseAddress
,
2097 IN BOOLEAN SkipDebuggerNotify
2103 IN PMM_AVL_TABLE Table
,
2104 IN PMMADDRESS_NODE NewNode
,
2105 PMMADDRESS_NODE Parent
,
2106 TABLE_SEARCH_RESULT Result
2112 IN PMMADDRESS_NODE Node
,
2113 IN PMM_AVL_TABLE Table
2119 IN PMMADDRESS_NODE Node
2125 IN PMMADDRESS_NODE Node
2130 MiInitializeSystemSpaceMap(
2131 IN PMMSESSION InputSession OPTIONAL
2136 MiSessionRemoveProcess(
2142 MiReleaseProcessReferenceToSessionDataPage(
2143 IN PMM_SESSION_SPACE SessionGlobal
2148 MiSessionAddProcess(
2149 IN PEPROCESS NewProcess
2154 MiSessionCommitPageTables(
2161 MiMakeProtectionMask(
2167 MiDeleteVirtualAddresses(
2169 IN ULONG_PTR EndingAddress
,
2176 IN PMMPTE PointerPte
,
2177 IN PVOID VirtualAddress
,
2178 IN PEPROCESS CurrentProcess
,
2179 IN PMMPTE PrototypePte
2184 MiMakeSystemAddressValid(
2185 IN PVOID PageTableVirtualAddress
,
2186 IN PEPROCESS CurrentProcess
2191 MiMakeSystemAddressValidPfn(
2192 IN PVOID VirtualAddress
,
2199 IN PEPROCESS CurrentProcess
,
2212 MiDeleteARM3Section(
2218 MiQueryMemorySectionName(
2219 IN HANDLE ProcessHandle
,
2220 IN PVOID BaseAddress
,
2221 OUT PVOID MemoryInformation
,
2222 IN SIZE_T MemoryInformationLength
,
2223 OUT PSIZE_T ReturnLength
2228 MiRosUnmapViewInSystemSpace(
2234 MmDeterminePoolType(
2235 IN PVOID PoolAddress
2240 MiMakePdeExistAndMakeValid(
2241 IN PMMPDE PointerPde
,
2242 IN PEPROCESS TargetProcess
,
2247 // MiRemoveZeroPage will use inline code to zero out the page manually if only
2248 // free pages are available. In some scenarios, we don't/can't run that piece of
2249 // code and would rather only have a real zero page. If we can't have a zero page,
2250 // then we'd like to have our own code to grab a free page and zero it out, by
2251 // using MiRemoveAnyPage. This macro implements this.
2255 MiRemoveZeroPageSafe(IN ULONG Color
)
2257 if (MmFreePagesByColor
[ZeroedPageList
][Color
].Flink
!= LIST_HEAD
) return MiRemoveZeroPage(Color
);