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