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