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