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