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 MmMapMemoryArea(PVOID BaseAddress,
 544                 SIZE_T Length,
 545                 ULONG Consumer,
 546                 ULONG Protection);
 547
 548 VOID
 549 NTAPI
 550 MiRosCheckMemoryAreas(
 551    PMMSUPPORT AddressSpace);
 552
 553 VOID
 554 NTAPI
 555 MiCheckAllProcessMemoryAreas(VOID);
 556
 557 /* npool.c *******************************************************************/
 558
 559 VOID
 560 NTAPI
 561 MiInitializeNonPagedPool(VOID);
 562
 563 PVOID
 564 NTAPI
 565 MiAllocatePoolPages(
 566     IN POOL_TYPE PoolType,
 567     IN SIZE_T SizeInBytes
 568 );
 569
 570 POOL_TYPE
 571 NTAPI
 572 MmDeterminePoolType(
 573     IN PVOID VirtualAddress
 574 );
 575
 576 ULONG
 577 NTAPI
 578 MiFreePoolPages(
 579     IN PVOID StartingAddress
 580 );
 581
 582 /* pool.c *******************************************************************/
 583
 584 BOOLEAN
 585 NTAPI
 586 MiRaisePoolQuota(
 587     IN POOL_TYPE PoolType,
 588     IN ULONG CurrentMaxQuota,
 589     OUT PULONG NewMaxQuota
 590 );
 591
 592 /* mdl.c *********************************************************************/
 593
 594 VOID
 595 NTAPI
 596 MmBuildMdlFromPages(
 597     PMDL Mdl,
 598     PPFN_NUMBER Pages
 599 );
 600
 601 /* mminit.c ******************************************************************/
 602
 603 VOID
 604 NTAPI
 605 MmInit1(
 606     VOID
 607 );
 608
 609 BOOLEAN
 610 NTAPI
 611 MmInitSystem(IN ULONG Phase,
 612              IN PLOADER_PARAMETER_BLOCK LoaderBlock);
 613
 614
 615 /* pagefile.c ****************************************************************/
 616
 617 SWAPENTRY
 618 NTAPI
 619 MmAllocSwapPage(VOID);
 620
 621 VOID
 622 NTAPI
 623 MmFreeSwapPage(SWAPENTRY Entry);
 624
 625 VOID
 626 NTAPI
 627 MmInitPagingFile(VOID);
 628
 629 BOOLEAN
 630 NTAPI
 631 MmIsFileObjectAPagingFile(PFILE_OBJECT FileObject);
 632
 633 NTSTATUS
 634 NTAPI
 635 MmReadFromSwapPage(
 636     SWAPENTRY SwapEntry,
 637     PFN_NUMBER Page
 638 );
 639
 640 NTSTATUS
 641 NTAPI
 642 MmWriteToSwapPage(
 643     SWAPENTRY SwapEntry,
 644     PFN_NUMBER Page
 645 );
 646
 647 VOID
 648 NTAPI
 649 MmShowOutOfSpaceMessagePagingFile(VOID);
 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 FreePage,
