ntoskrnl/include/internal/mm.h

   1 #ifndef __INCLUDE_INTERNAL_MM_H
   2 #define __INCLUDE_INTERNAL_MM_H
   3
   4 #include <internal/arch/mm.h>
   5
   6 /* TYPES *********************************************************************/
   7
   8 struct _EPROCESS;
   9
  10 extern ULONG MiFreeSwapPages;
  11 extern ULONG MiUsedSwapPages;
  12 extern ULONG MmPagedPoolSize;
  13 extern ULONG MmTotalPagedPoolQuota;
  14 extern ULONG MmTotalNonPagedPoolQuota;
  15 extern PHYSICAL_ADDRESS MmSharedDataPagePhysicalAddress;
  16 extern ULONG MmNumberOfPhysicalPages;
  17 extern UCHAR MmDisablePagingExecutive;
  18 extern ULONG MmLowestPhysicalPage;
  19 extern ULONG MmHighestPhysicalPage;
  20 extern ULONG MmAvailablePages;
  21 extern ULONG MmResidentAvailablePages;
  22
  23 extern PVOID MmPagedPoolBase;
  24 extern ULONG MmPagedPoolSize;
  25
  26 extern PMEMORY_ALLOCATION_DESCRIPTOR MiFreeDescriptor;
  27 extern MEMORY_ALLOCATION_DESCRIPTOR MiFreeDescriptorOrg;
  28
  29 extern LIST_ENTRY MmLoadedUserImageList;
  30
  31 extern KMUTANT MmSystemLoadLock;
  32
  33 extern ULONG MmNumberOfPagingFiles;
  34
  35 extern PVOID MmUnloadedDrivers;
  36 extern PVOID MmLastUnloadedDrivers;
  37 extern PVOID MmTriageActionTaken;
  38 extern PVOID KernelVerifier;
  39 extern MM_DRIVER_VERIFIER_DATA MmVerifierData;
  40
  41 extern SIZE_T MmTotalCommitLimit;
  42 extern SIZE_T MmTotalCommittedPages;
  43 extern SIZE_T MmSharedCommit;
  44 extern SIZE_T MmDriverCommit;
  45 extern SIZE_T MmProcessCommit;
  46 extern SIZE_T MmPagedPoolCommit;
  47 extern SIZE_T MmPeakCommitment;
  48 extern SIZE_T MmtotalCommitLimitMaximum;
  49
  50 extern BOOLEAN MiDbgReadyForPhysical;
  51
  52 struct _KTRAP_FRAME;
  53 struct _EPROCESS;
  54 struct _MM_RMAP_ENTRY;
  55 struct _MM_PAGEOP;
  56 typedef ULONG SWAPENTRY;
  57 typedef ULONG PFN_TYPE, *PPFN_TYPE;
  58
  59 //
  60 // MmDbgCopyMemory Flags
  61 //
  62 #define MMDBG_COPY_WRITE            0x00000001
  63 #define MMDBG_COPY_PHYSICAL         0x00000002
  64 #define MMDBG_COPY_UNSAFE           0x00000004
  65 #define MMDBG_COPY_CACHED           0x00000008
  66 #define MMDBG_COPY_UNCACHED         0x00000010
  67 #define MMDBG_COPY_WRITE_COMBINED   0x00000020
  68
  69 //
  70 // Maximum chunk size per copy
  71 //
  72 #define MMDBG_COPY_MAX_SIZE         0x8
  73
  74 #if defined(_X86_)
  75 #define MI_STATIC_MEMORY_AREAS              (14)
  76 #else
  77 #define MI_STATIC_MEMORY_AREAS              (13)
  78 #endif
  79
  80 #define MEMORY_AREA_INVALID                 (0)
  81 #define MEMORY_AREA_SECTION_VIEW            (1)
  82 #define MEMORY_AREA_CONTINUOUS_MEMORY       (2)
  83 #define MEMORY_AREA_NO_CACHE                (3)
  84 #define MEMORY_AREA_IO_MAPPING              (4)
  85 #define MEMORY_AREA_SYSTEM                  (5)
  86 #define MEMORY_AREA_MDL_MAPPING             (7)
  87 #define MEMORY_AREA_VIRTUAL_MEMORY          (8)
  88 #define MEMORY_AREA_CACHE_SEGMENT           (9)
  89 #define MEMORY_AREA_SHARED_DATA             (10)
  90 #define MEMORY_AREA_KERNEL_STACK            (11)
  91 #define MEMORY_AREA_PAGED_POOL              (12)
  92 #define MEMORY_AREA_NO_ACCESS               (13)
  93 #define MEMORY_AREA_PEB_OR_TEB              (14)
  94 #define MEMORY_AREA_OWNED_BY_ARM3           (15)
  95 #define MEMORY_AREA_STATIC                  (0x80000000)
  96
  97 #define MM_PHYSICAL_PAGE_MPW_PENDING        (0x8)
  98
  99 #define MM_CORE_DUMP_TYPE_NONE              (0x0)
 100 #define MM_CORE_DUMP_TYPE_MINIMAL           (0x1)
 101 #define MM_CORE_DUMP_TYPE_FULL              (0x2)
 102
 103 #define MM_PAGEOP_PAGEIN                    (1)
 104 #define MM_PAGEOP_PAGEOUT                   (2)
 105 #define MM_PAGEOP_PAGESYNCH                 (3)
 106 #define MM_PAGEOP_ACCESSFAULT               (4)
 107
 108 /* Number of list heads to use */
 109 #define MI_FREE_POOL_LISTS 4
 110
 111 #define MI_HYPERSPACE_PTES                  (256 - 1)
 112 #define MI_ZERO_PTES                        (32)
 113 #define MI_MAPPING_RANGE_START              (ULONG)HYPER_SPACE
 114 #define MI_MAPPING_RANGE_END                (MI_MAPPING_RANGE_START + \
 115                                              MI_HYPERSPACE_PTES * PAGE_SIZE)
 116 #define MI_ZERO_PTE                         (PMMPTE)(MI_MAPPING_RANGE_END + \
 117                                              PAGE_SIZE)
 118
 119 /* Signature of free pool blocks */
 120 #define MM_FREE_POOL_TAG    'lprF'
 121
 122 #define PAGE_TO_SECTION_PAGE_DIRECTORY_OFFSET(x) \
 123     ((x) / (4*1024*1024))
 124
 125 #define PAGE_TO_SECTION_PAGE_TABLE_OFFSET(x) \
 126     ((((x)) % (4*1024*1024)) / (4*1024))
 127
 128 #define NR_SECTION_PAGE_TABLES              1024
 129 #define NR_SECTION_PAGE_ENTRIES             1024
 130
 131 #define TEB_BASE                            0x7FFDE000
 132
 133 /* Although Microsoft says this isn't hardcoded anymore,
 134    they won't be able to change it. Stuff depends on it */
 135 #define MM_VIRTMEM_GRANULARITY              (64 * 1024)
 136
 137 #define STATUS_MM_RESTART_OPERATION         ((NTSTATUS)0xD0000001)
 138
 139 /*
 140  * Additional flags for protection attributes
 141  */
 142 #define PAGE_WRITETHROUGH                   (1024)
 143 #define PAGE_SYSTEM                         (2048)
 144
 145 #define SEC_PHYSICALMEMORY                  (0x80000000)
 146
 147 #define MM_PAGEFILE_SEGMENT                 (0x1)
 148 #define MM_DATAFILE_SEGMENT                 (0x2)
 149
 150 #define MC_CACHE                            (0)
 151 #define MC_USER                             (1)
 152 #define MC_PPOOL                            (2)
 153 #define MC_NPPOOL                           (3)
 154 #define MC_SYSTEM                           (4)
 155 #define MC_MAXIMUM                          (5)
 156
 157 #define PAGED_POOL_MASK                     1
 158 #define MUST_SUCCEED_POOL_MASK              2
 159 #define CACHE_ALIGNED_POOL_MASK             4
 160 #define QUOTA_POOL_MASK                     8
 161 #define SESSION_POOL_MASK                   32
 162 #define VERIFIER_POOL_MASK                  64
 163
 164 #define MM_PAGED_POOL_SIZE                  (100*1024*1024)
 165 #define MM_NONPAGED_POOL_SIZE               (100*1024*1024)
 166
 167 /*
 168  * Paged and non-paged pools are 8-byte aligned
 169  */
 170 #define MM_POOL_ALIGNMENT                   8
 171
 172 /*
 173  * Maximum size of the kmalloc area (this is totally arbitary)
 174  */
 175 #define MM_KERNEL_MAP_SIZE                  (16*1024*1024)
 176 #define MM_KERNEL_MAP_BASE                  (0xf0c00000)
 177
 178 /*
 179  * FIXME - different architectures have different cache line sizes...
 180  */
 181 #define MM_CACHE_LINE_SIZE                  32
 182
 183 #define MM_ROUND_UP(x,s)                    \
 184     ((PVOID)(((ULONG_PTR)(x)+(s)-1) & ~((ULONG_PTR)(s)-1)))
 185
 186 #define MM_ROUND_DOWN(x,s)                  \
 187     ((PVOID)(((ULONG_PTR)(x)) & ~((ULONG_PTR)(s)-1)))
 188
 189 #define PAGE_FLAGS_VALID_FROM_USER_MODE     \
 190     (PAGE_READONLY | \
 191     PAGE_READWRITE | \
 192     PAGE_WRITECOPY | \
 193     PAGE_EXECUTE | \
 194     PAGE_EXECUTE_READ | \
 195     PAGE_EXECUTE_READWRITE | \
 196     PAGE_EXECUTE_WRITECOPY | \
 197     PAGE_GUARD | \
 198     PAGE_NOACCESS | \
 199     PAGE_NOCACHE)
 200
 201 #define PAGE_FLAGS_VALID_FOR_SECTION \
 202     (PAGE_READONLY | \
 203      PAGE_READWRITE | \
 204      PAGE_WRITECOPY | \
 205      PAGE_EXECUTE | \
 206      PAGE_EXECUTE_READ | \
 207      PAGE_EXECUTE_READWRITE | \
 208      PAGE_EXECUTE_WRITECOPY | \
 209      PAGE_NOACCESS)
 210
 211 #define PAGE_IS_READABLE                    \
 212     (PAGE_READONLY | \
 213     PAGE_READWRITE | \
 214     PAGE_WRITECOPY | \
 215     PAGE_EXECUTE_READ | \
 216     PAGE_EXECUTE_READWRITE | \
 217     PAGE_EXECUTE_WRITECOPY)
 218
 219 #define PAGE_IS_WRITABLE                    \
 220     (PAGE_READWRITE | \
 221     PAGE_WRITECOPY | \
 222     PAGE_EXECUTE_READWRITE | \
 223     PAGE_EXECUTE_WRITECOPY)
 224
 225 #define PAGE_IS_EXECUTABLE                  \
 226     (PAGE_EXECUTE | \
 227     PAGE_EXECUTE_READ | \
 228     PAGE_EXECUTE_READWRITE | \
 229     PAGE_EXECUTE_WRITECOPY)
 230
 231 #define PAGE_IS_WRITECOPY                   \
 232     (PAGE_WRITECOPY | \
 233     PAGE_EXECUTE_WRITECOPY)
 234
 235
 236 #define InterlockedCompareExchangePte(PointerPte, Exchange, Comperand) \
 237     InterlockedCompareExchange((PLONG)(PointerPte), Exchange, Comperand)
 238
 239 #define InterlockedExchangePte(PointerPte, Value) \
 240     InterlockedExchange((PLONG)(PointerPte), Value)
 241
 242 typedef struct
 243 {
 244     ULONG Entry[NR_SECTION_PAGE_ENTRIES];
 245 } SECTION_PAGE_TABLE, *PSECTION_PAGE_TABLE;
 246
 247 typedef struct
 248 {
 249     PSECTION_PAGE_TABLE PageTables[NR_SECTION_PAGE_TABLES];
 250 } SECTION_PAGE_DIRECTORY, *PSECTION_PAGE_DIRECTORY;
 251
 252 typedef struct _MM_SECTION_SEGMENT
 253 {
 254     LONG FileOffset;            /* start offset into the file for image sections */
 255     ULONG_PTR VirtualAddress;   /* dtart offset into the address range for image sections */
 256     ULONG RawLength;            /* length of the segment which is part of the mapped file */
 257     ULONG Length;                       /* absolute length of the segment */
 258     ULONG Protection;
 259     FAST_MUTEX Lock;            /* lock which protects the page directory */
 260     ULONG ReferenceCount;
 261     SECTION_PAGE_DIRECTORY PageDirectory;
 262     ULONG Flags;
 263     ULONG Characteristics;
 264     BOOLEAN WriteCopy;
 265 } MM_SECTION_SEGMENT, *PMM_SECTION_SEGMENT;
 266
 267 typedef struct _MM_IMAGE_SECTION_OBJECT
 268 {
 269     ULONG_PTR ImageBase;
 270     ULONG_PTR StackReserve;
 271     ULONG_PTR StackCommit;
 272     ULONG_PTR EntryPoint;
 273     USHORT Subsystem;
 274     USHORT ImageCharacteristics;
 275     USHORT MinorSubsystemVersion;
 276     USHORT MajorSubsystemVersion;
 277     USHORT Machine;
 278     BOOLEAN Executable;
 279     ULONG NrSegments;
 280     ULONG ImageSize;
 281     PMM_SECTION_SEGMENT Segments;
 282 } MM_IMAGE_SECTION_OBJECT, *PMM_IMAGE_SECTION_OBJECT;
 283
 284 typedef struct _ROS_SECTION_OBJECT
 285 {
 286     CSHORT Type;
 287     CSHORT Size;
 288     LARGE_INTEGER MaximumSize;
 289     ULONG SectionPageProtection;
 290     ULONG AllocationAttributes;
 291     PFILE_OBJECT FileObject;
 292     union
 293     {
 294         PMM_IMAGE_SECTION_OBJECT ImageSection;
 295         PMM_SECTION_SEGMENT Segment;
 296     };
 297 } ROS_SECTION_OBJECT, *PROS_SECTION_OBJECT;
 298
 299 typedef struct _MEMORY_AREA
 300 {
 301     PVOID StartingAddress;
 302     PVOID EndingAddress;
 303     struct _MEMORY_AREA *Parent;
 304     struct _MEMORY_AREA *LeftChild;
 305     struct _MEMORY_AREA *RightChild;
 306     ULONG Type;
 307     ULONG Protect;
 308     ULONG Flags;
 309     BOOLEAN DeleteInProgress;
 310     ULONG PageOpCount;
 311     union
 312     {
 313         struct
 314         {
 315             ROS_SECTION_OBJECT* Section;
 316             ULONG ViewOffset;
 317             PMM_SECTION_SEGMENT Segment;
 318             BOOLEAN WriteCopyView;
 319             LIST_ENTRY RegionListHead;
 320         } SectionData;
 321         struct
 322         {
 323             LIST_ENTRY RegionListHead;
 324         } VirtualMemoryData;
 325     } Data;
 326 } MEMORY_AREA, *PMEMORY_AREA;
 327
 328 //
 329 // These two mappings are actually used by Windows itself, based on the ASSERTS
 330 //
 331 #define StartOfAllocation ReadInProgress
 332 #define EndOfAllocation WriteInProgress
 333
 334 typedef struct _MMPFNENTRY
 335 {
 336     USHORT Modified:1;
 337     USHORT ReadInProgress:1;                 // StartOfAllocation
 338     USHORT WriteInProgress:1;                // EndOfAllocation
 339     USHORT PrototypePte:1;                   // Zero
 340     USHORT PageColor:4;                      // LockCount
 341     USHORT PageLocation:3;                   // Consumer
 342     USHORT RemovalRequested:1;
 343     USHORT CacheAttribute:2;                 // Type
 344     USHORT Rom:1;
 345     USHORT ParityError:1;
 346 } MMPFNENTRY;
 347
 348 typedef struct _MMPFN
 349 {
 350     union
 351     {
 352         PFN_NUMBER Flink;                    // ListEntry.Flink
 353         ULONG WsIndex;
 354         PKEVENT Event;
 355         NTSTATUS ReadStatus;
 356         SINGLE_LIST_ENTRY NextStackPfn;
 357     } u1;
 358     PMMPTE PteAddress;                       // ListEntry.Blink
 359     union
 360     {
 361         PFN_NUMBER Blink;
 362         ULONG_PTR ShareCount;                // MapCount
 363     } u2;
 364     union
 365     {
 366         struct
 367         {
 368             USHORT ReferenceCount;           // ReferenceCount
 369             MMPFNENTRY e1;
 370         };
 371         struct
 372         {
 373             USHORT ReferenceCount;
 374             USHORT ShortFlags;
 375         } e2;
 376     } u3;
 377     union
 378     {
 379         MMPTE OriginalPte;
 380         LONG AweReferenceCount;              // RmapListHead
 381     };
 382     union
 383     {
 384         ULONG_PTR EntireFrame;               // SavedSwapEntry
 385         struct
 386         {
 387             ULONG_PTR PteFrame:25;
 388             ULONG_PTR InPageError:1;
 389             ULONG_PTR VerifierAllocation:1;
 390             ULONG_PTR AweAllocation:1;
 391             ULONG_PTR Priority:3;
 392             ULONG_PTR MustBeCached:1;
 393         };
 394     } u4;
 395 } MMPFN, *PMMPFN;
 396
 397 extern PMMPFN MmPfnDatabase;
 398
 399 typedef struct _MMPFNLIST
 400 {
 401     PFN_NUMBER Total;
 402     MMLISTS ListName;
 403     PFN_NUMBER Flink;
 404     PFN_NUMBER Blink;
 405 } MMPFNLIST, *PMMPFNLIST;
 406
 407 extern MMPFNLIST MmZeroedPageListHead;
 408 extern MMPFNLIST MmFreePageListHead;
 409 extern MMPFNLIST MmStandbyPageListHead;
 410 extern MMPFNLIST MmModifiedPageListHead;
 411 extern MMPFNLIST MmModifiedNoWritePageListHead;
 412
 413 typedef struct _MM_PAGEOP
 414 {
 415   /* Type of operation. */
 416   ULONG OpType;
 417   /* Number of threads interested in this operation. */
 418   ULONG ReferenceCount;
 419   /* Event that will be set when the operation is completed. */
 420   KEVENT CompletionEvent;
 421   /* Status of the operation once it is completed. */
 422   NTSTATUS Status;
 423   /* TRUE if the operation was abandoned. */
 424   BOOLEAN Abandoned;
 425   /* The memory area to be affected by the operation. */
 426   PMEMORY_AREA MArea;
 427   ULONG Hash;
 428   struct _MM_PAGEOP* Next;
 429   struct _ETHREAD* Thread;
 430   /*
 431    * These fields are used to identify the operation if it is against a
 432    * virtual memory area.
 433    */
 434   HANDLE Pid;
 435   PVOID Address;
 436   /*
 437    * These fields are used to identify the operation if it is against a
 438    * section mapping.
 439    */
 440   PMM_SECTION_SEGMENT Segment;
 441   ULONG Offset;
 442 } MM_PAGEOP, *PMM_PAGEOP;
 443
 444 typedef struct _MM_MEMORY_CONSUMER
 445 {
 446     ULONG PagesUsed;
 447     ULONG PagesTarget;
 448     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed);
 449 } MM_MEMORY_CONSUMER, *PMM_MEMORY_CONSUMER;
 450
 451 typedef struct _MM_REGION
 452 {
 453     ULONG Type;
 454     ULONG Protect;
 455     ULONG Length;
 456     LIST_ENTRY RegionListEntry;
 457 } MM_REGION, *PMM_REGION;
 458
 459 /* Entry describing free pool memory */
 460 typedef struct _MMFREE_POOL_ENTRY
 461 {
 462     LIST_ENTRY List;
 463     PFN_NUMBER Size;
 464     ULONG Signature;
 465     struct _MMFREE_POOL_ENTRY *Owner;
 466 } MMFREE_POOL_ENTRY, *PMMFREE_POOL_ENTRY;
 467
 468 /* Paged pool information */
 469 typedef struct _MM_PAGED_POOL_INFO
 470 {
 471     PRTL_BITMAP PagedPoolAllocationMap;
 472     PRTL_BITMAP EndOfPagedPoolBitmap;
 473     PMMPTE FirstPteForPagedPool;
 474     PMMPTE LastPteForPagedPool;
 475     PMMPTE NextPdeForPagedPoolExpansion;
 476     ULONG PagedPoolHint;
 477     SIZE_T PagedPoolCommit;
 478     SIZE_T AllocatedPagedPool;
 479 } MM_PAGED_POOL_INFO, *PMM_PAGED_POOL_INFO;
 480
 481 extern MM_MEMORY_CONSUMER MiMemoryConsumers[MC_MAXIMUM];
 482
 483 typedef VOID
 484 (*PMM_ALTER_REGION_FUNC)(
 485     PMMSUPPORT AddressSpace,
 486     PVOID BaseAddress,
 487     ULONG Length,
 488     ULONG OldType,
 489     ULONG OldProtect,
 490     ULONG NewType,
 491     ULONG NewProtect
 492 );
 493
 494 typedef VOID
 495 (*PMM_FREE_PAGE_FUNC)(
 496     PVOID Context,
 497     PMEMORY_AREA MemoryArea,
 498     PVOID Address,
 499     PFN_TYPE Page,
 500     SWAPENTRY SwapEntry,
 501     BOOLEAN Dirty
 502 );
 503
 504 //
 505 // Mm copy support for Kd
 506 //
 507 NTSTATUS
 508 NTAPI
 509 MmDbgCopyMemory(
 510     IN ULONG64 Address,
 511     IN PVOID Buffer,
 512     IN ULONG Size,
 513     IN ULONG Flags
 514 );
 515
 516 //
 517 // Determines if a given address is a session address
 518 //
 519 BOOLEAN
 520 NTAPI
 521 MmIsSessionAddress(
 522     IN PVOID Address
 523 );
 524
 525 /* marea.c *******************************************************************/
 526
 527 NTSTATUS
 528 NTAPI
 529 MmCreateMemoryArea(
 530     PMMSUPPORT AddressSpace,
 531     ULONG Type,
 532     PVOID *BaseAddress,
 533     ULONG_PTR Length,
 534     ULONG Protection,
 535     PMEMORY_AREA *Result,
 536     BOOLEAN FixedAddress,
 537     ULONG AllocationFlags,
 538     PHYSICAL_ADDRESS BoundaryAddressMultiple OPTIONAL
 539 );
 540
 541 PMEMORY_AREA
 542 NTAPI
 543 MmLocateMemoryAreaByAddress(
 544     PMMSUPPORT AddressSpace,
 545     PVOID Address
 546 );
 547
 548 ULONG_PTR
 549 NTAPI
 550 MmFindGapAtAddress(
 551     PMMSUPPORT AddressSpace,
 552     PVOID Address
 553 );
 554
 555 NTSTATUS
 556 NTAPI
 557 MmFreeMemoryArea(
 558     PMMSUPPORT AddressSpace,
 559     PMEMORY_AREA MemoryArea,
 560     PMM_FREE_PAGE_FUNC FreePage,
 561     PVOID FreePageContext
 562 );
 563
 564 NTSTATUS
 565 NTAPI
 566 MmFreeMemoryAreaByPtr(
 567     PMMSUPPORT AddressSpace,
 568     PVOID BaseAddress,
 569     PMM_FREE_PAGE_FUNC FreePage,
 570     PVOID FreePageContext
 571 );
 572
 573 VOID
 574 NTAPI
 575 MmDumpMemoryAreas(PMMSUPPORT AddressSpace);
 576
 577 PMEMORY_AREA
 578 NTAPI
 579 MmLocateMemoryAreaByRegion(
 580     PMMSUPPORT AddressSpace,
 581     PVOID Address,
 582     ULONG_PTR Length
 583 );
 584
 585 PVOID
 586 NTAPI
 587 MmFindGap(
 588     PMMSUPPORT AddressSpace,
 589     ULONG_PTR Length,
 590     ULONG_PTR Granularity,
 591     BOOLEAN TopDown
 592 );
 593
 594 VOID
 595 NTAPI
 596 MmReleaseMemoryAreaIfDecommitted(
 597     struct _EPROCESS *Process,
 598     PMMSUPPORT AddressSpace,
 599     PVOID BaseAddress
 600 );
 601
 602 VOID
 603 NTAPI
 604 MmMapMemoryArea(PVOID BaseAddress,
 605                 ULONG Length,
 606                 ULONG Consumer,
 607                 ULONG Protection);
 608
 609 /* npool.c *******************************************************************/
 610
 611 VOID
 612 NTAPI
 613 MiDebugDumpNonPagedPool(BOOLEAN NewOnly);
 614
 615 VOID
 616 NTAPI
 617 MiDebugDumpNonPagedPoolStats(BOOLEAN NewOnly);
 618
 619 VOID
 620 NTAPI
 621 MiInitializeNonPagedPool(VOID);
 622
 623 PVOID
 624 NTAPI
 625 MiAllocatePoolPages(
 626     IN POOL_TYPE PoolType,
 627     IN SIZE_T SizeInBytes
 628 );
 629
 630 POOL_TYPE
 631 NTAPI
 632 MmDeterminePoolType(
 633     IN PVOID VirtualAddress
 634 );
 635
 636 ULONG
 637 NTAPI
 638 MiFreePoolPages(
 639     IN PVOID StartingAddress
 640 );
 641
 642 PVOID
 643 NTAPI
 644 MmGetMdlPageAddress(
 645     PMDL Mdl,
 646     PVOID Offset
 647 );
 648
 649 /* pool.c *******************************************************************/
 650
 651 PVOID
 652 NTAPI
 653 ExAllocateNonPagedPoolWithTag(
 654     POOL_TYPE type,
 655     ULONG size,
 656     ULONG Tag,
 657     PVOID Caller
 658 );
 659
 660 PVOID
 661 NTAPI
 662 ExAllocatePagedPoolWithTag(
 663     POOL_TYPE Type,
 664     ULONG size,
 665     ULONG Tag
 666 );
 667
 668 VOID
 669 NTAPI
 670 ExFreeNonPagedPool(PVOID block);
 671
 672 VOID
 673 NTAPI
 674 ExFreePagedPool(IN PVOID Block);
 675
 676 BOOLEAN
 677 NTAPI
 678 ExpIsPoolTagDebuggable(ULONG Tag);
 679
 680 PVOID
 681 NTAPI
 682 ExpAllocateDebugPool(
 683     POOL_TYPE Type,
 684     ULONG Size,
 685     ULONG Tag,
 686     PVOID Caller,
 687     BOOLEAN EndOfPage
 688 );
 689
 690 VOID
 691 NTAPI
 692 ExpFreeDebugPool(PVOID Block, BOOLEAN PagedPool);
 693
 694 VOID
 695 NTAPI
 696 MmInitializePagedPool(VOID);
 697
 698 PVOID
 699 NTAPI
 700 MiAllocateSpecialPool(
 701     IN POOL_TYPE PoolType,
 702     IN SIZE_T NumberOfBytes,
 703     IN ULONG Tag,
 704     IN ULONG Underrun
 705 );
 706
 707 BOOLEAN
 708 NTAPI
 709 MiRaisePoolQuota(
 710     IN POOL_TYPE PoolType,
 711     IN ULONG CurrentMaxQuota,
 712     OUT PULONG NewMaxQuota
 713 );
 714
 715 /* mdl.c *********************************************************************/
 716
 717 VOID
 718 NTAPI
 719 MmBuildMdlFromPages(
 720     PMDL Mdl,
 721     PULONG Pages
 722 );
 723
 724 /* mminit.c ******************************************************************/
 725
 726 VOID
 727 NTAPI
 728 MiShutdownMemoryManager(VOID);
 729
 730 VOID
 731 NTAPI
 732 MmInit1(
 733     VOID
 734 );
 735
 736 BOOLEAN
 737 NTAPI
 738 MmInitSystem(IN ULONG Phase,
 739              IN PLOADER_PARAMETER_BLOCK LoaderBlock);
 740
 741 VOID
 742 NTAPI
 743 MiFreeInitMemory(VOID);
 744
 745 VOID
 746 NTAPI
 747 MmInitializeMdlImplementation(VOID);
 748
 749 /* pagefile.c ****************************************************************/
 750
 751 SWAPENTRY
 752 NTAPI
 753 MmAllocSwapPage(VOID);
 754
 755 VOID
 756 NTAPI
 757 MmDereserveSwapPages(ULONG Nr);
 758
 759 VOID
 760 NTAPI
 761 MmFreeSwapPage(SWAPENTRY Entry);
 762
 763 VOID
 764 NTAPI
 765 MmInitPagingFile(VOID);
 766
 767 NTSTATUS
 768 NTAPI
 769 MmReadFromSwapPage(
 770     SWAPENTRY SwapEntry,
 771     PFN_TYPE Page
 772 );
 773
 774 BOOLEAN
 775 NTAPI
 776 MmReserveSwapPages(ULONG Nr);
 777
 778 NTSTATUS
 779 NTAPI
 780 MmWriteToSwapPage(
 781     SWAPENTRY SwapEntry,
 782     PFN_TYPE Page
 783 );
 784
 785 NTSTATUS
 786 NTAPI
 787 MmDumpToPagingFile(
 788     ULONG BugCode,
 789     ULONG BugCodeParameter1,
 790     ULONG BugCodeParameter2,
 791     ULONG BugCodeParameter3,
 792     ULONG BugCodeParameter4,
 793     struct _KTRAP_FRAME* TrapFrame
 794 );
 795
 796 BOOLEAN
 797 NTAPI
 798 MmIsAvailableSwapPage(VOID);
 799
 800 VOID
 801 NTAPI
 802 MmShowOutOfSpaceMessagePagingFile(VOID);
 803
 804 /* process.c ****************************************************************/
 805
 806 NTSTATUS
 807 NTAPI
 808 MmInitializeProcessAddressSpace(
 809     IN PEPROCESS Process,
 810     IN PEPROCESS Clone OPTIONAL,
 811     IN PVOID Section OPTIONAL,
 812     IN OUT PULONG Flags,
 813     IN POBJECT_NAME_INFORMATION *AuditName OPTIONAL
 814 );
 815
 816 NTSTATUS
 817 NTAPI
 818 MmCreatePeb(
 819     IN PEPROCESS Process,
 820     IN PINITIAL_PEB InitialPeb,
 821     OUT PPEB *BasePeb
 822 );
 823
 824 NTSTATUS
 825 NTAPI
 826 MmCreateTeb(
 827     IN PEPROCESS Process,
 828     IN PCLIENT_ID ClientId,
 829     IN PINITIAL_TEB InitialTeb,
 830     OUT PTEB* BaseTeb
 831 );
 832
 833 VOID
 834 NTAPI
 835 MmDeleteTeb(
 836     struct _EPROCESS *Process,
 837     PTEB Teb
 838 );
 839
 840 VOID
 841 NTAPI
 842 MmCleanProcessAddressSpace(IN PEPROCESS Process);
 843
 844 NTSTATUS
 845 NTAPI
 846 MmDeleteProcessAddressSpace(IN PEPROCESS Process);
 847
 848 ULONG
 849 NTAPI
 850 MmGetSessionLocaleId(VOID);
 851
 852 NTSTATUS
 853 NTAPI
 854 MmSetMemoryPriorityProcess(
 855     IN PEPROCESS Process,
 856     IN UCHAR MemoryPriority
 857 );
 858
 859 /* i386/pfault.c *************************************************************/
 860
 861 NTSTATUS
 862 NTAPI
 863 MmPageFault(
 864     ULONG Cs,
 865     PULONG Eip,
 866     PULONG Eax,
 867     ULONG Cr2,
 868     ULONG ErrorCode
 869 );
 870
 871 /* mm.c **********************************************************************/
 872
 873 NTSTATUS
 874 NTAPI
 875 MmAccessFault(
 876     IN BOOLEAN StoreInstruction,
 877     IN PVOID Address,
 878     IN KPROCESSOR_MODE Mode,
 879     IN PVOID TrapInformation
 880 );
 881
 882 /* anonmem.c *****************************************************************/
 883
 884 NTSTATUS
 885 NTAPI
 886 MmNotPresentFaultVirtualMemory(
 887     PMMSUPPORT AddressSpace,
 888     MEMORY_AREA* MemoryArea,
 889     PVOID Address,
 890     BOOLEAN Locked
 891 );
 892
 893 NTSTATUS
 894 NTAPI
 895 MmPageOutVirtualMemory(
 896     PMMSUPPORT AddressSpace,
 897     PMEMORY_AREA MemoryArea,
 898     PVOID Address,
 899     struct _MM_PAGEOP* PageOp
 900 );
 901
 902 NTSTATUS
 903 NTAPI
 904 MmQueryAnonMem(
 905     PMEMORY_AREA MemoryArea,
 906     PVOID Address,
 907     PMEMORY_BASIC_INFORMATION Info,
 908     PULONG ResultLength
 909 );
 910
 911 VOID
 912 NTAPI
 913 MmFreeVirtualMemory(
 914     struct _EPROCESS* Process,
 915     PMEMORY_AREA MemoryArea
 916 );
 917
 918 NTSTATUS
 919 NTAPI
 920 MmProtectAnonMem(
 921     PMMSUPPORT AddressSpace,
 922     PMEMORY_AREA MemoryArea,
 923     PVOID BaseAddress,
 924     ULONG Length,
 925     ULONG Protect,
 926     PULONG OldProtect
 927 );
 928
 929 NTSTATUS
 930 NTAPI
 931 MmWritePageVirtualMemory(
 932     PMMSUPPORT AddressSpace,
 933     PMEMORY_AREA MArea,
 934     PVOID Address,
 935     PMM_PAGEOP PageOp
 936 );
 937
 938 /* kmap.c ********************************************************************/
 939
 940 PVOID
 941 NTAPI
 942 ExAllocatePage(VOID);
 943
 944 VOID
 945 NTAPI
 946 ExUnmapPage(PVOID Addr);
 947
 948 PVOID
 949 NTAPI
 950 ExAllocatePageWithPhysPage(PFN_TYPE Page);
 951
 952 NTSTATUS
 953 NTAPI
 954 MiCopyFromUserPage(
 955     PFN_TYPE Page,
 956     PVOID SourceAddress
 957 );
 958
 959 NTSTATUS
 960 NTAPI
 961 MiZeroPage(PFN_TYPE Page);
 962
 963 /* memsafe.s *****************************************************************/
 964
 965 PVOID
 966 FASTCALL
 967 MmSafeReadPtr(PVOID Source);
 968
 969 /* pageop.c ******************************************************************/
 970
 971 VOID
 972 NTAPI
 973 MmReleasePageOp(PMM_PAGEOP PageOp);
 974
 975 PMM_PAGEOP
 976 NTAPI
 977 MmGetPageOp(
 978     PMEMORY_AREA MArea,
 979     HANDLE Pid,
 980     PVOID Address,
 981     PMM_SECTION_SEGMENT Segment,
 982     ULONG Offset,
 983     ULONG OpType,
 984     BOOLEAN First
 985 );
 986
 987 PMM_PAGEOP
 988 NTAPI
 989 MmCheckForPageOp(
 990     PMEMORY_AREA MArea,
 991     HANDLE Pid,
 992     PVOID Address,
 993     PMM_SECTION_SEGMENT Segment,
 994     ULONG Offset
 995 );
 996
 997 VOID
 998 NTAPI
 999 MmInitializePageOp(VOID);
