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