reactos/ntoskrnl/include/internal/mm.h

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