1155     BOOLEAN* WasDirty,
1156     PPFN_NUMBER Page
1157 );
1158
1159 BOOLEAN
1160 NTAPI
1161 MmIsDirtyPage(
1162     struct _EPROCESS *Process,
1163     PVOID Address
1164 );
1165
1166 /* wset.c ********************************************************************/
1167
1168 NTSTATUS
1169 MmTrimUserMemory(
1170     ULONG Target,
1171     ULONG Priority,
1172     PULONG NrFreedPages
1173 );
1174
1175 /* region.c ************************************************************/
1176
1177 NTSTATUS
1178 NTAPI
1179 MmAlterRegion(
1180     PMMSUPPORT AddressSpace,
1181     PVOID BaseAddress,
1182     PLIST_ENTRY RegionListHead,
1183     PVOID StartAddress,
1184     SIZE_T Length,
1185     ULONG NewType,
1186     ULONG NewProtect,
1187     PMM_ALTER_REGION_FUNC AlterFunc
1188 );
1189
1190 VOID
1191 NTAPI
1192 MmInitializeRegion(
1193     PLIST_ENTRY RegionListHead,
1194     SIZE_T Length,
1195     ULONG Type,
1196     ULONG Protect
1197 );
1198
1199 PMM_REGION
1200 NTAPI
1201 MmFindRegion(
1202     PVOID BaseAddress,
1203     PLIST_ENTRY RegionListHead,
1204     PVOID Address,
1205     PVOID* RegionBaseAddress
1206 );
1207
1208 /* section.c *****************************************************************/
1209
1210 VOID
1211 NTAPI
1212 MmGetImageInformation(
1213     OUT PSECTION_IMAGE_INFORMATION ImageInformation
1214 );
1215
1216 PFILE_OBJECT
1217 NTAPI
1218 MmGetFileObjectForSection(
1219     IN PVOID Section
1220 );
1221 NTSTATUS
1222 NTAPI
1223 MmGetFileNameForAddress(
1224     IN PVOID Address,
1225     OUT PUNICODE_STRING ModuleName
1226 );
1227
1228 NTSTATUS
1229 NTAPI
1230 MmGetFileNameForSection(
1231     IN PVOID Section,
1232     OUT POBJECT_NAME_INFORMATION *ModuleName
1233 );
1234
1235 NTSTATUS
1236 NTAPI
1237 MmQuerySectionView(
1238     PMEMORY_AREA MemoryArea,
1239     PVOID Address,
1240     PMEMORY_BASIC_INFORMATION Info,
1241     PSIZE_T ResultLength
1242 );
1243
1244 NTSTATUS
1245 NTAPI
1246 MmProtectSectionView(
1247     PMMSUPPORT AddressSpace,
1248     PMEMORY_AREA MemoryArea,
1249     PVOID BaseAddress,
1250     SIZE_T Length,
1251     ULONG Protect,
1252     PULONG OldProtect
1253 );
1254
1255 NTSTATUS
1256 NTAPI
1257 MmInitSectionImplementation(VOID);
1258
1259 NTSTATUS
1260 NTAPI
1261 MmNotPresentFaultSectionView(
1262     PMMSUPPORT AddressSpace,
1263     MEMORY_AREA* MemoryArea,
1264     PVOID Address,
1265     BOOLEAN Locked
1266 );
1267
1268 NTSTATUS
1269 NTAPI
1270 MmPageOutSectionView(
1271     PMMSUPPORT AddressSpace,
1272     PMEMORY_AREA MemoryArea,
1273     PVOID Address,
1274     ULONG_PTR Entry
1275 );
1276
1277 NTSTATUS
1278 NTAPI
1279 MmCreatePhysicalMemorySection(VOID);
1280
1281 NTSTATUS
1282 NTAPI
1283 MmAccessFaultSectionView(
1284     PMMSUPPORT AddressSpace,
1285     MEMORY_AREA* MemoryArea,
1286     PVOID Address
1287 );
1288
1289 VOID
1290 NTAPI
1291 MmFreeSectionSegments(PFILE_OBJECT FileObject);
1292
1293 /* sysldr.c ******************************************************************/
1294
1295 VOID
1296 NTAPI
1297 MiReloadBootLoadedDrivers(
1298     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1299 );
1300
1301 BOOLEAN
1302 NTAPI
1303 MiInitializeLoadedModuleList(
1304     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1305 );
1306
1307 NTSTATUS
1308 NTAPI
1309 MmLoadSystemImage(
1310     IN PUNICODE_STRING FileName,
1311     IN PUNICODE_STRING NamePrefix OPTIONAL,
1312     IN PUNICODE_STRING LoadedName OPTIONAL,
1313     IN ULONG Flags,
1314     OUT PVOID *ModuleObject,
1315     OUT PVOID *ImageBaseAddress
1316 );
1317
1318 NTSTATUS
1319 NTAPI
1320 MmUnloadSystemImage(
1321     IN PVOID ImageHandle
1322 );
1323
1324 NTSTATUS
1325 NTAPI
1326 MmCheckSystemImage(
1327     IN HANDLE ImageHandle,
1328     IN BOOLEAN PurgeSection
1329 );
1330
1331 NTSTATUS
1332 NTAPI
1333 MmCallDllInitialize(
1334     IN PLDR_DATA_TABLE_ENTRY LdrEntry,
1335     IN PLIST_ENTRY ListHead
1336 );
1337
1338
1339 /* procsup.c *****************************************************************/
1340
1341 NTSTATUS
1342 NTAPI
1343 MmGrowKernelStack(
1344     IN PVOID StackPointer
1345 );
1346
1347
1348 FORCEINLINE
1349 VOID
1350 MmLockAddressSpace(PMMSUPPORT AddressSpace)
1351 {
1352     KeAcquireGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1353 }
1354
1355 FORCEINLINE
1356 VOID
1357 MmUnlockAddressSpace(PMMSUPPORT AddressSpace)
1358 {
1359     KeReleaseGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1360 }
1361
1362 FORCEINLINE
1363 PEPROCESS
1364 MmGetAddressSpaceOwner(IN PMMSUPPORT AddressSpace)
1365 {
1366     if (AddressSpace == MmKernelAddressSpace) return NULL;
1367     return CONTAINING_RECORD(AddressSpace, EPROCESS, Vm);
1368 }
1369
1370 FORCEINLINE
1371 PMMSUPPORT
1372 MmGetCurrentAddressSpace(VOID)
1373 {
1374     return &((PEPROCESS)KeGetCurrentThread()->ApcState.Process)->Vm;
1375 }
1376
1377 FORCEINLINE
1378 PMMSUPPORT
1379 MmGetKernelAddressSpace(VOID)
1380 {
1381     return MmKernelAddressSpace;
1382 }
1383
1384
1385 /* expool.c ******************************************************************/
1386
1387 VOID
1388 NTAPI
1389 ExpCheckPoolAllocation(
1390     PVOID P,
1391     POOL_TYPE PoolType,
1392     ULONG Tag);
1393
1394
1395 /* mmsup.c *****************************************************************/
1396
1397 NTSTATUS
1398 NTAPI
1399 MmAdjustWorkingSetSize(
1400     IN SIZE_T WorkingSetMinimumInBytes,
1401     IN SIZE_T WorkingSetMaximumInBytes,
1402     IN ULONG SystemCache,
1403     IN BOOLEAN IncreaseOkay);
1404
1405
1406 /* session.c *****************************************************************/
1407
1408 _IRQL_requires_max_(APC_LEVEL)
1409 NTSTATUS
1410 NTAPI
1411 MmAttachSession(
1412     _Inout_ PVOID SessionEntry,
1413     _Out_ PKAPC_STATE ApcState);
1414
1415 _IRQL_requires_max_(APC_LEVEL)
1416 VOID
1417 NTAPI
1418 MmDetachSession(
1419     _Inout_ PVOID SessionEntry,
1420     _Out_ PKAPC_STATE ApcState);
1421
1422 VOID
1423 NTAPI
1424 MmQuitNextSession(
1425     _Inout_ PVOID SessionEntry);
1426
1427 PVOID
1428 NTAPI
1429 MmGetSessionById(
1430     _In_ ULONG SessionId);
1431
1432 _IRQL_requires_max_(APC_LEVEL)
1433 VOID
1434 NTAPI
1435 MmSetSessionLocaleId(
1436     _In_ LCID LocaleId);
1437
1438
1439 /* virtual.c *****************************************************************/
1440
1441 NTSTATUS
1442 NTAPI
1443 MmCopyVirtualMemory(IN PEPROCESS SourceProcess,
1444                     IN PVOID SourceAddress,
1445                     IN PEPROCESS TargetProcess,
1446                     OUT PVOID TargetAddress,
1447                     IN SIZE_T BufferSize,
1448                     IN KPROCESSOR_MODE PreviousMode,
1449                     OUT PSIZE_T ReturnSize);
1450