reactos/ntoskrnl/include/internal/mm.h

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