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 PFN_COUNT MmNumberOfPhysicalPages;
  13 extern UCHAR MmDisablePagingExecutive;
  14 extern PFN_NUMBER MmLowestPhysicalPage;
  15 extern PFN_NUMBER MmHighestPhysicalPage;
  16 extern PFN_NUMBER MmAvailablePages;
  17 extern PFN_NUMBER MmResidentAvailablePages;
  18
  19 extern LIST_ENTRY MmLoadedUserImageList;
  20
  21 extern KMUTANT MmSystemLoadLock;
  22
  23 extern ULONG MmNumberOfPagingFiles;
  24
  25 extern PVOID MmUnloadedDrivers;
  26 extern PVOID MmLastUnloadedDrivers;
  27 extern PVOID MmTriageActionTaken;
  28 extern PVOID KernelVerifier;
  29 extern MM_DRIVER_VERIFIER_DATA MmVerifierData;
  30
  31 extern SIZE_T MmTotalCommitLimit;
  32 extern SIZE_T MmTotalCommittedPages;
  33 extern SIZE_T MmSharedCommit;
  34 extern SIZE_T MmDriverCommit;
  35 extern SIZE_T MmProcessCommit;
  36 extern SIZE_T MmPagedPoolCommit;
  37 extern SIZE_T MmPeakCommitment;
  38 extern SIZE_T MmtotalCommitLimitMaximum;
  39
  40 extern PVOID MiDebugMapping; // internal
  41 extern PMMPTE MmDebugPte; // internal
  42
  43 struct _KTRAP_FRAME;
  44 struct _EPROCESS;
  45 struct _MM_RMAP_ENTRY;
  46 typedef ULONG_PTR SWAPENTRY;
  47
  48 //
  49 // MmDbgCopyMemory Flags
  50 //
  51 #define MMDBG_COPY_WRITE            0x00000001
  52 #define MMDBG_COPY_PHYSICAL         0x00000002
  53 #define MMDBG_COPY_UNSAFE           0x00000004
  54 #define MMDBG_COPY_CACHED           0x00000008
  55 #define MMDBG_COPY_UNCACHED         0x00000010
  56 #define MMDBG_COPY_WRITE_COMBINED   0x00000020
  57
  58 //
  59 // Maximum chunk size per copy
  60 //
  61 #define MMDBG_COPY_MAX_SIZE         0x8
  62
  63 #if defined(_X86_) // intenal for marea.c
  64 #define MI_STATIC_MEMORY_AREAS              (14)
  65 #else
  66 #define MI_STATIC_MEMORY_AREAS              (13)
  67 #endif
  68
  69 #define MEMORY_AREA_SECTION_VIEW            (1)
  70 #define MEMORY_AREA_CACHE                   (2)
  71 #define MEMORY_AREA_OWNED_BY_ARM3           (15)
  72 #define MEMORY_AREA_STATIC                  (0x80000000)
  73
  74 /* Although Microsoft says this isn't hardcoded anymore,
  75    they won't be able to change it. Stuff depends on it */
  76 #define MM_VIRTMEM_GRANULARITY              (64 * 1024)
  77
  78 #define STATUS_MM_RESTART_OPERATION         ((NTSTATUS)0xD0000001)
  79
  80 /*
  81  * Additional flags for protection attributes
  82  */
  83 #define PAGE_WRITETHROUGH                   (1024)
  84 #define PAGE_SYSTEM                         (2048)
  85
  86 #define SEC_PHYSICALMEMORY                  (0x80000000)
  87
  88 #define MM_PAGEFILE_SEGMENT                 (0x1)
  89 #define MM_DATAFILE_SEGMENT                 (0x2)
  90
  91 #define MC_CACHE                            (0)
  92 #define MC_USER                             (1)
  93 #define MC_SYSTEM                           (2)
  94 #define MC_MAXIMUM                          (3)
  95
  96 #define PAGED_POOL_MASK                     1
  97 #define MUST_SUCCEED_POOL_MASK              2
  98 #define CACHE_ALIGNED_POOL_MASK             4
  99 #define QUOTA_POOL_MASK                     8
 100 #define SESSION_POOL_MASK                   32
 101 #define VERIFIER_POOL_MASK                  64
 102
 103 // FIXME: use ALIGN_UP_BY
 104 #define MM_ROUND_UP(x,s)                    \
 105     ((PVOID)(((ULONG_PTR)(x)+(s)-1) & ~((ULONG_PTR)(s)-1)))
 106
 107 #define MM_ROUND_DOWN(x,s)                  \
 108     ((PVOID)(((ULONG_PTR)(x)) & ~((ULONG_PTR)(s)-1)))
 109
 110 #define PAGE_FLAGS_VALID_FOR_SECTION \
 111     (PAGE_READONLY | \
 112      PAGE_READWRITE | \
 113      PAGE_WRITECOPY | \
 114      PAGE_EXECUTE | \
 115      PAGE_EXECUTE_READ | \
 116      PAGE_EXECUTE_READWRITE | \
 117      PAGE_EXECUTE_WRITECOPY | \
 118      PAGE_NOACCESS)
 119
 120 #define PAGE_IS_READABLE                    \
 121     (PAGE_READONLY | \
 122     PAGE_READWRITE | \
 123     PAGE_WRITECOPY | \
 124     PAGE_EXECUTE_READ | \
 125     PAGE_EXECUTE_READWRITE | \
 126     PAGE_EXECUTE_WRITECOPY)
 127
 128 #define PAGE_IS_WRITABLE                    \
 129     (PAGE_READWRITE | \
 130     PAGE_WRITECOPY | \
 131     PAGE_EXECUTE_READWRITE | \
 132     PAGE_EXECUTE_WRITECOPY)
 133
 134 #define PAGE_IS_EXECUTABLE                  \
 135     (PAGE_EXECUTE | \
 136     PAGE_EXECUTE_READ | \
 137     PAGE_EXECUTE_READWRITE | \
 138     PAGE_EXECUTE_WRITECOPY)
 139
 140 #define PAGE_IS_WRITECOPY                   \
 141     (PAGE_WRITECOPY | \
 142     PAGE_EXECUTE_WRITECOPY)
 143
 144 //
 145 // Wait entry for marking pages that are being serviced
 146 //
 147 #define MM_WAIT_ENTRY            0x7ffffc00
 148
 149 #define InterlockedCompareExchangePte(PointerPte, Exchange, Comperand) \
 150     InterlockedCompareExchange((PLONG)(PointerPte), Exchange, Comperand)
 151
 152 #define InterlockedExchangePte(PointerPte, Value) \
 153     InterlockedExchange((PLONG)(PointerPte), Value)
 154
 155 typedef struct _MM_SECTION_SEGMENT
 156 {
 157     FAST_MUTEX Lock;            /* lock which protects the page directory */
 158         PFILE_OBJECT FileObject;
 159     LARGE_INTEGER RawLength;            /* length of the segment which is part of the mapped file */
 160     LARGE_INTEGER Length;                       /* absolute length of the segment */
 161     ULONG ReferenceCount;
 162         ULONG CacheCount;
 163     ULONG Protection;
 164     ULONG Flags;
 165     BOOLEAN WriteCopy;
 166         BOOLEAN Locked;
 167
 168         struct
 169         {
 170                 ULONGLONG FileOffset;           /* start offset into the file for image sections */
 171                 ULONG_PTR VirtualAddress;       /* start offset into the address range for image sections */
 172                 ULONG Characteristics;
 173         } Image;
 174
 175         LIST_ENTRY ListOfSegments;
 176         RTL_GENERIC_TABLE PageTable;
 177 } MM_SECTION_SEGMENT, *PMM_SECTION_SEGMENT;
 178
 179 typedef struct _MM_IMAGE_SECTION_OBJECT
 180 {
 181     SECTION_IMAGE_INFORMATION ImageInformation;
 182     PVOID BasedAddress;
 183     ULONG NrSegments;
 184     PMM_SECTION_SEGMENT Segments;
 185 } MM_IMAGE_SECTION_OBJECT, *PMM_IMAGE_SECTION_OBJECT;
 186
 187 typedef struct _ROS_SECTION_OBJECT
 188 {
 189     CSHORT Type;
 190     CSHORT Size;
 191     LARGE_INTEGER MaximumSize;
 192     ULONG SectionPageProtection;
 193     ULONG AllocationAttributes;
 194     PFILE_OBJECT FileObject;
 195     union
 196     {
 197         PMM_IMAGE_SECTION_OBJECT ImageSection;
 198         PMM_SECTION_SEGMENT Segment;
 199     };
 200 } ROS_SECTION_OBJECT, *PROS_SECTION_OBJECT;
 201
 202 typedef struct _MEMORY_AREA
 203 {
 204     PVOID StartingAddress;
 205     PVOID EndingAddress;
 206     struct _MEMORY_AREA *Parent;
 207     struct _MEMORY_AREA *LeftChild;
 208     struct _MEMORY_AREA *RightChild;
 209     ULONG Type;
 210     ULONG Protect;
 211     ULONG Flags;
 212     BOOLEAN DeleteInProgress;
 213     ULONG Magic;
 214     PVOID Vad;
 215     union
 216     {
 217         struct
 218         {
 219             ROS_SECTION_OBJECT* Section;
 220             LARGE_INTEGER ViewOffset;
 221             PMM_SECTION_SEGMENT Segment;
 222             LIST_ENTRY RegionListHead;
 223         } SectionData;
 224         struct
 225         {
 226             LIST_ENTRY RegionListHead;
 227         } VirtualMemoryData;
 228     } Data;
 229 } MEMORY_AREA, *PMEMORY_AREA;
 230
 231 typedef struct _MM_RMAP_ENTRY
 232 {
 233    struct _MM_RMAP_ENTRY* Next;
 234    PEPROCESS Process;
 235    PVOID Address;
 236 #if DBG
 237    PVOID Caller;
 238 #endif
 239 }
 240 MM_RMAP_ENTRY, *PMM_RMAP_ENTRY;
 241
 242 #if MI_TRACE_PFNS
 243 extern ULONG MI_PFN_CURRENT_USAGE;
 244 extern CHAR MI_PFN_CURRENT_PROCESS_NAME[16];
 245 #define MI_SET_USAGE(x)     MI_PFN_CURRENT_USAGE = x
 246 #define MI_SET_PROCESS2(x)  memcpy(MI_PFN_CURRENT_PROCESS_NAME, x, 16)
 247 #else
 248 #define MI_SET_USAGE(x)
 249 #define MI_SET_PROCESS2(x)
 250 #endif
 251
 252 typedef enum _MI_PFN_USAGES
 253 {
 254     MI_USAGE_NOT_SET = 0,
 255     MI_USAGE_PAGED_POOL,
 256     MI_USAGE_NONPAGED_POOL,
 257     MI_USAGE_NONPAGED_POOL_EXPANSION,
 258     MI_USAGE_KERNEL_STACK,
 259     MI_USAGE_KERNEL_STACK_EXPANSION,
 260     MI_USAGE_SYSTEM_PTE,
 261     MI_USAGE_VAD,
 262     MI_USAGE_PEB_TEB,
 263     MI_USAGE_SECTION,
 264     MI_USAGE_PAGE_TABLE,
 265     MI_USAGE_PAGE_DIRECTORY,
 266     MI_USAGE_LEGACY_PAGE_DIRECTORY,
 267     MI_USAGE_DRIVER_PAGE,
 268     MI_USAGE_CONTINOUS_ALLOCATION,
 269     MI_USAGE_MDL,
 270     MI_USAGE_DEMAND_ZERO,
 271     MI_USAGE_ZERO_LOOP,
 272     MI_USAGE_CACHE,
 273     MI_USAGE_PFN_DATABASE,
 274     MI_USAGE_BOOT_DRIVER,
 275     MI_USAGE_INIT_MEMORY,
 276     MI_USAGE_FREE_PAGE
 277 } MI_PFN_USAGES;
 278
 279 //
 280 // These two mappings are actually used by Windows itself, based on the ASSERTS
 281 //
 282 #define StartOfAllocation ReadInProgress
 283 #define EndOfAllocation WriteInProgress
 284
 285 typedef struct _MMPFNENTRY
 286 {
 287     USHORT Modified:1;
 288     USHORT ReadInProgress:1;                 // StartOfAllocation
 289     USHORT WriteInProgress:1;                // EndOfAllocation
 290     USHORT PrototypePte:1;
 291     USHORT PageColor:4;
 292     USHORT PageLocation:3;
 293     USHORT RemovalRequested:1;
 294     USHORT CacheAttribute:2;
 295     USHORT Rom:1;
 296     USHORT ParityError:1;
 297 } MMPFNENTRY;
 298
 299 // Mm internal
 300 typedef struct _MMPFN
 301 {
 302     union
 303     {
 304         PFN_NUMBER Flink;
 305         ULONG WsIndex;
 306         PKEVENT Event;
 307         NTSTATUS ReadStatus;
 308         SINGLE_LIST_ENTRY NextStackPfn;
 309
 310         // HACK for ROSPFN
 311         SWAPENTRY SwapEntry;
 312     } u1;
 313     PMMPTE PteAddress;
 314     union
 315     {
 316         PFN_NUMBER Blink;
 317         ULONG_PTR ShareCount;
 318     } u2;
 319     union
 320     {
 321         struct
 322         {
 323             USHORT ReferenceCount;
 324             MMPFNENTRY e1;
 325         };
 326         struct
 327         {
 328             USHORT ReferenceCount;
 329             USHORT ShortFlags;
 330         } e2;
 331     } u3;
 332     union
 333     {
 334         MMPTE OriginalPte;
 335         LONG AweReferenceCount;
 336
 337         // HACK for ROSPFN
 338         PMM_RMAP_ENTRY RmapListHead;
 339     };
 340     union
 341     {
 342         ULONG_PTR EntireFrame;
 343         struct
 344         {
 345             ULONG_PTR PteFrame:25;
 346             ULONG_PTR InPageError:1;
 347             ULONG_PTR VerifierAllocation:1;
 348             ULONG_PTR AweAllocation:1;
 349             ULONG_PTR Priority:3;
 350             ULONG_PTR MustBeCached:1;
 351         };
 352     } u4;
 353 #if MI_TRACE_PFNS
 354     MI_PFN_USAGES PfnUsage;
 355     CHAR ProcessName[16];
 356 #endif
 357
 358     // HACK until WS lists are supported
 359     MMWSLE Wsle;
 360 } MMPFN, *PMMPFN;
 361
 362 extern PMMPFN MmPfnDatabase;
 363
 364 typedef struct _MMPFNLIST
 365 {
 366     PFN_NUMBER Total;
 367     MMLISTS ListName;
 368     PFN_NUMBER Flink;
 369     PFN_NUMBER Blink;
 370 } MMPFNLIST, *PMMPFNLIST;
 371
 372 extern MMPFNLIST MmZeroedPageListHead;
 373 extern MMPFNLIST MmFreePageListHead;
 374 extern MMPFNLIST MmStandbyPageListHead;
 375 extern MMPFNLIST MmModifiedPageListHead;
 376 extern MMPFNLIST MmModifiedNoWritePageListHead;
 377
 378 typedef struct _MM_MEMORY_CONSUMER
 379 {
 380     ULONG PagesUsed;
 381     ULONG PagesTarget;
 382     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed);
 383 } MM_MEMORY_CONSUMER, *PMM_MEMORY_CONSUMER;
 384
 385 typedef struct _MM_REGION
 386 {
 387     ULONG Type;
 388     ULONG Protect;
 389     SIZE_T Length;
 390     LIST_ENTRY RegionListEntry;
 391 } MM_REGION, *PMM_REGION;
 392
 393 // Mm internal
 394 /* Entry describing free pool memory */
 395 typedef struct _MMFREE_POOL_ENTRY
 396 {
 397     LIST_ENTRY List;
 398     PFN_COUNT Size;
 399     ULONG Signature;
 400     struct _MMFREE_POOL_ENTRY *Owner;
 401 } MMFREE_POOL_ENTRY, *PMMFREE_POOL_ENTRY;
 402
 403 /* Signature of a freed block */
 404 #define MM_FREE_POOL_SIGNATURE 'ARM3'
 405
 406 /* Paged pool information */
 407 typedef struct _MM_PAGED_POOL_INFO
 408 {
 409     PRTL_BITMAP PagedPoolAllocationMap;
 410     PRTL_BITMAP EndOfPagedPoolBitmap;
 411     PMMPTE FirstPteForPagedPool;
 412     PMMPTE LastPteForPagedPool;
 413     PMMPDE NextPdeForPagedPoolExpansion;
 414     ULONG PagedPoolHint;
 415     SIZE_T PagedPoolCommit;
 416     SIZE_T AllocatedPagedPool;
 417 } MM_PAGED_POOL_INFO, *PMM_PAGED_POOL_INFO;
 418
 419 extern MM_MEMORY_CONSUMER MiMemoryConsumers[MC_MAXIMUM];
 420
 421 typedef VOID
 422 (*PMM_ALTER_REGION_FUNC)(
 423     PMMSUPPORT AddressSpace,
 424     PVOID BaseAddress,
 425     SIZE_T Length,
 426     ULONG OldType,
 427     ULONG OldProtect,
 428     ULONG NewType,
 429     ULONG NewProtect
 430 );
 431
 432 typedef VOID
 433 (*PMM_FREE_PAGE_FUNC)(
 434     PVOID Context,
 435     PMEMORY_AREA MemoryArea,
 436     PVOID Address,
 437     PFN_NUMBER Page,
 438     SWAPENTRY SwapEntry,
 439     BOOLEAN Dirty
 440 );
 441
 442 //
 443 // Mm copy support for Kd
 444 //
 445 NTSTATUS
 446 NTAPI
 447 MmDbgCopyMemory(
 448     IN ULONG64 Address,
 449     IN PVOID Buffer,
 450     IN ULONG Size,
 451     IN ULONG Flags
 452 );
 453
 454 //
 455 // Determines if a given address is a session address
 456 //
 457 BOOLEAN
 458 NTAPI
 459 MmIsSessionAddress(
 460     IN PVOID Address
 461 );
 462
 463 ULONG
 464 NTAPI
 465 MmGetSessionId(
 466     IN PEPROCESS Process
 467 );
 468
 469 ULONG
 470 NTAPI
 471 MmGetSessionIdEx(
 472     IN PEPROCESS Process
 473 );
 474
 475 /* marea.c *******************************************************************/
 476
 477 NTSTATUS
 478 NTAPI
 479 MmCreateMemoryArea(
 480     PMMSUPPORT AddressSpace,
 481     ULONG Type,
 482     PVOID *BaseAddress,
 483     SIZE_T Length,
 484     ULONG Protection,
 485     PMEMORY_AREA *Result,
 486     BOOLEAN FixedAddress,
 487     ULONG AllocationFlags,
 488     ULONG AllocationGranularity
 489 );
 490
 491 PMEMORY_AREA
 492 NTAPI
 493 MmLocateMemoryAreaByAddress(
 494     PMMSUPPORT AddressSpace,
 495     PVOID Address
 496 );
 497
 498 // fixme: unused?
 499 ULONG_PTR
 500 NTAPI
 501 MmFindGapAtAddress_(
 502     PMMSUPPORT AddressSpace,
 503     PVOID Address
 504 );
 505
 506 NTSTATUS
 507 NTAPI
 508 MmFreeMemoryArea(
 509     PMMSUPPORT AddressSpace,
 510     PMEMORY_AREA MemoryArea,
 511     PMM_FREE_PAGE_FUNC FreePage,
 512     PVOID FreePageContext
 513 );
 514
 515 NTSTATUS
 516 NTAPI
 517 MmFreeMemoryAreaByPtr(
 518     PMMSUPPORT AddressSpace,
 519     PVOID BaseAddress,
 520     PMM_FREE_PAGE_FUNC FreePage,
 521     PVOID FreePageContext
 522 );
 523
 524 PMEMORY_AREA
 525 NTAPI
 526 MmLocateMemoryAreaByRegion(
 527     PMMSUPPORT AddressSpace,
 528     PVOID Address,
 529     SIZE_T Length
 530 );
 531
 532 PVOID
 533 NTAPI
 534 MmFindGap(
 535     PMMSUPPORT AddressSpace,
 536     SIZE_T Length,
 537     ULONG_PTR Granularity,
 538     BOOLEAN TopDown
 539 );
 540
 541 VOID
 542 NTAPI
 543 MiRosCheckMemoryAreas(
 544    PMMSUPPORT AddressSpace);
 545
 546 VOID
 547 NTAPI
 548 MiCheckAllProcessMemoryAreas(VOID);
 549
 550 /* npool.c *******************************************************************/
 551
 552 VOID
 553 NTAPI
 554 MiInitializeNonPagedPool(VOID);
 555
 556 PVOID
 557 NTAPI
 558 MiAllocatePoolPages(
 559     IN POOL_TYPE PoolType,
 560     IN SIZE_T SizeInBytes
 561 );
 562
 563 POOL_TYPE
 564 NTAPI
 565 MmDeterminePoolType(
 566     IN PVOID VirtualAddress
 567 );
 568
 569 ULONG
 570 NTAPI
 571 MiFreePoolPages(
 572     IN PVOID StartingAddress
 573 );
 574
 575 /* pool.c *******************************************************************/
 576
 577 BOOLEAN
 578 NTAPI
 579 MiRaisePoolQuota(
 580     IN POOL_TYPE PoolType,
 581     IN ULONG CurrentMaxQuota,
 582     OUT PULONG NewMaxQuota
 583 );
 584
 585 /* mdl.c *********************************************************************/
 586
 587 VOID
 588 NTAPI
 589 MmBuildMdlFromPages(
 590     PMDL Mdl,
 591     PPFN_NUMBER Pages
 592 );
 593
 594 /* mminit.c ******************************************************************/
 595
 596 VOID
 597 NTAPI
 598 MmInit1(
 599     VOID
 600 );
 601
 602 BOOLEAN
 603 NTAPI
 604 MmInitSystem(IN ULONG Phase,
 605              IN PLOADER_PARAMETER_BLOCK LoaderBlock);
 606
 607
 608 /* pagefile.c ****************************************************************/
 609
 610 SWAPENTRY
 611 NTAPI
 612 MmAllocSwapPage(VOID);
 613
 614 VOID
 615 NTAPI
 616 MmFreeSwapPage(SWAPENTRY Entry);
 617
 618 VOID
 619 NTAPI
 620 MmInitPagingFile(VOID);
 621
 622 BOOLEAN
 623 NTAPI
 624 MmIsFileObjectAPagingFile(PFILE_OBJECT FileObject);
 625
 626 NTSTATUS
 627 NTAPI
 628 MmReadFromSwapPage(
 629     SWAPENTRY SwapEntry,
 630     PFN_NUMBER Page
 631 );
 632
 633 NTSTATUS
 634 NTAPI
 635 MmWriteToSwapPage(
 636     SWAPENTRY SwapEntry,
 637     PFN_NUMBER Page
 638 );
 639
 640 VOID
 641 NTAPI
 642 MmShowOutOfSpaceMessagePagingFile(VOID);
 643
 644 NTSTATUS
 645 NTAPI
 646 MiReadPageFile(
 647     _In_ PFN_NUMBER Page,
 648     _In_ ULONG PageFileIndex,
 649     _In_ ULONG_PTR PageFileOffset);
 650
 651 /* process.c ****************************************************************/
 652
 653 NTSTATUS
 654 NTAPI
 655 MmInitializeProcessAddressSpace(
 656     IN PEPROCESS Process,
 657     IN PEPROCESS Clone OPTIONAL,
 658     IN PVOID Section OPTIONAL,
 659     IN OUT PULONG Flags,
 660     IN POBJECT_NAME_INFORMATION *AuditName OPTIONAL
 661 );
 662
 663 NTSTATUS
 664 NTAPI
 665 MmCreatePeb(
 666     IN PEPROCESS Process,
 667     IN PINITIAL_PEB InitialPeb,
 668     OUT PPEB *BasePeb
 669 );
 670
 671 NTSTATUS
 672 NTAPI
 673 MmCreateTeb(
 674     IN PEPROCESS Process,
 675     IN PCLIENT_ID ClientId,
 676     IN PINITIAL_TEB InitialTeb,
 677     OUT PTEB* BaseTeb
 678 );
 679
 680 VOID
 681 NTAPI
 682 MmDeleteTeb(
 683     struct _EPROCESS *Process,
 684     PTEB Teb
 685 );
 686
 687 VOID
 688 NTAPI
 689 MmCleanProcessAddressSpace(IN PEPROCESS Process);
 690
 691 NTSTATUS
 692 NTAPI
 693 MmDeleteProcessAddressSpace(IN PEPROCESS Process);
 694
 695 ULONG
 696 NTAPI
 697 MmGetSessionLocaleId(VOID);
 698
 699 NTSTATUS
 700 NTAPI
 701 MmSetMemoryPriorityProcess(
 702     IN PEPROCESS Process,
 703     IN UCHAR MemoryPriority
 704 );
 705
 706 /* i386/pfault.c *************************************************************/
 707
 708 NTSTATUS
 709 NTAPI
 710 MmPageFault(
 711     ULONG Cs,
 712     PULONG Eip,
 713     PULONG Eax,
 714     ULONG Cr2,
 715     ULONG ErrorCode
 716 );
 717
 718 /* special.c *****************************************************************/
 719
 720 VOID
 721 NTAPI
 722 MiInitializeSpecialPool();
 723
 724 BOOLEAN
 725 NTAPI
 726 MmUseSpecialPool(
 727     IN SIZE_T NumberOfBytes,
 728     IN ULONG Tag);
 729
 730 BOOLEAN
 731 NTAPI
 732 MmIsSpecialPoolAddress(
 733     IN PVOID P);
 734
 735 PVOID
 736 NTAPI
 737 MmAllocateSpecialPool(
 738     IN SIZE_T NumberOfBytes,
 739     IN ULONG Tag,
 740     IN POOL_TYPE PoolType,
 741     IN ULONG SpecialType);
 742
 743 VOID
 744 NTAPI
 745 MmFreeSpecialPool(
 746     IN PVOID P);
 747
 748 /* mm.c **********************************************************************/
 749
 750 NTSTATUS
 751 NTAPI
 752 MmAccessFault(
 753     IN BOOLEAN StoreInstruction,
 754     IN PVOID Address,
 755     IN KPROCESSOR_MODE Mode,
 756     IN PVOID TrapInformation
 757 );
 758
 759 /* kmap.c ********************************************************************/
 760
 761 NTSTATUS
 762 NTAPI
 763 MiCopyFromUserPage(
 764     PFN_NUMBER NewPage,
 765     PFN_NUMBER OldPage
 766 );
 767
 768 /* process.c *****************************************************************/
 769
 770 PVOID
 771 NTAPI
 772 MmCreateKernelStack(BOOLEAN GuiStack, UCHAR Node);
 773
 774 VOID
 775 NTAPI
 776 MmDeleteKernelStack(PVOID Stack,
 777                     BOOLEAN GuiStack);
 778
 779 /* balace.c ******************************************************************/
 780
 781 VOID
 782 NTAPI
 783 MmInitializeMemoryConsumer(
 784     ULONG Consumer,
 785     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed)
 786 );
 787
 788 VOID
 789 NTAPI
 790 MmInitializeBalancer(
 791     ULONG NrAvailablePages,
 792     ULONG NrSystemPages
 793 );
 794
 795 NTSTATUS
 796 NTAPI
 797 MmReleasePageMemoryConsumer(
 798     ULONG Consumer,
 799     PFN_NUMBER Page
 800 );
 801
 802 NTSTATUS
 803 NTAPI
 804 MmRequestPageMemoryConsumer(
 805     ULONG Consumer,
 806     BOOLEAN MyWait,
 807     PPFN_NUMBER AllocatedPage
 808 );
 809
 810 VOID
 811 NTAPI
 812 MiInitBalancerThread(VOID);
 813
 814 VOID
 815 NTAPI
 816 MmRebalanceMemoryConsumers(VOID);
 817
 818 /* rmap.c **************************************************************/
 819
 820 VOID
 821 NTAPI
 822 MmSetRmapListHeadPage(
 823     PFN_NUMBER Page,
 824     struct _MM_RMAP_ENTRY* ListHead
 825 );
 826
 827 struct _MM_RMAP_ENTRY*
 828 NTAPI
 829 MmGetRmapListHeadPage(PFN_NUMBER Page);
 830
 831 VOID
 832 NTAPI
 833 MmInsertRmap(
 834     PFN_NUMBER Page,
 835     struct _EPROCESS *Process,
 836     PVOID Address
 837 );
 838
 839 VOID
 840 NTAPI
 841 MmDeleteAllRmaps(
 842     PFN_NUMBER Page,
 843     PVOID Context,
 844     VOID (*DeleteMapping)(PVOID Context, struct _EPROCESS *Process, PVOID Address)
 845 );
 846
 847 VOID
 848 NTAPI
 849 MmDeleteRmap(
 850     PFN_NUMBER Page,
 851     struct _EPROCESS *Process,
 852     PVOID Address
 853 );
 854
 855 VOID
 856 NTAPI
 857 MmInitializeRmapList(VOID);
 858
 859 VOID
 860 NTAPI
 861 MmSetCleanAllRmaps(PFN_NUMBER Page);
 862
 863 VOID
 864 NTAPI
 865 MmSetDirtyAllRmaps(PFN_NUMBER Page);
 866
 867 BOOLEAN
 868 NTAPI
 869 MmIsDirtyPageRmap(PFN_NUMBER Page);
 870
 871 NTSTATUS
 872 NTAPI
 873 MmPageOutPhysicalAddress(PFN_NUMBER Page);
 874
 875 /* freelist.c **********************************************************/
 876
 877 FORCEINLINE
 878 PMMPFN
 879 MiGetPfnEntry(IN PFN_NUMBER Pfn)
 880 {
 881     PMMPFN Page;
 882     extern RTL_BITMAP MiPfnBitMap;
 883
 884     /* Make sure the PFN number is valid */
 885     if (Pfn > MmHighestPhysicalPage) return NULL;
 886
 887     /* Make sure this page actually has a PFN entry */
 888     if ((MiPfnBitMap.Buffer) && !(RtlTestBit(&MiPfnBitMap, (ULONG)Pfn))) return NULL;
 889
 890     /* Get the entry */
 891     Page = &MmPfnDatabase[Pfn];
 892
 893     /* Return it */
 894     return Page;
 895 };
 896
 897 FORCEINLINE
 898 PFN_NUMBER
 899 MiGetPfnEntryIndex(IN PMMPFN Pfn1)
 900 {
 901     //
 902     // This will return the Page Frame Number (PFN) from the MMPFN
 903     //
 904     return Pfn1 - MmPfnDatabase;
 905 }
 906
 907 PFN_NUMBER
 908 NTAPI
 909 MmGetLRUNextUserPage(PFN_NUMBER PreviousPage);
 910
 911 PFN_NUMBER
 912 NTAPI
 913 MmGetLRUFirstUserPage(VOID);
 914
 915 VOID
 916 NTAPI
 917 MmInsertLRULastUserPage(PFN_NUMBER Page);
 918
 919 VOID
 920 NTAPI
 921 MmRemoveLRUUserPage(PFN_NUMBER Page);
 922
 923 VOID
 924 NTAPI
 925 MmDumpArmPfnDatabase(
 926    IN BOOLEAN StatusOnly
 927 );
 928
 929 VOID
 930 NTAPI
 931 MmZeroPageThread(
 932     VOID
 933 );
 934
 935 /* hypermap.c *****************************************************************/
 936
 937 extern PEPROCESS HyperProcess;
 938 extern KIRQL HyperIrql;
 939
 940 PVOID
 941 NTAPI
 942 MiMapPageInHyperSpace(IN PEPROCESS Process,
 943                       IN PFN_NUMBER Page,
 944                       IN PKIRQL OldIrql);
 945
 946 VOID
 947 NTAPI
 948 MiUnmapPageInHyperSpace(IN PEPROCESS Process,
 949                         IN PVOID Address,
 950                         IN KIRQL OldIrql);
 951
 952 PVOID
 953 NTAPI
 954 MiMapPagesInZeroSpace(IN PMMPFN Pfn1,
 955                       IN PFN_NUMBER NumberOfPages);
 956
 957 VOID
 958 NTAPI
 959 MiUnmapPagesInZeroSpace(IN PVOID VirtualAddress,
 960                         IN PFN_NUMBER NumberOfPages);
 961
 962 //
 963 // ReactOS Compatibility Layer
 964 //
 965 FORCEINLINE
 966 PVOID
 967 MmCreateHyperspaceMapping(IN PFN_NUMBER Page)
 968 {
 969     HyperProcess = (PEPROCESS)KeGetCurrentThread()->ApcState.Process;
 970     return MiMapPageInHyperSpace(HyperProcess, Page, &HyperIrql);
 971 }
 972
 973 #define MmDeleteHyperspaceMapping(x) MiUnmapPageInHyperSpace(HyperProcess, x, HyperIrql);
 974
 975 /* i386/page.c *********************************************************/
 976
 977 NTSTATUS
 978 NTAPI
 979 MmCreateVirtualMapping(
 980     struct _EPROCESS* Process,
 981     PVOID Address,
 982     ULONG flProtect,
 983     PPFN_NUMBER Pages,
 984     ULONG PageCount
 985 );
 986
 987 NTSTATUS
 988 NTAPI
 989 MmCreateVirtualMappingUnsafe(
 990     struct _EPROCESS* Process,
 991     PVOID Address,
 992     ULONG flProtect,
 993     PPFN_NUMBER Pages,
 994     ULONG PageCount
 995 );
 996
 997 ULONG
 998 NTAPI
 999 MmGetPageProtect(
1000     struct _EPROCESS* Process,
1001     PVOID Address);
1002
1003 VOID
1004 NTAPI
1005 MmSetPageProtect(
1006     struct _EPROCESS* Process,
1007     PVOID Address,
1008     ULONG flProtect
1009 );
1010
1011 BOOLEAN
1012 NTAPI
1013 MmIsPagePresent(
1014     struct _EPROCESS* Process,
1015     PVOID Address
1016 );
1017
1018 BOOLEAN
1019 NTAPI
1020 MmIsDisabledPage(
1021     struct _EPROCESS* Process,
1022     PVOID Address
1023 );
1024
1025 VOID
1026 NTAPI
1027 MmInitGlobalKernelPageDirectory(VOID);
1028
1029 VOID
1030 NTAPI
1031 MmGetPageFileMapping(
1032         struct _EPROCESS *Process,
1033         PVOID Address,
1034         SWAPENTRY* SwapEntry);
1035
1036 VOID
1037 NTAPI
1038 MmDeletePageFileMapping(
1039     struct _EPROCESS *Process,
1040     PVOID Address,
1041     SWAPENTRY* SwapEntry
1042 );
1043
1044 NTSTATUS
1045 NTAPI
1046 MmCreatePageFileMapping(
1047     struct _EPROCESS *Process,
1048     PVOID Address,
1049     SWAPENTRY SwapEntry
1050 );
1051
1052 BOOLEAN
1053 NTAPI
1054 MmIsPageSwapEntry(
1055     struct _EPROCESS *Process,
1056     PVOID Address
1057 );
1058
1059 VOID
1060 NTAPI
1061 MmSetDirtyPage(
1062     struct _EPROCESS *Process,
1063     PVOID Address
1064 );
1065
1066 PFN_NUMBER
1067 NTAPI
1068 MmAllocPage(
1069     ULONG Consumer
1070 );
1071
1072 VOID
1073 NTAPI
1074 MmDereferencePage(PFN_NUMBER Page);
1075
1076 VOID
1077 NTAPI
1078 MmReferencePage(PFN_NUMBER Page);
1079
1080 ULONG
1081 NTAPI
1082 MmGetReferenceCountPage(PFN_NUMBER Page);
1083
1084 BOOLEAN
1085 NTAPI
1086 MmIsPageInUse(PFN_NUMBER Page);
1087
1088 VOID
1089 NTAPI
1090 MmSetSavedSwapEntryPage(
1091     PFN_NUMBER Page,
1092     SWAPENTRY SavedSwapEntry);
1093
1094 SWAPENTRY
1095 NTAPI
1096 MmGetSavedSwapEntryPage(PFN_NUMBER Page);
1097
1098 VOID
1099 NTAPI
1100 MmSetCleanPage(
1101     struct _EPROCESS *Process,
1102     PVOID Address
1103 );
1104
1105 VOID
1106 NTAPI
1107 MmDeletePageTable(
1108     struct _EPROCESS *Process,
1109     PVOID Address
1110 );
1111
1112 PFN_NUMBER
1113 NTAPI
1114 MmGetPfnForProcess(
1115     struct _EPROCESS *Process,
1116     PVOID Address
1117 );
1118
1119 BOOLEAN
1120 NTAPI
1121 MmCreateProcessAddressSpace(
1122     IN ULONG MinWs,
1123     IN PEPROCESS Dest,
1124     IN PULONG_PTR DirectoryTableBase
1125 );
1126
1127 NTSTATUS
1128 NTAPI
1129 MmInitializeHandBuiltProcess(
1130     IN PEPROCESS Process,
1131     IN PULONG_PTR DirectoryTableBase
1132 );
1133
1134
1135 NTSTATUS
1136 NTAPI
1137 MmInitializeHandBuiltProcess2(
1138     IN PEPROCESS Process
1139 );
1140
1141 NTSTATUS
1142 NTAPI
1143 MmSetExecuteOptions(IN ULONG ExecuteOptions);
1144
1145 NTSTATUS
1146 NTAPI
1147 MmGetExecuteOptions(IN PULONG ExecuteOptions);
1148
1149 VOID
1150 NTAPI
1151 MmDeleteVirtualMapping(
1152     struct _EPROCESS *Process,
1153     PVOID Address,
1154     BOOLEAN* WasDirty,
1155     PPFN_NUMBER Page
1156 );
1157
1158 BOOLEAN
1159 NTAPI
1160 MmIsDirtyPage(
1161     struct _EPROCESS *Process,
1162     PVOID Address
1163 );
1164
1165 /* wset.c ********************************************************************/
1166
1167 NTSTATUS
1168 MmTrimUserMemory(
1169     ULONG Target,
1170     ULONG Priority,
1171     PULONG NrFreedPages
1172 );
1173
1174 /* region.c ************************************************************/
1175
1176 NTSTATUS
1177 NTAPI
1178 MmAlterRegion(
1179     PMMSUPPORT AddressSpace,
1180     PVOID BaseAddress,
1181     PLIST_ENTRY RegionListHead,
1182     PVOID StartAddress,
1183     SIZE_T Length,
1184     ULONG NewType,
1185     ULONG NewProtect,
1186     PMM_ALTER_REGION_FUNC AlterFunc
1187 );
1188
1189 VOID
1190 NTAPI
1191 MmInitializeRegion(
1192     PLIST_ENTRY RegionListHead,
1193     SIZE_T Length,
1194     ULONG Type,
1195     ULONG Protect
1196 );
1197
1198 PMM_REGION
1199 NTAPI
1200 MmFindRegion(
1201     PVOID BaseAddress,
1202     PLIST_ENTRY RegionListHead,
1203     PVOID Address,
1204     PVOID* RegionBaseAddress
1205 );
1206
1207 /* section.c *****************************************************************/
1208
1209 VOID
1210 NTAPI
1211 MmGetImageInformation(
1212     OUT PSECTION_IMAGE_INFORMATION ImageInformation
1213 );
1214
1215 PFILE_OBJECT
1216 NTAPI
1217 MmGetFileObjectForSection(
1218     IN PVOID Section
1219 );
1220 NTSTATUS
1221 NTAPI
1222 MmGetFileNameForAddress(
1223     IN PVOID Address,
1224     OUT PUNICODE_STRING ModuleName
1225 );
1226
1227 NTSTATUS
1228 NTAPI
1229 MmGetFileNameForSection(
1230     IN PVOID Section,
1231     OUT POBJECT_NAME_INFORMATION *ModuleName
1232 );
1233
1234 NTSTATUS
1235 NTAPI
1236 MmQuerySectionView(
1237     PMEMORY_AREA MemoryArea,
1238     PVOID Address,
1239     PMEMORY_BASIC_INFORMATION Info,
1240     PSIZE_T ResultLength
1241 );
1242
1243 NTSTATUS
1244 NTAPI
1245 MmProtectSectionView(
1246     PMMSUPPORT AddressSpace,
1247     PMEMORY_AREA MemoryArea,
1248     PVOID BaseAddress,
1249     SIZE_T Length,
1250     ULONG Protect,
1251     PULONG OldProtect
1252 );
1253
1254 NTSTATUS
1255 NTAPI
1256 MmInitSectionImplementation(VOID);
1257
1258 NTSTATUS
1259 NTAPI
1260 MmNotPresentFaultSectionView(
1261     PMMSUPPORT AddressSpace,
1262     MEMORY_AREA* MemoryArea,
1263     PVOID Address,
1264     BOOLEAN Locked
1265 );
1266
1267 NTSTATUS
1268 NTAPI
1269 MmPageOutSectionView(
1270     PMMSUPPORT AddressSpace,
1271     PMEMORY_AREA MemoryArea,
1272     PVOID Address,
1273     ULONG_PTR Entry
1274 );
1275
1276 NTSTATUS
1277 NTAPI
1278 MmCreatePhysicalMemorySection(VOID);
1279
1280 NTSTATUS
1281 NTAPI
1282 MmAccessFaultSectionView(
1283     PMMSUPPORT AddressSpace,
1284     MEMORY_AREA* MemoryArea,
1285     PVOID Address
1286 );
1287
1288 VOID
1289 NTAPI
1290 MmFreeSectionSegments(PFILE_OBJECT FileObject);
1291
1292 /* sysldr.c ******************************************************************/
1293
1294 VOID
1295 NTAPI
1296 MiReloadBootLoadedDrivers(
1297     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1298 );
1299
1300 BOOLEAN
1301 NTAPI
1302 MiInitializeLoadedModuleList(
1303     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1304 );
1305
1306 NTSTATUS
1307 NTAPI
1308 MmLoadSystemImage(
1309     IN PUNICODE_STRING FileName,
1310     IN PUNICODE_STRING NamePrefix OPTIONAL,
1311     IN PUNICODE_STRING LoadedName OPTIONAL,
1312     IN ULONG Flags,
1313     OUT PVOID *ModuleObject,
1314     OUT PVOID *ImageBaseAddress
1315 );
1316
1317 NTSTATUS
1318 NTAPI
1319 MmUnloadSystemImage(
1320     IN PVOID ImageHandle
1321 );
1322
1323 NTSTATUS
1324 NTAPI
1325 MmCheckSystemImage(
1326     IN HANDLE ImageHandle,
1327     IN BOOLEAN PurgeSection
1328 );
1329
1330 NTSTATUS
1331 NTAPI
1332 MmCallDllInitialize(
1333     IN PLDR_DATA_TABLE_ENTRY LdrEntry,
1334     IN PLIST_ENTRY ListHead
1335 );
1336
1337
1338 /* procsup.c *****************************************************************/
1339
1340 NTSTATUS
1341 NTAPI
1342 MmGrowKernelStack(
1343     IN PVOID StackPointer
1344 );
1345
1346
1347 FORCEINLINE
1348 VOID
1349 MmLockAddressSpace(PMMSUPPORT AddressSpace)
1350 {
1351     KeAcquireGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1352 }
1353
1354 FORCEINLINE
1355 VOID
1356 MmUnlockAddressSpace(PMMSUPPORT AddressSpace)
1357 {
1358     KeReleaseGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1359 }
1360
1361 FORCEINLINE
1362 PEPROCESS
1363 MmGetAddressSpaceOwner(IN PMMSUPPORT AddressSpace)
1364 {
1365     if (AddressSpace == MmKernelAddressSpace) return NULL;
1366     return CONTAINING_RECORD(AddressSpace, EPROCESS, Vm);
1367 }
1368
1369 FORCEINLINE
1370 PMMSUPPORT
1371 MmGetCurrentAddressSpace(VOID)
1372 {
1373     return &((PEPROCESS)KeGetCurrentThread()->ApcState.Process)->Vm;
1374 }
1375
1376 FORCEINLINE
1377 PMMSUPPORT
1378 MmGetKernelAddressSpace(VOID)
1379 {
1380     return MmKernelAddressSpace;
1381 }
1382
1383
1384 /* expool.c ******************************************************************/
1385
1386 VOID
1387 NTAPI
1388 ExpCheckPoolAllocation(
1389     PVOID P,
1390     POOL_TYPE PoolType,
1391     ULONG Tag);
1392
1393
1394 /* mmsup.c *****************************************************************/
1395
1396 NTSTATUS
1397 NTAPI
1398 MmAdjustWorkingSetSize(
1399     IN SIZE_T WorkingSetMinimumInBytes,
1400     IN SIZE_T WorkingSetMaximumInBytes,
1401     IN ULONG SystemCache,
1402     IN BOOLEAN IncreaseOkay);
1403
1404
1405 /* session.c *****************************************************************/
1406
1407 _IRQL_requires_max_(APC_LEVEL)
1408 NTSTATUS
1409 NTAPI
1410 MmAttachSession(
1411     _Inout_ PVOID SessionEntry,
1412     _Out_ PKAPC_STATE ApcState);
1413
1414 _IRQL_requires_max_(APC_LEVEL)
1415 VOID
1416 NTAPI
1417 MmDetachSession(
1418     _Inout_ PVOID SessionEntry,
1419     _Out_ PKAPC_STATE ApcState);
1420
1421 VOID
1422 NTAPI
1423 MmQuitNextSession(
1424     _Inout_ PVOID SessionEntry);
1425
1426 PVOID
1427 NTAPI
1428 MmGetSessionById(
1429     _In_ ULONG SessionId);
1430
1431 _IRQL_requires_max_(APC_LEVEL)
1432 VOID
1433 NTAPI
1434 MmSetSessionLocaleId(
1435     _In_ LCID LocaleId);
1436
1437
1438 /* virtual.c *****************************************************************/
1439
1440 NTSTATUS
1441 NTAPI
1442 MmCopyVirtualMemory(IN PEPROCESS SourceProcess,
1443                     IN PVOID SourceAddress,
1444                     IN PEPROCESS TargetProcess,
1445                     OUT PVOID TargetAddress,
1446                     IN SIZE_T BufferSize,
1447                     IN KPROCESSOR_MODE PreviousMode,
1448                     OUT PSIZE_T ReturnSize);
1449