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(VOID);
 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 BOOLEAN
 736 NTAPI
 737 MmIsSpecialPoolAddressFree(
 738     IN PVOID P);
 739
 740 PVOID
 741 NTAPI
 742 MmAllocateSpecialPool(
 743     IN SIZE_T NumberOfBytes,
 744     IN ULONG Tag,
 745     IN POOL_TYPE PoolType,
 746     IN ULONG SpecialType);
 747
 748 VOID
 749 NTAPI
 750 MmFreeSpecialPool(
 751     IN PVOID P);
 752
 753 /* mm.c **********************************************************************/
 754
 755 NTSTATUS
 756 NTAPI
 757 MmAccessFault(
 758     IN BOOLEAN StoreInstruction,
 759     IN PVOID Address,
 760     IN KPROCESSOR_MODE Mode,
 761     IN PVOID TrapInformation
 762 );
 763
 764 /* kmap.c ********************************************************************/
 765
 766 NTSTATUS
 767 NTAPI
 768 MiCopyFromUserPage(
 769     PFN_NUMBER NewPage,
 770     PFN_NUMBER OldPage
 771 );
 772
 773 /* process.c *****************************************************************/
 774
 775 PVOID
 776 NTAPI
 777 MmCreateKernelStack(BOOLEAN GuiStack, UCHAR Node);
 778
 779 VOID
 780 NTAPI
 781 MmDeleteKernelStack(PVOID Stack,
 782                     BOOLEAN GuiStack);
 783
 784 /* balace.c ******************************************************************/
 785
 786 VOID
 787 NTAPI
 788 MmInitializeMemoryConsumer(
 789     ULONG Consumer,
 790     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed)
 791 );
 792
 793 VOID
 794 NTAPI
 795 MmInitializeBalancer(
 796     ULONG NrAvailablePages,
 797     ULONG NrSystemPages
 798 );
 799
 800 NTSTATUS
 801 NTAPI
 802 MmReleasePageMemoryConsumer(
 803     ULONG Consumer,
 804     PFN_NUMBER Page
 805 );
 806
 807 NTSTATUS
 808 NTAPI
 809 MmRequestPageMemoryConsumer(
 810     ULONG Consumer,
 811     BOOLEAN MyWait,
 812     PPFN_NUMBER AllocatedPage
 813 );
 814
 815 VOID
 816 NTAPI
 817 MiInitBalancerThread(VOID);
 818
 819 VOID
 820 NTAPI
 821 MmRebalanceMemoryConsumers(VOID);
 822
 823 /* rmap.c **************************************************************/
 824
 825 VOID
 826 NTAPI
 827 MmSetRmapListHeadPage(
 828     PFN_NUMBER Page,
 829     struct _MM_RMAP_ENTRY* ListHead
 830 );
 831
 832 struct _MM_RMAP_ENTRY*
 833 NTAPI
 834 MmGetRmapListHeadPage(PFN_NUMBER Page);
 835
 836 VOID
 837 NTAPI
 838 MmInsertRmap(
 839     PFN_NUMBER Page,
 840     struct _EPROCESS *Process,
 841     PVOID Address
 842 );
 843
 844 VOID
 845 NTAPI
 846 MmDeleteAllRmaps(
 847     PFN_NUMBER Page,
 848     PVOID Context,
 849     VOID (*DeleteMapping)(PVOID Context, struct _EPROCESS *Process, PVOID Address)
 850 );
 851
 852 VOID
 853 NTAPI
 854 MmDeleteRmap(
 855     PFN_NUMBER Page,
 856     struct _EPROCESS *Process,
 857     PVOID Address
 858 );
 859
 860 VOID
 861 NTAPI
 862 MmInitializeRmapList(VOID);
 863
 864 VOID
 865 NTAPI
 866 MmSetCleanAllRmaps(PFN_NUMBER Page);
 867
 868 VOID
 869 NTAPI
 870 MmSetDirtyAllRmaps(PFN_NUMBER Page);
 871
 872 BOOLEAN
 873 NTAPI
 874 MmIsDirtyPageRmap(PFN_NUMBER Page);
 875
 876 NTSTATUS
 877 NTAPI
 878 MmPageOutPhysicalAddress(PFN_NUMBER Page);
 879
 880 /* freelist.c **********************************************************/
 881
 882 FORCEINLINE
 883 PMMPFN
 884 MiGetPfnEntry(IN PFN_NUMBER Pfn)
 885 {
 886     PMMPFN Page;
 887     extern RTL_BITMAP MiPfnBitMap;
 888
 889     /* Make sure the PFN number is valid */
 890     if (Pfn > MmHighestPhysicalPage) return NULL;
 891
 892     /* Make sure this page actually has a PFN entry */
 893     if ((MiPfnBitMap.Buffer) && !(RtlTestBit(&MiPfnBitMap, (ULONG)Pfn))) return NULL;
 894
 895     /* Get the entry */
 896     Page = &MmPfnDatabase[Pfn];
 897
 898     /* Return it */
 899     return Page;
 900 };
 901
 902 FORCEINLINE
 903 PFN_NUMBER
 904 MiGetPfnEntryIndex(IN PMMPFN Pfn1)
 905 {
 906     //
 907     // This will return the Page Frame Number (PFN) from the MMPFN
 908     //
 909     return Pfn1 - MmPfnDatabase;
 910 }
 911
 912 PFN_NUMBER
 913 NTAPI
 914 MmGetLRUNextUserPage(PFN_NUMBER PreviousPage);
 915
 916 PFN_NUMBER
 917 NTAPI
 918 MmGetLRUFirstUserPage(VOID);
 919
 920 VOID
 921 NTAPI
 922 MmInsertLRULastUserPage(PFN_NUMBER Page);
 923
 924 VOID
 925 NTAPI
 926 MmRemoveLRUUserPage(PFN_NUMBER Page);
 927
 928 VOID
 929 NTAPI
 930 MmDumpArmPfnDatabase(
 931    IN BOOLEAN StatusOnly
 932 );
 933
 934 VOID
 935 NTAPI
 936 MmZeroPageThread(
 937     VOID
 938 );
 939
 940 /* hypermap.c *****************************************************************/
 941
 942 extern PEPROCESS HyperProcess;
 943 extern KIRQL HyperIrql;
 944
 945 PVOID
 946 NTAPI
 947 MiMapPageInHyperSpace(IN PEPROCESS Process,
 948                       IN PFN_NUMBER Page,
 949                       IN PKIRQL OldIrql);
 950
 951 VOID
 952 NTAPI
 953 MiUnmapPageInHyperSpace(IN PEPROCESS Process,
 954                         IN PVOID Address,
 955                         IN KIRQL OldIrql);
 956
 957 PVOID
 958 NTAPI
 959 MiMapPagesInZeroSpace(IN PMMPFN Pfn1,
 960                       IN PFN_NUMBER NumberOfPages);
 961
 962 VOID
 963 NTAPI
 964 MiUnmapPagesInZeroSpace(IN PVOID VirtualAddress,
 965                         IN PFN_NUMBER NumberOfPages);
 966
 967 //
 968 // ReactOS Compatibility Layer
 969 //
 970 FORCEINLINE
 971 PVOID
 972 MmCreateHyperspaceMapping(IN PFN_NUMBER Page)
 973 {
 974     HyperProcess = (PEPROCESS)KeGetCurrentThread()->ApcState.Process;
 975     return MiMapPageInHyperSpace(HyperProcess, Page, &HyperIrql);
 976 }
 977
 978 #define MmDeleteHyperspaceMapping(x) MiUnmapPageInHyperSpace(HyperProcess, x, HyperIrql);
 979
 980 /* i386/page.c *********************************************************/
 981
 982 NTSTATUS
 983 NTAPI
 984 MmCreateVirtualMapping(
 985     struct _EPROCESS* Process,
 986     PVOID Address,
 987     ULONG flProtect,
 988     PPFN_NUMBER Pages,
 989     ULONG PageCount
 990 );
 991
 992 NTSTATUS
 993 NTAPI
 994 MmCreateVirtualMappingUnsafe(
 995     struct _EPROCESS* Process,
 996     PVOID Address,
 997     ULONG flProtect,
 998     PPFN_NUMBER Pages,
 999     ULONG PageCount
1000 );
1001
1002 ULONG
1003 NTAPI
1004 MmGetPageProtect(
1005     struct _EPROCESS* Process,
1006     PVOID Address);
1007
1008 VOID
1009 NTAPI
1010 MmSetPageProtect(
1011     struct _EPROCESS* Process,
1012     PVOID Address,
1013     ULONG flProtect
1014 );
1015
1016 BOOLEAN
1017 NTAPI
1018 MmIsPagePresent(
1019     struct _EPROCESS* Process,
1020     PVOID Address
1021 );
1022
1023 BOOLEAN
1024 NTAPI
1025 MmIsDisabledPage(
1026     struct _EPROCESS* Process,
1027     PVOID Address
1028 );
1029
1030 VOID
1031 NTAPI
1032 MmInitGlobalKernelPageDirectory(VOID);
1033
1034 VOID
1035 NTAPI
1036 MmGetPageFileMapping(
1037         struct _EPROCESS *Process,
1038         PVOID Address,
1039         SWAPENTRY* SwapEntry);
1040
1041 VOID
1042 NTAPI
1043 MmDeletePageFileMapping(
1044     struct _EPROCESS *Process,
1045     PVOID Address,
1046     SWAPENTRY* SwapEntry
1047 );
1048
1049 NTSTATUS
1050 NTAPI
1051 MmCreatePageFileMapping(
1052     struct _EPROCESS *Process,
1053     PVOID Address,
1054     SWAPENTRY SwapEntry
1055 );
1056
1057 BOOLEAN
1058 NTAPI
1059 MmIsPageSwapEntry(
1060     struct _EPROCESS *Process,
1061     PVOID Address
1062 );
1063
1064 VOID
1065 NTAPI
1066 MmSetDirtyPage(
1067     struct _EPROCESS *Process,
1068     PVOID Address
1069 );
1070
1071 PFN_NUMBER
1072 NTAPI
1073 MmAllocPage(
1074     ULONG Consumer
1075 );
1076
1077 VOID
1078 NTAPI
1079 MmDereferencePage(PFN_NUMBER Page);
1080
1081 VOID
1082 NTAPI
1083 MmReferencePage(PFN_NUMBER Page);
1084
1085 ULONG
1086 NTAPI
1087 MmGetReferenceCountPage(PFN_NUMBER Page);
1088
1089 BOOLEAN
1090 NTAPI
1091 MmIsPageInUse(PFN_NUMBER Page);
1092
1093 VOID
1094 NTAPI
1095 MmSetSavedSwapEntryPage(
1096     PFN_NUMBER Page,
1097     SWAPENTRY SavedSwapEntry);
1098
1099 SWAPENTRY
1100 NTAPI
1101 MmGetSavedSwapEntryPage(PFN_NUMBER Page);
1102
1103 VOID
1104 NTAPI
1105 MmSetCleanPage(
1106     struct _EPROCESS *Process,
1107     PVOID Address
1108 );
1109
1110 VOID
1111 NTAPI
1112 MmDeletePageTable(
1113     struct _EPROCESS *Process,
1114     PVOID Address
1115 );
1116
1117 PFN_NUMBER
1118 NTAPI
1119 MmGetPfnForProcess(
1120     struct _EPROCESS *Process,
1121     PVOID Address
1122 );
1123
1124 BOOLEAN
1125 NTAPI
1126 MmCreateProcessAddressSpace(
1127     IN ULONG MinWs,
1128     IN PEPROCESS Dest,
1129     IN PULONG_PTR DirectoryTableBase
1130 );
1131
1132 NTSTATUS
1133 NTAPI
1134 MmInitializeHandBuiltProcess(
1135     IN PEPROCESS Process,
1136     IN PULONG_PTR DirectoryTableBase
1137 );
1138
1139
1140 NTSTATUS
1141 NTAPI
1142 MmInitializeHandBuiltProcess2(
1143     IN PEPROCESS Process
1144 );
1145
1146 NTSTATUS
1147 NTAPI
1148 MmSetExecuteOptions(IN ULONG ExecuteOptions);
1149
1150 NTSTATUS
1151 NTAPI
1152 MmGetExecuteOptions(IN PULONG ExecuteOptions);
1153
1154 VOID
1155 NTAPI
1156 MmDeleteVirtualMapping(
1157     struct _EPROCESS *Process,
1158     PVOID Address,
1159     BOOLEAN* WasDirty,
1160     PPFN_NUMBER Page
1161 );
1162
1163 BOOLEAN
1164 NTAPI
1165 MmIsDirtyPage(
1166     struct _EPROCESS *Process,
1167     PVOID Address
1168 );
1169
1170 /* wset.c ********************************************************************/
1171
1172 NTSTATUS
1173 MmTrimUserMemory(
1174     ULONG Target,
1175     ULONG Priority,
1176     PULONG NrFreedPages
1177 );
1178
1179 /* region.c ************************************************************/
1180
1181 NTSTATUS
1182 NTAPI
1183 MmAlterRegion(
1184     PMMSUPPORT AddressSpace,
1185     PVOID BaseAddress,
1186     PLIST_ENTRY RegionListHead,
1187     PVOID StartAddress,
1188     SIZE_T Length,
1189     ULONG NewType,
1190     ULONG NewProtect,
1191     PMM_ALTER_REGION_FUNC AlterFunc
1192 );
1193
1194 VOID
1195 NTAPI
1196 MmInitializeRegion(
1197     PLIST_ENTRY RegionListHead,
1198     SIZE_T Length,
1199     ULONG Type,
1200     ULONG Protect
1201 );
1202
1203 PMM_REGION
1204 NTAPI
1205 MmFindRegion(
1206     PVOID BaseAddress,
1207     PLIST_ENTRY RegionListHead,
1208     PVOID Address,
1209     PVOID* RegionBaseAddress
1210 );
1211
1212 /* section.c *****************************************************************/
1213
1214 VOID
1215 NTAPI
1216 MmGetImageInformation(
1217     OUT PSECTION_IMAGE_INFORMATION ImageInformation
1218 );
1219
1220 PFILE_OBJECT
1221 NTAPI
1222 MmGetFileObjectForSection(
1223     IN PVOID Section
1224 );
1225 NTSTATUS
1226 NTAPI
1227 MmGetFileNameForAddress(
1228     IN PVOID Address,
1229     OUT PUNICODE_STRING ModuleName
1230 );
1231
1232 NTSTATUS
1233 NTAPI
1234 MmGetFileNameForSection(
1235     IN PVOID Section,
1236     OUT POBJECT_NAME_INFORMATION *ModuleName
1237 );
1238
1239 NTSTATUS
1240 NTAPI
1241 MmQuerySectionView(
1242     PMEMORY_AREA MemoryArea,
1243     PVOID Address,
1244     PMEMORY_BASIC_INFORMATION Info,
1245     PSIZE_T ResultLength
1246 );
1247
1248 NTSTATUS
1249 NTAPI
1250 MmProtectSectionView(
1251     PMMSUPPORT AddressSpace,
1252     PMEMORY_AREA MemoryArea,
1253     PVOID BaseAddress,
1254     SIZE_T Length,
1255     ULONG Protect,
1256     PULONG OldProtect
1257 );
1258
1259 NTSTATUS
1260 NTAPI
1261 MmInitSectionImplementation(VOID);
1262
1263 NTSTATUS
1264 NTAPI
1265 MmNotPresentFaultSectionView(
1266     PMMSUPPORT AddressSpace,
1267     MEMORY_AREA* MemoryArea,
1268     PVOID Address,
1269     BOOLEAN Locked
1270 );
1271
1272 NTSTATUS
1273 NTAPI
1274 MmPageOutSectionView(
1275     PMMSUPPORT AddressSpace,
1276     PMEMORY_AREA MemoryArea,
1277     PVOID Address,
1278     ULONG_PTR Entry
1279 );
1280
1281 NTSTATUS
1282 NTAPI
1283 MmCreatePhysicalMemorySection(VOID);
1284
1285 NTSTATUS
1286 NTAPI
1287 MmAccessFaultSectionView(
1288     PMMSUPPORT AddressSpace,
1289     MEMORY_AREA* MemoryArea,
1290     PVOID Address
1291 );
1292
1293 VOID
1294 NTAPI
1295 MmFreeSectionSegments(PFILE_OBJECT FileObject);
1296
1297 /* sysldr.c ******************************************************************/
1298
1299 VOID
1300 NTAPI
1301 MiReloadBootLoadedDrivers(
1302     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1303 );
1304
1305 BOOLEAN
1306 NTAPI
1307 MiInitializeLoadedModuleList(
1308     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1309 );
1310
1311 NTSTATUS
1312 NTAPI
1313 MmLoadSystemImage(
1314     IN PUNICODE_STRING FileName,
1315     IN PUNICODE_STRING NamePrefix OPTIONAL,
1316     IN PUNICODE_STRING LoadedName OPTIONAL,
1317     IN ULONG Flags,
1318     OUT PVOID *ModuleObject,
1319     OUT PVOID *ImageBaseAddress
1320 );
1321
1322 NTSTATUS
1323 NTAPI
1324 MmUnloadSystemImage(
1325     IN PVOID ImageHandle
1326 );
1327
1328 NTSTATUS
1329 NTAPI
1330 MmCheckSystemImage(
1331     IN HANDLE ImageHandle,
1332     IN BOOLEAN PurgeSection
1333 );
1334
1335 NTSTATUS
1336 NTAPI
1337 MmCallDllInitialize(
1338     IN PLDR_DATA_TABLE_ENTRY LdrEntry,
1339     IN PLIST_ENTRY ListHead
1340 );
1341
1342
1343 /* procsup.c *****************************************************************/
1344
1345 NTSTATUS
1346 NTAPI
1347 MmGrowKernelStack(
1348     IN PVOID StackPointer
1349 );
1350
1351
1352 FORCEINLINE
1353 VOID
1354 MmLockAddressSpace(PMMSUPPORT AddressSpace)
1355 {
1356     KeAcquireGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1357 }
1358
1359 FORCEINLINE
1360 VOID
1361 MmUnlockAddressSpace(PMMSUPPORT AddressSpace)
1362 {
1363     KeReleaseGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1364 }
1365
1366 FORCEINLINE
1367 PEPROCESS
1368 MmGetAddressSpaceOwner(IN PMMSUPPORT AddressSpace)
1369 {
1370     if (AddressSpace == MmKernelAddressSpace) return NULL;
1371     return CONTAINING_RECORD(AddressSpace, EPROCESS, Vm);
1372 }
1373
1374 FORCEINLINE
1375 PMMSUPPORT
1376 MmGetCurrentAddressSpace(VOID)
1377 {
1378     return &((PEPROCESS)KeGetCurrentThread()->ApcState.Process)->Vm;
1379 }
1380
1381 FORCEINLINE
1382 PMMSUPPORT
1383 MmGetKernelAddressSpace(VOID)
1384 {
1385     return MmKernelAddressSpace;
1386 }
1387
1388
1389 /* expool.c ******************************************************************/
1390
1391 VOID
1392 NTAPI
1393 ExpCheckPoolAllocation(
1394     PVOID P,
1395     POOL_TYPE PoolType,
1396     ULONG Tag);
1397
1398
1399 /* mmsup.c *****************************************************************/
1400
1401 NTSTATUS
1402 NTAPI
1403 MmAdjustWorkingSetSize(
1404     IN SIZE_T WorkingSetMinimumInBytes,
1405     IN SIZE_T WorkingSetMaximumInBytes,
1406     IN ULONG SystemCache,
1407     IN BOOLEAN IncreaseOkay);
1408
1409
1410 /* session.c *****************************************************************/
1411
1412 _IRQL_requires_max_(APC_LEVEL)
1413 NTSTATUS
1414 NTAPI
1415 MmAttachSession(
1416     _Inout_ PVOID SessionEntry,
1417     _Out_ PKAPC_STATE ApcState);
1418
1419 _IRQL_requires_max_(APC_LEVEL)
1420 VOID
1421 NTAPI
1422 MmDetachSession(
1423     _Inout_ PVOID SessionEntry,
1424     _Out_ PKAPC_STATE ApcState);
1425
1426 VOID
1427 NTAPI
1428 MmQuitNextSession(
1429     _Inout_ PVOID SessionEntry);
1430
1431 PVOID
1432 NTAPI
1433 MmGetSessionById(
1434     _In_ ULONG SessionId);
1435
1436 _IRQL_requires_max_(APC_LEVEL)
1437 VOID
1438 NTAPI
1439 MmSetSessionLocaleId(
1440     _In_ LCID LocaleId);
1441
1442
1443 /* virtual.c *****************************************************************/
1444
1445 NTSTATUS
1446 NTAPI
1447 MmCopyVirtualMemory(IN PEPROCESS SourceProcess,
1448                     IN PVOID SourceAddress,
1449                     IN PEPROCESS TargetProcess,
1450                     OUT PVOID TargetAddress,
1451                     IN SIZE_T BufferSize,
1452                     IN KPROCESSOR_MODE PreviousMode,
1453                     OUT PSIZE_T ReturnSize);
1454