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