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 PageOpCount;
 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 /* npool.c *******************************************************************/
 590
 591 VOID
 592 NTAPI
 593 MiDebugDumpNonPagedPool(BOOLEAN NewOnly);
 594
 595 VOID
 596 NTAPI
 597 MiDebugDumpNonPagedPoolStats(BOOLEAN NewOnly);
 598
 599 VOID
 600 NTAPI
 601 MiInitializeNonPagedPool(VOID);
 602
 603 PVOID
 604 NTAPI
 605 MiAllocatePoolPages(
 606     IN POOL_TYPE PoolType,
 607     IN SIZE_T SizeInBytes
 608 );
 609
 610 POOL_TYPE
 611 NTAPI
 612 MmDeterminePoolType(
 613     IN PVOID VirtualAddress
 614 );
 615
 616 ULONG
 617 NTAPI
 618 MiFreePoolPages(
 619     IN PVOID StartingAddress
 620 );
 621
 622 PVOID
 623 NTAPI
 624 MmGetMdlPageAddress(
 625     PMDL Mdl,
 626     PVOID Offset
 627 );
 628
 629 /* pool.c *******************************************************************/
 630
 631 PVOID
 632 NTAPI
 633 ExAllocateNonPagedPoolWithTag(
 634     POOL_TYPE type,
 635     ULONG size,
 636     ULONG Tag,
 637     PVOID Caller
 638 );
 639
 640 PVOID
 641 NTAPI
 642 ExAllocatePagedPoolWithTag(
 643     POOL_TYPE Type,
 644     ULONG size,
 645     ULONG Tag
 646 );
 647
 648 VOID
 649 NTAPI
 650 ExFreeNonPagedPool(PVOID block);
 651
 652 VOID
 653 NTAPI
 654 ExFreePagedPool(IN PVOID Block);
 655
 656 BOOLEAN
 657 NTAPI
 658 ExpIsPoolTagDebuggable(ULONG Tag);
 659
 660 PVOID
 661 NTAPI
 662 ExpAllocateDebugPool(
 663     POOL_TYPE Type,
 664     ULONG Size,
 665     ULONG Tag,
 666     PVOID Caller,
 667     BOOLEAN EndOfPage
 668 );
 669
 670 VOID
 671 NTAPI
 672 ExpFreeDebugPool(PVOID Block, BOOLEAN PagedPool);
 673
 674 VOID
 675 NTAPI
 676 MmInitializePagedPool(VOID);
 677
 678 PVOID
 679 NTAPI
 680 MiAllocateSpecialPool(
 681     IN POOL_TYPE PoolType,
 682     IN SIZE_T NumberOfBytes,
 683     IN ULONG Tag,
 684     IN ULONG Underrun
 685 );
 686
 687 BOOLEAN
 688 NTAPI
 689 MiRaisePoolQuota(
 690     IN POOL_TYPE PoolType,
 691     IN ULONG CurrentMaxQuota,
 692     OUT PULONG NewMaxQuota
 693 );
 694
 695 /* mdl.c *********************************************************************/
 696
 697 VOID
 698 NTAPI
 699 MmBuildMdlFromPages(
 700     PMDL Mdl,
 701     PPFN_NUMBER Pages
 702 );
 703
 704 /* mminit.c ******************************************************************/
 705
 706 VOID
 707 NTAPI
 708 MiShutdownMemoryManager(VOID);
 709
 710 VOID
 711 NTAPI
 712 MmInit1(
 713     VOID
 714 );
 715
 716 BOOLEAN
 717 NTAPI
 718 MmInitSystem(IN ULONG Phase,
 719              IN PLOADER_PARAMETER_BLOCK LoaderBlock);
 720
 721 VOID
 722 NTAPI
 723 MiFreeInitMemory(VOID);
 724
 725 VOID
 726 NTAPI
 727 MmInitializeMdlImplementation(VOID);
 728
 729 /* pagefile.c ****************************************************************/
 730
 731 SWAPENTRY
 732 NTAPI
 733 MmAllocSwapPage(VOID);
 734
 735 VOID
 736 NTAPI
 737 MmDereserveSwapPages(ULONG Nr);
 738
 739 VOID
 740 NTAPI
 741 MmFreeSwapPage(SWAPENTRY Entry);
 742
 743 VOID
 744 NTAPI
 745 MmInitPagingFile(VOID);
 746
 747 BOOLEAN
 748 NTAPI
 749 MmIsFileObjectAPagingFile(PFILE_OBJECT FileObject);
 750
 751 NTSTATUS
 752 NTAPI
 753 MmReadFromSwapPage(
 754     SWAPENTRY SwapEntry,
 755     PFN_NUMBER Page
 756 );
 757
 758 BOOLEAN
 759 NTAPI
 760 MmReserveSwapPages(ULONG Nr);
 761
 762 NTSTATUS
 763 NTAPI
 764 MmWriteToSwapPage(
 765     SWAPENTRY SwapEntry,
 766     PFN_NUMBER Page
 767 );
 768
 769 NTSTATUS
 770 NTAPI
 771 MmDumpToPagingFile(
 772     ULONG BugCode,
 773     ULONG BugCodeParameter1,
 774     ULONG BugCodeParameter2,
 775     ULONG BugCodeParameter3,
 776     ULONG BugCodeParameter4,
 777     struct _KTRAP_FRAME* TrapFrame
 778 );
 779
 780 BOOLEAN
 781 NTAPI
 782 MmIsAvailableSwapPage(VOID);
 783
 784 VOID
 785 NTAPI
 786 MmShowOutOfSpaceMessagePagingFile(VOID);
 787
 788 /* process.c ****************************************************************/
 789
 790 NTSTATUS
 791 NTAPI
 792 MmInitializeProcessAddressSpace(
 793     IN PEPROCESS Process,
 794     IN PEPROCESS Clone OPTIONAL,
 795     IN PVOID Section OPTIONAL,
 796     IN OUT PULONG Flags,
 797     IN POBJECT_NAME_INFORMATION *AuditName OPTIONAL
 798 );
 799
 800 NTSTATUS
 801 NTAPI
 802 MmCreatePeb(
 803     IN PEPROCESS Process,
 804     IN PINITIAL_PEB InitialPeb,
 805     OUT PPEB *BasePeb
 806 );
 807
 808 NTSTATUS
 809 NTAPI
 810 MmCreateTeb(
 811     IN PEPROCESS Process,
 812     IN PCLIENT_ID ClientId,
 813     IN PINITIAL_TEB InitialTeb,
 814     OUT PTEB* BaseTeb
 815 );
 816
 817 VOID
 818 NTAPI
 819 MmDeleteTeb(
 820     struct _EPROCESS *Process,
 821     PTEB Teb
 822 );
 823
 824 VOID
 825 NTAPI
 826 MmCleanProcessAddressSpace(IN PEPROCESS Process);
 827
 828 NTSTATUS
 829 NTAPI
 830 MmDeleteProcessAddressSpace(IN PEPROCESS Process);
 831
 832 ULONG
 833 NTAPI
 834 MmGetSessionLocaleId(VOID);
 835
 836 NTSTATUS
 837 NTAPI
 838 MmSetMemoryPriorityProcess(
 839     IN PEPROCESS Process,
 840     IN UCHAR MemoryPriority
 841 );
 842
 843 /* i386/pfault.c *************************************************************/
 844
 845 NTSTATUS
 846 NTAPI
 847 MmPageFault(
 848     ULONG Cs,
 849     PULONG Eip,
 850     PULONG Eax,
 851     ULONG Cr2,
 852     ULONG ErrorCode
 853 );
 854
 855 /* special.c *****************************************************************/
 856
 857 VOID
 858 NTAPI
 859 MiInitializeSpecialPool();
 860
 861 BOOLEAN
 862 NTAPI
 863 MmUseSpecialPool(
 864     IN SIZE_T NumberOfBytes,
 865     IN ULONG Tag);
 866
 867 BOOLEAN
 868 NTAPI
 869 MmIsSpecialPoolAddress(
 870     IN PVOID P);
 871
 872 PVOID
 873 NTAPI
 874 MmAllocateSpecialPool(
 875     IN SIZE_T NumberOfBytes,
 876     IN ULONG Tag,
 877     IN POOL_TYPE PoolType,
 878     IN ULONG SpecialType);
 879
 880 VOID
 881 NTAPI
 882 MmFreeSpecialPool(
 883     IN PVOID P);
 884
 885 /* mm.c **********************************************************************/
 886
 887 NTSTATUS
 888 NTAPI
 889 MmAccessFault(
 890     IN BOOLEAN StoreInstruction,
 891     IN PVOID Address,
 892     IN KPROCESSOR_MODE Mode,
 893     IN PVOID TrapInformation
 894 );
 895
 896 /* anonmem.c *****************************************************************/
 897
 898 NTSTATUS
 899 NTAPI
 900 MmNotPresentFaultVirtualMemory(
 901     PMMSUPPORT AddressSpace,
 902     MEMORY_AREA* MemoryArea,
 903     PVOID Address
 904 );
 905
 906 NTSTATUS
 907 NTAPI
 908 MmPageOutVirtualMemory(
 909     PMMSUPPORT AddressSpace,
 910     PMEMORY_AREA MemoryArea,
 911     PVOID Address,
 912     PFN_NUMBER Page
 913 );
 914
 915 NTSTATUS
 916 NTAPI
 917 MmQueryAnonMem(
 918     PMEMORY_AREA MemoryArea,
 919     PVOID Address,
 920     PMEMORY_BASIC_INFORMATION Info,
 921     PSIZE_T ResultLength
 922 );
 923
 924 VOID
 925 NTAPI
 926 MmFreeVirtualMemory(
 927     struct _EPROCESS* Process,
 928     PMEMORY_AREA MemoryArea
 929 );
 930
 931 NTSTATUS
 932 NTAPI
 933 MmProtectAnonMem(
 934     PMMSUPPORT AddressSpace,
 935     PMEMORY_AREA MemoryArea,
 936     PVOID BaseAddress,
 937     SIZE_T Length,
 938     ULONG Protect,
 939     PULONG OldProtect
 940 );
 941
 942 NTSTATUS
 943 NTAPI
 944 MmWritePageVirtualMemory(
 945     PMMSUPPORT AddressSpace,
 946     PMEMORY_AREA MArea,
 947     PVOID Address,
 948     PFN_NUMBER Page
 949 );
 950
 951 /* kmap.c ********************************************************************/
 952
 953 PVOID
 954 NTAPI
 955 ExAllocatePage(VOID);
 956
 957 VOID
 958 NTAPI
 959 ExUnmapPage(PVOID Addr);
 960
 961 PVOID
 962 NTAPI
 963 ExAllocatePageWithPhysPage(PFN_NUMBER Page);
 964
 965 NTSTATUS
 966 NTAPI
 967 MiCopyFromUserPage(
 968     PFN_NUMBER NewPage,
 969     PFN_NUMBER OldPage
 970 );
 971
 972 NTSTATUS
 973 NTAPI
 974 MiZeroPage(PFN_NUMBER Page);
 975
 976 /* memsafe.s *****************************************************************/
 977
 978 PVOID
 979 FASTCALL
 980 MmSafeReadPtr(PVOID Source);
 981
 982 /* process.c *****************************************************************/
 983
 984 PVOID
 985 NTAPI
 986 MmCreateKernelStack(BOOLEAN GuiStack, UCHAR Node);
 987
 988 VOID
 989 NTAPI
 990 MmDeleteKernelStack(PVOID Stack,
 991                     BOOLEAN GuiStack);
 992
 993 /* balace.c ******************************************************************/
 994
 995 VOID
 996 NTAPI
 997 MmInitializeMemoryConsumer(
 998     ULONG Consumer,
 999     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed)
