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(struct _EPROCESS *Process);
 780
 781 PTEB
 782 NTAPI
 783 MmCreateTeb(
 784     struct _EPROCESS *Process,
 785     PCLIENT_ID ClientId,
 786     PINITIAL_TEB InitialTeb
 787 );
 788
 789 VOID
 790 NTAPI
 791 MmDeleteTeb(
 792     struct _EPROCESS *Process,
 793     PTEB Teb
 794 );
 795
 796 VOID
 797 NTAPI
 798 MmCleanProcessAddressSpace(IN PEPROCESS Process);
 799
 800 NTSTATUS
 801 NTAPI
 802 MmDeleteProcessAddressSpace(IN PEPROCESS Process);
 803
 804 ULONG
 805 NTAPI
 806 MmGetSessionLocaleId(VOID);
 807
 808 NTSTATUS
 809 NTAPI
 810 MmSetMemoryPriorityProcess(
 811     IN PEPROCESS Process,
 812     IN UCHAR MemoryPriority
 813 );
 814
 815 /* i386/pfault.c *************************************************************/
 816
 817 NTSTATUS
 818 NTAPI
 819 MmPageFault(
 820     ULONG Cs,
 821     PULONG Eip,
 822     PULONG Eax,
 823     ULONG Cr2,
 824     ULONG ErrorCode
 825 );
 826
 827 /* mm.c **********************************************************************/
 828
 829 NTSTATUS
 830 NTAPI
 831 MmAccessFault(
 832     IN BOOLEAN StoreInstruction,
 833     IN PVOID Address,
 834     IN KPROCESSOR_MODE Mode,
 835     IN PVOID TrapInformation
 836 );
 837
 838 /* anonmem.c *****************************************************************/
 839
 840 NTSTATUS
 841 NTAPI
 842 MmNotPresentFaultVirtualMemory(
 843     PMMSUPPORT AddressSpace,
 844     MEMORY_AREA* MemoryArea,
 845     PVOID Address,
 846     BOOLEAN Locked
 847 );
 848
 849 NTSTATUS
 850 NTAPI
 851 MmPageOutVirtualMemory(
 852     PMMSUPPORT AddressSpace,
 853     PMEMORY_AREA MemoryArea,
 854     PVOID Address,
 855     struct _MM_PAGEOP* PageOp
 856 );
 857
 858 NTSTATUS
 859 NTAPI
 860 MmQueryAnonMem(
 861     PMEMORY_AREA MemoryArea,
 862     PVOID Address,
 863     PMEMORY_BASIC_INFORMATION Info,
 864     PULONG ResultLength
 865 );
 866
 867 VOID
 868 NTAPI
 869 MmFreeVirtualMemory(
 870     struct _EPROCESS* Process,
 871     PMEMORY_AREA MemoryArea
 872 );
 873
 874 NTSTATUS
 875 NTAPI
 876 MmProtectAnonMem(
 877     PMMSUPPORT AddressSpace,
 878     PMEMORY_AREA MemoryArea,
 879     PVOID BaseAddress,
 880     ULONG Length,
 881     ULONG Protect,
 882     PULONG OldProtect
 883 );
 884
 885 NTSTATUS
 886 NTAPI
 887 MmWritePageVirtualMemory(
 888     PMMSUPPORT AddressSpace,
 889     PMEMORY_AREA MArea,
 890     PVOID Address,
 891     PMM_PAGEOP PageOp
 892 );
 893
 894 /* kmap.c ********************************************************************/
 895
 896 PVOID
 897 NTAPI
 898 ExAllocatePage(VOID);
 899
 900 VOID
 901 NTAPI
 902 ExUnmapPage(PVOID Addr);
 903
 904 PVOID
 905 NTAPI
 906 ExAllocatePageWithPhysPage(PFN_TYPE Page);
 907
 908 NTSTATUS
 909 NTAPI
 910 MiCopyFromUserPage(
 911     PFN_TYPE Page,
 912     PVOID SourceAddress
 913 );
 914
 915 NTSTATUS
 916 NTAPI
 917 MiZeroPage(PFN_TYPE Page);
 918
 919 /* memsafe.s *****************************************************************/
 920
 921 PVOID
 922 FASTCALL
 923 MmSafeReadPtr(PVOID Source);
 924
 925 /* pageop.c ******************************************************************/
 926
 927 VOID
 928 NTAPI
 929 MmReleasePageOp(PMM_PAGEOP PageOp);
 930
 931 PMM_PAGEOP
 932 NTAPI
 933 MmGetPageOp(
 934     PMEMORY_AREA MArea,
 935     HANDLE Pid,
 936     PVOID Address,
 937     PMM_SECTION_SEGMENT Segment,
 938     ULONG Offset,
 939     ULONG OpType,
 940     BOOLEAN First
 941 );
 942
 943 PMM_PAGEOP
 944 NTAPI
 945 MmCheckForPageOp(
 946     PMEMORY_AREA MArea,
 947     HANDLE Pid,
 948     PVOID Address,
 949     PMM_SECTION_SEGMENT Segment,
 950     ULONG Offset
 951 );
 952
 953 VOID
 954 NTAPI
 955 MmInitializePageOp(VOID);
 956
 957 /* process.c *****************************************************************/
 958
 959 PVOID
 960 NTAPI
 961 MmCreateKernelStack(BOOLEAN GuiStack, UCHAR Node);
 962
 963 VOID
 964 NTAPI
 965 MmDeleteKernelStack(PVOID Stack,
 966                     BOOLEAN GuiStack);
 967
 968 /* balace.c ******************************************************************/
 969
 970 VOID
 971 NTAPI
 972 MmInitializeMemoryConsumer(
 973     ULONG Consumer,
 974     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed)
 975 );
 976
 977 VOID
 978 NTAPI
 979 MmInitializeBalancer(
 980     ULONG NrAvailablePages,
 981     ULONG NrSystemPages
 982 );
 983
 984 NTSTATUS
 985 NTAPI
 986 MmReleasePageMemoryConsumer(
 987     ULONG Consumer,
 988     PFN_TYPE Page
 989 );
 990
 991 NTSTATUS
 992 NTAPI
 993 MmRequestPageMemoryConsumer(
 994     ULONG Consumer,
 995     BOOLEAN MyWait,
 996     PPFN_TYPE AllocatedPage
 997 );
 998
 999 VOID
