ntoskrnl/include/internal/mm.h

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