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 //
 515 // Determines if a given address is a session address
 516 //
 517 BOOLEAN
 518 NTAPI
 519 MmIsSessionAddress(
 520     IN PVOID Address
 521 );
 522
 523 /* marea.c *******************************************************************/
 524
 525 NTSTATUS
 526 NTAPI
 527 MmCreateMemoryArea(
 528     PMMSUPPORT AddressSpace,
 529     ULONG Type,
 530     PVOID *BaseAddress,
 531     ULONG_PTR Length,
 532     ULONG Protection,
 533     PMEMORY_AREA *Result,
 534     BOOLEAN FixedAddress,
 535     ULONG AllocationFlags,
 536     PHYSICAL_ADDRESS BoundaryAddressMultiple OPTIONAL
 537 );
 538
 539 PMEMORY_AREA
 540 NTAPI
 541 MmLocateMemoryAreaByAddress(
 542     PMMSUPPORT AddressSpace,
 543     PVOID Address
 544 );
 545
 546 ULONG_PTR
 547 NTAPI
 548 MmFindGapAtAddress(
 549     PMMSUPPORT AddressSpace,
 550     PVOID Address
 551 );
 552
 553 NTSTATUS
 554 NTAPI
 555 MmFreeMemoryArea(
 556     PMMSUPPORT AddressSpace,
 557     PMEMORY_AREA MemoryArea,
 558     PMM_FREE_PAGE_FUNC FreePage,
 559     PVOID FreePageContext
 560 );
 561
 562 NTSTATUS
 563 NTAPI
 564 MmFreeMemoryAreaByPtr(
 565     PMMSUPPORT AddressSpace,
 566     PVOID BaseAddress,
 567     PMM_FREE_PAGE_FUNC FreePage,
 568     PVOID FreePageContext
 569 );
 570
 571 VOID
 572 NTAPI
 573 MmDumpMemoryAreas(PMMSUPPORT AddressSpace);
 574
 575 PMEMORY_AREA
 576 NTAPI
 577 MmLocateMemoryAreaByRegion(
 578     PMMSUPPORT AddressSpace,
 579     PVOID Address,
 580     ULONG_PTR Length
 581 );
 582
 583 PVOID
 584 NTAPI
 585 MmFindGap(
 586     PMMSUPPORT AddressSpace,
 587     ULONG_PTR Length,
 588     ULONG_PTR Granularity,
 589     BOOLEAN TopDown
 590 );
 591
 592 VOID
 593 NTAPI
 594 MmReleaseMemoryAreaIfDecommitted(
 595     struct _EPROCESS *Process,
 596     PMMSUPPORT AddressSpace,
 597     PVOID BaseAddress
 598 );
 599
 600 VOID
 601 NTAPI
 602 MmMapMemoryArea(PVOID BaseAddress,
 603                 ULONG Length,
 604                 ULONG Consumer,
 605                 ULONG Protection);
 606
 607 /* npool.c *******************************************************************/
 608
 609 VOID
 610 NTAPI
 611 MiDebugDumpNonPagedPool(BOOLEAN NewOnly);
 612
 613 VOID
 614 NTAPI
 615 MiDebugDumpNonPagedPoolStats(BOOLEAN NewOnly);
 616
 617 VOID
 618 NTAPI
 619 MiInitializeNonPagedPool(VOID);
 620
 621 PVOID
 622 NTAPI
 623 MiAllocatePoolPages(
 624     IN POOL_TYPE PoolType,
 625     IN SIZE_T SizeInBytes
 626 );
 627
 628 POOL_TYPE
 629 NTAPI
 630 MmDeterminePoolType(
 631     IN PVOID VirtualAddress
 632 );
 633
 634 ULONG
 635 NTAPI
 636 MiFreePoolPages(
 637     IN PVOID StartingAddress
 638 );
 639
 640 PVOID
 641 NTAPI
 642 MmGetMdlPageAddress(
 643     PMDL Mdl,
 644     PVOID Offset
 645 );
 646
 647 /* pool.c *******************************************************************/
 648
 649 PVOID
 650 NTAPI
 651 ExAllocateNonPagedPoolWithTag(
 652     POOL_TYPE type,
 653     ULONG size,
 654     ULONG Tag,
 655     PVOID Caller
 656 );
 657
 658 PVOID
 659 NTAPI
 660 ExAllocatePagedPoolWithTag(
 661     POOL_TYPE Type,
 662     ULONG size,
 663     ULONG Tag
 664 );
 665
 666 VOID
 667 NTAPI
 668 ExFreeNonPagedPool(PVOID block);
 669
 670 VOID
 671 NTAPI
 672 ExFreePagedPool(IN PVOID Block);
 673
 674 BOOLEAN
 675 NTAPI
 676 ExpIsPoolTagDebuggable(ULONG Tag);
 677
 678 PVOID
 679 NTAPI
 680 ExpAllocateDebugPool(
 681     POOL_TYPE Type,
 682     ULONG Size,
 683     ULONG Tag,
 684     PVOID Caller,
 685     BOOLEAN EndOfPage
 686 );
 687
 688 VOID
 689 NTAPI
 690 ExpFreeDebugPool(PVOID Block, BOOLEAN PagedPool);
 691
 692 VOID
 693 NTAPI
 694 MmInitializePagedPool(VOID);
 695
 696 PVOID
 697 NTAPI
 698 MiAllocateSpecialPool(
 699     IN POOL_TYPE PoolType,
 700     IN SIZE_T NumberOfBytes,
 701     IN ULONG Tag,
 702     IN ULONG Underrun
 703 );
 704
 705 BOOLEAN
 706 NTAPI
 707 MiRaisePoolQuota(
 708     IN POOL_TYPE PoolType,
 709     IN ULONG CurrentMaxQuota,
 710     OUT PULONG NewMaxQuota
 711 );
 712
 713 /* mdl.c *********************************************************************/
 714
 715 VOID
 716 NTAPI
 717 MmBuildMdlFromPages(
 718     PMDL Mdl,
 719     PULONG Pages
 720 );
 721
 722 /* mminit.c ******************************************************************/
 723
 724 VOID
 725 NTAPI
 726 MiShutdownMemoryManager(VOID);
 727
 728 VOID
 729 NTAPI
 730 MmInit1(
 731     VOID
 732 );
 733
 734 BOOLEAN
 735 NTAPI
 736 MmInitSystem(IN ULONG Phase,
 737              IN PLOADER_PARAMETER_BLOCK LoaderBlock);
 738
 739 VOID
 740 NTAPI
 741 MiFreeInitMemory(VOID);
 742
 743 VOID
 744 NTAPI
 745 MmInitializeMdlImplementation(VOID);
 746
 747 /* pagefile.c ****************************************************************/
 748
 749 SWAPENTRY
 750 NTAPI
 751 MmAllocSwapPage(VOID);
 752
 753 VOID
 754 NTAPI
 755 MmDereserveSwapPages(ULONG Nr);
 756
 757 VOID
 758 NTAPI
 759 MmFreeSwapPage(SWAPENTRY Entry);
 760
 761 VOID
 762 NTAPI
 763 MmInitPagingFile(VOID);
 764
 765 NTSTATUS
 766 NTAPI
 767 MmReadFromSwapPage(
 768     SWAPENTRY SwapEntry,
 769     PFN_TYPE Page
 770 );
 771
 772 BOOLEAN
 773 NTAPI
 774 MmReserveSwapPages(ULONG Nr);
 775
 776 NTSTATUS
 777 NTAPI
 778 MmWriteToSwapPage(
 779     SWAPENTRY SwapEntry,
 780     PFN_TYPE Page
 781 );
 782
 783 NTSTATUS
 784 NTAPI
 785 MmDumpToPagingFile(
 786     ULONG BugCode,
 787     ULONG BugCodeParameter1,
 788     ULONG BugCodeParameter2,
 789     ULONG BugCodeParameter3,
 790     ULONG BugCodeParameter4,
 791     struct _KTRAP_FRAME* TrapFrame
 792 );
 793
 794 BOOLEAN
 795 NTAPI
 796 MmIsAvailableSwapPage(VOID);
 797
 798 VOID
 799 NTAPI
 800 MmShowOutOfSpaceMessagePagingFile(VOID);
 801
 802 /* process.c ****************************************************************/
 803
 804 NTSTATUS
 805 NTAPI
 806 MmInitializeProcessAddressSpace(
 807     IN PEPROCESS Process,
 808     IN PEPROCESS Clone OPTIONAL,
 809     IN PVOID Section OPTIONAL,
 810     IN OUT PULONG Flags,
 811     IN POBJECT_NAME_INFORMATION *AuditName OPTIONAL
 812 );
 813
 814 NTSTATUS
 815 NTAPI
 816 MmCreatePeb(
 817     IN PEPROCESS Process,
 818     IN PINITIAL_PEB InitialPeb,
 819     OUT PPEB *BasePeb
 820 );
 821
 822 NTSTATUS
 823 NTAPI
 824 MmCreateTeb(
 825     IN PEPROCESS Process,
 826     IN PCLIENT_ID ClientId,
 827     IN PINITIAL_TEB InitialTeb,
 828     OUT PTEB* BaseTeb
 829 );
 830
 831 VOID
 832 NTAPI
 833 MmDeleteTeb(
 834     struct _EPROCESS *Process,
 835     PTEB Teb
 836 );
 837
 838 VOID
 839 NTAPI
 840 MmCleanProcessAddressSpace(IN PEPROCESS Process);
 841
 842 NTSTATUS
 843 NTAPI
 844 MmDeleteProcessAddressSpace(IN PEPROCESS Process);
 845
 846 ULONG
 847 NTAPI
 848 MmGetSessionLocaleId(VOID);
 849
 850 NTSTATUS
 851 NTAPI
 852 MmSetMemoryPriorityProcess(
 853     IN PEPROCESS Process,
 854     IN UCHAR MemoryPriority
 855 );
 856
 857 /* i386/pfault.c *************************************************************/
 858
 859 NTSTATUS
 860 NTAPI
 861 MmPageFault(
 862     ULONG Cs,
 863     PULONG Eip,
 864     PULONG Eax,
 865     ULONG Cr2,
 866     ULONG ErrorCode
 867 );
 868
 869 /* mm.c **********************************************************************/
 870
 871 NTSTATUS
 872 NTAPI
 873 MmAccessFault(
 874     IN BOOLEAN StoreInstruction,
 875     IN PVOID Address,
 876     IN KPROCESSOR_MODE Mode,
 877     IN PVOID TrapInformation
 878 );
 879
 880 /* anonmem.c *****************************************************************/
 881
 882 NTSTATUS
 883 NTAPI
 884 MmNotPresentFaultVirtualMemory(
 885     PMMSUPPORT AddressSpace,
 886     MEMORY_AREA* MemoryArea,
 887     PVOID Address,
 888     BOOLEAN Locked
 889 );
 890
 891 NTSTATUS
 892 NTAPI
 893 MmPageOutVirtualMemory(
 894     PMMSUPPORT AddressSpace,
 895     PMEMORY_AREA MemoryArea,
 896     PVOID Address,
 897     struct _MM_PAGEOP* PageOp
 898 );
 899
 900 NTSTATUS
 901 NTAPI
 902 MmQueryAnonMem(
 903     PMEMORY_AREA MemoryArea,
 904     PVOID Address,
 905     PMEMORY_BASIC_INFORMATION Info,
 906     PSIZE_T ResultLength
 907 );
 908
 909 VOID
 910 NTAPI
 911 MmFreeVirtualMemory(
 912     struct _EPROCESS* Process,
 913     PMEMORY_AREA MemoryArea
 914 );
 915
 916 NTSTATUS
 917 NTAPI
 918 MmProtectAnonMem(
 919     PMMSUPPORT AddressSpace,
 920     PMEMORY_AREA MemoryArea,
 921     PVOID BaseAddress,
 922     ULONG Length,
 923     ULONG Protect,
 924     PULONG OldProtect
 925 );
 926
 927 NTSTATUS
 928 NTAPI
 929 MmWritePageVirtualMemory(
 930     PMMSUPPORT AddressSpace,
 931     PMEMORY_AREA MArea,
 932     PVOID Address,
 933     PMM_PAGEOP PageOp
 934 );
 935
 936 /* kmap.c ********************************************************************/
 937
 938 PVOID
 939 NTAPI
 940 ExAllocatePage(VOID);
 941
 942 VOID
 943 NTAPI
 944 ExUnmapPage(PVOID Addr);
 945
 946 PVOID
 947 NTAPI
 948 ExAllocatePageWithPhysPage(PFN_TYPE Page);
 949
 950 NTSTATUS
 951 NTAPI
 952 MiCopyFromUserPage(
 953     PFN_TYPE Page,
 954     PVOID SourceAddress
 955 );
 956
 957 NTSTATUS
 958 NTAPI
 959 MiZeroPage(PFN_TYPE Page);
 960
 961 /* memsafe.s *****************************************************************/
 962
 963 PVOID
 964 FASTCALL
 965 MmSafeReadPtr(PVOID Source);
 966
 967 /* pageop.c ******************************************************************/
 968
 969 VOID
 970 NTAPI
 971 MmReleasePageOp(PMM_PAGEOP PageOp);
 972
 973 PMM_PAGEOP
 974 NTAPI
 975 MmGetPageOp(
 976     PMEMORY_AREA MArea,
 977     HANDLE Pid,
 978     PVOID Address,
 979     PMM_SECTION_SEGMENT Segment,
 980     ULONG Offset,
 981     ULONG OpType,
 982     BOOLEAN First
 983 );
 984
 985 PMM_PAGEOP
 986 NTAPI
 987 MmCheckForPageOp(
 988     PMEMORY_AREA MArea,
 989     HANDLE Pid,
 990     PVOID Address,
 991     PMM_SECTION_SEGMENT Segment,
 992     ULONG Offset
 993 );
 994
 995 VOID
 996 NTAPI
 997 MmInitializePageOp(VOID);
 998
 999 /* process.c *****************************************************************/
