reactos/ntoskrnl/include/internal/mm.h

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