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