1000 );
1001
1002 VOID
1003 NTAPI
1004 MmInitializeBalancer(
1005     ULONG NrAvailablePages,
1006     ULONG NrSystemPages
1007 );
1008
1009 NTSTATUS
1010 NTAPI
1011 MmReleasePageMemoryConsumer(
1012     ULONG Consumer,
1013     PFN_NUMBER Page
1014 );
1015
1016 NTSTATUS
1017 NTAPI
1018 MmRequestPageMemoryConsumer(
1019     ULONG Consumer,
1020     BOOLEAN MyWait,
1021     PPFN_NUMBER AllocatedPage
1022 );
1023
1024 VOID
1025 NTAPI
1026 MiInitBalancerThread(VOID);
1027
1028 VOID
1029 NTAPI
1030 MmRebalanceMemoryConsumers(VOID);
1031
1032 /* rmap.c **************************************************************/
1033
1034 VOID
1035 NTAPI
1036 MmSetRmapListHeadPage(
1037     PFN_NUMBER Page,
1038     struct _MM_RMAP_ENTRY* ListHead
1039 );
1040
1041 struct _MM_RMAP_ENTRY*
1042 NTAPI
1043 MmGetRmapListHeadPage(PFN_NUMBER Page);
1044
1045 VOID
1046 NTAPI
1047 MmInsertRmap(
1048     PFN_NUMBER Page,
1049     struct _EPROCESS *Process,
1050     PVOID Address
1051 );
1052
1053 VOID
1054 NTAPI
1055 MmDeleteAllRmaps(
1056     PFN_NUMBER Page,
1057     PVOID Context,
1058     VOID (*DeleteMapping)(PVOID Context, struct _EPROCESS *Process, PVOID Address)
1059 );
1060
1061 VOID
1062 NTAPI
1063 MmDeleteRmap(
1064     PFN_NUMBER Page,
1065     struct _EPROCESS *Process,
1066     PVOID Address
1067 );
1068
1069 VOID
1070 NTAPI
1071 MmInitializeRmapList(VOID);
1072
1073 VOID
1074 NTAPI
1075 MmSetCleanAllRmaps(PFN_NUMBER Page);
1076
1077 VOID
1078 NTAPI
1079 MmSetDirtyAllRmaps(PFN_NUMBER Page);
1080
1081 BOOLEAN
1082 NTAPI
1083 MmIsDirtyPageRmap(PFN_NUMBER Page);
1084
1085 NTSTATUS
1086 NTAPI
1087 MmPageOutPhysicalAddress(PFN_NUMBER Page);
1088
1089 /* freelist.c **********************************************************/
1090
1091 FORCEINLINE
1092 PMMPFN
1093 MiGetPfnEntry(IN PFN_NUMBER Pfn)
1094 {
1095     PMMPFN Page;
1096     extern RTL_BITMAP MiPfnBitMap;
1097
1098     /* Make sure the PFN number is valid */
1099     if (Pfn > MmHighestPhysicalPage) return NULL;
1100
1101     /* Make sure this page actually has a PFN entry */
1102     if ((MiPfnBitMap.Buffer) && !(RtlTestBit(&MiPfnBitMap, (ULONG)Pfn))) return NULL;
1103
1104     /* Get the entry */
1105     Page = &MmPfnDatabase[Pfn];
1106
1107     /* Return it */
1108     return Page;
1109 };
1110
1111 FORCEINLINE
1112 PFN_NUMBER
1113 MiGetPfnEntryIndex(IN PMMPFN Pfn1)
1114 {
1115     //
1116     // This will return the Page Frame Number (PFN) from the MMPFN
1117     //
1118     return Pfn1 - MmPfnDatabase;
1119 }
1120
1121 PFN_NUMBER
1122 NTAPI
1123 MmGetLRUNextUserPage(PFN_NUMBER PreviousPage);
1124
1125 PFN_NUMBER
1126 NTAPI
1127 MmGetLRUFirstUserPage(VOID);
1128
1129 VOID
1130 NTAPI
1131 MmInsertLRULastUserPage(PFN_NUMBER Page);
1132
1133 VOID
1134 NTAPI
1135 MmRemoveLRUUserPage(PFN_NUMBER Page);
1136
1137 VOID
1138 NTAPI
1139 MmLockPage(PFN_NUMBER Page);
1140
1141 VOID
1142 NTAPI
1143 MmUnlockPage(PFN_NUMBER Page);
1144
1145 ULONG
1146 NTAPI
1147 MmGetLockCountPage(PFN_NUMBER Page);
1148
1149 VOID
1150 NTAPI
1151 MmInitializePageList(
1152     VOID
1153 );
1154
1155 VOID
1156 NTAPI
1157 MmDumpArmPfnDatabase(
1158    IN BOOLEAN StatusOnly
1159 );
1160
1161 PFN_NUMBER
1162 NTAPI
1163 MmGetContinuousPages(
1164     ULONG NumberOfBytes,
1165     PHYSICAL_ADDRESS LowestAcceptableAddress,
1166     PHYSICAL_ADDRESS HighestAcceptableAddress,
1167     PHYSICAL_ADDRESS BoundaryAddressMultiple,
1168     BOOLEAN ZeroPages
1169 );
1170
1171 VOID
1172 NTAPI
1173 MmZeroPageThread(
1174     VOID
1175 );
1176
1177 /* hypermap.c *****************************************************************/
1178
1179 extern PEPROCESS HyperProcess;
1180 extern KIRQL HyperIrql;
1181
1182 PVOID
1183 NTAPI
1184 MiMapPageInHyperSpace(IN PEPROCESS Process,
1185                       IN PFN_NUMBER Page,
1186                       IN PKIRQL OldIrql);
1187
1188 VOID
1189 NTAPI
1190 MiUnmapPageInHyperSpace(IN PEPROCESS Process,
1191                         IN PVOID Address,
1192                         IN KIRQL OldIrql);
1193
1194 PVOID
1195 NTAPI
1196 MiMapPagesInZeroSpace(IN PMMPFN Pfn1,
1197                       IN PFN_NUMBER NumberOfPages);
1198
1199 VOID
1200 NTAPI
1201 MiUnmapPagesInZeroSpace(IN PVOID VirtualAddress,
1202                         IN PFN_NUMBER NumberOfPages);
1203
1204 //
1205 // ReactOS Compatibility Layer
1206 //
1207 FORCEINLINE
1208 PVOID
1209 MmCreateHyperspaceMapping(IN PFN_NUMBER Page)
1210 {
1211     HyperProcess = (PEPROCESS)KeGetCurrentThread()->ApcState.Process;
1212     return MiMapPageInHyperSpace(HyperProcess, Page, &HyperIrql);
1213 }
1214
1215 #define MmDeleteHyperspaceMapping(x) MiUnmapPageInHyperSpace(HyperProcess, x, HyperIrql);
1216
1217 /* i386/page.c *********************************************************/
1218
1219 NTSTATUS
1220 NTAPI
1221 MmCreateVirtualMappingForKernel(
1222     PVOID Address,
1223     ULONG flProtect,
1224     PPFN_NUMBER Pages,
1225     ULONG PageCount
1226 );
1227
1228 NTSTATUS
1229 NTAPI
1230 MmCommitPagedPoolAddress(
1231     PVOID Address,
1232     BOOLEAN Locked
1233 );
1234
1235 NTSTATUS
1236 NTAPI
1237 MmCreateVirtualMapping(
1238     struct _EPROCESS* Process,
1239     PVOID Address,
1240     ULONG flProtect,
1241     PPFN_NUMBER Pages,
1242     ULONG PageCount
1243 );
1244
1245 NTSTATUS
1246 NTAPI
1247 MmCreateVirtualMappingUnsafe(
1248     struct _EPROCESS* Process,
1249     PVOID Address,
1250     ULONG flProtect,
1251     PPFN_NUMBER Pages,
1252     ULONG PageCount
1253 );
1254
1255 ULONG
1256 NTAPI
1257 MmGetPageProtect(
1258     struct _EPROCESS* Process,
1259     PVOID Address);
1260
1261 VOID
1262 NTAPI
1263 MmSetPageProtect(
1264     struct _EPROCESS* Process,
1265     PVOID Address,
1266     ULONG flProtect
1267 );
1268
1269 BOOLEAN
1270 NTAPI
1271 MmIsPagePresent(
1272     struct _EPROCESS* Process,
1273     PVOID Address
1274 );
1275
1276 BOOLEAN
1277 NTAPI
1278 MmIsDisabledPage(
1279     struct _EPROCESS* Process,
1280     PVOID Address
1281 );
1282
1283 VOID
1284 NTAPI
1285 MmInitGlobalKernelPageDirectory(VOID);
1286
1287 VOID
1288 NTAPI
1289 MmDisableVirtualMapping(
1290     struct _EPROCESS *Process,
1291     PVOID Address,
1292     BOOLEAN* WasDirty,
1293     PPFN_NUMBER Page
1294 );
1295
1296 VOID
1297 NTAPI
1298 MmEnableVirtualMapping(
1299     struct _EPROCESS *Process,
1300     PVOID Address
1301 );
1302
1303 VOID
1304 NTAPI
1305 MmRawDeleteVirtualMapping(PVOID Address);
1306
1307
1308 VOID
1309 NTAPI
1310 MmGetPageFileMapping(
1311         struct _EPROCESS *Process,
1312         PVOID Address,
1313         SWAPENTRY* SwapEntry);
1314
1315 VOID
1316 NTAPI
1317 MmDeletePageFileMapping(
1318     struct _EPROCESS *Process,
1319     PVOID Address,
1320     SWAPENTRY* SwapEntry
1321 );
1322
1323 NTSTATUS
1324 NTAPI
1325 MmCreatePageFileMapping(
1326     struct _EPROCESS *Process,
1327     PVOID Address,
1328     SWAPENTRY SwapEntry
1329 );
1330
1331 BOOLEAN
1332 NTAPI
1333 MmIsPageSwapEntry(
1334     struct _EPROCESS *Process,
1335     PVOID Address
1336 );
1337
1338 VOID
1339 NTAPI
1340 MmTransferOwnershipPage(
1341     PFN_NUMBER Page,
1342     ULONG NewConsumer
1343 );
1344
1345 VOID
1346 NTAPI
1347 MmSetDirtyPage(
1348     struct _EPROCESS *Process,
1349     PVOID Address
1350 );
1351
1352 PFN_NUMBER
1353 NTAPI
1354 MmAllocPage(
1355     ULONG Consumer
1356 );
1357
1358 LONG
1359 NTAPI
1360 MmAllocPagesSpecifyRange(
1361     ULONG Consumer,
1362     PHYSICAL_ADDRESS LowestAddress,
1363     PHYSICAL_ADDRESS HighestAddress,
1364     ULONG NumberOfPages,
1365     PPFN_NUMBER Pages
1366 );
1367
1368 VOID
1369 NTAPI
1370 MmDereferencePage(PFN_NUMBER Page);
1371
1372 VOID
1373 NTAPI
1374 MmReferencePage(PFN_NUMBER Page);
1375
1376 ULONG
1377 NTAPI
1378 MmGetReferenceCountPage(PFN_NUMBER Page);
1379
1380 BOOLEAN
1381 NTAPI
1382 MmIsPageInUse(PFN_NUMBER Page);
1383
1384 VOID
1385 NTAPI
1386 MmSetSavedSwapEntryPage(
1387     PFN_NUMBER Page,
1388     SWAPENTRY SavedSwapEntry);
1389
1390 SWAPENTRY
1391 NTAPI
1392 MmGetSavedSwapEntryPage(PFN_NUMBER Page);
1393
1394 VOID
1395 NTAPI
1396 MmSetCleanPage(
1397     struct _EPROCESS *Process,
1398     PVOID Address
1399 );
1400
1401 NTSTATUS
1402 NTAPI
1403 MmCreatePageTable(PVOID PAddress);
1404
1405 VOID
1406 NTAPI
1407 MmDeletePageTable(
1408     struct _EPROCESS *Process,
1409     PVOID Address
1410 );
1411
1412 PFN_NUMBER
1413 NTAPI
1414 MmGetPfnForProcess(
1415     struct _EPROCESS *Process,
1416     PVOID Address
1417 );
1418
1419 BOOLEAN
1420 NTAPI
1421 MmCreateProcessAddressSpace(
1422     IN ULONG MinWs,
1423     IN PEPROCESS Dest,
1424     IN PULONG_PTR DirectoryTableBase
1425 );
1426
1427 NTSTATUS
1428 NTAPI
1429 MmInitializeHandBuiltProcess(
1430     IN PEPROCESS Process,
1431     IN PULONG_PTR DirectoryTableBase
1432 );
1433
1434
1435 NTSTATUS
1436 NTAPI
1437 MmInitializeHandBuiltProcess2(
1438     IN PEPROCESS Process
1439 );
1440
1441 NTSTATUS
1442 NTAPI
1443 MmReleaseMmInfo(struct _EPROCESS *Process);
1444
1445 NTSTATUS
1446 NTAPI
1447 MmSetExecuteOptions(IN ULONG ExecuteOptions);
1448
1449 NTSTATUS
1450 NTAPI
1451 MmGetExecuteOptions(IN PULONG ExecuteOptions);
1452
1453 VOID
1454 NTAPI
1455 MmDeleteProcessPageDirectory(struct _EPROCESS *Process);
1456
1457 VOID
1458 NTAPI
1459 MmDeleteVirtualMapping(
1460     struct _EPROCESS *Process,
1461     PVOID Address,
1462     BOOLEAN FreePage,
1463     BOOLEAN* WasDirty,
1464     PPFN_NUMBER Page
1465 );
1466
1467 BOOLEAN
1468 NTAPI
1469 MmIsDirtyPage(
1470     struct _EPROCESS *Process,
1471     PVOID Address
1472 );
1473
1474 VOID
1475 NTAPI
1476 MmMarkPageMapped(PFN_NUMBER Page);
1477
1478 VOID
1479 NTAPI
1480 MmMarkPageUnmapped(PFN_NUMBER Page);
1481
1482 VOID
1483 NTAPI
1484 MmUpdatePageDir(
1485     struct _EPROCESS *Process,
1486     PVOID Address,
1487     ULONG Size
1488 );
1489
1490 VOID
1491 NTAPI
1492 MiInitPageDirectoryMap(VOID);
1493
1494 ULONG
1495 NTAPI
1496 MiGetUserPageDirectoryCount(VOID);
1497
1498 /* wset.c ********************************************************************/
1499
1500 NTSTATUS
1501 MmTrimUserMemory(
1502     ULONG Target,
1503     ULONG Priority,
1504     PULONG NrFreedPages
1505 );
1506
1507 /* region.c ************************************************************/
1508
1509 NTSTATUS
1510 NTAPI
1511 MmAlterRegion(
1512     PMMSUPPORT AddressSpace,
1513     PVOID BaseAddress,
1514     PLIST_ENTRY RegionListHead,
1515     PVOID StartAddress,
1516     SIZE_T Length,
1517     ULONG NewType,
1518     ULONG NewProtect,
1519     PMM_ALTER_REGION_FUNC AlterFunc
1520 );
1521
1522 VOID
1523 NTAPI
1524 MmInitializeRegion(
1525     PLIST_ENTRY RegionListHead,
1526     SIZE_T Length,
1527     ULONG Type,
1528     ULONG Protect
1529 );
1530
1531 PMM_REGION
1532 NTAPI
1533 MmFindRegion(
1534     PVOID BaseAddress,
1535     PLIST_ENTRY RegionListHead,
1536     PVOID Address,
1537     PVOID* RegionBaseAddress
1538 );
1539
1540 /* section.c *****************************************************************/
1541
1542 PFILE_OBJECT
1543 NTAPI
1544 MmGetFileObjectForSection(
1545     IN PVOID Section
1546 );
1547 NTSTATUS
1548 NTAPI
1549 MmGetFileNameForAddress(
1550     IN PVOID Address,
1551     OUT PUNICODE_STRING ModuleName
1552 );
1553
1554 NTSTATUS
1555 NTAPI
1556 MmGetFileNameForSection(
1557     IN PVOID Section,
1558     OUT POBJECT_NAME_INFORMATION *ModuleName
1559 );
1560
1561 PVOID
1562 NTAPI
1563 MmAllocateSection(
1564     IN SIZE_T Length,
1565     PVOID BaseAddress
1566 );
1567
1568 NTSTATUS
1569 NTAPI
1570 MmQuerySectionView(
1571     PMEMORY_AREA MemoryArea,
1572     PVOID Address,
1573     PMEMORY_BASIC_INFORMATION Info,
1574     PSIZE_T ResultLength
1575 );
1576
1577 NTSTATUS
1578 NTAPI
1579 MmProtectSectionView(
1580     PMMSUPPORT AddressSpace,
1581     PMEMORY_AREA MemoryArea,
1582     PVOID BaseAddress,
1583     SIZE_T Length,
1584     ULONG Protect,
1585     PULONG OldProtect
1586 );
1587
1588 NTSTATUS
1589 NTAPI
1590 MmInitSectionImplementation(VOID);
1591
1592 NTSTATUS
1593 NTAPI
1594 MmNotPresentFaultSectionView(
1595     PMMSUPPORT AddressSpace,
1596     MEMORY_AREA* MemoryArea,
1597     PVOID Address,
1598     BOOLEAN Locked
1599 );
1600
1601 NTSTATUS
1602 NTAPI
1603 MmPageOutSectionView(
1604     PMMSUPPORT AddressSpace,
1605     PMEMORY_AREA MemoryArea,
1606     PVOID Address,
1607     ULONG_PTR Entry
1608 );
1609
1610 NTSTATUS
1611 NTAPI
1612 MmCreatePhysicalMemorySection(VOID);
1613
1614 NTSTATUS
1615 NTAPI
1616 MmAccessFaultSectionView(
1617     PMMSUPPORT AddressSpace,
1618     MEMORY_AREA* MemoryArea,
1619     PVOID Address
1620 );
1621
1622 VOID
1623 NTAPI
1624 MmFreeSectionSegments(PFILE_OBJECT FileObject);
1625
1626 /* mpw.c *********************************************************************/
1627
1628 NTSTATUS
1629 NTAPI
1630 MmInitMpwThread(VOID);
1631
1632 NTSTATUS
1633 NTAPI
1634 MmInitBsmThread(VOID);
1635
1636 /* pager.c *******************************************************************/
1637
1638 BOOLEAN
1639 NTAPI
1640 MiIsPagerThread(VOID);
1641
1642 VOID
1643 NTAPI
1644 MiStartPagerThread(VOID);
1645
1646 VOID
1647 NTAPI
1648 MiStopPagerThread(VOID);
1649
1650 NTSTATUS
1651 FASTCALL
1652 MiQueryVirtualMemory(
1653     IN HANDLE ProcessHandle,
1654     IN PVOID Address,
1655     IN MEMORY_INFORMATION_CLASS VirtualMemoryInformationClass,
1656     OUT PVOID VirtualMemoryInformation,
1657     IN SIZE_T Length,
1658     OUT PSIZE_T ResultLength
1659 );
1660
1661 /* sysldr.c ******************************************************************/
1662
1663 VOID
1664 NTAPI
1665 MiReloadBootLoadedDrivers(
1666     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1667 );
1668
1669 BOOLEAN
1670 NTAPI
1671 MiInitializeLoadedModuleList(
1672     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1673 );
1674
1675 NTSTATUS
1676 NTAPI
1677 MmLoadSystemImage(
1678     IN PUNICODE_STRING FileName,
1679     IN PUNICODE_STRING NamePrefix OPTIONAL,
1680     IN PUNICODE_STRING LoadedName OPTIONAL,
1681     IN ULONG Flags,
1682     OUT PVOID *ModuleObject,
1683     OUT PVOID *ImageBaseAddress
1684 );
1685
1686 NTSTATUS
1687 NTAPI
1688 MmUnloadSystemImage(
1689     IN PVOID ImageHandle
1690 );
1691
1692 NTSTATUS
1693 NTAPI
1694 MmCheckSystemImage(
1695     IN HANDLE ImageHandle,
1696     IN BOOLEAN PurgeSection
1697 );
1698
1699 NTSTATUS
1700 NTAPI
1701 MmCallDllInitialize(
1702     IN PLDR_DATA_TABLE_ENTRY LdrEntry,
1703     IN PLIST_ENTRY ListHead
1704 );
1705
1706
1707 /* procsup.c *****************************************************************/
1708
1709 NTSTATUS
1710 NTAPI
1711 MmGrowKernelStack(
1712     IN PVOID StackPointer
1713 );
1714
1715
1716 FORCEINLINE
1717 VOID
1718 MmLockAddressSpace(PMMSUPPORT AddressSpace)
1719 {
1720     KeAcquireGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1721 }
1722
1723 FORCEINLINE
1724 VOID
1725 MmUnlockAddressSpace(PMMSUPPORT AddressSpace)
1726 {
1727     KeReleaseGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1728 }
1729
1730 FORCEINLINE
1731 PEPROCESS
1732 MmGetAddressSpaceOwner(IN PMMSUPPORT AddressSpace)
1733 {
1734     if (AddressSpace == MmKernelAddressSpace) return NULL;
1735     return CONTAINING_RECORD(AddressSpace, EPROCESS, Vm);
1736 }
1737
1738 FORCEINLINE
1739 PMMSUPPORT
1740 MmGetCurrentAddressSpace(VOID)
1741 {
1742     return &((PEPROCESS)KeGetCurrentThread()->ApcState.Process)->Vm;
1743 }
1744
1745 FORCEINLINE
1746 PMMSUPPORT
1747 MmGetKernelAddressSpace(VOID)
1748 {
1749     return MmKernelAddressSpace;
1750 }