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