1000
1001 PVOID
1002 NTAPI
1003 MmCreateKernelStack(BOOLEAN GuiStack, UCHAR Node);
1004
1005 VOID
1006 NTAPI
1007 MmDeleteKernelStack(PVOID Stack,
1008                     BOOLEAN GuiStack);
1009
1010 /* balace.c ******************************************************************/
1011
1012 VOID
1013 NTAPI
1014 MmInitializeMemoryConsumer(
1015     ULONG Consumer,
1016     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed)
1017 );
1018
1019 VOID
1020 NTAPI
1021 MmInitializeBalancer(
1022     ULONG NrAvailablePages,
1023     ULONG NrSystemPages
1024 );
1025
1026 NTSTATUS
1027 NTAPI
1028 MmReleasePageMemoryConsumer(
1029     ULONG Consumer,
1030     PFN_TYPE Page
1031 );
1032
1033 NTSTATUS
1034 NTAPI
1035 MmRequestPageMemoryConsumer(
1036     ULONG Consumer,
1037     BOOLEAN MyWait,
1038     PPFN_TYPE AllocatedPage
1039 );
1040
1041 VOID
1042 NTAPI
1043 MiInitBalancerThread(VOID);
1044
1045 VOID
1046 NTAPI
1047 MmRebalanceMemoryConsumers(VOID);
1048
1049 /* rmap.c **************************************************************/
1050
1051 VOID
1052 NTAPI
1053 MmSetRmapListHeadPage(
1054     PFN_TYPE Page,
1055     struct _MM_RMAP_ENTRY* ListHead
1056 );
1057
1058 struct _MM_RMAP_ENTRY*
1059 NTAPI
1060 MmGetRmapListHeadPage(PFN_TYPE Page);
1061
1062 VOID
1063 NTAPI
1064 MmInsertRmap(
1065     PFN_TYPE Page,
1066     struct _EPROCESS *Process,
1067     PVOID Address
1068 );
1069
1070 VOID
1071 NTAPI
1072 MmDeleteAllRmaps(
1073     PFN_TYPE Page,
1074     PVOID Context,
1075     VOID (*DeleteMapping)(PVOID Context, struct _EPROCESS *Process, PVOID Address)
1076 );
1077
1078 VOID
1079 NTAPI
1080 MmDeleteRmap(
1081     PFN_TYPE Page,
1082     struct _EPROCESS *Process,
1083     PVOID Address
1084 );
1085
1086 VOID
1087 NTAPI
1088 MmInitializeRmapList(VOID);
1089
1090 VOID
1091 NTAPI
1092 MmSetCleanAllRmaps(PFN_TYPE Page);
1093
1094 VOID
1095 NTAPI
1096 MmSetDirtyAllRmaps(PFN_TYPE Page);
1097
1098 BOOLEAN
1099 NTAPI
1100 MmIsDirtyPageRmap(PFN_TYPE Page);
1101
1102 NTSTATUS
1103 NTAPI
1104 MmWritePagePhysicalAddress(PFN_TYPE Page);
1105
1106 NTSTATUS
1107 NTAPI
1108 MmPageOutPhysicalAddress(PFN_TYPE Page);
1109
1110 /* freelist.c **********************************************************/
1111
1112 #define ASSERT_PFN(x) ASSERT((x)->u3.e1.CacheAttribute != 0)
1113
1114 FORCEINLINE
1115 PMMPFN
1116 MiGetPfnEntry(IN PFN_TYPE Pfn)
1117 {
1118     PMMPFN Page;
1119     extern RTL_BITMAP MiPfnBitMap;
1120
1121     /* Make sure the PFN number is valid */
1122     if (Pfn > MmHighestPhysicalPage) return NULL;
1123
1124     /* Make sure this page actually has a PFN entry */
1125     if ((MiPfnBitMap.Buffer) && !(RtlTestBit(&MiPfnBitMap, Pfn))) return NULL;
1126
1127     /* Get the entry */
1128     Page = &MmPfnDatabase[Pfn];
1129
1130     /* Make sure it's valid */
1131     ASSERT_PFN(Page);
1132
1133     /* Return it */
1134     return Page;
1135 };
1136
1137 FORCEINLINE
1138 PFN_NUMBER
1139 MiGetPfnEntryIndex(IN PMMPFN Pfn1)
1140 {
1141     //
1142     // This will return the Page Frame Number (PFN) from the MMPFN
1143     //
1144     return Pfn1 - MmPfnDatabase;
1145 }
1146
1147 PFN_TYPE
1148 NTAPI
1149 MmGetLRUNextUserPage(PFN_TYPE PreviousPage);
1150
1151 PFN_TYPE
1152 NTAPI
1153 MmGetLRUFirstUserPage(VOID);
1154
1155 VOID
1156 NTAPI
1157 MmInsertLRULastUserPage(PFN_TYPE Page);
1158
1159 VOID
1160 NTAPI
1161 MmRemoveLRUUserPage(PFN_TYPE Page);
1162
1163 VOID
1164 NTAPI
1165 MmLockPage(PFN_TYPE Page);
1166
1167 VOID
1168 NTAPI
1169 MmUnlockPage(PFN_TYPE Page);
1170
1171 ULONG
1172 NTAPI
1173 MmGetLockCountPage(PFN_TYPE Page);
1174
1175 VOID
1176 NTAPI
1177 MmInitializePageList(
1178     VOID
1179 );
1180
1181 VOID
1182 NTAPI
1183 MmDumpPfnDatabase(
1184    VOID
1185 );
1186
1187 PFN_TYPE
1188 NTAPI
1189 MmGetContinuousPages(
1190     ULONG NumberOfBytes,
1191     PHYSICAL_ADDRESS LowestAcceptableAddress,
1192     PHYSICAL_ADDRESS HighestAcceptableAddress,
1193     PHYSICAL_ADDRESS BoundaryAddressMultiple,
1194     BOOLEAN ZeroPages
1195 );
1196
1197 NTSTATUS
1198 NTAPI
1199 MmZeroPageThreadMain(
1200     PVOID Context
1201 );
1202
1203 /* hypermap.c *****************************************************************/
1204
1205 extern PEPROCESS HyperProcess;
1206 extern KIRQL HyperIrql;
1207
1208 PVOID
1209 NTAPI
1210 MiMapPageInHyperSpace(IN PEPROCESS Process,
1211                       IN PFN_NUMBER Page,
1212                       IN PKIRQL OldIrql);
1213
1214 VOID
1215 NTAPI
1216 MiUnmapPageInHyperSpace(IN PEPROCESS Process,
1217                         IN PVOID Address,
1218                         IN KIRQL OldIrql);
1219
1220 PVOID
1221 NTAPI
1222 MiMapPagesToZeroInHyperSpace(IN PMMPFN *Pages,
1223                              IN PFN_NUMBER NumberOfPages);
1224
1225 VOID
1226 NTAPI
1227 MiUnmapPagesInZeroSpace(IN PVOID VirtualAddress,
1228                         IN PFN_NUMBER NumberOfPages);
1229
1230 //
1231 // ReactOS Compatibility Layer
1232 //
1233 FORCEINLINE
1234 PVOID
1235 MmCreateHyperspaceMapping(IN PFN_NUMBER Page)
1236 {
1237     HyperProcess = (PEPROCESS)KeGetCurrentThread()->ApcState.Process;
1238     return MiMapPageInHyperSpace(HyperProcess, Page, &HyperIrql);
1239 }
1240
1241 FORCEINLINE
1242 PVOID
1243 MiMapPageToZeroInHyperSpace(IN PFN_NUMBER Page)
1244 {
1245     PMMPFN Pfn1 = MiGetPfnEntry(Page);
1246     return MiMapPagesToZeroInHyperSpace(&Pfn1, 1);
1247 }
1248
1249 #define MmDeleteHyperspaceMapping(x) MiUnmapPageInHyperSpace(HyperProcess, x, HyperIrql);
1250
1251 /* i386/page.c *********************************************************/
1252
1253 NTSTATUS
1254 NTAPI
1255 MmCreateVirtualMappingForKernel(
1256     PVOID Address,
1257     ULONG flProtect,
1258     PPFN_TYPE Pages,
1259     ULONG PageCount
1260 );
1261
1262 NTSTATUS
1263 NTAPI
1264 MmCommitPagedPoolAddress(
1265     PVOID Address,
1266     BOOLEAN Locked
1267 );
1268
1269 NTSTATUS
1270 NTAPI
1271 MmCreateVirtualMapping(
1272     struct _EPROCESS* Process,
1273     PVOID Address,
1274     ULONG flProtect,
1275     PPFN_TYPE Pages,
1276     ULONG PageCount
1277 );
1278
1279 NTSTATUS
1280 NTAPI
1281 MmCreateVirtualMappingUnsafe(
1282     struct _EPROCESS* Process,
1283     PVOID Address,
1284     ULONG flProtect,
1285     PPFN_TYPE Pages,
1286     ULONG PageCount
1287 );
1288
1289 ULONG
1290 NTAPI
1291 MmGetPageProtect(
1292     struct _EPROCESS* Process,
1293     PVOID Address);
1294
1295 VOID
1296 NTAPI
1297 MmSetPageProtect(
1298     struct _EPROCESS* Process,
1299     PVOID Address,
1300     ULONG flProtect
1301 );
1302
1303 BOOLEAN
1304 NTAPI
1305 MmIsPagePresent(
1306     struct _EPROCESS* Process,
1307     PVOID Address
1308 );
1309
1310 VOID
1311 NTAPI
1312 MmInitGlobalKernelPageDirectory(VOID);
1313
1314 VOID
1315 NTAPI
1316 MmDisableVirtualMapping(
1317     struct _EPROCESS *Process,
1318     PVOID Address,
1319     BOOLEAN* WasDirty,
1320     PPFN_TYPE Page
1321 );
1322
1323 VOID
1324 NTAPI
1325 MmEnableVirtualMapping(
1326     struct _EPROCESS *Process,
1327     PVOID Address
1328 );
1329
1330 VOID
1331 NTAPI
1332 MmRawDeleteVirtualMapping(PVOID Address);
1333
1334 VOID
1335 NTAPI
1336 MmDeletePageFileMapping(
1337     struct _EPROCESS *Process,
1338     PVOID Address,
1339     SWAPENTRY* SwapEntry
1340 );
1341
1342 NTSTATUS
1343 NTAPI
1344 MmCreatePageFileMapping(
1345     struct _EPROCESS *Process,
1346     PVOID Address,
1347     SWAPENTRY SwapEntry
1348 );
1349
1350 BOOLEAN
1351 NTAPI
1352 MmIsPageSwapEntry(
1353     struct _EPROCESS *Process,
1354     PVOID Address
1355 );
1356
1357 VOID
1358 NTAPI
1359 MmTransferOwnershipPage(
1360     PFN_TYPE Page,
1361     ULONG NewConsumer
1362 );
1363
1364 VOID
1365 NTAPI
1366 MmSetDirtyPage(
1367     struct _EPROCESS *Process,
1368     PVOID Address
1369 );
1370
1371 PFN_TYPE
1372 NTAPI
1373 MmAllocPage(
1374     ULONG Consumer,
1375     SWAPENTRY SavedSwapEntry
1376 );
1377
1378 LONG
1379 NTAPI
1380 MmAllocPagesSpecifyRange(
1381     ULONG Consumer,
1382     PHYSICAL_ADDRESS LowestAddress,
1383     PHYSICAL_ADDRESS HighestAddress,
1384     ULONG NumberOfPages,
1385     PPFN_TYPE Pages
1386 );
1387
1388 VOID
1389 NTAPI
1390 MmDereferencePage(PFN_TYPE Page);
1391
1392 VOID
1393 NTAPI
1394 MmReferencePage(PFN_TYPE Page);
1395
1396 ULONG
1397 NTAPI
1398 MmGetReferenceCountPage(PFN_TYPE Page);
1399
1400 BOOLEAN
1401 NTAPI
1402 MmIsPageInUse(PFN_TYPE Page);
1403
1404 VOID
1405 NTAPI
1406 MmSetSavedSwapEntryPage(
1407     PFN_TYPE Page,
1408     SWAPENTRY SavedSwapEntry);
1409
1410 SWAPENTRY
1411 NTAPI
1412 MmGetSavedSwapEntryPage(PFN_TYPE Page);
1413
1414 VOID
1415 NTAPI
1416 MmSetCleanPage(
1417     struct _EPROCESS *Process,
1418     PVOID Address
1419 );
1420
1421 NTSTATUS
1422 NTAPI
1423 MmCreatePageTable(PVOID PAddress);
1424
1425 VOID
1426 NTAPI
1427 MmDeletePageTable(
1428     struct _EPROCESS *Process,
1429     PVOID Address
1430 );
1431
1432 PFN_TYPE
1433 NTAPI
1434 MmGetPfnForProcess(
1435     struct _EPROCESS *Process,
1436     PVOID Address
1437 );
1438
1439 BOOLEAN
1440 NTAPI
1441 MmCreateProcessAddressSpace(
1442     IN ULONG MinWs,
1443     IN PEPROCESS Dest,
1444     IN PULONG_PTR DirectoryTableBase
1445 );
1446
1447 NTSTATUS
1448 NTAPI
1449 MmInitializeHandBuiltProcess(
1450     IN PEPROCESS Process,
1451     IN PULONG_PTR DirectoryTableBase
1452 );
1453
1454
1455 NTSTATUS
1456 NTAPI
1457 MmInitializeHandBuiltProcess2(
1458     IN PEPROCESS Process
1459 );
1460
1461 NTSTATUS
1462 NTAPI
1463 MmReleaseMmInfo(struct _EPROCESS *Process);
1464
1465 NTSTATUS
1466 NTAPI
1467 Mmi386ReleaseMmInfo(struct _EPROCESS *Process);
1468
1469 VOID
1470 NTAPI
1471 MmDeleteVirtualMapping(
1472     struct _EPROCESS *Process,
1473     PVOID Address,
1474     BOOLEAN FreePage,
1475     BOOLEAN* WasDirty,
1476     PPFN_TYPE Page
1477 );
1478
1479 BOOLEAN
1480 NTAPI
1481 MmIsDirtyPage(
1482     struct _EPROCESS *Process,
1483     PVOID Address
1484 );
1485
1486 VOID
1487 NTAPI
1488 MmMarkPageMapped(PFN_TYPE Page);
1489
1490 VOID
1491 NTAPI
1492 MmMarkPageUnmapped(PFN_TYPE Page);
1493
1494 VOID
1495 NTAPI
1496 MmUpdatePageDir(
1497     struct _EPROCESS *Process,
1498     PVOID Address,
1499     ULONG Size
1500 );
1501
1502 VOID
1503 NTAPI
1504 MiInitPageDirectoryMap(VOID);
1505
1506 ULONG
1507 NTAPI
1508 MiGetUserPageDirectoryCount(VOID);
1509
1510 /* wset.c ********************************************************************/
1511
1512 NTSTATUS
1513 MmTrimUserMemory(
1514     ULONG Target,
1515     ULONG Priority,
1516     PULONG NrFreedPages
1517 );
1518
1519 /* region.c ************************************************************/
1520
1521 NTSTATUS
1522 NTAPI
1523 MmAlterRegion(
1524     PMMSUPPORT AddressSpace,
1525     PVOID BaseAddress,
1526     PLIST_ENTRY RegionListHead,
1527     PVOID StartAddress,
1528     ULONG Length,
1529     ULONG NewType,
1530     ULONG NewProtect,
1531     PMM_ALTER_REGION_FUNC AlterFunc
1532 );
1533
1534 VOID
1535 NTAPI
1536 MmInitializeRegion(
1537     PLIST_ENTRY RegionListHead,
1538     SIZE_T Length,
1539     ULONG Type,
1540     ULONG Protect
1541 );
1542
1543 PMM_REGION
1544 NTAPI
1545 MmFindRegion(
1546     PVOID BaseAddress,
1547     PLIST_ENTRY RegionListHead,
1548     PVOID Address,
1549     PVOID* RegionBaseAddress
1550 );
1551
1552 /* section.c *****************************************************************/
1553
1554 PFILE_OBJECT
1555 NTAPI
1556 MmGetFileObjectForSection(
1557     IN PROS_SECTION_OBJECT Section
1558 );
1559 NTSTATUS
1560 NTAPI
1561 MmGetFileNameForAddress(
1562     IN PVOID Address,
1563     OUT PUNICODE_STRING ModuleName
1564 );
1565
1566 NTSTATUS
1567 NTAPI
1568 MmGetFileNameForSection(
1569     IN PROS_SECTION_OBJECT Section,
1570     OUT POBJECT_NAME_INFORMATION *ModuleName
1571 );
1572
1573 PVOID
1574 NTAPI
1575 MmAllocateSection(
1576     IN ULONG Length,
1577     PVOID BaseAddress
1578 );
1579
1580 NTSTATUS
1581 NTAPI
1582 MmQuerySectionView(
1583     PMEMORY_AREA MemoryArea,
1584     PVOID Address,
1585     PMEMORY_BASIC_INFORMATION Info,
1586     PSIZE_T ResultLength
1587 );
1588
1589 NTSTATUS
1590 NTAPI
1591 MmProtectSectionView(
1592     PMMSUPPORT AddressSpace,
1593     PMEMORY_AREA MemoryArea,
1594     PVOID BaseAddress,
1595     ULONG Length,
1596     ULONG Protect,
1597     PULONG OldProtect
1598 );
1599
1600 NTSTATUS
1601 NTAPI
1602 MmWritePageSectionView(
1603     PMMSUPPORT AddressSpace,
1604     PMEMORY_AREA MArea,
1605     PVOID Address,
1606     PMM_PAGEOP PageOp
1607 );
1608
1609 NTSTATUS
1610 NTAPI
1611 MmInitSectionImplementation(VOID);
1612
1613 NTSTATUS
1614 NTAPI
1615 MmNotPresentFaultSectionView(
1616     PMMSUPPORT AddressSpace,
1617     MEMORY_AREA* MemoryArea,
1618     PVOID Address,
1619     BOOLEAN Locked
1620 );
1621
1622 NTSTATUS
1623 NTAPI
1624 MmPageOutSectionView(
1625     PMMSUPPORT AddressSpace,
1626     PMEMORY_AREA MemoryArea,
1627     PVOID Address,
1628     struct _MM_PAGEOP *PageOp
1629 );
1630
1631 NTSTATUS
1632 NTAPI
1633 MmCreatePhysicalMemorySection(VOID);
1634
1635 NTSTATUS
1636 NTAPI
1637 MmAccessFaultSectionView(
1638     PMMSUPPORT AddressSpace,
1639     MEMORY_AREA* MemoryArea,
1640     PVOID Address,
1641     BOOLEAN Locked
1642 );
1643
1644 VOID
1645 NTAPI
1646 MmFreeSectionSegments(PFILE_OBJECT FileObject);
1647
1648 /* mpw.c *********************************************************************/
1649
1650 NTSTATUS
1651 NTAPI
1652 MmInitMpwThread(VOID);
1653
1654 NTSTATUS
1655 NTAPI
1656 MmInitBsmThread(VOID);
1657
1658 /* pager.c *******************************************************************/
1659
1660 BOOLEAN
1661 NTAPI
1662 MiIsPagerThread(VOID);
1663
1664 VOID
1665 NTAPI
1666 MiStartPagerThread(VOID);
1667
1668 VOID
1669 NTAPI
1670 MiStopPagerThread(VOID);
1671
1672 NTSTATUS
1673 FASTCALL
1674 MiQueryVirtualMemory(
1675     IN HANDLE ProcessHandle,
1676     IN PVOID Address,
1677     IN MEMORY_INFORMATION_CLASS VirtualMemoryInformationClass,
1678     OUT PVOID VirtualMemoryInformation,
1679     IN SIZE_T Length,
1680     OUT PSIZE_T ResultLength
1681 );
1682
1683 /* sysldr.c ******************************************************************/
1684
1685 VOID
1686 NTAPI
1687 MiReloadBootLoadedDrivers(
1688     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1689 );
1690
1691 BOOLEAN
1692 NTAPI
1693 MiInitializeLoadedModuleList(
1694     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1695 );
1696
1697 NTSTATUS
1698 NTAPI
1699 MmLoadSystemImage(
1700     IN PUNICODE_STRING FileName,
1701     IN PUNICODE_STRING NamePrefix OPTIONAL,
1702     IN PUNICODE_STRING LoadedName OPTIONAL,
1703     IN ULONG Flags,
1704     OUT PVOID *ModuleObject,
1705     OUT PVOID *ImageBaseAddress
1706 );
1707
1708 NTSTATUS
1709 NTAPI
1710 MmUnloadSystemImage(
1711     IN PVOID ImageHandle
1712 );
1713
1714 NTSTATUS
1715 NTAPI
1716 MmCheckSystemImage(
1717     IN HANDLE ImageHandle,
1718     IN BOOLEAN PurgeSection
1719 );
1720
1721 NTSTATUS
1722 NTAPI
1723 MmCallDllInitialize(
1724     IN PLDR_DATA_TABLE_ENTRY LdrEntry,
1725     IN PLIST_ENTRY ListHead
1726 );
1727
1728 /* ReactOS Mm Hacks */
1729 VOID
1730 FASTCALL
1731 MiSyncForProcessAttach(
1732     IN PKTHREAD NextThread,
1733     IN PEPROCESS Process
1734 );
1735
1736 VOID
1737 FASTCALL
1738 MiSyncForContextSwitch(
1739     IN PKTHREAD Thread
1740 );
1741
1742 extern PMMSUPPORT MmKernelAddressSpace;
1743
1744 FORCEINLINE
1745 VOID
1746 MmLockAddressSpace(PMMSUPPORT AddressSpace)
1747 {
1748     KeAcquireGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1749 }
1750
1751 FORCEINLINE
1752 VOID
1753 MmUnlockAddressSpace(PMMSUPPORT AddressSpace)
1754 {
1755     KeReleaseGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1756 }
1757
1758 FORCEINLINE
1759 PEPROCESS
1760 MmGetAddressSpaceOwner(IN PMMSUPPORT AddressSpace)
1761 {
1762     if (AddressSpace == MmKernelAddressSpace) return NULL;
1763     return CONTAINING_RECORD(AddressSpace, EPROCESS, Vm);
1764 }
1765
1766 FORCEINLINE
1767 PMMSUPPORT
1768 MmGetCurrentAddressSpace(VOID)
1769 {
1770     return &((PEPROCESS)KeGetCurrentThread()->ApcState.Process)->Vm;
1771 }
1772
1773 FORCEINLINE
1774 PMMSUPPORT
1775 MmGetKernelAddressSpace(VOID)
1776 {
1777     return MmKernelAddressSpace;
1778 }
1779
1780 #endif