1000 NTAPI
1001 MiInitBalancerThread(VOID);
1002
1003 VOID
1004 NTAPI
1005 MmRebalanceMemoryConsumers(VOID);
1006
1007 /* rmap.c **************************************************************/
1008
1009 VOID
1010 NTAPI
1011 MmSetRmapListHeadPage(
1012     PFN_TYPE Page,
1013     struct _MM_RMAP_ENTRY* ListHead
1014 );
1015
1016 struct _MM_RMAP_ENTRY*
1017 NTAPI
1018 MmGetRmapListHeadPage(PFN_TYPE Page);
1019
1020 VOID
1021 NTAPI
1022 MmInsertRmap(
1023     PFN_TYPE Page,
1024     struct _EPROCESS *Process,
1025     PVOID Address
1026 );
1027
1028 VOID
1029 NTAPI
1030 MmDeleteAllRmaps(
1031     PFN_TYPE Page,
1032     PVOID Context,
1033     VOID (*DeleteMapping)(PVOID Context, struct _EPROCESS *Process, PVOID Address)
1034 );
1035
1036 VOID
1037 NTAPI
1038 MmDeleteRmap(
1039     PFN_TYPE Page,
1040     struct _EPROCESS *Process,
1041     PVOID Address
1042 );
1043
1044 VOID
1045 NTAPI
1046 MmInitializeRmapList(VOID);
1047
1048 VOID
1049 NTAPI
1050 MmSetCleanAllRmaps(PFN_TYPE Page);
1051
1052 VOID
1053 NTAPI
1054 MmSetDirtyAllRmaps(PFN_TYPE Page);
1055
1056 BOOLEAN
1057 NTAPI
1058 MmIsDirtyPageRmap(PFN_TYPE Page);
1059
1060 NTSTATUS
1061 NTAPI
1062 MmWritePagePhysicalAddress(PFN_TYPE Page);
1063
1064 NTSTATUS
1065 NTAPI
1066 MmPageOutPhysicalAddress(PFN_TYPE Page);
1067
1068 /* freelist.c **********************************************************/
1069
1070 #define ASSERT_PFN(x) ASSERT((x)->u3.e1.CacheAttribute != 0)
1071
1072 FORCEINLINE
1073 PMMPFN
1074 MiGetPfnEntry(IN PFN_TYPE Pfn)
1075 {
1076     PMMPFN Page;
1077     extern RTL_BITMAP MiPfnBitMap;
1078
1079     /* Make sure the PFN number is valid */
1080     if (Pfn > MmHighestPhysicalPage) return NULL;
1081
1082     /* Make sure this page actually has a PFN entry */
1083     if ((MiPfnBitMap.Buffer) && !(RtlTestBit(&MiPfnBitMap, Pfn))) return NULL;
1084
1085     /* Get the entry */
1086     Page = &MmPfnDatabase[Pfn];
1087
1088     /* Make sure it's valid */
1089     ASSERT_PFN(Page);
1090
1091     /* Return it */
1092     return Page;
1093 };
1094
1095 FORCEINLINE
1096 PFN_NUMBER
1097 MiGetPfnEntryIndex(IN PMMPFN Pfn1)
1098 {
1099     //
1100     // This will return the Page Frame Number (PFN) from the MMPFN
1101     //
1102     return Pfn1 - MmPfnDatabase;
1103 }
1104
1105 PFN_TYPE
1106 NTAPI
1107 MmGetLRUNextUserPage(PFN_TYPE PreviousPage);
1108
1109 PFN_TYPE
1110 NTAPI
1111 MmGetLRUFirstUserPage(VOID);
1112
1113 VOID
1114 NTAPI
1115 MmInsertLRULastUserPage(PFN_TYPE Page);
1116
1117 VOID
1118 NTAPI
1119 MmRemoveLRUUserPage(PFN_TYPE Page);
1120
1121 VOID
1122 NTAPI
1123 MmLockPage(PFN_TYPE Page);
1124
1125 VOID
1126 NTAPI
1127 MmUnlockPage(PFN_TYPE Page);
1128
1129 ULONG
1130 NTAPI
1131 MmGetLockCountPage(PFN_TYPE Page);
1132
1133 VOID
1134 NTAPI
1135 MmInitializePageList(
1136     VOID
1137 );
1138
1139 VOID
1140 NTAPI
1141 MmDumpPfnDatabase(
1142    VOID
1143 );
1144
1145 PFN_TYPE
1146 NTAPI
1147 MmGetContinuousPages(
1148     ULONG NumberOfBytes,
1149     PHYSICAL_ADDRESS LowestAcceptableAddress,
1150     PHYSICAL_ADDRESS HighestAcceptableAddress,
1151     PHYSICAL_ADDRESS BoundaryAddressMultiple,
1152     BOOLEAN ZeroPages
1153 );
1154
1155 NTSTATUS
1156 NTAPI
1157 MmZeroPageThreadMain(
1158     PVOID Context
1159 );
1160
1161 /* hypermap.c *****************************************************************/
1162
1163 extern PEPROCESS HyperProcess;
1164 extern KIRQL HyperIrql;
1165
1166 PVOID
1167 NTAPI
1168 MiMapPageInHyperSpace(IN PEPROCESS Process,
1169                       IN PFN_NUMBER Page,
1170                       IN PKIRQL OldIrql);
1171
1172 VOID
1173 NTAPI
1174 MiUnmapPageInHyperSpace(IN PEPROCESS Process,
1175                         IN PVOID Address,
1176                         IN KIRQL OldIrql);
1177
1178 PVOID
1179 NTAPI
1180 MiMapPagesToZeroInHyperSpace(IN PMMPFN *Pages,
1181                              IN PFN_NUMBER NumberOfPages);
1182
1183 VOID
1184 NTAPI
1185 MiUnmapPagesInZeroSpace(IN PVOID VirtualAddress,
1186                         IN PFN_NUMBER NumberOfPages);
1187
1188 //
1189 // ReactOS Compatibility Layer
1190 //
1191 FORCEINLINE
1192 PVOID
1193 MmCreateHyperspaceMapping(IN PFN_NUMBER Page)
1194 {
1195     HyperProcess = (PEPROCESS)KeGetCurrentThread()->ApcState.Process;
1196     return MiMapPageInHyperSpace(HyperProcess, Page, &HyperIrql);
1197 }
1198
1199 FORCEINLINE
1200 PVOID
1201 MiMapPageToZeroInHyperSpace(IN PFN_NUMBER Page)
1202 {
1203     PMMPFN Pfn1 = MiGetPfnEntry(Page);
1204     return MiMapPagesToZeroInHyperSpace(&Pfn1, 1);
1205 }
1206
1207 #define MmDeleteHyperspaceMapping(x) MiUnmapPageInHyperSpace(HyperProcess, x, HyperIrql);
1208
1209 /* i386/page.c *********************************************************/
1210
1211 NTSTATUS
1212 NTAPI
1213 MmCreateVirtualMappingForKernel(
1214     PVOID Address,
1215     ULONG flProtect,
1216     PPFN_TYPE Pages,
1217     ULONG PageCount
1218 );
1219
1220 NTSTATUS
1221 NTAPI
1222 MmCommitPagedPoolAddress(
1223     PVOID Address,
1224     BOOLEAN Locked
1225 );
1226
1227 NTSTATUS
1228 NTAPI
1229 MmCreateVirtualMapping(
1230     struct _EPROCESS* Process,
1231     PVOID Address,
1232     ULONG flProtect,
1233     PPFN_TYPE Pages,
1234     ULONG PageCount
1235 );
1236
1237 NTSTATUS
1238 NTAPI
1239 MmCreateVirtualMappingUnsafe(
1240     struct _EPROCESS* Process,
1241     PVOID Address,
1242     ULONG flProtect,
1243     PPFN_TYPE Pages,
1244     ULONG PageCount
1245 );
1246
1247 ULONG
1248 NTAPI
1249 MmGetPageProtect(
1250     struct _EPROCESS* Process,
1251     PVOID Address);
1252
1253 VOID
1254 NTAPI
1255 MmSetPageProtect(
1256     struct _EPROCESS* Process,
1257     PVOID Address,
1258     ULONG flProtect
1259 );
1260
1261 BOOLEAN
1262 NTAPI
1263 MmIsPagePresent(
1264     struct _EPROCESS* Process,
1265     PVOID Address
1266 );
1267
1268 VOID
1269 NTAPI
1270 MmInitGlobalKernelPageDirectory(VOID);
1271
1272 VOID
1273 NTAPI
1274 MmDisableVirtualMapping(
1275     struct _EPROCESS *Process,
1276     PVOID Address,
1277     BOOLEAN* WasDirty,
1278     PPFN_TYPE Page
1279 );
1280
1281 VOID
1282 NTAPI
1283 MmEnableVirtualMapping(
1284     struct _EPROCESS *Process,
1285     PVOID Address
1286 );
1287
1288 VOID
1289 NTAPI
1290 MmRawDeleteVirtualMapping(PVOID Address);
1291
1292 VOID
1293 NTAPI
1294 MmDeletePageFileMapping(
1295     struct _EPROCESS *Process,
1296     PVOID Address,
1297     SWAPENTRY* SwapEntry
1298 );
1299
1300 NTSTATUS
1301 NTAPI
1302 MmCreatePageFileMapping(
1303     struct _EPROCESS *Process,
1304     PVOID Address,
1305     SWAPENTRY SwapEntry
1306 );
1307
1308 BOOLEAN
1309 NTAPI
1310 MmIsPageSwapEntry(
1311     struct _EPROCESS *Process,
1312     PVOID Address
1313 );
1314
1315 VOID
1316 NTAPI
1317 MmTransferOwnershipPage(
1318     PFN_TYPE Page,
1319     ULONG NewConsumer
1320 );
1321
1322 VOID
1323 NTAPI
1324 MmSetDirtyPage(
1325     struct _EPROCESS *Process,
1326     PVOID Address
1327 );
1328
1329 PFN_TYPE
1330 NTAPI
1331 MmAllocPage(
1332     ULONG Consumer,
1333     SWAPENTRY SavedSwapEntry
1334 );
1335
1336 LONG
1337 NTAPI
1338 MmAllocPagesSpecifyRange(
1339     ULONG Consumer,
1340     PHYSICAL_ADDRESS LowestAddress,
1341     PHYSICAL_ADDRESS HighestAddress,
1342     ULONG NumberOfPages,
1343     PPFN_TYPE Pages
1344 );
1345
1346 VOID
1347 NTAPI
1348 MmDereferencePage(PFN_TYPE Page);
1349
1350 VOID
1351 NTAPI
1352 MmReferencePage(PFN_TYPE Page);
1353
1354 ULONG
1355 NTAPI
1356 MmGetReferenceCountPage(PFN_TYPE Page);
1357
1358 BOOLEAN
1359 NTAPI
1360 MmIsPageInUse(PFN_TYPE Page);
1361
1362 VOID
1363 NTAPI
1364 MmSetSavedSwapEntryPage(
1365     PFN_TYPE Page,
1366     SWAPENTRY SavedSwapEntry);
1367
1368 SWAPENTRY
1369 NTAPI
1370 MmGetSavedSwapEntryPage(PFN_TYPE Page);
1371
1372 VOID
1373 NTAPI
1374 MmSetCleanPage(
1375     struct _EPROCESS *Process,
1376     PVOID Address
1377 );
1378
1379 NTSTATUS
1380 NTAPI
1381 MmCreatePageTable(PVOID PAddress);
1382
1383 VOID
1384 NTAPI
1385 MmDeletePageTable(
1386     struct _EPROCESS *Process,
1387     PVOID Address
1388 );
1389
1390 PFN_TYPE
1391 NTAPI
1392 MmGetPfnForProcess(
1393     struct _EPROCESS *Process,
1394     PVOID Address
1395 );
1396
1397 BOOLEAN
1398 NTAPI
1399 MmCreateProcessAddressSpace(
1400     IN ULONG MinWs,
1401     IN PEPROCESS Dest,
1402     IN PULONG DirectoryTableBase
1403 );
1404
1405 NTSTATUS
1406 NTAPI
1407 MmInitializeHandBuiltProcess(
1408     IN PEPROCESS Process,
1409     IN PULONG DirectoryTableBase
1410 );
1411
1412
1413 NTSTATUS
1414 NTAPI
1415 MmInitializeHandBuiltProcess2(
1416     IN PEPROCESS Process
1417 );
1418
1419 NTSTATUS
1420 NTAPI
1421 MmReleaseMmInfo(struct _EPROCESS *Process);
1422
1423 NTSTATUS
1424 NTAPI
1425 Mmi386ReleaseMmInfo(struct _EPROCESS *Process);
1426
1427 VOID
1428 NTAPI
1429 MmDeleteVirtualMapping(
1430     struct _EPROCESS *Process,
1431     PVOID Address,
1432     BOOLEAN FreePage,
1433     BOOLEAN* WasDirty,
1434     PPFN_TYPE Page
1435 );
1436
1437 BOOLEAN
1438 NTAPI
1439 MmIsDirtyPage(
1440     struct _EPROCESS *Process,
1441     PVOID Address
1442 );
1443
1444 VOID
1445 NTAPI
1446 MmMarkPageMapped(PFN_TYPE Page);
1447
1448 VOID
1449 NTAPI
1450 MmMarkPageUnmapped(PFN_TYPE Page);
1451
1452 VOID
1453 NTAPI
1454 MmUpdatePageDir(
1455     struct _EPROCESS *Process,
1456     PVOID Address,
1457     ULONG Size
1458 );
1459
1460 VOID
1461 NTAPI
1462 MiInitPageDirectoryMap(VOID);
1463
1464 ULONG
1465 NTAPI
1466 MiGetUserPageDirectoryCount(VOID);
1467
1468 /* wset.c ********************************************************************/
1469
1470 NTSTATUS
1471 MmTrimUserMemory(
1472     ULONG Target,
1473     ULONG Priority,
1474     PULONG NrFreedPages
1475 );
1476
1477 /* region.c ************************************************************/
1478
1479 NTSTATUS
1480 NTAPI
1481 MmAlterRegion(
1482     PMMSUPPORT AddressSpace,
1483     PVOID BaseAddress,
1484     PLIST_ENTRY RegionListHead,
1485     PVOID StartAddress,
1486     ULONG Length,
1487     ULONG NewType,
1488     ULONG NewProtect,
1489     PMM_ALTER_REGION_FUNC AlterFunc
1490 );
1491
1492 VOID
1493 NTAPI
1494 MmInitializeRegion(
1495     PLIST_ENTRY RegionListHead,
1496     SIZE_T Length,
1497     ULONG Type,
1498     ULONG Protect
1499 );
1500
1501 PMM_REGION
1502 NTAPI
1503 MmFindRegion(
1504     PVOID BaseAddress,
1505     PLIST_ENTRY RegionListHead,
1506     PVOID Address,
1507     PVOID* RegionBaseAddress
1508 );
1509
1510 /* section.c *****************************************************************/
1511
1512 PFILE_OBJECT
1513 NTAPI
1514 MmGetFileObjectForSection(
1515     IN PROS_SECTION_OBJECT Section
1516 );
1517 NTSTATUS
1518 NTAPI
1519 MmGetFileNameForAddress(
1520     IN PVOID Address,
1521     OUT PUNICODE_STRING ModuleName
1522 );
1523
1524 NTSTATUS
1525 NTAPI
1526 MmGetFileNameForSection(
1527     IN PROS_SECTION_OBJECT Section,
1528     OUT POBJECT_NAME_INFORMATION *ModuleName
1529 );
1530
1531 PVOID
1532 NTAPI
1533 MmAllocateSection(
1534     IN ULONG Length,
1535     PVOID BaseAddress
1536 );
1537
1538 NTSTATUS
1539 NTAPI
1540 MmQuerySectionView(
1541     PMEMORY_AREA MemoryArea,
1542     PVOID Address,
1543     PMEMORY_BASIC_INFORMATION Info,
1544     PULONG ResultLength
1545 );
1546
1547 NTSTATUS
1548 NTAPI
1549 MmProtectSectionView(
1550     PMMSUPPORT AddressSpace,
1551     PMEMORY_AREA MemoryArea,
1552     PVOID BaseAddress,
1553     ULONG Length,
1554     ULONG Protect,
1555     PULONG OldProtect
1556 );
1557
1558 NTSTATUS
1559 NTAPI
1560 MmWritePageSectionView(
1561     PMMSUPPORT AddressSpace,
1562     PMEMORY_AREA MArea,
1563     PVOID Address,
1564     PMM_PAGEOP PageOp
1565 );
1566
1567 NTSTATUS
1568 NTAPI
1569 MmInitSectionImplementation(VOID);
1570
1571 NTSTATUS
1572 NTAPI
1573 MmNotPresentFaultSectionView(
1574     PMMSUPPORT AddressSpace,
1575     MEMORY_AREA* MemoryArea,
1576     PVOID Address,
1577     BOOLEAN Locked
1578 );
1579
1580 NTSTATUS
1581 NTAPI
1582 MmPageOutSectionView(
1583     PMMSUPPORT AddressSpace,
1584     PMEMORY_AREA MemoryArea,
1585     PVOID Address,
1586     struct _MM_PAGEOP *PageOp
1587 );
1588
1589 NTSTATUS
1590 NTAPI
1591 MmCreatePhysicalMemorySection(VOID);
1592
1593 NTSTATUS
1594 NTAPI
1595 MmAccessFaultSectionView(
1596     PMMSUPPORT AddressSpace,
1597     MEMORY_AREA* MemoryArea,
1598     PVOID Address,
1599     BOOLEAN Locked
1600 );
1601
1602 VOID
1603 NTAPI
1604 MmFreeSectionSegments(PFILE_OBJECT FileObject);
1605
1606 /* mpw.c *********************************************************************/
1607
1608 NTSTATUS
1609 NTAPI
1610 MmInitMpwThread(VOID);
1611
1612 NTSTATUS
1613 NTAPI
1614 MmInitBsmThread(VOID);
1615
1616 /* pager.c *******************************************************************/
1617
1618 BOOLEAN
1619 NTAPI
1620 MiIsPagerThread(VOID);
1621
1622 VOID
1623 NTAPI
1624 MiStartPagerThread(VOID);
1625
1626 VOID
1627 NTAPI
1628 MiStopPagerThread(VOID);
1629
1630 NTSTATUS
1631 FASTCALL
1632 MiQueryVirtualMemory(
1633     IN HANDLE ProcessHandle,
1634     IN PVOID Address,
1635     IN MEMORY_INFORMATION_CLASS VirtualMemoryInformationClass,
1636     OUT PVOID VirtualMemoryInformation,
1637     IN ULONG Length,
1638     OUT PULONG ResultLength
1639 );
1640
1641 /* sysldr.c ******************************************************************/
1642
1643 VOID
1644 NTAPI
1645 MiReloadBootLoadedDrivers(
1646     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1647 );
1648
1649 BOOLEAN
1650 NTAPI
1651 MiInitializeLoadedModuleList(
1652     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1653 );
1654
1655 NTSTATUS
1656 NTAPI
1657 MmLoadSystemImage(
1658     IN PUNICODE_STRING FileName,
1659     IN PUNICODE_STRING NamePrefix OPTIONAL,
1660     IN PUNICODE_STRING LoadedName OPTIONAL,
1661     IN ULONG Flags,
1662     OUT PVOID *ModuleObject,
1663     OUT PVOID *ImageBaseAddress
1664 );
1665
1666 NTSTATUS
1667 NTAPI
1668 MmUnloadSystemImage(
1669     IN PVOID ImageHandle
1670 );
1671
1672 NTSTATUS
1673 NTAPI
1674 MmCheckSystemImage(
1675     IN HANDLE ImageHandle,
1676     IN BOOLEAN PurgeSection
1677 );
1678
1679 NTSTATUS
1680 NTAPI
1681 MmCallDllInitialize(
1682     IN PLDR_DATA_TABLE_ENTRY LdrEntry,
1683     IN PLIST_ENTRY ListHead
1684 );
1685
1686 /* ReactOS Mm Hacks */
1687 VOID
1688 FASTCALL
1689 MiSyncForProcessAttach(
1690     IN PKTHREAD NextThread,
1691     IN PEPROCESS Process
1692 );
1693
1694 VOID
1695 FASTCALL
1696 MiSyncForContextSwitch(
1697     IN PKTHREAD Thread
1698 );
1699
1700 extern PMMSUPPORT MmKernelAddressSpace;
1701
1702 FORCEINLINE
1703 VOID
1704 MmLockAddressSpace(PMMSUPPORT AddressSpace)
1705 {
1706     KeAcquireGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1707 }
1708
1709 FORCEINLINE
1710 VOID
1711 MmUnlockAddressSpace(PMMSUPPORT AddressSpace)
1712 {
1713     KeReleaseGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1714 }
1715
1716 FORCEINLINE
1717 PEPROCESS
1718 MmGetAddressSpaceOwner(IN PMMSUPPORT AddressSpace)
1719 {
1720     if (AddressSpace == MmKernelAddressSpace) return NULL;
1721     return CONTAINING_RECORD(AddressSpace, EPROCESS, Vm);
1722 }
1723
1724 FORCEINLINE
1725 PMMSUPPORT
1726 MmGetCurrentAddressSpace(VOID)
1727 {
1728     return &((PEPROCESS)KeGetCurrentThread()->ApcState.Process)->Vm;
1729 }
1730
1731 FORCEINLINE
1732 PMMSUPPORT
1733 MmGetKernelAddressSpace(VOID)
1734 {
1735     return MmKernelAddressSpace;
1736 }
1737
1738 #endif