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