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