ntoskrnl/include/internal/mm.h

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