1000
1001 /* process.c *****************************************************************/
1002
1003 PVOID
1004 NTAPI
1005 MmCreateKernelStack(BOOLEAN GuiStack, UCHAR Node);
1006
1007 VOID
1008 NTAPI
1009 MmDeleteKernelStack(PVOID Stack,
1010                     BOOLEAN GuiStack);
1011
1012 /* balace.c ******************************************************************/
1013
1014 VOID
1015 NTAPI
1016 MmInitializeMemoryConsumer(
1017     ULONG Consumer,
1018     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed)
1019 );
1020
1021 VOID
1022 NTAPI
1023 MmInitializeBalancer(
1024     ULONG NrAvailablePages,
1025     ULONG NrSystemPages
1026 );
1027
1028 NTSTATUS
1029 NTAPI
1030 MmReleasePageMemoryConsumer(
1031     ULONG Consumer,
1032     PFN_TYPE Page
1033 );
1034
1035 NTSTATUS
1036 NTAPI
1037 MmRequestPageMemoryConsumer(
1038     ULONG Consumer,
1039     BOOLEAN MyWait,
1040     PPFN_TYPE AllocatedPage
1041 );
1042
1043 VOID
1044 NTAPI
1045 MiInitBalancerThread(VOID);
1046
1047 VOID
1048 NTAPI
1049 MmRebalanceMemoryConsumers(VOID);
1050
1051 /* rmap.c **************************************************************/
1052
1053 VOID
1054 NTAPI
1055 MmSetRmapListHeadPage(
1056     PFN_TYPE Page,
1057     struct _MM_RMAP_ENTRY* ListHead
1058 );
1059
1060 struct _MM_RMAP_ENTRY*
1061 NTAPI
1062 MmGetRmapListHeadPage(PFN_TYPE Page);
1063
1064 VOID
1065 NTAPI
1066 MmInsertRmap(
1067     PFN_TYPE Page,
1068     struct _EPROCESS *Process,
1069     PVOID Address
1070 );
1071
1072 VOID
1073 NTAPI
1074 MmDeleteAllRmaps(
1075     PFN_TYPE Page,
1076     PVOID Context,
1077     VOID (*DeleteMapping)(PVOID Context, struct _EPROCESS *Process, PVOID Address)
1078 );
1079
1080 VOID
1081 NTAPI
1082 MmDeleteRmap(
1083     PFN_TYPE Page,
1084     struct _EPROCESS *Process,
1085     PVOID Address
1086 );
1087
1088 VOID
1089 NTAPI
1090 MmInitializeRmapList(VOID);
1091
1092 VOID
1093 NTAPI
1094 MmSetCleanAllRmaps(PFN_TYPE Page);
1095
1096 VOID
1097 NTAPI
1098 MmSetDirtyAllRmaps(PFN_TYPE Page);
1099
1100 BOOLEAN
1101 NTAPI
1102 MmIsDirtyPageRmap(PFN_TYPE Page);
1103
1104 NTSTATUS
1105 NTAPI
1106 MmWritePagePhysicalAddress(PFN_TYPE Page);
1107
1108 NTSTATUS
1109 NTAPI
1110 MmPageOutPhysicalAddress(PFN_TYPE Page);
1111
1112 /* freelist.c **********************************************************/
1113
1114 #define ASSERT_PFN(x) ASSERT((x)->u3.e1.CacheAttribute != 0)
1115
1116 FORCEINLINE
1117 PMMPFN
1118 MiGetPfnEntry(IN PFN_TYPE Pfn)
1119 {
1120     PMMPFN Page;
1121     extern RTL_BITMAP MiPfnBitMap;
1122
1123     /* Make sure the PFN number is valid */
1124     if (Pfn > MmHighestPhysicalPage) return NULL;
1125
1126     /* Make sure this page actually has a PFN entry */
1127     if ((MiPfnBitMap.Buffer) && !(RtlTestBit(&MiPfnBitMap, Pfn))) return NULL;
1128
1129     /* Get the entry */
1130     Page = &MmPfnDatabase[Pfn];
1131
1132     /* Make sure it's valid */
1133     ASSERT_PFN(Page);
1134
1135     /* Return it */
1136     return Page;
1137 };
1138
1139 FORCEINLINE
1140 PFN_NUMBER
1141 MiGetPfnEntryIndex(IN PMMPFN Pfn1)
1142 {
1143     //
1144     // This will return the Page Frame Number (PFN) from the MMPFN
1145     //
1146     return Pfn1 - MmPfnDatabase;
1147 }
1148
1149 PFN_TYPE
1150 NTAPI
1151 MmGetLRUNextUserPage(PFN_TYPE PreviousPage);
1152
1153 PFN_TYPE
1154 NTAPI
1155 MmGetLRUFirstUserPage(VOID);
1156
1157 VOID
1158 NTAPI
1159 MmInsertLRULastUserPage(PFN_TYPE Page);
1160
1161 VOID
1162 NTAPI
1163 MmRemoveLRUUserPage(PFN_TYPE Page);
1164
1165 VOID
1166 NTAPI
1167 MmLockPage(PFN_TYPE Page);
1168
1169 VOID
1170 NTAPI
1171 MmUnlockPage(PFN_TYPE Page);
1172
1173 ULONG
1174 NTAPI
1175 MmGetLockCountPage(PFN_TYPE Page);
1176
1177 VOID
1178 NTAPI
1179 MmInitializePageList(
1180     VOID
1181 );
1182
1183 VOID
1184 NTAPI
1185 MmDumpPfnDatabase(
1186    VOID
1187 );
1188
1189 PFN_TYPE
1190 NTAPI
1191 MmGetContinuousPages(
1192     ULONG NumberOfBytes,
1193     PHYSICAL_ADDRESS LowestAcceptableAddress,
1194     PHYSICAL_ADDRESS HighestAcceptableAddress,
1195     PHYSICAL_ADDRESS BoundaryAddressMultiple,
1196     BOOLEAN ZeroPages
1197 );
1198
1199 NTSTATUS
1200 NTAPI
1201 MmZeroPageThreadMain(
1202     PVOID Context
1203 );
1204
1205 /* hypermap.c *****************************************************************/
1206
1207 extern PEPROCESS HyperProcess;
1208 extern KIRQL HyperIrql;
1209
1210 PVOID
1211 NTAPI
1212 MiMapPageInHyperSpace(IN PEPROCESS Process,
1213                       IN PFN_NUMBER Page,
1214                       IN PKIRQL OldIrql);
1215
1216 VOID
1217 NTAPI
1218 MiUnmapPageInHyperSpace(IN PEPROCESS Process,
1219                         IN PVOID Address,
1220                         IN KIRQL OldIrql);
1221
1222 PVOID
1223 NTAPI
1224 MiMapPagesToZeroInHyperSpace(IN PMMPFN *Pages,
1225                              IN PFN_NUMBER NumberOfPages);
1226
1227 VOID
1228 NTAPI
1229 MiUnmapPagesInZeroSpace(IN PVOID VirtualAddress,
1230                         IN PFN_NUMBER NumberOfPages);
1231
1232 //
1233 // ReactOS Compatibility Layer
1234 //
1235 FORCEINLINE
1236 PVOID
1237 MmCreateHyperspaceMapping(IN PFN_NUMBER Page)
1238 {
1239     HyperProcess = (PEPROCESS)KeGetCurrentThread()->ApcState.Process;
1240     return MiMapPageInHyperSpace(HyperProcess, Page, &HyperIrql);
1241 }
1242
1243 FORCEINLINE
1244 PVOID
1245 MiMapPageToZeroInHyperSpace(IN PFN_NUMBER Page)
1246 {
1247     PMMPFN Pfn1 = MiGetPfnEntry(Page);
1248     return MiMapPagesToZeroInHyperSpace(&Pfn1, 1);
1249 }
1250
1251 #define MmDeleteHyperspaceMapping(x) MiUnmapPageInHyperSpace(HyperProcess, x, HyperIrql);
1252
1253 /* i386/page.c *********************************************************/
1254
1255 NTSTATUS
1256 NTAPI
1257 MmCreateVirtualMappingForKernel(
1258     PVOID Address,
1259     ULONG flProtect,
1260     PPFN_TYPE Pages,
1261     ULONG PageCount
1262 );
1263
1264 NTSTATUS
1265 NTAPI
1266 MmCommitPagedPoolAddress(
1267     PVOID Address,
1268     BOOLEAN Locked
1269 );
1270
1271 NTSTATUS
1272 NTAPI
1273 MmCreateVirtualMapping(
1274     struct _EPROCESS* Process,
1275     PVOID Address,
1276     ULONG flProtect,
1277     PPFN_TYPE Pages,
1278     ULONG PageCount
1279 );
1280
1281 NTSTATUS
1282 NTAPI
1283 MmCreateVirtualMappingUnsafe(
1284     struct _EPROCESS* Process,
1285     PVOID Address,
1286     ULONG flProtect,
1287     PPFN_TYPE Pages,
1288     ULONG PageCount
1289 );
1290
1291 ULONG
1292 NTAPI
1293 MmGetPageProtect(
1294     struct _EPROCESS* Process,
1295     PVOID Address);
1296
1297 VOID
1298 NTAPI
1299 MmSetPageProtect(
1300     struct _EPROCESS* Process,
1301     PVOID Address,
1302     ULONG flProtect
1303 );
1304
1305 BOOLEAN
1306 NTAPI
1307 MmIsPagePresent(
1308     struct _EPROCESS* Process,
1309     PVOID Address
1310 );
1311
1312 VOID
1313 NTAPI
1314 MmInitGlobalKernelPageDirectory(VOID);
1315
1316 VOID
1317 NTAPI
1318 MmDisableVirtualMapping(
1319     struct _EPROCESS *Process,
1320     PVOID Address,
1321     BOOLEAN* WasDirty,
1322     PPFN_TYPE Page
1323 );
1324
1325 VOID
1326 NTAPI
1327 MmEnableVirtualMapping(
1328     struct _EPROCESS *Process,
1329     PVOID Address
1330 );
1331
1332 VOID
1333 NTAPI
1334 MmRawDeleteVirtualMapping(PVOID Address);
1335
1336 VOID
1337 NTAPI
1338 MmDeletePageFileMapping(
1339     struct _EPROCESS *Process,
1340     PVOID Address,
1341     SWAPENTRY* SwapEntry
1342 );
1343
1344 NTSTATUS
1345 NTAPI
1346 MmCreatePageFileMapping(
1347     struct _EPROCESS *Process,
1348     PVOID Address,
1349     SWAPENTRY SwapEntry
1350 );
1351
1352 BOOLEAN
1353 NTAPI
1354 MmIsPageSwapEntry(
1355     struct _EPROCESS *Process,
1356     PVOID Address
1357 );
1358
1359 VOID
1360 NTAPI
1361 MmTransferOwnershipPage(
1362     PFN_TYPE Page,
1363     ULONG NewConsumer
1364 );
1365
1366 VOID
1367 NTAPI
1368 MmSetDirtyPage(
1369     struct _EPROCESS *Process,
1370     PVOID Address
1371 );
1372
1373 PFN_TYPE
1374 NTAPI
1375 MmAllocPage(
1376     ULONG Consumer,
1377     SWAPENTRY SavedSwapEntry
1378 );
1379
1380 LONG
1381 NTAPI
1382 MmAllocPagesSpecifyRange(
1383     ULONG Consumer,
1384     PHYSICAL_ADDRESS LowestAddress,
1385     PHYSICAL_ADDRESS HighestAddress,
1386     ULONG NumberOfPages,
1387     PPFN_TYPE Pages
1388 );
1389
1390 VOID
1391 NTAPI
1392 MmDereferencePage(PFN_TYPE Page);
1393
1394 VOID
1395 NTAPI
1396 MmReferencePage(PFN_TYPE Page);
1397
1398 ULONG
1399 NTAPI
1400 MmGetReferenceCountPage(PFN_TYPE Page);
1401
1402 BOOLEAN
1403 NTAPI
1404 MmIsPageInUse(PFN_TYPE Page);
1405
1406 VOID
1407 NTAPI
1408 MmSetSavedSwapEntryPage(
1409     PFN_TYPE Page,
1410     SWAPENTRY SavedSwapEntry);
1411
1412 SWAPENTRY
1413 NTAPI
1414 MmGetSavedSwapEntryPage(PFN_TYPE Page);
1415
1416 VOID
1417 NTAPI
1418 MmSetCleanPage(
1419     struct _EPROCESS *Process,
1420     PVOID Address
1421 );
1422
1423 NTSTATUS
1424 NTAPI
1425 MmCreatePageTable(PVOID PAddress);
1426
1427 VOID
1428 NTAPI
1429 MmDeletePageTable(
1430     struct _EPROCESS *Process,
1431     PVOID Address
1432 );
1433
1434 PFN_TYPE
1435 NTAPI
1436 MmGetPfnForProcess(
1437     struct _EPROCESS *Process,
1438     PVOID Address
1439 );
1440
1441 BOOLEAN
1442 NTAPI
1443 MmCreateProcessAddressSpace(
1444     IN ULONG MinWs,
1445     IN PEPROCESS Dest,
1446     IN PULONG DirectoryTableBase
1447 );
1448
1449 NTSTATUS
1450 NTAPI
1451 MmInitializeHandBuiltProcess(
1452     IN PEPROCESS Process,
1453     IN PULONG DirectoryTableBase
1454 );
1455
1456
1457 NTSTATUS
1458 NTAPI
1459 MmInitializeHandBuiltProcess2(
1460     IN PEPROCESS Process
1461 );
1462
1463 NTSTATUS
1464 NTAPI
1465 MmReleaseMmInfo(struct _EPROCESS *Process);
1466
1467 NTSTATUS
1468 NTAPI
1469 Mmi386ReleaseMmInfo(struct _EPROCESS *Process);
1470
1471 VOID
1472 NTAPI
1473 MmDeleteVirtualMapping(
1474     struct _EPROCESS *Process,
1475     PVOID Address,
1476     BOOLEAN FreePage,
1477     BOOLEAN* WasDirty,
1478     PPFN_TYPE Page
1479 );
1480
1481 BOOLEAN
1482 NTAPI
1483 MmIsDirtyPage(
1484     struct _EPROCESS *Process,
1485     PVOID Address
1486 );
1487
1488 VOID
1489 NTAPI
1490 MmMarkPageMapped(PFN_TYPE Page);
1491
1492 VOID
1493 NTAPI
1494 MmMarkPageUnmapped(PFN_TYPE Page);
1495
1496 VOID
1497 NTAPI
1498 MmUpdatePageDir(
1499     struct _EPROCESS *Process,
1500     PVOID Address,
1501     ULONG Size
1502 );
1503
1504 VOID
1505 NTAPI
1506 MiInitPageDirectoryMap(VOID);
1507
1508 ULONG
1509 NTAPI
1510 MiGetUserPageDirectoryCount(VOID);
1511
1512 /* wset.c ********************************************************************/
1513
1514 NTSTATUS
1515 MmTrimUserMemory(
1516     ULONG Target,
1517     ULONG Priority,
1518     PULONG NrFreedPages
1519 );
1520
1521 /* region.c ************************************************************/
1522
1523 NTSTATUS
1524 NTAPI
1525 MmAlterRegion(
1526     PMMSUPPORT AddressSpace,
1527     PVOID BaseAddress,
1528     PLIST_ENTRY RegionListHead,
1529     PVOID StartAddress,
1530     ULONG Length,
1531     ULONG NewType,
1532     ULONG NewProtect,
1533     PMM_ALTER_REGION_FUNC AlterFunc
1534 );
1535
1536 VOID
1537 NTAPI
1538 MmInitializeRegion(
1539     PLIST_ENTRY RegionListHead,
1540     SIZE_T Length,
1541     ULONG Type,
1542     ULONG Protect
1543 );
1544
1545 PMM_REGION
1546 NTAPI
1547 MmFindRegion(
1548     PVOID BaseAddress,
1549     PLIST_ENTRY RegionListHead,
1550     PVOID Address,
1551     PVOID* RegionBaseAddress
1552 );
1553
1554 /* section.c *****************************************************************/
1555
1556 PFILE_OBJECT
1557 NTAPI
1558 MmGetFileObjectForSection(
1559     IN PROS_SECTION_OBJECT Section
1560 );
1561 NTSTATUS
1562 NTAPI
1563 MmGetFileNameForAddress(
1564     IN PVOID Address,
1565     OUT PUNICODE_STRING ModuleName
1566 );
1567
1568 NTSTATUS
1569 NTAPI
1570 MmGetFileNameForSection(
1571     IN PROS_SECTION_OBJECT Section,
1572     OUT POBJECT_NAME_INFORMATION *ModuleName
1573 );
1574
1575 PVOID
1576 NTAPI
1577 MmAllocateSection(
1578     IN ULONG Length,
1579     PVOID BaseAddress
1580 );
1581
1582 NTSTATUS
1583 NTAPI
1584 MmQuerySectionView(
1585     PMEMORY_AREA MemoryArea,
1586     PVOID Address,
1587     PMEMORY_BASIC_INFORMATION Info,
1588     PULONG ResultLength
1589 );
1590
1591 NTSTATUS
1592 NTAPI
1593 MmProtectSectionView(
1594     PMMSUPPORT AddressSpace,
1595     PMEMORY_AREA MemoryArea,
1596     PVOID BaseAddress,
1597     ULONG Length,
1598     ULONG Protect,
1599     PULONG OldProtect
1600 );
1601
1602 NTSTATUS
1603 NTAPI
1604 MmWritePageSectionView(
1605     PMMSUPPORT AddressSpace,
1606     PMEMORY_AREA MArea,
1607     PVOID Address,
1608     PMM_PAGEOP PageOp
1609 );
1610
1611 NTSTATUS
1612 NTAPI
1613 MmInitSectionImplementation(VOID);
1614
1615 NTSTATUS
1616 NTAPI
1617 MmNotPresentFaultSectionView(
1618     PMMSUPPORT AddressSpace,
1619     MEMORY_AREA* MemoryArea,
1620     PVOID Address,
1621     BOOLEAN Locked
1622 );
1623
1624 NTSTATUS
1625 NTAPI
1626 MmPageOutSectionView(
1627     PMMSUPPORT AddressSpace,
1628     PMEMORY_AREA MemoryArea,
1629     PVOID Address,
1630     struct _MM_PAGEOP *PageOp
1631 );
1632
1633 NTSTATUS
1634 NTAPI
1635 MmCreatePhysicalMemorySection(VOID);
1636
1637 NTSTATUS
1638 NTAPI
1639 MmAccessFaultSectionView(
1640     PMMSUPPORT AddressSpace,
1641     MEMORY_AREA* MemoryArea,
1642     PVOID Address,
1643     BOOLEAN Locked
1644 );
1645
1646 VOID
1647 NTAPI
1648 MmFreeSectionSegments(PFILE_OBJECT FileObject);
1649
1650 /* mpw.c *********************************************************************/
1651
1652 NTSTATUS
1653 NTAPI
1654 MmInitMpwThread(VOID);
1655
1656 NTSTATUS
1657 NTAPI
1658 MmInitBsmThread(VOID);
1659
1660 /* pager.c *******************************************************************/
1661
1662 BOOLEAN
1663 NTAPI
1664 MiIsPagerThread(VOID);
1665
1666 VOID
1667 NTAPI
1668 MiStartPagerThread(VOID);
1669
1670 VOID
1671 NTAPI
1672 MiStopPagerThread(VOID);
1673
1674 NTSTATUS
1675 FASTCALL
1676 MiQueryVirtualMemory(
1677     IN HANDLE ProcessHandle,
1678     IN PVOID Address,
1679     IN MEMORY_INFORMATION_CLASS VirtualMemoryInformationClass,
1680     OUT PVOID VirtualMemoryInformation,
1681     IN ULONG Length,
1682     OUT PULONG ResultLength
1683 );
1684
1685 /* sysldr.c ******************************************************************/
1686
1687 VOID
1688 NTAPI
1689 MiReloadBootLoadedDrivers(
1690     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1691 );
1692
1693 BOOLEAN
1694 NTAPI
1695 MiInitializeLoadedModuleList(
1696     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1697 );
1698
1699 NTSTATUS
1700 NTAPI
1701 MmLoadSystemImage(
1702     IN PUNICODE_STRING FileName,
1703     IN PUNICODE_STRING NamePrefix OPTIONAL,
1704     IN PUNICODE_STRING LoadedName OPTIONAL,
1705     IN ULONG Flags,
1706     OUT PVOID *ModuleObject,
1707     OUT PVOID *ImageBaseAddress
1708 );
1709
1710 NTSTATUS
1711 NTAPI
1712 MmUnloadSystemImage(
1713     IN PVOID ImageHandle
1714 );
1715
1716 NTSTATUS
1717 NTAPI
1718 MmCheckSystemImage(
1719     IN HANDLE ImageHandle,
1720     IN BOOLEAN PurgeSection
1721 );
1722
1723 NTSTATUS
1724 NTAPI
1725 MmCallDllInitialize(
1726     IN PLDR_DATA_TABLE_ENTRY LdrEntry,
1727     IN PLIST_ENTRY ListHead
1728 );
1729
1730 /* ReactOS Mm Hacks */
1731 VOID
1732 FASTCALL
1733 MiSyncForProcessAttach(
1734     IN PKTHREAD NextThread,
1735     IN PEPROCESS Process
1736 );
1737
1738 VOID
1739 FASTCALL
1740 MiSyncForContextSwitch(
1741     IN PKTHREAD Thread
1742 );
1743
1744 extern PMMSUPPORT MmKernelAddressSpace;
1745
1746 FORCEINLINE
1747 VOID
1748 MmLockAddressSpace(PMMSUPPORT AddressSpace)
1749 {
1750     KeAcquireGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1751 }
1752
1753 FORCEINLINE
1754 VOID
1755 MmUnlockAddressSpace(PMMSUPPORT AddressSpace)
1756 {
1757     KeReleaseGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1758 }
1759
1760 FORCEINLINE
1761 PEPROCESS
1762 MmGetAddressSpaceOwner(IN PMMSUPPORT AddressSpace)
1763 {
1764     if (AddressSpace == MmKernelAddressSpace) return NULL;
1765     return CONTAINING_RECORD(AddressSpace, EPROCESS, Vm);
1766 }
1767
1768 FORCEINLINE
1769 PMMSUPPORT
1770 MmGetCurrentAddressSpace(VOID)
1771 {
1772     return &((PEPROCESS)KeGetCurrentThread()->ApcState.Process)->Vm;
1773 }
1774
1775 FORCEINLINE
1776 PMMSUPPORT
1777 MmGetKernelAddressSpace(VOID)
1778 {
1779     return MmKernelAddressSpace;
1780 }
1781
1782 #endif