[NTOS] Deduplicate MiSynchronizeSystemPde(). #179
[reactos.git] / ntoskrnl / mm / ARM3 / miarm.h
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 #define MI_LOWEST_VAD_ADDRESS (PVOID)MM_LOWEST_USER_ADDRESS
12
13 /* Make the code cleaner with some definitions for size multiples */
14 #define _1KB (1024u)
15 #define _1MB (1024 * _1KB)
16 #define _1GB (1024 * _1MB)
17
18 /* Everyone loves 64K */
19 #define _64K (64 * _1KB)
20
21 /* Area mapped by a PDE */
22 #define PDE_MAPPED_VA (PTE_COUNT * PAGE_SIZE)
23
24 /* Size of a page table */
25 #define PT_SIZE (PTE_COUNT * sizeof(MMPTE))
26
27 /* Size of a page directory */
28 #define PD_SIZE (PDE_COUNT * sizeof(MMPDE))
29
30 /* Stop using these! */
31 #define PD_COUNT PPE_PER_PAGE
32 #define PDE_COUNT PDE_PER_PAGE
33 #define PTE_COUNT PTE_PER_PAGE
34
35 /* Size of all page directories for a process */
36 #define SYSTEM_PD_SIZE (PD_COUNT * PD_SIZE)
37 #ifdef _M_IX86
38 C_ASSERT(SYSTEM_PD_SIZE == PAGE_SIZE);
39 #endif
40
41 //
42 // Protection Bits part of the internal memory manager Protection Mask, from:
43 // http://reactos.org/wiki/Techwiki:Memory_management_in_the_Windows_XP_kernel
44 // https://www.reactos.org/wiki/Techwiki:Memory_Protection_constants
45 // and public assertions.
46 //
47 #define MM_ZERO_ACCESS 0
48 #define MM_READONLY 1
49 #define MM_EXECUTE 2
50 #define MM_EXECUTE_READ 3
51 #define MM_READWRITE 4
52 #define MM_WRITECOPY 5
53 #define MM_EXECUTE_READWRITE 6
54 #define MM_EXECUTE_WRITECOPY 7
55 #define MM_PROTECT_ACCESS 7
56
57 //
58 // These are flags on top of the actual protection mask
59 //
60 #define MM_NOCACHE 0x08
61 #define MM_GUARDPAGE 0x10
62 #define MM_WRITECOMBINE 0x18
63 #define MM_PROTECT_SPECIAL 0x18
64
65 //
66 // These are special cases
67 //
68 #define MM_DECOMMIT (MM_ZERO_ACCESS | MM_GUARDPAGE)
69 #define MM_NOACCESS (MM_ZERO_ACCESS | MM_WRITECOMBINE)
70 #define MM_OUTSWAPPED_KSTACK (MM_EXECUTE_WRITECOPY | MM_WRITECOMBINE)
71 #define MM_INVALID_PROTECTION 0xFFFFFFFF
72
73 //
74 // Specific PTE Definitions that map to the Memory Manager's Protection Mask Bits
75 // The Memory Manager's definition define the attributes that must be preserved
76 // and these PTE definitions describe the attributes in the hardware sense. This
77 // helps deal with hardware differences between the actual boolean expression of
78 // the argument.
79 //
80 // For example, in the logical attributes, we want to express read-only as a flag
81 // but on x86, it is writability that must be set. On the other hand, on x86, just
82 // like in the kernel, it is disabling the caches that requires a special flag,
83 // while on certain architectures such as ARM, it is enabling the cache which
84 // requires a flag.
85 //
86 #if defined(_M_IX86) || defined(_M_AMD64)
87 //
88 // Access Flags
89 //
90 #define PTE_READONLY 0 // Doesn't exist on x86
91 #define PTE_EXECUTE 0 // Not worrying about NX yet
92 #define PTE_EXECUTE_READ 0 // Not worrying about NX yet
93 #define PTE_READWRITE 0x2
94 #define PTE_WRITECOPY 0x200
95 #define PTE_EXECUTE_READWRITE 0x2 // Not worrying about NX yet
96 #define PTE_EXECUTE_WRITECOPY 0x200
97 #define PTE_PROTOTYPE 0x400
98
99 //
100 // State Flags
101 //
102 #define PTE_VALID 0x1
103 #define PTE_ACCESSED 0x20
104 #define PTE_DIRTY 0x40
105
106 //
107 // Cache flags
108 //
109 #define PTE_ENABLE_CACHE 0
110 #define PTE_DISABLE_CACHE 0x10
111 #define PTE_WRITECOMBINED_CACHE 0x10
112 #elif defined(_M_ARM)
113 #define PTE_READONLY 0x200
114 #define PTE_EXECUTE 0 // Not worrying about NX yet
115 #define PTE_EXECUTE_READ 0 // Not worrying about NX yet
116 #define PTE_READWRITE 0 // Doesn't exist on ARM
117 #define PTE_WRITECOPY 0 // Doesn't exist on ARM
118 #define PTE_EXECUTE_READWRITE 0 // Not worrying about NX yet
119 #define PTE_EXECUTE_WRITECOPY 0 // Not worrying about NX yet
120 #define PTE_PROTOTYPE 0x400 // Using the Shared bit
121 //
122 // Cache flags
123 //
124 #define PTE_ENABLE_CACHE 0
125 #define PTE_DISABLE_CACHE 0x10
126 #define PTE_WRITECOMBINED_CACHE 0x10
127 #else
128 #error Define these please!
129 #endif
130
131 extern const ULONG_PTR MmProtectToPteMask[32];
132 extern const ULONG MmProtectToValue[32];
133
134 //
135 // Assertions for session images, addresses, and PTEs
136 //
137 #define MI_IS_SESSION_IMAGE_ADDRESS(Address) \
138 (((Address) >= MiSessionImageStart) && ((Address) < MiSessionImageEnd))
139
140 #define MI_IS_SESSION_ADDRESS(Address) \
141 (((Address) >= MmSessionBase) && ((Address) < MiSessionSpaceEnd))
142
143 #define MI_IS_SESSION_PTE(Pte) \
144 ((((PMMPTE)Pte) >= MiSessionBasePte) && (((PMMPTE)Pte) < MiSessionLastPte))
145
146 #define MI_IS_PAGE_TABLE_ADDRESS(Address) \
147 (((PVOID)(Address) >= (PVOID)PTE_BASE) && ((PVOID)(Address) <= (PVOID)PTE_TOP))
148
149 #define MI_IS_SYSTEM_PAGE_TABLE_ADDRESS(Address) \
150 (((Address) >= (PVOID)MiAddressToPte(MmSystemRangeStart)) && ((Address) <= (PVOID)PTE_TOP))
151
152 #define MI_IS_PAGE_TABLE_OR_HYPER_ADDRESS(Address) \
153 (((PVOID)(Address) >= (PVOID)PTE_BASE) && ((PVOID)(Address) <= (PVOID)MmHyperSpaceEnd))
154
155 //
156 // Creates a software PTE with the given protection
157 //
158 #define MI_MAKE_SOFTWARE_PTE(p, x) ((p)->u.Long = (x << MM_PTE_SOFTWARE_PROTECTION_BITS))
159
160 //
161 // Marks a PTE as deleted
162 //
163 #define MI_SET_PFN_DELETED(x) ((x)->PteAddress = (PMMPTE)((ULONG_PTR)(x)->PteAddress | 1))
164 #define MI_IS_PFN_DELETED(x) ((ULONG_PTR)((x)->PteAddress) & 1)
165
166 //
167 // Special values for LoadedImports
168 //
169 #ifdef _WIN64
170 #define MM_SYSLDR_NO_IMPORTS (PVOID)0xFFFFFFFFFFFFFFFEULL
171 #define MM_SYSLDR_BOOT_LOADED (PVOID)0xFFFFFFFFFFFFFFFFULL
172 #else
173 #define MM_SYSLDR_NO_IMPORTS (PVOID)0xFFFFFFFE
174 #define MM_SYSLDR_BOOT_LOADED (PVOID)0xFFFFFFFF
175 #endif
176 #define MM_SYSLDR_SINGLE_ENTRY 0x1
177
178 //
179 // Number of initial session IDs
180 //
181 #define MI_INITIAL_SESSION_IDS 64
182
183 #if defined(_M_IX86) || defined(_M_ARM)
184 //
185 // PFN List Sentinel
186 //
187 #define LIST_HEAD 0xFFFFFFFF
188
189 //
190 // Because GCC cannot automatically downcast 0xFFFFFFFF to lesser-width bits,
191 // we need a manual definition suited to the number of bits in the PteFrame.
192 // This is used as a LIST_HEAD for the colored list
193 //
194 #define COLORED_LIST_HEAD ((1 << 25) - 1) // 0x1FFFFFF
195 #elif defined(_M_AMD64)
196 #define LIST_HEAD 0xFFFFFFFFFFFFFFFFLL
197 #define COLORED_LIST_HEAD ((1ULL << 57) - 1) // 0x1FFFFFFFFFFFFFFLL
198 #else
199 #error Define these please!
200 #endif
201
202 //
203 // Special IRQL value (found in assertions)
204 //
205 #define MM_NOIRQL (KIRQL)0xFFFFFFFF
206
207 //
208 // Returns the color of a page
209 //
210 #define MI_GET_PAGE_COLOR(x) ((x) & MmSecondaryColorMask)
211 #define MI_GET_NEXT_COLOR() (MI_GET_PAGE_COLOR(++MmSystemPageColor))
212 #define MI_GET_NEXT_PROCESS_COLOR(x) (MI_GET_PAGE_COLOR(++(x)->NextPageColor))
213
214 //
215 // Prototype PTEs that don't yet have a pagefile association
216 //
217 #ifdef _WIN64
218 #define MI_PTE_LOOKUP_NEEDED 0xffffffffULL
219 #else
220 #define MI_PTE_LOOKUP_NEEDED 0xFFFFF
221 #endif
222
223 //
224 // Number of session data and tag pages
225 //
226 #define MI_SESSION_DATA_PAGES_MAXIMUM (MM_ALLOCATION_GRANULARITY / PAGE_SIZE)
227 #define MI_SESSION_TAG_PAGES_MAXIMUM (MM_ALLOCATION_GRANULARITY / PAGE_SIZE)
228
229 //
230 // Used by MiCheckSecuredVad
231 //
232 #define MM_READ_WRITE_ALLOWED 11
233 #define MM_READ_ONLY_ALLOWED 10
234 #define MM_NO_ACCESS_ALLOWED 01
235 #define MM_DELETE_CHECK 85
236
237 //
238 // System views are binned into 64K chunks
239 //
240 #define MI_SYSTEM_VIEW_BUCKET_SIZE _64K
241
242 //
243 // FIXFIX: These should go in ex.h after the pool merge
244 //
245 #ifdef _WIN64
246 #define POOL_BLOCK_SIZE 16
247 #else
248 #define POOL_BLOCK_SIZE 8
249 #endif
250 #define POOL_LISTS_PER_PAGE (PAGE_SIZE / POOL_BLOCK_SIZE)
251 #define BASE_POOL_TYPE_MASK 1
252 #define POOL_MAX_ALLOC (PAGE_SIZE - (sizeof(POOL_HEADER) + POOL_BLOCK_SIZE))
253
254 //
255 // Pool debugging/analysis/tracing flags
256 //
257 #define POOL_FLAG_CHECK_TIMERS 0x1
258 #define POOL_FLAG_CHECK_WORKERS 0x2
259 #define POOL_FLAG_CHECK_RESOURCES 0x4
260 #define POOL_FLAG_VERIFIER 0x8
261 #define POOL_FLAG_CHECK_DEADLOCK 0x10
262 #define POOL_FLAG_SPECIAL_POOL 0x20
263 #define POOL_FLAG_DBGPRINT_ON_FAILURE 0x40
264 #define POOL_FLAG_CRASH_ON_FAILURE 0x80
265
266 //
267 // BAD_POOL_HEADER codes during pool bugcheck
268 //
269 #define POOL_CORRUPTED_LIST 3
270 #define POOL_SIZE_OR_INDEX_MISMATCH 5
271 #define POOL_ENTRIES_NOT_ALIGNED_PREVIOUS 6
272 #define POOL_HEADER_NOT_ALIGNED 7
273 #define POOL_HEADER_IS_ZERO 8
274 #define POOL_ENTRIES_NOT_ALIGNED_NEXT 9
275 #define POOL_ENTRY_NOT_FOUND 10
276
277 //
278 // BAD_POOL_CALLER codes during pool bugcheck
279 //
280 #define POOL_ENTRY_CORRUPTED 1
281 #define POOL_ENTRY_ALREADY_FREE 6
282 #define POOL_ENTRY_NOT_ALLOCATED 7
283 #define POOL_ALLOC_IRQL_INVALID 8
284 #define POOL_FREE_IRQL_INVALID 9
285 #define POOL_BILLED_PROCESS_INVALID 13
286 #define POOL_HEADER_SIZE_INVALID 32
287
288 typedef struct _POOL_DESCRIPTOR
289 {
290 POOL_TYPE PoolType;
291 ULONG PoolIndex;
292 ULONG RunningAllocs;
293 ULONG RunningDeAllocs;
294 ULONG TotalPages;
295 ULONG TotalBigPages;
296 ULONG Threshold;
297 PVOID LockAddress;
298 PVOID PendingFrees;
299 LONG PendingFreeDepth;
300 SIZE_T TotalBytes;
301 SIZE_T Spare0;
302 LIST_ENTRY ListHeads[POOL_LISTS_PER_PAGE];
303 } POOL_DESCRIPTOR, *PPOOL_DESCRIPTOR;
304
305 typedef struct _POOL_HEADER
306 {
307 union
308 {
309 struct
310 {
311 #ifdef _WIN64
312 USHORT PreviousSize:8;
313 USHORT PoolIndex:8;
314 USHORT BlockSize:8;
315 USHORT PoolType:8;
316 #else
317 USHORT PreviousSize:9;
318 USHORT PoolIndex:7;
319 USHORT BlockSize:9;
320 USHORT PoolType:7;
321 #endif
322 };
323 ULONG Ulong1;
324 };
325 #ifdef _WIN64
326 ULONG PoolTag;
327 #endif
328 union
329 {
330 #ifdef _WIN64
331 PEPROCESS ProcessBilled;
332 #else
333 ULONG PoolTag;
334 #endif
335 struct
336 {
337 USHORT AllocatorBackTraceIndex;
338 USHORT PoolTagHash;
339 };
340 };
341 } POOL_HEADER, *PPOOL_HEADER;
342
343 C_ASSERT(sizeof(POOL_HEADER) == POOL_BLOCK_SIZE);
344 C_ASSERT(POOL_BLOCK_SIZE == sizeof(LIST_ENTRY));
345
346 typedef struct _POOL_TRACKER_TABLE
347 {
348 ULONG Key;
349 LONG NonPagedAllocs;
350 LONG NonPagedFrees;
351 SIZE_T NonPagedBytes;
352 LONG PagedAllocs;
353 LONG PagedFrees;
354 SIZE_T PagedBytes;
355 } POOL_TRACKER_TABLE, *PPOOL_TRACKER_TABLE;
356
357 typedef struct _POOL_TRACKER_BIG_PAGES
358 {
359 PVOID Va;
360 ULONG Key;
361 ULONG NumberOfPages;
362 PVOID QuotaObject;
363 } POOL_TRACKER_BIG_PAGES, *PPOOL_TRACKER_BIG_PAGES;
364
365 extern ULONG ExpNumberOfPagedPools;
366 extern POOL_DESCRIPTOR NonPagedPoolDescriptor;
367 extern PPOOL_DESCRIPTOR ExpPagedPoolDescriptor[16 + 1];
368 extern PPOOL_TRACKER_TABLE PoolTrackTable;
369
370 //
371 // END FIXFIX
372 //
373
374 typedef struct _MI_LARGE_PAGE_DRIVER_ENTRY
375 {
376 LIST_ENTRY Links;
377 UNICODE_STRING BaseName;
378 } MI_LARGE_PAGE_DRIVER_ENTRY, *PMI_LARGE_PAGE_DRIVER_ENTRY;
379
380 typedef enum _MMSYSTEM_PTE_POOL_TYPE
381 {
382 SystemPteSpace,
383 NonPagedPoolExpansion,
384 MaximumPtePoolTypes
385 } MMSYSTEM_PTE_POOL_TYPE;
386
387 typedef enum _MI_PFN_CACHE_ATTRIBUTE
388 {
389 MiNonCached,
390 MiCached,
391 MiWriteCombined,
392 MiNotMapped
393 } MI_PFN_CACHE_ATTRIBUTE, *PMI_PFN_CACHE_ATTRIBUTE;
394
395 typedef struct _PHYSICAL_MEMORY_RUN
396 {
397 PFN_NUMBER BasePage;
398 PFN_NUMBER PageCount;
399 } PHYSICAL_MEMORY_RUN, *PPHYSICAL_MEMORY_RUN;
400
401 typedef struct _PHYSICAL_MEMORY_DESCRIPTOR
402 {
403 ULONG NumberOfRuns;
404 PFN_NUMBER NumberOfPages;
405 PHYSICAL_MEMORY_RUN Run[1];
406 } PHYSICAL_MEMORY_DESCRIPTOR, *PPHYSICAL_MEMORY_DESCRIPTOR;
407
408 typedef struct _MMCOLOR_TABLES
409 {
410 PFN_NUMBER Flink;
411 PVOID Blink;
412 PFN_NUMBER Count;
413 } MMCOLOR_TABLES, *PMMCOLOR_TABLES;
414
415 typedef struct _MI_LARGE_PAGE_RANGES
416 {
417 PFN_NUMBER StartFrame;
418 PFN_NUMBER LastFrame;
419 } MI_LARGE_PAGE_RANGES, *PMI_LARGE_PAGE_RANGES;
420
421 typedef struct _MMVIEW
422 {
423 ULONG_PTR Entry;
424 PCONTROL_AREA ControlArea;
425 } MMVIEW, *PMMVIEW;
426
427 typedef struct _MMSESSION
428 {
429 KGUARDED_MUTEX SystemSpaceViewLock;
430 PKGUARDED_MUTEX SystemSpaceViewLockPointer;
431 PCHAR SystemSpaceViewStart;
432 PMMVIEW SystemSpaceViewTable;
433 ULONG SystemSpaceHashSize;
434 ULONG SystemSpaceHashEntries;
435 ULONG SystemSpaceHashKey;
436 ULONG BitmapFailures;
437 PRTL_BITMAP SystemSpaceBitMap;
438 } MMSESSION, *PMMSESSION;
439
440 typedef struct _MM_SESSION_SPACE_FLAGS
441 {
442 ULONG Initialized:1;
443 ULONG DeletePending:1;
444 ULONG Filler:30;
445 } MM_SESSION_SPACE_FLAGS;
446
447 typedef struct _MM_SESSION_SPACE
448 {
449 struct _MM_SESSION_SPACE *GlobalVirtualAddress;
450 LONG ReferenceCount;
451 union
452 {
453 ULONG LongFlags;
454 MM_SESSION_SPACE_FLAGS Flags;
455 } u;
456 ULONG SessionId;
457 LIST_ENTRY ProcessList;
458 LARGE_INTEGER LastProcessSwappedOutTime;
459 PFN_NUMBER SessionPageDirectoryIndex;
460 SIZE_T NonPageablePages;
461 SIZE_T CommittedPages;
462 PVOID PagedPoolStart;
463 PVOID PagedPoolEnd;
464 PMMPDE PagedPoolBasePde;
465 ULONG Color;
466 LONG ResidentProcessCount;
467 ULONG SessionPoolAllocationFailures[4];
468 LIST_ENTRY ImageList;
469 LCID LocaleId;
470 ULONG AttachCount;
471 KEVENT AttachEvent;
472 PEPROCESS LastProcess;
473 LONG ProcessReferenceToSession;
474 LIST_ENTRY WsListEntry;
475 GENERAL_LOOKASIDE Lookaside[SESSION_POOL_LOOKASIDES];
476 MMSESSION Session;
477 KGUARDED_MUTEX PagedPoolMutex;
478 MM_PAGED_POOL_INFO PagedPoolInfo;
479 MMSUPPORT Vm;
480 PMMWSLE Wsle;
481 PDRIVER_UNLOAD Win32KDriverUnload;
482 POOL_DESCRIPTOR PagedPool;
483 #if defined (_M_AMD64)
484 MMPDE PageDirectory;
485 #else
486 PMMPDE PageTables;
487 #endif
488 #if defined (_M_AMD64)
489 PMMPTE SpecialPoolFirstPte;
490 PMMPTE SpecialPoolLastPte;
491 PMMPTE NextPdeForSpecialPoolExpansion;
492 PMMPTE LastPdeForSpecialPoolExpansion;
493 PFN_NUMBER SpecialPagesInUse;
494 #endif
495 LONG ImageLoadingCount;
496 } MM_SESSION_SPACE, *PMM_SESSION_SPACE;
497
498 extern PMM_SESSION_SPACE MmSessionSpace;
499 extern MMPTE HyperTemplatePte;
500 extern MMPDE ValidKernelPde;
501 extern MMPTE ValidKernelPte;
502 extern MMPDE ValidKernelPdeLocal;
503 extern MMPTE ValidKernelPteLocal;
504 extern MMPDE DemandZeroPde;
505 extern MMPTE DemandZeroPte;
506 extern MMPTE PrototypePte;
507 extern MMPTE MmDecommittedPte;
508 extern BOOLEAN MmLargeSystemCache;
509 extern BOOLEAN MmZeroPageFile;
510 extern BOOLEAN MmProtectFreedNonPagedPool;
511 extern BOOLEAN MmTrackLockedPages;
512 extern BOOLEAN MmTrackPtes;
513 extern BOOLEAN MmDynamicPfn;
514 extern BOOLEAN MmMirroring;
515 extern BOOLEAN MmMakeLowMemory;
516 extern BOOLEAN MmEnforceWriteProtection;
517 extern SIZE_T MmAllocationFragment;
518 extern ULONG MmConsumedPoolPercentage;
519 extern ULONG MmVerifyDriverBufferType;
520 extern ULONG MmVerifyDriverLevel;
521 extern WCHAR MmVerifyDriverBuffer[512];
522 extern WCHAR MmLargePageDriverBuffer[512];
523 extern LIST_ENTRY MiLargePageDriverList;
524 extern BOOLEAN MiLargePageAllDrivers;
525 extern ULONG MmVerifyDriverBufferLength;
526 extern ULONG MmLargePageDriverBufferLength;
527 extern SIZE_T MmSizeOfNonPagedPoolInBytes;
528 extern SIZE_T MmMaximumNonPagedPoolInBytes;
529 extern PFN_NUMBER MmMaximumNonPagedPoolInPages;
530 extern PFN_NUMBER MmSizeOfPagedPoolInPages;
531 extern PVOID MmNonPagedSystemStart;
532 extern PVOID MmNonPagedPoolStart;
533 extern PVOID MmNonPagedPoolExpansionStart;
534 extern PVOID MmNonPagedPoolEnd;
535 extern SIZE_T MmSizeOfPagedPoolInBytes;
536 extern PVOID MmPagedPoolStart;
537 extern PVOID MmPagedPoolEnd;
538 extern PVOID MmSessionBase;
539 extern SIZE_T MmSessionSize;
540 extern PMMPTE MmFirstReservedMappingPte, MmLastReservedMappingPte;
541 extern PMMPTE MiFirstReservedZeroingPte;
542 extern MI_PFN_CACHE_ATTRIBUTE MiPlatformCacheAttributes[2][MmMaximumCacheType];
543 extern PPHYSICAL_MEMORY_DESCRIPTOR MmPhysicalMemoryBlock;
544 extern SIZE_T MmBootImageSize;
545 extern PMMPTE MmSystemPtesStart[MaximumPtePoolTypes];
546 extern PMMPTE MmSystemPtesEnd[MaximumPtePoolTypes];
547 extern PMEMORY_ALLOCATION_DESCRIPTOR MxFreeDescriptor;
548 extern MEMORY_ALLOCATION_DESCRIPTOR MxOldFreeDescriptor;
549 extern ULONG_PTR MxPfnAllocation;
550 extern MM_PAGED_POOL_INFO MmPagedPoolInfo;
551 extern RTL_BITMAP MiPfnBitMap;
552 extern KGUARDED_MUTEX MmPagedPoolMutex;
553 extern KGUARDED_MUTEX MmSectionCommitMutex;
554 extern PVOID MmPagedPoolStart;
555 extern PVOID MmPagedPoolEnd;
556 extern PVOID MmNonPagedSystemStart;
557 extern PVOID MiSystemViewStart;
558 extern SIZE_T MmSystemViewSize;
559 extern PVOID MmSessionBase;
560 extern PVOID MiSessionSpaceEnd;
561 extern PMMPTE MiSessionImagePteStart;
562 extern PMMPTE MiSessionImagePteEnd;
563 extern PMMPTE MiSessionBasePte;
564 extern PMMPTE MiSessionLastPte;
565 extern SIZE_T MmSizeOfPagedPoolInBytes;
566 extern PMMPDE MmSystemPagePtes;
567 extern PVOID MmSystemCacheStart;
568 extern PVOID MmSystemCacheEnd;
569 extern MMSUPPORT MmSystemCacheWs;
570 extern SIZE_T MmAllocatedNonPagedPool;
571 extern ULONG MmSpecialPoolTag;
572 extern PVOID MmHyperSpaceEnd;
573 extern PMMWSL MmSystemCacheWorkingSetList;
574 extern SIZE_T MmMinimumNonPagedPoolSize;
575 extern ULONG MmMinAdditionNonPagedPoolPerMb;
576 extern SIZE_T MmDefaultMaximumNonPagedPool;
577 extern ULONG MmMaxAdditionNonPagedPoolPerMb;
578 extern ULONG MmSecondaryColors;
579 extern ULONG MmSecondaryColorMask;
580 extern ULONG MmNumberOfSystemPtes;
581 extern ULONG MmMaximumNonPagedPoolPercent;
582 extern ULONG MmLargeStackSize;
583 extern PMMCOLOR_TABLES MmFreePagesByColor[FreePageList + 1];
584 extern MMPFNLIST MmStandbyPageListByPriority[8];
585 extern ULONG MmProductType;
586 extern MM_SYSTEMSIZE MmSystemSize;
587 extern PKEVENT MiLowMemoryEvent;
588 extern PKEVENT MiHighMemoryEvent;
589 extern PKEVENT MiLowPagedPoolEvent;
590 extern PKEVENT MiHighPagedPoolEvent;
591 extern PKEVENT MiLowNonPagedPoolEvent;
592 extern PKEVENT MiHighNonPagedPoolEvent;
593 extern PFN_NUMBER MmLowMemoryThreshold;
594 extern PFN_NUMBER MmHighMemoryThreshold;
595 extern PFN_NUMBER MiLowPagedPoolThreshold;
596 extern PFN_NUMBER MiHighPagedPoolThreshold;
597 extern PFN_NUMBER MiLowNonPagedPoolThreshold;
598 extern PFN_NUMBER MiHighNonPagedPoolThreshold;
599 extern PFN_NUMBER MmMinimumFreePages;
600 extern PFN_NUMBER MmPlentyFreePages;
601 extern SIZE_T MmMinimumStackCommitInBytes;
602 extern PFN_COUNT MiExpansionPoolPagesInitialCharge;
603 extern PFN_NUMBER MmResidentAvailablePages;
604 extern PFN_NUMBER MmResidentAvailableAtInit;
605 extern ULONG MmTotalFreeSystemPtes[MaximumPtePoolTypes];
606 extern PFN_NUMBER MmTotalSystemDriverPages;
607 extern ULONG MmCritsectTimeoutSeconds;
608 extern PVOID MiSessionImageStart;
609 extern PVOID MiSessionImageEnd;
610 extern PMMPTE MiHighestUserPte;
611 extern PMMPDE MiHighestUserPde;
612 extern PFN_NUMBER MmSystemPageDirectory[PD_COUNT];
613 extern PMMPTE MmSharedUserDataPte;
614 extern LIST_ENTRY MmProcessList;
615 extern BOOLEAN MmZeroingPageThreadActive;
616 extern KEVENT MmZeroingPageEvent;
617 extern ULONG MmSystemPageColor;
618 extern ULONG MmProcessColorSeed;
619 extern PMMWSL MmWorkingSetList;
620 extern PFN_NUMBER MiNumberOfFreePages;
621 extern SIZE_T MmSessionViewSize;
622 extern SIZE_T MmSessionPoolSize;
623 extern SIZE_T MmSessionImageSize;
624 extern PVOID MiSystemViewStart;
625 extern PVOID MiSessionPoolEnd; // 0xBE000000
626 extern PVOID MiSessionPoolStart; // 0xBD000000
627 extern PVOID MiSessionViewStart; // 0xBE000000
628 extern PVOID MiSessionSpaceWs;
629 extern ULONG MmMaximumDeadKernelStacks;
630 extern SLIST_HEADER MmDeadStackSListHead;
631 extern MM_AVL_TABLE MmSectionBasedRoot;
632 extern KGUARDED_MUTEX MmSectionBasedMutex;
633 extern PVOID MmHighSectionBase;
634 extern SIZE_T MmSystemLockPagesCount;
635 extern ULONG_PTR MmSubsectionBase;
636 extern LARGE_INTEGER MmCriticalSectionTimeout;
637 extern LIST_ENTRY MmWorkingSetExpansionHead;
638 extern KSPIN_LOCK MmExpansionLock;
639 extern PETHREAD MiExpansionLockOwner;
640
641 FORCEINLINE
642 BOOLEAN
643 MiIsMemoryTypeFree(TYPE_OF_MEMORY MemoryType)
644 {
645 return ((MemoryType == LoaderFree) ||
646 (MemoryType == LoaderLoadedProgram) ||
647 (MemoryType == LoaderFirmwareTemporary) ||
648 (MemoryType == LoaderOsloaderStack));
649 }
650
651 FORCEINLINE
652 BOOLEAN
653 MiIsMemoryTypeInvisible(TYPE_OF_MEMORY MemoryType)
654 {
655 return ((MemoryType == LoaderFirmwarePermanent) ||
656 (MemoryType == LoaderSpecialMemory) ||
657 (MemoryType == LoaderHALCachedMemory) ||
658 (MemoryType == LoaderBBTMemory));
659 }
660
661 #ifdef _M_AMD64
662 FORCEINLINE
663 BOOLEAN
664 MiIsUserPxe(PVOID Address)
665 {
666 return ((ULONG_PTR)Address >> 7) == 0x1FFFFEDF6FB7DA0ULL;
667 }
668
669 FORCEINLINE
670 BOOLEAN
671 MiIsUserPpe(PVOID Address)
672 {
673 return ((ULONG_PTR)Address >> 16) == 0xFFFFF6FB7DA0ULL;
674 }
675
676 FORCEINLINE
677 BOOLEAN
678 MiIsUserPde(PVOID Address)
679 {
680 return ((ULONG_PTR)Address >> 25) == 0x7FFFFB7DA0ULL;
681 }
682
683 FORCEINLINE
684 BOOLEAN
685 MiIsUserPte(PVOID Address)
686 {
687 return ((ULONG_PTR)Address >> 34) == 0x3FFFFDA0ULL;
688 }
689 #else
690 FORCEINLINE
691 BOOLEAN
692 MiIsUserPde(PVOID Address)
693 {
694 return ((Address >= (PVOID)MiAddressToPde(NULL)) &&
695 (Address <= (PVOID)MiHighestUserPde));
696 }
697
698 FORCEINLINE
699 BOOLEAN
700 MiIsUserPte(PVOID Address)
701 {
702 return (Address <= (PVOID)MiHighestUserPte);
703 }
704 #endif
705
706 //
707 // Figures out the hardware bits for a PTE
708 //
709 FORCEINLINE
710 ULONG_PTR
711 MiDetermineUserGlobalPteMask(IN PVOID PointerPte)
712 {
713 MMPTE TempPte;
714
715 /* Start fresh */
716 TempPte.u.Long = 0;
717
718 /* Make it valid and accessed */
719 TempPte.u.Hard.Valid = TRUE;
720 MI_MAKE_ACCESSED_PAGE(&TempPte);
721
722 /* Is this for user-mode? */
723 if (
724 #if (_MI_PAGING_LEVELS == 4)
725 MiIsUserPxe(PointerPte) ||
726 #endif
727 #if (_MI_PAGING_LEVELS >= 3)
728 MiIsUserPpe(PointerPte) ||
729 #endif
730 MiIsUserPde(PointerPte) ||
731 MiIsUserPte(PointerPte))
732 {
733 /* Set the owner bit */
734 MI_MAKE_OWNER_PAGE(&TempPte);
735 }
736
737 /* FIXME: We should also set the global bit */
738
739 /* Return the protection */
740 return TempPte.u.Long;
741 }
742
743 //
744 // Creates a valid kernel PTE with the given protection
745 //
746 FORCEINLINE
747 VOID
748 MI_MAKE_HARDWARE_PTE_KERNEL(IN PMMPTE NewPte,
749 IN PMMPTE MappingPte,
750 IN ULONG_PTR ProtectionMask,
751 IN PFN_NUMBER PageFrameNumber)
752 {
753 /* Only valid for kernel, non-session PTEs */
754 ASSERT(MappingPte > MiHighestUserPte);
755 ASSERT(!MI_IS_SESSION_PTE(MappingPte));
756 ASSERT((MappingPte < (PMMPTE)PDE_BASE) || (MappingPte > (PMMPTE)PDE_TOP));
757
758 /* Start fresh */
759 *NewPte = ValidKernelPte;
760
761 /* Set the protection and page */
762 NewPte->u.Hard.PageFrameNumber = PageFrameNumber;
763 NewPte->u.Long |= MmProtectToPteMask[ProtectionMask];
764 }
765
766 //
767 // Creates a valid PTE with the given protection
768 //
769 FORCEINLINE
770 VOID
771 MI_MAKE_HARDWARE_PTE(IN PMMPTE NewPte,
772 IN PMMPTE MappingPte,
773 IN ULONG_PTR ProtectionMask,
774 IN PFN_NUMBER PageFrameNumber)
775 {
776 /* Set the protection and page */
777 NewPte->u.Long = MiDetermineUserGlobalPteMask(MappingPte);
778 NewPte->u.Long |= MmProtectToPteMask[ProtectionMask];
779 NewPte->u.Hard.PageFrameNumber = PageFrameNumber;
780 }
781
782 //
783 // Creates a valid user PTE with the given protection
784 //
785 FORCEINLINE
786 VOID
787 MI_MAKE_HARDWARE_PTE_USER(IN PMMPTE NewPte,
788 IN PMMPTE MappingPte,
789 IN ULONG_PTR ProtectionMask,
790 IN PFN_NUMBER PageFrameNumber)
791 {
792 /* Only valid for kernel, non-session PTEs */
793 ASSERT(MappingPte <= MiHighestUserPte);
794
795 /* Start fresh */
796 NewPte->u.Long = 0;
797
798 /* Set the protection and page */
799 NewPte->u.Hard.Valid = TRUE;
800 NewPte->u.Hard.Owner = TRUE;
801 NewPte->u.Hard.PageFrameNumber = PageFrameNumber;
802 NewPte->u.Long |= MmProtectToPteMask[ProtectionMask];
803 }
804
805 #ifndef _M_AMD64
806 //
807 // Builds a Prototype PTE for the address of the PTE
808 //
809 FORCEINLINE
810 VOID
811 MI_MAKE_PROTOTYPE_PTE(IN PMMPTE NewPte,
812 IN PMMPTE PointerPte)
813 {
814 ULONG_PTR Offset;
815
816 /* Mark this as a prototype */
817 NewPte->u.Long = 0;
818 NewPte->u.Proto.Prototype = 1;
819
820 /*
821 * Prototype PTEs are only valid in paged pool by design, this little trick
822 * lets us only use 30 bits for the adress of the PTE, as long as the area
823 * stays 1024MB At most.
824 */
825 Offset = (ULONG_PTR)PointerPte - (ULONG_PTR)MmPagedPoolStart;
826
827 /*
828 * 7 bits go in the "low" (but we assume the bottom 2 are zero)
829 * and the other 21 bits go in the "high"
830 */
831 NewPte->u.Proto.ProtoAddressLow = (Offset & 0x1FC) >> 2;
832 NewPte->u.Proto.ProtoAddressHigh = (Offset & 0x3FFFFE00) >> 9;
833 }
834
835 //
836 // Builds a Subsection PTE for the address of the Segment
837 //
838 FORCEINLINE
839 VOID
840 MI_MAKE_SUBSECTION_PTE(IN PMMPTE NewPte,
841 IN PVOID Segment)
842 {
843 ULONG_PTR Offset;
844
845 /* Mark this as a prototype */
846 NewPte->u.Long = 0;
847 NewPte->u.Subsect.Prototype = 1;
848
849 /*
850 * Segments are only valid either in nonpaged pool. We store the 20 bit
851 * difference either from the top or bottom of nonpaged pool, giving a
852 * maximum of 128MB to each delta, meaning nonpaged pool cannot exceed
853 * 256MB.
854 */
855 if ((ULONG_PTR)Segment < ((ULONG_PTR)MmSubsectionBase + (128 * _1MB)))
856 {
857 Offset = (ULONG_PTR)Segment - (ULONG_PTR)MmSubsectionBase;
858 NewPte->u.Subsect.WhichPool = PagedPool;
859 }
860 else
861 {
862 Offset = (ULONG_PTR)MmNonPagedPoolEnd - (ULONG_PTR)Segment;
863 NewPte->u.Subsect.WhichPool = NonPagedPool;
864 }
865
866 /*
867 * 4 bits go in the "low" (but we assume the bottom 3 are zero)
868 * and the other 20 bits go in the "high"
869 */
870 NewPte->u.Subsect.SubsectionAddressLow = (Offset & 0x78) >> 3;
871 NewPte->u.Subsect.SubsectionAddressHigh = (Offset & 0xFFFFF80) >> 7;
872 }
873
874 FORCEINLINE
875 BOOLEAN
876 MI_IS_MAPPED_PTE(PMMPTE PointerPte)
877 {
878 /// \todo Make this reasonable code, this is UGLY!
879 return ((PointerPte->u.Long & 0xFFFFFC01) != 0);
880 }
881
882 #endif
883
884 FORCEINLINE
885 VOID
886 MI_MAKE_TRANSITION_PTE(_Out_ PMMPTE NewPte,
887 _In_ PFN_NUMBER Page,
888 _In_ ULONG Protection)
889 {
890 NewPte->u.Long = 0;
891 NewPte->u.Trans.Transition = 1;
892 NewPte->u.Trans.Protection = Protection;
893 NewPte->u.Trans.PageFrameNumber = Page;
894 }
895
896 //
897 // Returns if the page is physically resident (ie: a large page)
898 // FIXFIX: CISC/x86 only?
899 //
900 FORCEINLINE
901 BOOLEAN
902 MI_IS_PHYSICAL_ADDRESS(IN PVOID Address)
903 {
904 PMMPDE PointerPde;
905
906 /* Large pages are never paged out, always physically resident */
907 PointerPde = MiAddressToPde(Address);
908 return ((PointerPde->u.Hard.LargePage) && (PointerPde->u.Hard.Valid));
909 }
910
911 //
912 // Writes a valid PTE
913 //
914 FORCEINLINE
915 VOID
916 MI_WRITE_VALID_PTE(IN PMMPTE PointerPte,
917 IN MMPTE TempPte)
918 {
919 /* Write the valid PTE */
920 ASSERT(PointerPte->u.Hard.Valid == 0);
921 ASSERT(TempPte.u.Hard.Valid == 1);
922 *PointerPte = TempPte;
923 }
924
925 //
926 // Updates a valid PTE
927 //
928 FORCEINLINE
929 VOID
930 MI_UPDATE_VALID_PTE(IN PMMPTE PointerPte,
931 IN MMPTE TempPte)
932 {
933 /* Write the valid PTE */
934 ASSERT(PointerPte->u.Hard.Valid == 1);
935 ASSERT(TempPte.u.Hard.Valid == 1);
936 ASSERT(PointerPte->u.Hard.PageFrameNumber == TempPte.u.Hard.PageFrameNumber);
937 *PointerPte = TempPte;
938 }
939
940 //
941 // Writes an invalid PTE
942 //
943 FORCEINLINE
944 VOID
945 MI_WRITE_INVALID_PTE(IN PMMPTE PointerPte,
946 IN MMPTE InvalidPte)
947 {
948 /* Write the invalid PTE */
949 ASSERT(InvalidPte.u.Hard.Valid == 0);
950 ASSERT(InvalidPte.u.Long != 0);
951 *PointerPte = InvalidPte;
952 }
953
954 //
955 // Erase the PTE completely
956 //
957 FORCEINLINE
958 VOID
959 MI_ERASE_PTE(IN PMMPTE PointerPte)
960 {
961 /* Zero out the PTE */
962 ASSERT(PointerPte->u.Long != 0);
963 PointerPte->u.Long = 0;
964 }
965
966 //
967 // Writes a valid PDE
968 //
969 FORCEINLINE
970 VOID
971 MI_WRITE_VALID_PDE(IN PMMPDE PointerPde,
972 IN MMPDE TempPde)
973 {
974 /* Write the valid PDE */
975 ASSERT(PointerPde->u.Hard.Valid == 0);
976 ASSERT(TempPde.u.Hard.Valid == 1);
977 *PointerPde = TempPde;
978 }
979
980 //
981 // Writes an invalid PDE
982 //
983 FORCEINLINE
984 VOID
985 MI_WRITE_INVALID_PDE(IN PMMPDE PointerPde,
986 IN MMPDE InvalidPde)
987 {
988 /* Write the invalid PDE */
989 ASSERT(InvalidPde.u.Hard.Valid == 0);
990 ASSERT(InvalidPde.u.Long != 0);
991 *PointerPde = InvalidPde;
992 }
993
994 //
995 // Checks if the thread already owns a working set
996 //
997 FORCEINLINE
998 BOOLEAN
999 MM_ANY_WS_LOCK_HELD(IN PETHREAD Thread)
1000 {
1001 /* If any of these are held, return TRUE */
1002 return ((Thread->OwnsProcessWorkingSetExclusive) ||
1003 (Thread->OwnsProcessWorkingSetShared) ||
1004 (Thread->OwnsSystemWorkingSetExclusive) ||
1005 (Thread->OwnsSystemWorkingSetShared) ||
1006 (Thread->OwnsSessionWorkingSetExclusive) ||
1007 (Thread->OwnsSessionWorkingSetShared));
1008 }
1009
1010 //
1011 // Checks if the process owns the working set lock
1012 //
1013 FORCEINLINE
1014 BOOLEAN
1015 MI_WS_OWNER(IN PEPROCESS Process)
1016 {
1017 /* Check if this process is the owner, and that the thread owns the WS */
1018 if (PsGetCurrentThread()->OwnsProcessWorkingSetExclusive == 0)
1019 {
1020 DPRINT("Thread: %p is not an owner\n", PsGetCurrentThread());
1021 }
1022 if (KeGetCurrentThread()->ApcState.Process != &Process->Pcb)
1023 {
1024 DPRINT("Current thread %p is attached to another process %p\n", PsGetCurrentThread(), Process);
1025 }
1026 return ((KeGetCurrentThread()->ApcState.Process == &Process->Pcb) &&
1027 ((PsGetCurrentThread()->OwnsProcessWorkingSetExclusive) ||
1028 (PsGetCurrentThread()->OwnsProcessWorkingSetShared)));
1029 }
1030
1031 //
1032 // New ARM3<->RosMM PAGE Architecture
1033 //
1034 FORCEINLINE
1035 BOOLEAN
1036 MiIsRosSectionObject(IN PVOID Section)
1037 {
1038 PROS_SECTION_OBJECT RosSection = Section;
1039 if ((RosSection->Type == 'SC') && (RosSection->Size == 'TN')) return TRUE;
1040 return FALSE;
1041 }
1042
1043 #define MI_IS_ROS_PFN(x) ((x)->u4.AweAllocation == TRUE)
1044
1045 VOID
1046 NTAPI
1047 MiDecrementReferenceCount(
1048 IN PMMPFN Pfn1,
1049 IN PFN_NUMBER PageFrameIndex
1050 );
1051
1052 FORCEINLINE
1053 BOOLEAN
1054 MI_IS_WS_UNSAFE(IN PEPROCESS Process)
1055 {
1056 return (Process->Vm.Flags.AcquiredUnsafe == TRUE);
1057 }
1058
1059 //
1060 // Locks the working set for the given process
1061 //
1062 FORCEINLINE
1063 VOID
1064 MiLockProcessWorkingSet(IN PEPROCESS Process,
1065 IN PETHREAD Thread)
1066 {
1067 /* Shouldn't already be owning the process working set */
1068 ASSERT(Thread->OwnsProcessWorkingSetShared == FALSE);
1069 ASSERT(Thread->OwnsProcessWorkingSetExclusive == FALSE);
1070
1071 /* Block APCs, make sure that still nothing is already held */
1072 KeEnterGuardedRegion();
1073 ASSERT(!MM_ANY_WS_LOCK_HELD(Thread));
1074
1075 /* Lock the working set */
1076 ExAcquirePushLockExclusive(&Process->Vm.WorkingSetMutex);
1077
1078 /* Now claim that we own the lock */
1079 ASSERT(!MI_IS_WS_UNSAFE(Process));
1080 ASSERT(Thread->OwnsProcessWorkingSetExclusive == FALSE);
1081 Thread->OwnsProcessWorkingSetExclusive = TRUE;
1082 }
1083
1084 FORCEINLINE
1085 VOID
1086 MiLockProcessWorkingSetShared(IN PEPROCESS Process,
1087 IN PETHREAD Thread)
1088 {
1089 /* Shouldn't already be owning the process working set */
1090 ASSERT(Thread->OwnsProcessWorkingSetShared == FALSE);
1091 ASSERT(Thread->OwnsProcessWorkingSetExclusive == FALSE);
1092
1093 /* Block APCs, make sure that still nothing is already held */
1094 KeEnterGuardedRegion();
1095 ASSERT(!MM_ANY_WS_LOCK_HELD(Thread));
1096
1097 /* Lock the working set */
1098 ExAcquirePushLockShared(&Process->Vm.WorkingSetMutex);
1099
1100 /* Now claim that we own the lock */
1101 ASSERT(!MI_IS_WS_UNSAFE(Process));
1102 ASSERT(Thread->OwnsProcessWorkingSetShared == FALSE);
1103 ASSERT(Thread->OwnsProcessWorkingSetExclusive == FALSE);
1104 Thread->OwnsProcessWorkingSetShared = TRUE;
1105 }
1106
1107 FORCEINLINE
1108 VOID
1109 MiLockProcessWorkingSetUnsafe(IN PEPROCESS Process,
1110 IN PETHREAD Thread)
1111 {
1112 /* Shouldn't already be owning the process working set */
1113 ASSERT(Thread->OwnsProcessWorkingSetExclusive == FALSE);
1114
1115 /* APCs must be blocked, make sure that still nothing is already held */
1116 ASSERT(KeAreAllApcsDisabled() == TRUE);
1117 ASSERT(!MM_ANY_WS_LOCK_HELD(Thread));
1118
1119 /* Lock the working set */
1120 ExAcquirePushLockExclusive(&Process->Vm.WorkingSetMutex);
1121
1122 /* Now claim that we own the lock */
1123 ASSERT(!MI_IS_WS_UNSAFE(Process));
1124 Process->Vm.Flags.AcquiredUnsafe = 1;
1125 ASSERT(Thread->OwnsProcessWorkingSetExclusive == FALSE);
1126 Thread->OwnsProcessWorkingSetExclusive = TRUE;
1127 }
1128
1129 //
1130 // Unlocks the working set for the given process
1131 //
1132 FORCEINLINE
1133 VOID
1134 MiUnlockProcessWorkingSet(IN PEPROCESS Process,
1135 IN PETHREAD Thread)
1136 {
1137 /* Make sure we are the owner of a safe acquisition */
1138 ASSERT(MI_WS_OWNER(Process));
1139 ASSERT(!MI_IS_WS_UNSAFE(Process));
1140
1141 /* The thread doesn't own it anymore */
1142 ASSERT(Thread->OwnsProcessWorkingSetExclusive == TRUE);
1143 Thread->OwnsProcessWorkingSetExclusive = FALSE;
1144
1145 /* Release the lock and re-enable APCs */
1146 ExReleasePushLockExclusive(&Process->Vm.WorkingSetMutex);
1147 KeLeaveGuardedRegion();
1148 }
1149
1150 //
1151 // Unlocks the working set for the given process
1152 //
1153 FORCEINLINE
1154 VOID
1155 MiUnlockProcessWorkingSetShared(IN PEPROCESS Process,
1156 IN PETHREAD Thread)
1157 {
1158 /* Make sure we are the owner of a safe acquisition (because shared) */
1159 ASSERT(MI_WS_OWNER(Process));
1160 ASSERT(!MI_IS_WS_UNSAFE(Process));
1161
1162 /* Ensure we are in a shared acquisition */
1163 ASSERT(Thread->OwnsProcessWorkingSetShared == TRUE);
1164 ASSERT(Thread->OwnsProcessWorkingSetExclusive == FALSE);
1165
1166 /* Don't claim the lock anylonger */
1167 Thread->OwnsProcessWorkingSetShared = FALSE;
1168
1169 /* Release the lock and re-enable APCs */
1170 ExReleasePushLockShared(&Process->Vm.WorkingSetMutex);
1171 KeLeaveGuardedRegion();
1172 }
1173
1174 //
1175 // Unlocks the working set for the given process
1176 //
1177 FORCEINLINE
1178 VOID
1179 MiUnlockProcessWorkingSetUnsafe(IN PEPROCESS Process,
1180 IN PETHREAD Thread)
1181 {
1182 /* Make sure we are the owner of an unsafe acquisition */
1183 ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
1184 ASSERT(KeAreAllApcsDisabled() == TRUE);
1185 ASSERT(MI_WS_OWNER(Process));
1186 ASSERT(MI_IS_WS_UNSAFE(Process));
1187
1188 /* No longer unsafe */
1189 Process->Vm.Flags.AcquiredUnsafe = 0;
1190
1191 /* The thread doesn't own it anymore */
1192 ASSERT(Thread->OwnsProcessWorkingSetExclusive == TRUE);
1193 Thread->OwnsProcessWorkingSetExclusive = FALSE;
1194
1195 /* Release the lock but don't touch APC state */
1196 ExReleasePushLockExclusive(&Process->Vm.WorkingSetMutex);
1197 ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
1198 }
1199
1200 //
1201 // Locks the working set
1202 //
1203 FORCEINLINE
1204 VOID
1205 MiLockWorkingSet(IN PETHREAD Thread,
1206 IN PMMSUPPORT WorkingSet)
1207 {
1208 /* Block APCs */
1209 KeEnterGuardedRegion();
1210
1211 /* Working set should be in global memory */
1212 ASSERT(MI_IS_SESSION_ADDRESS((PVOID)WorkingSet) == FALSE);
1213
1214 /* Thread shouldn't already be owning something */
1215 ASSERT(!MM_ANY_WS_LOCK_HELD(Thread));
1216
1217 /* Lock this working set */
1218 ExAcquirePushLockExclusive(&WorkingSet->WorkingSetMutex);
1219
1220 /* Which working set is this? */
1221 if (WorkingSet == &MmSystemCacheWs)
1222 {
1223 /* Own the system working set */
1224 ASSERT((Thread->OwnsSystemWorkingSetExclusive == FALSE) &&
1225 (Thread->OwnsSystemWorkingSetShared == FALSE));
1226 Thread->OwnsSystemWorkingSetExclusive = TRUE;
1227 }
1228 else if (WorkingSet->Flags.SessionSpace)
1229 {
1230 /* Own the session working set */
1231 ASSERT((Thread->OwnsSessionWorkingSetExclusive == FALSE) &&
1232 (Thread->OwnsSessionWorkingSetShared == FALSE));
1233 Thread->OwnsSessionWorkingSetExclusive = TRUE;
1234 }
1235 else
1236 {
1237 /* Own the process working set */
1238 ASSERT((Thread->OwnsProcessWorkingSetExclusive == FALSE) &&
1239 (Thread->OwnsProcessWorkingSetShared == FALSE));
1240 Thread->OwnsProcessWorkingSetExclusive = TRUE;
1241 }
1242 }
1243
1244 //
1245 // Unlocks the working set
1246 //
1247 FORCEINLINE
1248 VOID
1249 MiUnlockWorkingSet(IN PETHREAD Thread,
1250 IN PMMSUPPORT WorkingSet)
1251 {
1252 /* Working set should be in global memory */
1253 ASSERT(MI_IS_SESSION_ADDRESS((PVOID)WorkingSet) == FALSE);
1254
1255 /* Which working set is this? */
1256 if (WorkingSet == &MmSystemCacheWs)
1257 {
1258 /* Release the system working set */
1259 ASSERT((Thread->OwnsSystemWorkingSetExclusive == TRUE) ||
1260 (Thread->OwnsSystemWorkingSetShared == TRUE));
1261 Thread->OwnsSystemWorkingSetExclusive = FALSE;
1262 }
1263 else if (WorkingSet->Flags.SessionSpace)
1264 {
1265 /* Release the session working set */
1266 ASSERT((Thread->OwnsSessionWorkingSetExclusive == TRUE) ||
1267 (Thread->OwnsSessionWorkingSetShared == TRUE));
1268 Thread->OwnsSessionWorkingSetExclusive = 0;
1269 }
1270 else
1271 {
1272 /* Release the process working set */
1273 ASSERT((Thread->OwnsProcessWorkingSetExclusive) ||
1274 (Thread->OwnsProcessWorkingSetShared));
1275 Thread->OwnsProcessWorkingSetExclusive = FALSE;
1276 }
1277
1278 /* Release the working set lock */
1279 ExReleasePushLockExclusive(&WorkingSet->WorkingSetMutex);
1280
1281 /* Unblock APCs */
1282 KeLeaveGuardedRegion();
1283 }
1284
1285 FORCEINLINE
1286 VOID
1287 MiUnlockProcessWorkingSetForFault(IN PEPROCESS Process,
1288 IN PETHREAD Thread,
1289 OUT PBOOLEAN Safe,
1290 OUT PBOOLEAN Shared)
1291 {
1292 ASSERT(MI_WS_OWNER(Process));
1293
1294 /* Check if the current owner is unsafe */
1295 if (MI_IS_WS_UNSAFE(Process))
1296 {
1297 /* Release unsafely */
1298 MiUnlockProcessWorkingSetUnsafe(Process, Thread);
1299 *Safe = FALSE;
1300 *Shared = FALSE;
1301 }
1302 else if (Thread->OwnsProcessWorkingSetExclusive == 1)
1303 {
1304 /* Owner is safe and exclusive, release normally */
1305 MiUnlockProcessWorkingSet(Process, Thread);
1306 *Safe = TRUE;
1307 *Shared = FALSE;
1308 }
1309 else
1310 {
1311 /* Owner is shared (implies safe), release normally */
1312 MiUnlockProcessWorkingSetShared(Process, Thread);
1313 *Safe = TRUE;
1314 *Shared = TRUE;
1315 }
1316 }
1317
1318 FORCEINLINE
1319 VOID
1320 MiLockProcessWorkingSetForFault(IN PEPROCESS Process,
1321 IN PETHREAD Thread,
1322 IN BOOLEAN Safe,
1323 IN BOOLEAN Shared)
1324 {
1325 /* Check if this was a safe lock or not */
1326 if (Safe)
1327 {
1328 if (Shared)
1329 {
1330 /* Reacquire safely & shared */
1331 MiLockProcessWorkingSetShared(Process, Thread);
1332 }
1333 else
1334 {
1335 /* Reacquire safely */
1336 MiLockProcessWorkingSet(Process, Thread);
1337 }
1338 }
1339 else
1340 {
1341 /* Unsafe lock cannot be shared */
1342 ASSERT(Shared == FALSE);
1343 /* Reacquire unsafely */
1344 MiLockProcessWorkingSetUnsafe(Process, Thread);
1345 }
1346 }
1347
1348 FORCEINLINE
1349 KIRQL
1350 MiAcquireExpansionLock(VOID)
1351 {
1352 KIRQL OldIrql;
1353
1354 ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
1355 KeAcquireSpinLock(&MmExpansionLock, &OldIrql);
1356 ASSERT(MiExpansionLockOwner == NULL);
1357 MiExpansionLockOwner = PsGetCurrentThread();
1358 return OldIrql;
1359 }
1360
1361 FORCEINLINE
1362 VOID
1363 MiReleaseExpansionLock(KIRQL OldIrql)
1364 {
1365 ASSERT(MiExpansionLockOwner == PsGetCurrentThread());
1366 MiExpansionLockOwner = NULL;
1367 KeReleaseSpinLock(&MmExpansionLock, OldIrql);
1368 ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
1369 }
1370
1371 //
1372 // Returns the ProtoPTE inside a VAD for the given VPN
1373 //
1374 FORCEINLINE
1375 PMMPTE
1376 MI_GET_PROTOTYPE_PTE_FOR_VPN(IN PMMVAD Vad,
1377 IN ULONG_PTR Vpn)
1378 {
1379 PMMPTE ProtoPte;
1380
1381 /* Find the offset within the VAD's prototype PTEs */
1382 ProtoPte = Vad->FirstPrototypePte + (Vpn - Vad->StartingVpn);
1383 ASSERT(ProtoPte <= Vad->LastContiguousPte);
1384 return ProtoPte;
1385 }
1386
1387 //
1388 // Returns the PFN Database entry for the given page number
1389 // Warning: This is not necessarily a valid PFN database entry!
1390 //
1391 FORCEINLINE
1392 PMMPFN
1393 MI_PFN_ELEMENT(IN PFN_NUMBER Pfn)
1394 {
1395 /* Get the entry */
1396 return &MmPfnDatabase[Pfn];
1397 };
1398
1399 //
1400 // Drops a locked page without dereferencing it
1401 //
1402 FORCEINLINE
1403 VOID
1404 MiDropLockCount(IN PMMPFN Pfn1)
1405 {
1406 /* This page shouldn't be locked, but it should be valid */
1407 ASSERT(Pfn1->u3.e2.ReferenceCount != 0);
1408 ASSERT(Pfn1->u2.ShareCount == 0);
1409
1410 /* Is this the last reference to the page */
1411 if (Pfn1->u3.e2.ReferenceCount == 1)
1412 {
1413 /* It better not be valid */
1414 ASSERT(Pfn1->u3.e1.PageLocation != ActiveAndValid);
1415
1416 /* Is it a prototype PTE? */
1417 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1418 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1419 {
1420 /* FIXME: We should return commit */
1421 DPRINT1("Not returning commit for prototype PTE\n");
1422 }
1423
1424 /* Update the counter */
1425 InterlockedDecrementSizeT(&MmSystemLockPagesCount);
1426 }
1427 }
1428
1429 //
1430 // Drops a locked page and dereferences it
1431 //
1432 FORCEINLINE
1433 VOID
1434 MiDereferencePfnAndDropLockCount(IN PMMPFN Pfn1)
1435 {
1436 USHORT RefCount, OldRefCount;
1437 PFN_NUMBER PageFrameIndex;
1438
1439 /* Loop while we decrement the page successfully */
1440 do
1441 {
1442 /* There should be at least one reference */
1443 OldRefCount = Pfn1->u3.e2.ReferenceCount;
1444 ASSERT(OldRefCount != 0);
1445
1446 /* Are we the last one */
1447 if (OldRefCount == 1)
1448 {
1449 /* The page shoudln't be shared not active at this point */
1450 ASSERT(Pfn1->u3.e2.ReferenceCount == 1);
1451 ASSERT(Pfn1->u3.e1.PageLocation != ActiveAndValid);
1452 ASSERT(Pfn1->u2.ShareCount == 0);
1453
1454 /* Is it a prototype PTE? */
1455 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1456 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1457 {
1458 /* FIXME: We should return commit */
1459 DPRINT1("Not returning commit for prototype PTE\n");
1460 }
1461
1462 /* Update the counter, and drop a reference the long way */
1463 InterlockedDecrementSizeT(&MmSystemLockPagesCount);
1464 PageFrameIndex = MiGetPfnEntryIndex(Pfn1);
1465 MiDecrementReferenceCount(Pfn1, PageFrameIndex);
1466 return;
1467 }
1468
1469 /* Drop a reference the short way, and that's it */
1470 RefCount = InterlockedCompareExchange16((PSHORT)&Pfn1->u3.e2.ReferenceCount,
1471 OldRefCount - 1,
1472 OldRefCount);
1473 ASSERT(RefCount != 0);
1474 } while (OldRefCount != RefCount);
1475
1476 /* If we got here, there should be more than one reference */
1477 ASSERT(RefCount > 1);
1478 if (RefCount == 2)
1479 {
1480 /* Is it still being shared? */
1481 if (Pfn1->u2.ShareCount >= 1)
1482 {
1483 /* Then it should be valid */
1484 ASSERT(Pfn1->u3.e1.PageLocation == ActiveAndValid);
1485
1486 /* Is it a prototype PTE? */
1487 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1488 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1489 {
1490 /* We don't handle ethis */
1491 ASSERT(FALSE);
1492 }
1493
1494 /* Update the counter */
1495 InterlockedDecrementSizeT(&MmSystemLockPagesCount);
1496 }
1497 }
1498 }
1499
1500 //
1501 // References a locked page and updates the counter
1502 // Used in MmProbeAndLockPages to handle different edge cases
1503 //
1504 FORCEINLINE
1505 VOID
1506 MiReferenceProbedPageAndBumpLockCount(IN PMMPFN Pfn1)
1507 {
1508 USHORT RefCount, OldRefCount;
1509
1510 /* Sanity check */
1511 ASSERT(Pfn1->u3.e2.ReferenceCount != 0);
1512
1513 /* Does ARM3 own the page? */
1514 if (MI_IS_ROS_PFN(Pfn1))
1515 {
1516 /* ReactOS Mm doesn't track share count */
1517 ASSERT(Pfn1->u3.e1.PageLocation == ActiveAndValid);
1518 }
1519 else
1520 {
1521 /* On ARM3 pages, we should see a valid share count */
1522 ASSERT((Pfn1->u2.ShareCount != 0) && (Pfn1->u3.e1.PageLocation == ActiveAndValid));
1523
1524 /* Is it a prototype PTE? */
1525 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1526 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1527 {
1528 /* FIXME: We should charge commit */
1529 DPRINT1("Not charging commit for prototype PTE\n");
1530 }
1531 }
1532
1533 /* More locked pages! */
1534 InterlockedIncrementSizeT(&MmSystemLockPagesCount);
1535
1536 /* Loop trying to update the reference count */
1537 do
1538 {
1539 /* Get the current reference count, make sure it's valid */
1540 OldRefCount = Pfn1->u3.e2.ReferenceCount;
1541 ASSERT(OldRefCount != 0);
1542 ASSERT(OldRefCount < 2500);
1543
1544 /* Bump it up by one */
1545 RefCount = InterlockedCompareExchange16((PSHORT)&Pfn1->u3.e2.ReferenceCount,
1546 OldRefCount + 1,
1547 OldRefCount);
1548 ASSERT(RefCount != 0);
1549 } while (OldRefCount != RefCount);
1550
1551 /* Was this the first lock attempt? If not, undo our bump */
1552 if (OldRefCount != 1) InterlockedDecrementSizeT(&MmSystemLockPagesCount);
1553 }
1554
1555 //
1556 // References a locked page and updates the counter
1557 // Used in all other cases except MmProbeAndLockPages
1558 //
1559 FORCEINLINE
1560 VOID
1561 MiReferenceUsedPageAndBumpLockCount(IN PMMPFN Pfn1)
1562 {
1563 USHORT NewRefCount;
1564
1565 /* Is it a prototype PTE? */
1566 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1567 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1568 {
1569 /* FIXME: We should charge commit */
1570 DPRINT1("Not charging commit for prototype PTE\n");
1571 }
1572
1573 /* More locked pages! */
1574 InterlockedIncrementSizeT(&MmSystemLockPagesCount);
1575
1576 /* Update the reference count */
1577 NewRefCount = InterlockedIncrement16((PSHORT)&Pfn1->u3.e2.ReferenceCount);
1578 if (NewRefCount == 2)
1579 {
1580 /* Is it locked or shared? */
1581 if (Pfn1->u2.ShareCount)
1582 {
1583 /* It's shared, so make sure it's active */
1584 ASSERT(Pfn1->u3.e1.PageLocation == ActiveAndValid);
1585 }
1586 else
1587 {
1588 /* It's locked, so we shouldn't lock again */
1589 InterlockedDecrementSizeT(&MmSystemLockPagesCount);
1590 }
1591 }
1592 else
1593 {
1594 /* Someone had already locked the page, so undo our bump */
1595 ASSERT(NewRefCount < 2500);
1596 InterlockedDecrementSizeT(&MmSystemLockPagesCount);
1597 }
1598 }
1599
1600 //
1601 // References a locked page and updates the counter
1602 // Used in all other cases except MmProbeAndLockPages
1603 //
1604 FORCEINLINE
1605 VOID
1606 MiReferenceUnusedPageAndBumpLockCount(IN PMMPFN Pfn1)
1607 {
1608 USHORT NewRefCount;
1609
1610 /* Make sure the page isn't used yet */
1611 ASSERT(Pfn1->u2.ShareCount == 0);
1612 ASSERT(Pfn1->u3.e1.PageLocation != ActiveAndValid);
1613
1614 /* Is it a prototype PTE? */
1615 if ((Pfn1->u3.e1.PrototypePte == 1) &&
1616 (Pfn1->OriginalPte.u.Soft.Prototype == 1))
1617 {
1618 /* FIXME: We should charge commit */
1619 DPRINT1("Not charging commit for prototype PTE\n");
1620 }
1621
1622 /* More locked pages! */
1623 InterlockedIncrementSizeT(&MmSystemLockPagesCount);
1624
1625 /* Update the reference count */
1626 NewRefCount = InterlockedIncrement16((PSHORT)&Pfn1->u3.e2.ReferenceCount);
1627 if (NewRefCount != 1)
1628 {
1629 /* Someone had already locked the page, so undo our bump */
1630 ASSERT(NewRefCount < 2500);
1631 InterlockedDecrementSizeT(&MmSystemLockPagesCount);
1632 }
1633 }
1634
1635 FORCEINLINE
1636 VOID
1637 MiIncrementPageTableReferences(IN PVOID Address)
1638 {
1639 PUSHORT RefCount;
1640
1641 RefCount = &MmWorkingSetList->UsedPageTableEntries[MiGetPdeOffset(Address)];
1642
1643 *RefCount += 1;
1644 ASSERT(*RefCount <= PTE_PER_PAGE);
1645 }
1646
1647 FORCEINLINE
1648 VOID
1649 MiDecrementPageTableReferences(IN PVOID Address)
1650 {
1651 PUSHORT RefCount;
1652
1653 RefCount = &MmWorkingSetList->UsedPageTableEntries[MiGetPdeOffset(Address)];
1654
1655 *RefCount -= 1;
1656 ASSERT(*RefCount < PTE_PER_PAGE);
1657 }
1658
1659 FORCEINLINE
1660 USHORT
1661 MiQueryPageTableReferences(IN PVOID Address)
1662 {
1663 PUSHORT RefCount;
1664
1665 RefCount = &MmWorkingSetList->UsedPageTableEntries[MiGetPdeOffset(Address)];
1666
1667 return *RefCount;
1668 }
1669
1670 BOOLEAN
1671 NTAPI
1672 MmArmInitSystem(
1673 IN ULONG Phase,
1674 IN PLOADER_PARAMETER_BLOCK LoaderBlock
1675 );
1676
1677 VOID
1678 NTAPI
1679 MiInitializeSessionSpaceLayout(VOID);
1680
1681 NTSTATUS
1682 NTAPI
1683 MiInitMachineDependent(
1684 IN PLOADER_PARAMETER_BLOCK LoaderBlock
1685 );
1686
1687 VOID
1688 NTAPI
1689 MiComputeColorInformation(
1690 VOID
1691 );
1692
1693 VOID
1694 NTAPI
1695 MiMapPfnDatabase(
1696 IN PLOADER_PARAMETER_BLOCK LoaderBlock
1697 );
1698
1699 VOID
1700 NTAPI
1701 MiInitializeColorTables(
1702 VOID
1703 );
1704
1705 VOID
1706 NTAPI
1707 MiInitializePfnDatabase(
1708 IN PLOADER_PARAMETER_BLOCK LoaderBlock
1709 );
1710
1711 VOID
1712 NTAPI
1713 MiInitializeSessionWsSupport(
1714 VOID
1715 );
1716
1717 VOID
1718 NTAPI
1719 MiInitializeSessionIds(
1720 VOID
1721 );
1722
1723 BOOLEAN
1724 NTAPI
1725 MiInitializeMemoryEvents(
1726 VOID
1727 );
1728
1729 PFN_NUMBER
1730 NTAPI
1731 MxGetNextPage(
1732 IN PFN_NUMBER PageCount
1733 );
1734
1735 PPHYSICAL_MEMORY_DESCRIPTOR
1736 NTAPI
1737 MmInitializeMemoryLimits(
1738 IN PLOADER_PARAMETER_BLOCK LoaderBlock,
1739 IN PBOOLEAN IncludeType
1740 );
1741
1742 PFN_NUMBER
1743 NTAPI
1744 MiPagesInLoaderBlock(
1745 IN PLOADER_PARAMETER_BLOCK LoaderBlock,
1746 IN PBOOLEAN IncludeType
1747 );
1748
1749 VOID
1750 FASTCALL
1751 MiSyncARM3WithROS(
1752 IN PVOID AddressStart,
1753 IN PVOID AddressEnd
1754 );
1755
1756 NTSTATUS
1757 NTAPI
1758 MiRosProtectVirtualMemory(
1759 IN PEPROCESS Process,
1760 IN OUT PVOID *BaseAddress,
1761 IN OUT PSIZE_T NumberOfBytesToProtect,
1762 IN ULONG NewAccessProtection,
1763 OUT PULONG OldAccessProtection OPTIONAL
1764 );
1765
1766 NTSTATUS
1767 NTAPI
1768 MmArmAccessFault(
1769 IN BOOLEAN StoreInstruction,
1770 IN PVOID Address,
1771 IN KPROCESSOR_MODE Mode,
1772 IN PVOID TrapInformation
1773 );
1774
1775 NTSTATUS
1776 FASTCALL
1777 MiCheckPdeForPagedPool(
1778 IN PVOID Address
1779 );
1780
1781 VOID
1782 NTAPI
1783 MiInitializeNonPagedPool(
1784 VOID
1785 );
1786
1787 VOID
1788 NTAPI
1789 MiInitializeNonPagedPoolThresholds(
1790 VOID
1791 );
1792
1793 VOID
1794 NTAPI
1795 MiInitializePoolEvents(
1796 VOID
1797 );
1798
1799 VOID //
1800 NTAPI //
1801 InitializePool( //
1802 IN POOL_TYPE PoolType,// FIXFIX: This should go in ex.h after the pool merge
1803 IN ULONG Threshold //
1804 ); //
1805
1806 // FIXFIX: THIS ONE TOO
1807 VOID
1808 NTAPI
1809 INIT_FUNCTION
1810 ExInitializePoolDescriptor(
1811 IN PPOOL_DESCRIPTOR PoolDescriptor,
1812 IN POOL_TYPE PoolType,
1813 IN ULONG PoolIndex,
1814 IN ULONG Threshold,
1815 IN PVOID PoolLock
1816 );
1817
1818 NTSTATUS
1819 NTAPI
1820 MiInitializeSessionPool(
1821 VOID
1822 );
1823
1824 VOID
1825 NTAPI
1826 MiInitializeSystemPtes(
1827 IN PMMPTE StartingPte,
1828 IN ULONG NumberOfPtes,
1829 IN MMSYSTEM_PTE_POOL_TYPE PoolType
1830 );
1831
1832 PMMPTE
1833 NTAPI
1834 MiReserveSystemPtes(
1835 IN ULONG NumberOfPtes,
1836 IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType
1837 );
1838
1839 VOID
1840 NTAPI
1841 MiReleaseSystemPtes(
1842 IN PMMPTE StartingPte,
1843 IN ULONG NumberOfPtes,
1844 IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType
1845 );
1846
1847
1848 PFN_NUMBER
1849 NTAPI
1850 MiFindContiguousPages(
1851 IN PFN_NUMBER LowestPfn,
1852 IN PFN_NUMBER HighestPfn,
1853 IN PFN_NUMBER BoundaryPfn,
1854 IN PFN_NUMBER SizeInPages,
1855 IN MEMORY_CACHING_TYPE CacheType
1856 );
1857
1858 PVOID
1859 NTAPI
1860 MiCheckForContiguousMemory(
1861 IN PVOID BaseAddress,
1862 IN PFN_NUMBER BaseAddressPages,
1863 IN PFN_NUMBER SizeInPages,
1864 IN PFN_NUMBER LowestPfn,
1865 IN PFN_NUMBER HighestPfn,
1866 IN PFN_NUMBER BoundaryPfn,
1867 IN MI_PFN_CACHE_ATTRIBUTE CacheAttribute
1868 );
1869
1870 PMDL
1871 NTAPI
1872 MiAllocatePagesForMdl(
1873 IN PHYSICAL_ADDRESS LowAddress,
1874 IN PHYSICAL_ADDRESS HighAddress,
1875 IN PHYSICAL_ADDRESS SkipBytes,
1876 IN SIZE_T TotalBytes,
1877 IN MI_PFN_CACHE_ATTRIBUTE CacheAttribute,
1878 IN ULONG Flags
1879 );
1880
1881 VOID
1882 NTAPI
1883 MiInsertPageInList(
1884 IN PMMPFNLIST ListHead,
1885 IN PFN_NUMBER PageFrameIndex
1886 );
1887
1888 VOID
1889 NTAPI
1890 MiUnlinkFreeOrZeroedPage(
1891 IN PMMPFN Entry
1892 );
1893
1894 VOID
1895 NTAPI
1896 MiUnlinkPageFromList(
1897 IN PMMPFN Pfn
1898 );
1899
1900 VOID
1901 NTAPI
1902 MiInitializePfn(
1903 IN PFN_NUMBER PageFrameIndex,
1904 IN PMMPTE PointerPte,
1905 IN BOOLEAN Modified
1906 );
1907
1908 NTSTATUS
1909 NTAPI
1910 MiInitializeAndChargePfn(
1911 OUT PPFN_NUMBER PageFrameIndex,
1912 IN PMMPDE PointerPde,
1913 IN PFN_NUMBER ContainingPageFrame,
1914 IN BOOLEAN SessionAllocation
1915 );
1916
1917 VOID
1918 NTAPI
1919 MiInitializePfnAndMakePteValid(
1920 IN PFN_NUMBER PageFrameIndex,
1921 IN PMMPTE PointerPte,
1922 IN MMPTE TempPte
1923 );
1924
1925 VOID
1926 NTAPI
1927 MiInitializePfnForOtherProcess(
1928 IN PFN_NUMBER PageFrameIndex,
1929 IN PVOID PteAddress,
1930 IN PFN_NUMBER PteFrame
1931 );
1932
1933 VOID
1934 NTAPI
1935 MiDecrementShareCount(
1936 IN PMMPFN Pfn1,
1937 IN PFN_NUMBER PageFrameIndex
1938 );
1939
1940 PFN_NUMBER
1941 NTAPI
1942 MiRemoveAnyPage(
1943 IN ULONG Color
1944 );
1945
1946 PFN_NUMBER
1947 NTAPI
1948 MiRemoveZeroPage(
1949 IN ULONG Color
1950 );
1951
1952 VOID
1953 NTAPI
1954 MiZeroPhysicalPage(
1955 IN PFN_NUMBER PageFrameIndex
1956 );
1957
1958 VOID
1959 NTAPI
1960 MiInsertPageInFreeList(
1961 IN PFN_NUMBER PageFrameIndex
1962 );
1963
1964 PFN_COUNT
1965 NTAPI
1966 MiDeleteSystemPageableVm(
1967 IN PMMPTE PointerPte,
1968 IN PFN_NUMBER PageCount,
1969 IN ULONG Flags,
1970 OUT PPFN_NUMBER ValidPages
1971 );
1972
1973 ULONG
1974 NTAPI
1975 MiGetPageProtection(
1976 IN PMMPTE PointerPte
1977 );
1978
1979 PLDR_DATA_TABLE_ENTRY
1980 NTAPI
1981 MiLookupDataTableEntry(
1982 IN PVOID Address
1983 );
1984
1985 VOID
1986 NTAPI
1987 MiInitializeDriverLargePageList(
1988 VOID
1989 );
1990
1991 VOID
1992 NTAPI
1993 MiInitializeLargePageSupport(
1994 VOID
1995 );
1996
1997 VOID
1998 NTAPI
1999 MiSyncCachedRanges(
2000 VOID
2001 );
2002
2003 BOOLEAN
2004 NTAPI
2005 MiIsPfnInUse(
2006 IN PMMPFN Pfn1
2007 );
2008
2009 PMMVAD
2010 NTAPI
2011 MiLocateAddress(
2012 IN PVOID VirtualAddress
2013 );
2014
2015 TABLE_SEARCH_RESULT
2016 NTAPI
2017 MiCheckForConflictingNode(
2018 IN ULONG_PTR StartVpn,
2019 IN ULONG_PTR EndVpn,
2020 IN PMM_AVL_TABLE Table,
2021 OUT PMMADDRESS_NODE *NodeOrParent
2022 );
2023
2024 TABLE_SEARCH_RESULT
2025 NTAPI
2026 MiFindEmptyAddressRangeDownTree(
2027 IN SIZE_T Length,
2028 IN ULONG_PTR BoundaryAddress,
2029 IN ULONG_PTR Alignment,
2030 IN PMM_AVL_TABLE Table,
2031 OUT PULONG_PTR Base,
2032 OUT PMMADDRESS_NODE *Parent
2033 );
2034
2035 NTSTATUS
2036 NTAPI
2037 MiFindEmptyAddressRangeDownBasedTree(
2038 IN SIZE_T Length,
2039 IN ULONG_PTR BoundaryAddress,
2040 IN ULONG_PTR Alignment,
2041 IN PMM_AVL_TABLE Table,
2042 OUT PULONG_PTR Base
2043 );
2044
2045 TABLE_SEARCH_RESULT
2046 NTAPI
2047 MiFindEmptyAddressRangeInTree(
2048 IN SIZE_T Length,
2049 IN ULONG_PTR Alignment,
2050 IN PMM_AVL_TABLE Table,
2051 OUT PMMADDRESS_NODE *PreviousVad,
2052 OUT PULONG_PTR Base
2053 );
2054
2055 NTSTATUS
2056 NTAPI
2057 MiCheckSecuredVad(
2058 IN PMMVAD Vad,
2059 IN PVOID Base,
2060 IN SIZE_T Size,
2061 IN ULONG ProtectionMask
2062 );
2063
2064 VOID
2065 NTAPI
2066 MiInsertVad(
2067 _Inout_ PMMVAD Vad,
2068 _Inout_ PMM_AVL_TABLE VadRoot);
2069
2070 NTSTATUS
2071 NTAPI
2072 MiInsertVadEx(
2073 _Inout_ PMMVAD Vad,
2074 _In_ ULONG_PTR *BaseAddress,
2075 _In_ SIZE_T ViewSize,
2076 _In_ ULONG_PTR HighestAddress,
2077 _In_ ULONG_PTR Alignment,
2078 _In_ ULONG AllocationType);
2079
2080 VOID
2081 NTAPI
2082 MiInsertBasedSection(
2083 IN PSECTION Section
2084 );
2085
2086 NTSTATUS
2087 NTAPI
2088 MiUnmapViewOfSection(
2089 IN PEPROCESS Process,
2090 IN PVOID BaseAddress,
2091 IN ULONG Flags
2092 );
2093
2094 NTSTATUS
2095 NTAPI
2096 MiRosUnmapViewOfSection(
2097 IN PEPROCESS Process,
2098 IN PVOID BaseAddress,
2099 IN BOOLEAN SkipDebuggerNotify
2100 );
2101
2102 VOID
2103 NTAPI
2104 MiInsertNode(
2105 IN PMM_AVL_TABLE Table,
2106 IN PMMADDRESS_NODE NewNode,
2107 PMMADDRESS_NODE Parent,
2108 TABLE_SEARCH_RESULT Result
2109 );
2110
2111 VOID
2112 NTAPI
2113 MiRemoveNode(
2114 IN PMMADDRESS_NODE Node,
2115 IN PMM_AVL_TABLE Table
2116 );
2117
2118 PMMADDRESS_NODE
2119 NTAPI
2120 MiGetPreviousNode(
2121 IN PMMADDRESS_NODE Node
2122 );
2123
2124 PMMADDRESS_NODE
2125 NTAPI
2126 MiGetNextNode(
2127 IN PMMADDRESS_NODE Node
2128 );
2129
2130 BOOLEAN
2131 NTAPI
2132 MiInitializeSystemSpaceMap(
2133 IN PMMSESSION InputSession OPTIONAL
2134 );
2135
2136 VOID
2137 NTAPI
2138 MiSessionRemoveProcess(
2139 VOID
2140 );
2141
2142 VOID
2143 NTAPI
2144 MiReleaseProcessReferenceToSessionDataPage(
2145 IN PMM_SESSION_SPACE SessionGlobal
2146 );
2147
2148 VOID
2149 NTAPI
2150 MiSessionAddProcess(
2151 IN PEPROCESS NewProcess
2152 );
2153
2154 NTSTATUS
2155 NTAPI
2156 MiSessionCommitPageTables(
2157 IN PVOID StartVa,
2158 IN PVOID EndVa
2159 );
2160
2161 ULONG
2162 NTAPI
2163 MiMakeProtectionMask(
2164 IN ULONG Protect
2165 );
2166
2167 VOID
2168 NTAPI
2169 MiDeleteVirtualAddresses(
2170 IN ULONG_PTR Va,
2171 IN ULONG_PTR EndingAddress,
2172 IN PMMVAD Vad
2173 );
2174
2175 VOID
2176 NTAPI
2177 MiDeletePte(
2178 IN PMMPTE PointerPte,
2179 IN PVOID VirtualAddress,
2180 IN PEPROCESS CurrentProcess,
2181 IN PMMPTE PrototypePte
2182 );
2183
2184 ULONG
2185 NTAPI
2186 MiMakeSystemAddressValid(
2187 IN PVOID PageTableVirtualAddress,
2188 IN PEPROCESS CurrentProcess
2189 );
2190
2191 ULONG
2192 NTAPI
2193 MiMakeSystemAddressValidPfn(
2194 IN PVOID VirtualAddress,
2195 IN KIRQL OldIrql
2196 );
2197
2198 VOID
2199 NTAPI
2200 MiRemoveMappedView(
2201 IN PEPROCESS CurrentProcess,
2202 IN PMMVAD Vad
2203 );
2204
2205 PSUBSECTION
2206 NTAPI
2207 MiLocateSubsection(
2208 IN PMMVAD Vad,
2209 IN ULONG_PTR Vpn
2210 );
2211
2212 VOID
2213 NTAPI
2214 MiDeleteARM3Section(
2215 PVOID ObjectBody
2216 );
2217
2218 NTSTATUS
2219 NTAPI
2220 MiQueryMemorySectionName(
2221 IN HANDLE ProcessHandle,
2222 IN PVOID BaseAddress,
2223 OUT PVOID MemoryInformation,
2224 IN SIZE_T MemoryInformationLength,
2225 OUT PSIZE_T ReturnLength
2226 );
2227
2228 NTSTATUS
2229 NTAPI
2230 MiRosUnmapViewInSystemSpace(
2231 IN PVOID MappedBase
2232 );
2233
2234 POOL_TYPE
2235 NTAPI
2236 MmDeterminePoolType(
2237 IN PVOID PoolAddress
2238 );
2239
2240 VOID
2241 NTAPI
2242 MiMakePdeExistAndMakeValid(
2243 IN PMMPDE PointerPde,
2244 IN PEPROCESS TargetProcess,
2245 IN KIRQL OldIrql
2246 );
2247
2248 //
2249 // MiRemoveZeroPage will use inline code to zero out the page manually if only
2250 // free pages are available. In some scenarios, we don't/can't run that piece of
2251 // code and would rather only have a real zero page. If we can't have a zero page,
2252 // then we'd like to have our own code to grab a free page and zero it out, by
2253 // using MiRemoveAnyPage. This macro implements this.
2254 //
2255 FORCEINLINE
2256 PFN_NUMBER
2257 MiRemoveZeroPageSafe(IN ULONG Color)
2258 {
2259 if (MmFreePagesByColor[ZeroedPageList][Color].Flink != LIST_HEAD) return MiRemoveZeroPage(Color);
2260 return 0;
2261 }
2262
2263 #if (_MI_PAGING_LEVELS == 2)
2264 FORCEINLINE
2265 BOOLEAN
2266 MiSynchronizeSystemPde(PMMPDE PointerPde)
2267 {
2268 MMPDE SystemPde;
2269 ULONG Index;
2270
2271 /* Get the Index from the PDE */
2272 Index = ((ULONG_PTR)PointerPde & (SYSTEM_PD_SIZE - 1)) / sizeof(MMPTE);
2273
2274 /* Copy the PDE from the double-mapped system page directory */
2275 SystemPde = MmSystemPagePtes[Index];
2276 *PointerPde = SystemPde;
2277
2278 /* Make sure we re-read the PDE and PTE */
2279 KeMemoryBarrierWithoutFence();
2280
2281 /* Return, if we had success */
2282 return SystemPde.u.Hard.Valid != 0;
2283 }
2284 #endif
2285
2286 /* EOF */