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