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