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 extern ULONG MiFreeSwapPages;
   9 extern ULONG MiUsedSwapPages;
  10 extern ULONG MmPagedPoolSize;
  11 extern ULONG MmTotalPagedPoolQuota;
  12 extern ULONG MmTotalNonPagedPoolQuota;
  13 extern PHYSICAL_ADDRESS MmSharedDataPagePhysicalAddress;
  14
  15 extern PVOID MmPagedPoolBase;
  16 extern ULONG MmPagedPoolSize;
  17
  18 struct _KTRAP_FRAME;
  19 struct _EPROCESS;
  20 struct _MM_RMAP_ENTRY;
  21 struct _MM_PAGEOP;
  22 typedef ULONG SWAPENTRY;
  23 typedef ULONG PFN_TYPE, *PPFN_TYPE;
  24
  25 #define MEMORY_AREA_INVALID                 (0)
  26 #define MEMORY_AREA_SECTION_VIEW            (1)
  27 #define MEMORY_AREA_CONTINUOUS_MEMORY       (2)
  28 #define MEMORY_AREA_NO_CACHE                (3)
  29 #define MEMORY_AREA_IO_MAPPING              (4)
  30 #define MEMORY_AREA_SYSTEM                  (5)
  31 #define MEMORY_AREA_MDL_MAPPING             (7)
  32 #define MEMORY_AREA_VIRTUAL_MEMORY          (8)
  33 #define MEMORY_AREA_CACHE_SEGMENT           (9)
  34 #define MEMORY_AREA_SHARED_DATA             (10)
  35 #define MEMORY_AREA_KERNEL_STACK            (11)
  36 #define MEMORY_AREA_PAGED_POOL              (12)
  37 #define MEMORY_AREA_NO_ACCESS               (13)
  38 #define MEMORY_AREA_PEB_OR_TEB              (14)
  39
  40 #define MM_PHYSICAL_PAGE_MPW_PENDING        (0x8)
  41
  42 #define MM_CORE_DUMP_TYPE_NONE              (0x0)
  43 #define MM_CORE_DUMP_TYPE_MINIMAL           (0x1)
  44 #define MM_CORE_DUMP_TYPE_FULL              (0x2)
  45
  46 #define MM_PAGEOP_PAGEIN                    (1)
  47 #define MM_PAGEOP_PAGEOUT                   (2)
  48 #define MM_PAGEOP_PAGESYNCH                 (3)
  49 #define MM_PAGEOP_ACCESSFAULT               (4)
  50
  51 #define PAGE_TO_SECTION_PAGE_DIRECTORY_OFFSET(x) \
  52     ((x) / (4*1024*1024))
  53
  54 #define PAGE_TO_SECTION_PAGE_TABLE_OFFSET(x) \
  55     ((((x)) % (4*1024*1024)) / (4*1024))
  56
  57 #define NR_SECTION_PAGE_TABLES              1024
  58 #define NR_SECTION_PAGE_ENTRIES             1024
  59
  60 #define TEB_BASE                            0x7FFDE000
  61 #define KPCR_BASE                           0xFF000000
  62
  63 /* Although Microsoft says this isn't hardcoded anymore,
  64    they won't be able to change it. Stuff depends on it */
  65 #define MM_VIRTMEM_GRANULARITY              (64 * 1024)
  66
  67 #define STATUS_MM_RESTART_OPERATION         ((NTSTATUS)0xD0000001)
  68
  69 /*
  70  * Additional flags for protection attributes
  71  */
  72 #define PAGE_WRITETHROUGH                   (1024)
  73 #define PAGE_SYSTEM                         (2048)
  74
  75 #define SEC_PHYSICALMEMORY                  (0x80000000)
  76
  77 #define MM_PAGEFILE_SEGMENT                 (0x1)
  78 #define MM_DATAFILE_SEGMENT                 (0x2)
  79
  80 #define MC_CACHE                            (0)
  81 #define MC_USER                             (1)
  82 #define MC_PPOOL                            (2)
  83 #define MC_NPPOOL                           (3)
  84 #define MC_MAXIMUM                          (4)
  85
  86 #define PAGED_POOL_MASK                     1
  87 #define MUST_SUCCEED_POOL_MASK              2
  88 #define CACHE_ALIGNED_POOL_MASK             4
  89 #define QUOTA_POOL_MASK                     8
  90 #define SESSION_POOL_MASK                   32
  91 #define VERIFIER_POOL_MASK                  64
  92
  93 #define MM_PAGED_POOL_SIZE                  (100*1024*1024)
  94 #define MM_NONPAGED_POOL_SIZE               (100*1024*1024)
  95
  96 /*
  97  * Paged and non-paged pools are 8-byte aligned
  98  */
  99 #define MM_POOL_ALIGNMENT                   8
 100
 101 /*
 102  * Maximum size of the kmalloc area (this is totally arbitary)
 103  */
 104 #define MM_KERNEL_MAP_SIZE                  (16*1024*1024)
 105 #define MM_KERNEL_MAP_BASE                  (0xf0c00000)
 106
 107 /*
 108  * FIXME - different architectures have different cache line sizes...
 109  */
 110 #define MM_CACHE_LINE_SIZE                  32
 111
 112 #define MM_ROUND_UP(x,s)                    \
 113     ((PVOID)(((ULONG_PTR)(x)+(s)-1) & ~((ULONG_PTR)(s)-1)))
 114
 115 #define MM_ROUND_DOWN(x,s)                  \
 116     ((PVOID)(((ULONG_PTR)(x)) & ~((ULONG_PTR)(s)-1)))
 117
 118 #define PAGE_FLAGS_VALID_FROM_USER_MODE     \
 119     (PAGE_READONLY | \
 120     PAGE_READWRITE | \
 121     PAGE_WRITECOPY | \
 122     PAGE_EXECUTE | \
 123     PAGE_EXECUTE_READ | \
 124     PAGE_EXECUTE_READWRITE | \
 125     PAGE_EXECUTE_WRITECOPY | \
 126     PAGE_GUARD | \
 127     PAGE_NOACCESS | \
 128     PAGE_NOCACHE)
 129
 130 #define PAGE_IS_READABLE                    \
 131     (PAGE_READONLY | \
 132     PAGE_READWRITE | \
 133     PAGE_WRITECOPY | \
 134     PAGE_EXECUTE_READ | \
 135     PAGE_EXECUTE_READWRITE | \
 136     PAGE_EXECUTE_WRITECOPY)
 137
 138 #define PAGE_IS_WRITABLE                    \
 139     (PAGE_READWRITE | \
 140     PAGE_WRITECOPY | \
 141     PAGE_EXECUTE_READWRITE | \
 142     PAGE_EXECUTE_WRITECOPY)
 143
 144 #define PAGE_IS_EXECUTABLE                  \
 145     (PAGE_EXECUTE | \
 146     PAGE_EXECUTE_READ | \
 147     PAGE_EXECUTE_READWRITE | \
 148     PAGE_EXECUTE_WRITECOPY)
 149
 150 #define PAGE_IS_WRITECOPY                   \
 151     (PAGE_WRITECOPY | \
 152     PAGE_EXECUTE_WRITECOPY)
 153
 154 typedef struct
 155 {
 156     ULONG Entry[NR_SECTION_PAGE_ENTRIES];
 157 } SECTION_PAGE_TABLE, *PSECTION_PAGE_TABLE;
 158
 159 typedef struct
 160 {
 161     PSECTION_PAGE_TABLE PageTables[NR_SECTION_PAGE_TABLES];
 162 } SECTION_PAGE_DIRECTORY, *PSECTION_PAGE_DIRECTORY;
 163
 164 typedef struct _MM_SECTION_SEGMENT
 165 {
 166     LONGLONG FileOffset;
 167     ULONG_PTR VirtualAddress;
 168     ULONG RawLength;
 169     ULONG Length;
 170     ULONG Protection;
 171     FAST_MUTEX Lock;
 172     ULONG ReferenceCount;
 173     SECTION_PAGE_DIRECTORY PageDirectory;
 174     ULONG Flags;
 175     ULONG Characteristics;
 176     BOOLEAN WriteCopy;
 177 } MM_SECTION_SEGMENT, *PMM_SECTION_SEGMENT;
 178
 179 typedef struct _MM_IMAGE_SECTION_OBJECT
 180 {
 181     ULONG_PTR ImageBase;
 182     ULONG_PTR StackReserve;
 183     ULONG_PTR StackCommit;
 184     ULONG_PTR EntryPoint;
 185     ULONG Subsystem;
 186     ULONG ImageCharacteristics;
 187     USHORT MinorSubsystemVersion;
 188     USHORT MajorSubsystemVersion;
 189     USHORT Machine;
 190     BOOLEAN Executable;
 191     ULONG NrSegments;
 192     PMM_SECTION_SEGMENT Segments;
 193 } MM_IMAGE_SECTION_OBJECT, *PMM_IMAGE_SECTION_OBJECT;
 194
 195 typedef struct _SECTION_OBJECT
 196 {
 197     CSHORT Type;
 198     CSHORT Size;
 199     LARGE_INTEGER MaximumSize;
 200     ULONG SectionPageProtection;
 201     ULONG AllocationAttributes;
 202     PFILE_OBJECT FileObject;
 203     union
 204     {
 205         PMM_IMAGE_SECTION_OBJECT ImageSection;
 206         PMM_SECTION_SEGMENT Segment;
 207     };
 208 } SECTION_OBJECT;
 209
 210 typedef struct _MEMORY_AREA
 211 {
 212     PVOID StartingAddress;
 213     PVOID EndingAddress;
 214     struct _MEMORY_AREA *Parent;
 215     struct _MEMORY_AREA *LeftChild;
 216     struct _MEMORY_AREA *RightChild;
 217     ULONG Type;
 218     ULONG Protect;
 219     ULONG Flags;
 220     ULONG LockCount;
 221     BOOLEAN DeleteInProgress;
 222     ULONG PageOpCount;
 223     union
 224     {
 225         struct
 226         {
 227             SECTION_OBJECT* Section;
 228             ULONG ViewOffset;
 229             PMM_SECTION_SEGMENT Segment;
 230             BOOLEAN WriteCopyView;
 231             LIST_ENTRY RegionListHead;
 232         } SectionData;
 233         struct
 234         {
 235             LIST_ENTRY RegionListHead;
 236         } VirtualMemoryData;
 237     } Data;
 238 } MEMORY_AREA, *PMEMORY_AREA;
 239
 240 #ifndef _MMTYPES_H
 241 typedef struct _MADDRESS_SPACE
 242 {
 243     PMEMORY_AREA MemoryAreaRoot;
 244     FAST_MUTEX Lock;
 245     PVOID LowestAddress;
 246     struct _EPROCESS* Process;
 247     PUSHORT PageTableRefCountTable;
 248     ULONG PageTableRefCountTableSize;
 249 } MADDRESS_SPACE, *PMADDRESS_SPACE;
 250 #endif
 251
 252 typedef struct
 253 {
 254     ULONG NrTotalPages;
 255     ULONG NrSystemPages;
 256     ULONG NrReservedPages;
 257     ULONG NrUserPages;
 258     ULONG NrFreePages;
 259     ULONG NrDirtyPages;
 260     ULONG NrLockedPages;
 261     ULONG PagingRequestsInLastMinute;
 262     ULONG PagingRequestsInLastFiveMinutes;
 263     ULONG PagingRequestsInLastFifteenMinutes;
 264 } MM_STATS;
 265
 266 extern MM_STATS MmStats;
 267
 268 typedef struct _MM_PAGEOP
 269 {
 270   /* Type of operation. */
 271   ULONG OpType;
 272   /* Number of threads interested in this operation. */
 273   ULONG ReferenceCount;
 274   /* Event that will be set when the operation is completed. */
 275   KEVENT CompletionEvent;
 276   /* Status of the operation once it is completed. */
 277   NTSTATUS Status;
 278   /* TRUE if the operation was abandoned. */
 279   BOOLEAN Abandoned;
 280   /* The memory area to be affected by the operation. */
 281   PMEMORY_AREA MArea;
 282   ULONG Hash;
 283   struct _MM_PAGEOP* Next;
 284   struct _ETHREAD* Thread;
 285   /*
 286    * These fields are used to identify the operation if it is against a
 287    * virtual memory area.
 288    */
 289   HANDLE Pid;
 290   PVOID Address;
 291   /*
 292    * These fields are used to identify the operation if it is against a
 293    * section mapping.
 294    */
 295   PMM_SECTION_SEGMENT Segment;
 296   ULONG Offset;
 297 } MM_PAGEOP, *PMM_PAGEOP;
 298
 299 typedef struct _MM_MEMORY_CONSUMER
 300 {
 301     ULONG PagesUsed;
 302     ULONG PagesTarget;
 303     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed);
 304 } MM_MEMORY_CONSUMER, *PMM_MEMORY_CONSUMER;
 305
 306 typedef struct _MM_REGION
 307 {
 308     ULONG Type;
 309     ULONG Protect;
 310     ULONG Length;
 311     LIST_ENTRY RegionListEntry;
 312 } MM_REGION, *PMM_REGION;
 313
 314 extern MM_MEMORY_CONSUMER MiMemoryConsumers[MC_MAXIMUM];
 315
 316 typedef VOID
 317 (*PMM_ALTER_REGION_FUNC)(
 318     PMADDRESS_SPACE AddressSpace,
 319     PVOID BaseAddress,
 320     ULONG Length,
 321     ULONG OldType,
 322     ULONG OldProtect,
 323     ULONG NewType,
 324     ULONG NewProtect
 325 );
 326
 327 typedef VOID
 328 (*PMM_FREE_PAGE_FUNC)(
 329     PVOID Context,
 330     PMEMORY_AREA MemoryArea,
 331     PVOID Address,
 332     PFN_TYPE Page,
 333     SWAPENTRY SwapEntry,
 334     BOOLEAN Dirty
 335 );
 336
 337
 338 /* FUNCTIONS */
 339
 340 /* aspace.c ******************************************************************/
 341
 342 VOID
 343 NTAPI
 344 MmLockAddressSpace(PMADDRESS_SPACE AddressSpace);
 345
 346 VOID
 347 NTAPI
 348 MmUnlockAddressSpace(PMADDRESS_SPACE AddressSpace);
 349
 350 VOID
 351 NTAPI
 352 MmInitializeKernelAddressSpace(VOID);
 353
 354 PMADDRESS_SPACE
 355 NTAPI
 356 MmGetCurrentAddressSpace(VOID);
 357
 358 PMADDRESS_SPACE
 359 NTAPI
 360 MmGetKernelAddressSpace(VOID);
 361
 362 NTSTATUS
 363 NTAPI
 364 MmInitializeAddressSpace(
 365     struct _EPROCESS* Process,
 366     PMADDRESS_SPACE AddressSpace);
 367
 368 NTSTATUS
 369 NTAPI
 370 MmDestroyAddressSpace(PMADDRESS_SPACE AddressSpace);
 371
 372 /* marea.c *******************************************************************/
 373
 374 NTSTATUS
 375 NTAPI
 376 MmInitMemoryAreas(VOID);
 377
 378 NTSTATUS
 379 STDCALL
 380 MmCreateMemoryArea(
 381     PMADDRESS_SPACE AddressSpace,
 382     ULONG Type,
 383     PVOID *BaseAddress,
 384     ULONG_PTR Length,
 385     ULONG Protection,
 386     PMEMORY_AREA *Result,
 387     BOOLEAN FixedAddress,
 388     ULONG AllocationFlags,
 389     PHYSICAL_ADDRESS BoundaryAddressMultiple OPTIONAL
 390 );
 391
 392 PMEMORY_AREA
 393 STDCALL
 394 MmLocateMemoryAreaByAddress(
 395     PMADDRESS_SPACE AddressSpace,
 396     PVOID Address
 397 );
 398
 399 ULONG_PTR
 400 STDCALL
 401 MmFindGapAtAddress(
 402     PMADDRESS_SPACE AddressSpace,
 403     PVOID Address
 404 );
 405
 406 NTSTATUS
 407 STDCALL
 408 MmFreeMemoryArea(
 409     PMADDRESS_SPACE AddressSpace,
 410     PMEMORY_AREA MemoryArea,
 411     PMM_FREE_PAGE_FUNC FreePage,
 412     PVOID FreePageContext
 413 );
 414
 415 NTSTATUS
 416 STDCALL
 417 MmFreeMemoryAreaByPtr(
 418     PMADDRESS_SPACE AddressSpace,
 419     PVOID BaseAddress,
 420     PMM_FREE_PAGE_FUNC FreePage,
 421     PVOID FreePageContext
 422 );
 423
 424 VOID
 425 STDCALL
 426 MmDumpMemoryAreas(PMADDRESS_SPACE AddressSpace);
 427
 428 PMEMORY_AREA
 429 STDCALL
 430 MmLocateMemoryAreaByRegion(
 431     PMADDRESS_SPACE AddressSpace,
 432     PVOID Address,
 433     ULONG_PTR Length
 434 );
 435
 436 PVOID
 437 STDCALL
 438 MmFindGap(
 439     PMADDRESS_SPACE AddressSpace,
 440     ULONG_PTR Length,
 441     ULONG_PTR Granularity,
 442     BOOLEAN TopDown
 443 );
 444
 445 VOID
 446 STDCALL
 447 MmReleaseMemoryAreaIfDecommitted(
 448     PEPROCESS Process,
 449     PMADDRESS_SPACE AddressSpace,
 450     PVOID BaseAddress
 451 );
 452
 453 /* npool.c *******************************************************************/
 454
 455 VOID
 456 NTAPI
 457 MiDebugDumpNonPagedPool(BOOLEAN NewOnly);
 458
 459 VOID
 460 NTAPI
 461 MiDebugDumpNonPagedPoolStats(BOOLEAN NewOnly);
 462
 463 VOID
 464 NTAPI
 465 MiInitializeNonPagedPool(VOID);
 466
 467 PVOID
 468 NTAPI
 469 MmGetMdlPageAddress(
 470     PMDL Mdl,
 471     PVOID Offset
 472 );
 473
 474 /* pool.c *******************************************************************/
 475
 476 PVOID
 477 STDCALL
 478 ExAllocateNonPagedPoolWithTag(
 479     POOL_TYPE type,
 480     ULONG size,
 481     ULONG Tag,
 482     PVOID Caller
 483 );
 484
 485 PVOID
 486 STDCALL
 487 ExAllocatePagedPoolWithTag(
 488     POOL_TYPE Type,
 489     ULONG size,
 490     ULONG Tag
 491 );
 492
 493 VOID
 494 STDCALL
 495 ExFreeNonPagedPool(PVOID block);
 496
 497 VOID
 498 STDCALL
 499 ExFreePagedPool(IN PVOID Block);
 500
 501 VOID
 502 NTAPI
 503 MmInitializePagedPool(VOID);
 504
 505 PVOID
 506 STDCALL
 507 MiAllocateSpecialPool(
 508     IN POOL_TYPE PoolType,
 509     IN SIZE_T NumberOfBytes,
 510     IN ULONG Tag,
 511     IN ULONG Underrun
 512 );
 513
 514 BOOLEAN
 515 STDCALL
 516 MiRaisePoolQuota(
 517     IN POOL_TYPE PoolType,
 518     IN ULONG CurrentMaxQuota,
 519     OUT PULONG NewMaxQuota
 520 );
 521
 522 /* mdl.c *********************************************************************/
 523
 524 VOID
 525 NTAPI
 526 MmBuildMdlFromPages(
 527     PMDL Mdl,
 528     PULONG Pages
 529 );
 530
 531 /* mminit.c ******************************************************************/
 532
 533 VOID
 534 NTAPI
 535 MiShutdownMemoryManager(VOID);
 536
 537 VOID
 538 NTAPI
 539 MmInit1(
 540     ULONG_PTR FirstKernelPhysAddress,
 541     ULONG_PTR LastKernelPhysAddress,
 542     ULONG_PTR LastKernelAddress,
 543     PADDRESS_RANGE BIOSMemoryMap,
 544     ULONG AddressRangeCount,
 545     ULONG MaxMemInMeg
 546 );
 547
 548 VOID
 549 NTAPI
 550 MmInit2(VOID);
 551
 552 VOID
 553 NTAPI
 554 MmInit3(VOID);
 555
 556 VOID
 557 NTAPI
 558 MiFreeInitMemory(VOID);
 559
 560 VOID
 561 NTAPI
 562 MmInitializeMdlImplementation(VOID);
 563
 564 /* pagefile.c ****************************************************************/
 565
 566 SWAPENTRY
 567 NTAPI
 568 MmAllocSwapPage(VOID);
 569
 570 VOID
 571 NTAPI
 572 MmDereserveSwapPages(ULONG Nr);
 573
 574 VOID
 575 NTAPI
 576 MmFreeSwapPage(SWAPENTRY Entry);
 577
 578 VOID
 579 NTAPI
 580 MmInitPagingFile(VOID);
 581
 582 NTSTATUS
 583 NTAPI
 584 MmReadFromSwapPage(
 585     SWAPENTRY SwapEntry,
 586     PFN_TYPE Page
 587 );
 588
 589 BOOLEAN
 590 NTAPI
 591 MmReserveSwapPages(ULONG Nr);
 592
 593 NTSTATUS
 594 NTAPI
 595 MmWriteToSwapPage(
 596     SWAPENTRY SwapEntry,
 597     PFN_TYPE Page
 598 );
 599
 600 NTSTATUS
 601 STDCALL
 602 MmDumpToPagingFile(
 603     ULONG BugCode,
 604     ULONG BugCodeParameter1,
 605     ULONG BugCodeParameter2,
 606     ULONG BugCodeParameter3,
 607     ULONG BugCodeParameter4,
 608     struct _KTRAP_FRAME* TrapFrame
 609 );
 610
 611 BOOLEAN
 612 NTAPI
 613 MmIsAvailableSwapPage(VOID);
 614
 615 VOID
 616 NTAPI
 617 MmShowOutOfSpaceMessagePagingFile(VOID);
 618
 619 /* process.c ****************************************************************/
 620
 621 NTSTATUS
 622 STDCALL
 623 MmCreateProcessAddressSpace(
 624     IN struct _EPROCESS* Process,
 625     IN PSECTION_OBJECT Section OPTIONAL
 626 );
 627
 628 NTSTATUS
 629 STDCALL
 630 MmCreatePeb(PEPROCESS Process);
 631
 632 struct _TEB*
 633 STDCALL
 634 MmCreateTeb(
 635     PEPROCESS Process,
 636     PCLIENT_ID ClientId,
 637     PINITIAL_TEB InitialTeb
 638 );
 639
 640 VOID
 641 STDCALL
 642 MmDeleteTeb(
 643     PEPROCESS Process,
 644     struct _TEB* Teb
 645 );
 646
 647 /* i386/pfault.c *************************************************************/
 648
 649 NTSTATUS
 650 NTAPI
 651 MmPageFault(
 652     ULONG Cs,
 653     PULONG Eip,
 654     PULONG Eax,
 655     ULONG Cr2,
 656     ULONG ErrorCode
 657 );
 658
 659 /* mm.c **********************************************************************/
 660
 661 NTSTATUS
 662 NTAPI
 663 MmAccessFault(
 664     KPROCESSOR_MODE Mode,
 665     ULONG_PTR Address,
 666     BOOLEAN FromMdl
 667 );
 668
 669 NTSTATUS
 670 NTAPI
 671 MmNotPresentFault(
 672     KPROCESSOR_MODE Mode,
 673     ULONG_PTR Address,
 674     BOOLEAN FromMdl
 675 );
 676
 677 /* anonmem.c *****************************************************************/
 678
 679 NTSTATUS
 680 NTAPI
 681 MmNotPresentFaultVirtualMemory(
 682     PMADDRESS_SPACE AddressSpace,
 683     MEMORY_AREA* MemoryArea,
 684     PVOID Address,
 685     BOOLEAN Locked
 686 );
 687
 688 NTSTATUS
 689 NTAPI
 690 MmPageOutVirtualMemory(
 691     PMADDRESS_SPACE AddressSpace,
 692     PMEMORY_AREA MemoryArea,
 693     PVOID Address,
 694     struct _MM_PAGEOP* PageOp
 695 );
 696
 697 NTSTATUS
 698 STDCALL
 699 MmQueryAnonMem(
 700     PMEMORY_AREA MemoryArea,
 701     PVOID Address,
 702     PMEMORY_BASIC_INFORMATION Info,
 703     PULONG ResultLength
 704 );
 705
 706 VOID
 707 NTAPI
 708 MmFreeVirtualMemory(
 709     struct _EPROCESS* Process,
 710     PMEMORY_AREA MemoryArea
 711 );
 712
 713 NTSTATUS
 714 NTAPI
 715 MmProtectAnonMem(
 716     PMADDRESS_SPACE AddressSpace,
 717     PMEMORY_AREA MemoryArea,
 718     PVOID BaseAddress,
 719     ULONG Length,
 720     ULONG Protect,
 721     PULONG OldProtect
 722 );
 723
 724 NTSTATUS
 725 NTAPI
 726 MmWritePageVirtualMemory(
 727     PMADDRESS_SPACE AddressSpace,
 728     PMEMORY_AREA MArea,
 729     PVOID Address,
 730     PMM_PAGEOP PageOp
 731 );
 732
 733 /* kmap.c ********************************************************************/
 734
 735 PVOID
 736 NTAPI
 737 ExAllocatePage(VOID);
 738
 739 VOID
 740 NTAPI
 741 ExUnmapPage(PVOID Addr);
 742
 743 PVOID
 744 NTAPI
 745 ExAllocatePageWithPhysPage(PFN_TYPE Page);
 746
 747 NTSTATUS
 748 NTAPI
 749 MiCopyFromUserPage(
 750     PFN_TYPE Page,
 751     PVOID SourceAddress
 752 );
 753
 754 NTSTATUS
 755 NTAPI
 756 MiZeroPage(PFN_TYPE Page);
 757
 758 /* memsafe.s *****************************************************************/
 759
 760 PVOID
 761 FASTCALL
 762 MmSafeReadPtr(PVOID Source);
 763
 764 /* pageop.c ******************************************************************/
 765
 766 VOID
 767 NTAPI
 768 MmReleasePageOp(PMM_PAGEOP PageOp);
 769
 770 PMM_PAGEOP
 771 NTAPI
 772 MmGetPageOp(
 773     PMEMORY_AREA MArea,
 774     HANDLE Pid,
 775     PVOID Address,
 776     PMM_SECTION_SEGMENT Segment,
 777     ULONG Offset,
 778     ULONG OpType,
 779     BOOL First
 780 );
 781
 782 PMM_PAGEOP
 783 NTAPI
 784 MmCheckForPageOp(
 785     PMEMORY_AREA MArea,
 786     HANDLE Pid,
 787     PVOID Address,
 788     PMM_SECTION_SEGMENT Segment,
 789     ULONG Offset
 790 );
 791
 792 VOID
 793 NTAPI
 794 MmInitializePageOp(VOID);
 795
 796 /* process.c *****************************************************************/
 797
 798 PVOID
 799 STDCALL
 800 MmCreateKernelStack(BOOLEAN GuiStack);
 801
 802 VOID
 803 STDCALL
 804 MmDeleteKernelStack(PVOID Stack,
 805                     BOOLEAN GuiStack);
 806
 807 /* balace.c ******************************************************************/
 808
 809 VOID
 810 NTAPI
 811 MmInitializeMemoryConsumer(
 812     ULONG Consumer,
 813     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed)
 814 );
 815
 816 VOID
 817 NTAPI
 818 MmInitializeBalancer(
 819     ULONG NrAvailablePages,
 820     ULONG NrSystemPages
 821 );
 822
 823 NTSTATUS
 824 NTAPI
 825 MmReleasePageMemoryConsumer(
 826     ULONG Consumer,
 827     PFN_TYPE Page
 828 );
 829
 830 NTSTATUS
 831 NTAPI
 832 MmRequestPageMemoryConsumer(
 833     ULONG Consumer,
 834     BOOLEAN MyWait,
 835     PPFN_TYPE AllocatedPage
 836 );
 837
 838 VOID
 839 NTAPI
 840 MiInitBalancerThread(VOID);
 841
 842 VOID
 843 NTAPI
 844 MmRebalanceMemoryConsumers(VOID);
 845
 846 /* rmap.c **************************************************************/
 847
 848 VOID
 849 NTAPI
 850 MmSetRmapListHeadPage(
 851     PFN_TYPE Page,
 852     struct _MM_RMAP_ENTRY* ListHead
 853 );
 854
 855 struct _MM_RMAP_ENTRY*
 856 NTAPI
 857 MmGetRmapListHeadPage(PFN_TYPE Page);
 858
 859 VOID
 860 NTAPI
 861 MmInsertRmap(
 862     PFN_TYPE Page,
 863     PEPROCESS Process,
 864     PVOID Address
 865 );
 866
 867 VOID
 868 NTAPI
 869 MmDeleteAllRmaps(
 870     PFN_TYPE Page,
 871     PVOID Context,
 872     VOID (*DeleteMapping)(PVOID Context, PEPROCESS Process, PVOID Address)
 873 );
 874
 875 VOID
 876 NTAPI
 877 MmDeleteRmap(
 878     PFN_TYPE Page,
 879     PEPROCESS Process,
 880     PVOID Address
 881 );
 882
 883 VOID
 884 NTAPI
 885 MmInitializeRmapList(VOID);
 886
 887 VOID
 888 NTAPI
 889 MmSetCleanAllRmaps(PFN_TYPE Page);
 890
 891 VOID
 892 NTAPI
 893 MmSetDirtyAllRmaps(PFN_TYPE Page);
 894
 895 BOOL
 896 NTAPI
 897 MmIsDirtyPageRmap(PFN_TYPE Page);
 898
 899 NTSTATUS
 900 NTAPI
 901 MmWritePagePhysicalAddress(PFN_TYPE Page);
 902
 903 NTSTATUS
 904 NTAPI
 905 MmPageOutPhysicalAddress(PFN_TYPE Page);
 906
 907 /* freelist.c **********************************************************/
 908
 909 PFN_TYPE
 910 NTAPI
 911 MmGetLRUNextUserPage(PFN_TYPE PreviousPage);
 912
 913 PFN_TYPE
 914 NTAPI
 915 MmGetLRUFirstUserPage(VOID);
 916
 917 VOID
 918 NTAPI
 919 MmSetLRULastPage(PFN_TYPE Page);
 920
 921 VOID
 922 NTAPI
 923 MmLockPage(PFN_TYPE Page);
 924
 925 VOID
 926 NTAPI
 927 MmLockPageUnsafe(PFN_TYPE Page);
 928
 929 VOID
 930 NTAPI
 931 MmUnlockPage(PFN_TYPE Page);
 932
 933 ULONG
 934 NTAPI
 935 MmGetLockCountPage(PFN_TYPE Page);
 936
 937 PVOID
 938 NTAPI
 939 MmInitializePageList(
 940     ULONG_PTR FirstPhysKernelAddress,
 941     ULONG_PTR LastPhysKernelAddress,
 942     ULONG MemorySizeInPages,
 943     ULONG_PTR LastKernelBase,
 944     PADDRESS_RANGE BIOSMemoryMap,
 945     ULONG AddressRangeCount
 946 );
 947
 948 PFN_TYPE
 949 NTAPI
 950 MmGetContinuousPages(
 951     ULONG NumberOfBytes,
 952     PHYSICAL_ADDRESS LowestAcceptableAddress,
 953     PHYSICAL_ADDRESS HighestAcceptableAddress,
 954     PHYSICAL_ADDRESS BoundaryAddressMultiple
 955 );
 956
 957 NTSTATUS
 958 NTAPI
 959 MmInitZeroPageThread(VOID);
 960
 961 /* i386/page.c *********************************************************/
 962
 963 PVOID
 964 NTAPI
 965 MmCreateHyperspaceMapping(PFN_TYPE Page);
 966
 967 PFN_TYPE
 968 NTAPI
 969 MmChangeHyperspaceMapping(
 970     PVOID Address,
 971     PFN_TYPE Page
 972 );
 973
 974 PFN_TYPE
 975 NTAPI
 976 MmDeleteHyperspaceMapping(PVOID Address);
 977
 978 NTSTATUS
 979 NTAPI
 980 MmCreateVirtualMappingForKernel(
 981     PVOID Address,
 982     ULONG flProtect,
 983     PPFN_TYPE Pages,
 984     ULONG PageCount
 985 );
 986
 987 NTSTATUS
 988 NTAPI
 989 MmCommitPagedPoolAddress(
 990     PVOID Address,
 991     BOOLEAN Locked
 992 );
 993
 994 NTSTATUS
 995 NTAPI
 996 MmCreateVirtualMapping(
 997     struct _EPROCESS* Process,
 998     PVOID Address,
 999     ULONG flProtect,
1000     PPFN_TYPE Pages,
1001     ULONG PageCount
1002 );
1003
1004 NTSTATUS
1005 NTAPI
1006 MmCreateVirtualMappingUnsafe(
1007     struct _EPROCESS* Process,
1008     PVOID Address,
1009     ULONG flProtect,
1010     PPFN_TYPE Pages,
1011     ULONG PageCount
1012 );
1013
1014 ULONG
1015 NTAPI
1016 MmGetPageProtect(
1017     struct _EPROCESS* Process,
1018     PVOID Address);
1019
1020 VOID
1021 NTAPI
1022 MmSetPageProtect(
1023     struct _EPROCESS* Process,
1024     PVOID Address,
1025     ULONG flProtect
1026 );
1027
1028 BOOLEAN
1029 NTAPI
1030 MmIsPagePresent(
1031     struct _EPROCESS* Process,
1032     PVOID Address
1033 );
1034
1035 VOID
1036 NTAPI
1037 MmInitGlobalKernelPageDirectory(VOID);
1038
1039 VOID
1040 NTAPI
1041 MmDisableVirtualMapping(
1042     PEPROCESS Process,
1043     PVOID Address,
1044     BOOL* WasDirty,
1045     PPFN_TYPE Page
1046 );
1047
1048 VOID
1049 NTAPI
1050 MmEnableVirtualMapping(
1051     PEPROCESS Process,
1052     PVOID Address
1053 );
1054
1055 VOID
1056 NTAPI
1057 MmRawDeleteVirtualMapping(PVOID Address);
1058
1059 VOID
1060 NTAPI
1061 MmDeletePageFileMapping(
1062     PEPROCESS Process,
1063     PVOID Address,
1064     SWAPENTRY* SwapEntry
1065 );
1066
1067 NTSTATUS
1068 NTAPI
1069 MmCreatePageFileMapping(
1070     PEPROCESS Process,
1071     PVOID Address,
1072     SWAPENTRY SwapEntry
1073 );
1074
1075 BOOLEAN
1076 NTAPI
1077 MmIsPageSwapEntry(
1078     PEPROCESS Process,
1079     PVOID Address
1080 );
1081
1082 VOID
1083 NTAPI
1084 MmTransferOwnershipPage(
1085     PFN_TYPE Page,
1086     ULONG NewConsumer
1087 );
1088
1089 VOID
1090 NTAPI
1091 MmSetDirtyPage(
1092     PEPROCESS Process,
1093     PVOID Address
1094 );
1095
1096 PFN_TYPE
1097 NTAPI
1098 MmAllocPage(
1099     ULONG Consumer,
1100     SWAPENTRY SavedSwapEntry
1101 );
1102
1103 LONG
1104 NTAPI
1105 MmAllocPagesSpecifyRange(
1106     ULONG Consumer,
1107     PHYSICAL_ADDRESS LowestAddress,
1108     PHYSICAL_ADDRESS HighestAddress,
1109     ULONG NumberOfPages,
1110     PPFN_TYPE Pages
1111 );
1112
1113 VOID
1114 NTAPI
1115 MmDereferencePage(PFN_TYPE Page);
1116
1117 VOID
1118 NTAPI
1119 MmReferencePage(PFN_TYPE Page);
1120
1121 VOID
1122 NTAPI
1123 MmReferencePageUnsafe(PFN_TYPE Page);
1124
1125 BOOLEAN
1126 NTAPI
1127 MmIsAccessedAndResetAccessPage(
1128     PEPROCESS Process,
1129     PVOID Address
1130 );
1131
1132 ULONG
1133 NTAPI
1134 MmGetReferenceCountPage(PFN_TYPE Page);
1135
1136 BOOLEAN
1137 NTAPI
1138 MmIsUsablePage(PFN_TYPE Page);
1139
1140 VOID
1141 NTAPI
1142 MmSetFlagsPage(
1143     PFN_TYPE Page,
1144     ULONG Flags);
1145
1146 ULONG
1147 NTAPI
1148 MmGetFlagsPage(PFN_TYPE Page);
1149
1150 VOID
1151 NTAPI
1152 MmSetSavedSwapEntryPage(
1153     PFN_TYPE Page,
1154     SWAPENTRY SavedSwapEntry);
1155
1156 SWAPENTRY
1157 NTAPI
1158 MmGetSavedSwapEntryPage(PFN_TYPE Page);
1159
1160 VOID
1161 NTAPI
1162 MmSetCleanPage(
1163     PEPROCESS Process,
1164     PVOID Address
1165 );
1166
1167 NTSTATUS
1168 NTAPI
1169 MmCreatePageTable(PVOID PAddress);
1170
1171 VOID
1172 NTAPI
1173 MmDeletePageTable(
1174     PEPROCESS Process,
1175     PVOID Address
1176 );
1177
1178 PFN_TYPE
1179 NTAPI
1180 MmGetPfnForProcess(
1181     PEPROCESS Process,
1182     PVOID Address
1183 );
1184
1185 NTSTATUS
1186 STDCALL
1187 MmCopyMmInfo(
1188     PEPROCESS Src,
1189     PEPROCESS Dest,
1190     PPHYSICAL_ADDRESS DirectoryTableBase
1191 );
1192
1193 NTSTATUS
1194 NTAPI
1195 MmReleaseMmInfo(PEPROCESS Process);
1196
1197 NTSTATUS
1198 NTAPI
1199 Mmi386ReleaseMmInfo(PEPROCESS Process);
1200
1201 VOID
1202 NTAPI
1203 MmDeleteVirtualMapping(
1204     PEPROCESS Process,
1205     PVOID Address,
1206     BOOL FreePage,
1207     BOOL* WasDirty,
1208     PPFN_TYPE Page
1209 );
1210
1211 BOOLEAN
1212 NTAPI
1213 MmIsDirtyPage(
1214     PEPROCESS Process,
1215     PVOID Address
1216 );
1217
1218 VOID
1219 NTAPI
1220 MmMarkPageMapped(PFN_TYPE Page);
1221
1222 VOID
1223 NTAPI
1224 MmMarkPageUnmapped(PFN_TYPE Page);
1225
1226 VOID
1227 NTAPI
1228 MmUpdatePageDir(
1229     PEPROCESS Process,
1230     PVOID Address,
1231     ULONG Size
1232 );
1233
1234 VOID
1235 NTAPI
1236 MiInitPageDirectoryMap(VOID);
1237
1238 ULONG
1239 NTAPI
1240 MiGetUserPageDirectoryCount(VOID);
1241
1242 /* wset.c ********************************************************************/
1243
1244 NTSTATUS
1245 MmTrimUserMemory(
1246     ULONG Target,
1247     ULONG Priority,
1248     PULONG NrFreedPages
1249 );
1250
1251 /* cont.c ********************************************************************/
1252
1253 PVOID
1254 STDCALL
1255 MmAllocateContiguousMemorySpecifyCache(
1256     IN SIZE_T NumberOfBytes,
1257     IN PHYSICAL_ADDRESS LowestAcceptableAddress,
1258     IN PHYSICAL_ADDRESS HighestAcceptableAddress,
1259     IN PHYSICAL_ADDRESS BoundaryAddressMultiple OPTIONAL,
1260     IN MEMORY_CACHING_TYPE CacheType OPTIONAL
1261 );
1262
1263 /* region.c ************************************************************/
1264
1265 NTSTATUS
1266 NTAPI
1267 MmAlterRegion(
1268     PMADDRESS_SPACE AddressSpace,
1269     PVOID BaseAddress,
1270     PLIST_ENTRY RegionListHead,
1271     PVOID StartAddress,
1272     ULONG Length,
1273     ULONG NewType,
1274     ULONG NewProtect,
1275     PMM_ALTER_REGION_FUNC AlterFunc
1276 );
1277
1278 VOID
1279 NTAPI
1280 MmInitializeRegion(
1281     PLIST_ENTRY RegionListHead,
1282     SIZE_T Length,
1283     ULONG Type,
1284     ULONG Protect
1285 );
1286
1287 PMM_REGION
1288 NTAPI
1289 MmFindRegion(
1290     PVOID BaseAddress,
1291     PLIST_ENTRY RegionListHead,
1292     PVOID Address,
1293     PVOID* RegionBaseAddress
1294 );
1295
1296 /* section.c *****************************************************************/
1297
1298 PVOID
1299 STDCALL
1300 MmAllocateSection(
1301     IN ULONG Length,
1302     PVOID BaseAddress
1303 );
1304
1305 NTSTATUS
1306 STDCALL
1307 MmQuerySectionView(
1308     PMEMORY_AREA MemoryArea,
1309     PVOID Address,
1310     PMEMORY_BASIC_INFORMATION Info,
1311     PULONG ResultLength
1312 );
1313
1314 NTSTATUS
1315 NTAPI
1316 MmProtectSectionView(
1317     PMADDRESS_SPACE AddressSpace,
1318     PMEMORY_AREA MemoryArea,
1319     PVOID BaseAddress,
1320     ULONG Length,
1321     ULONG Protect,
1322     PULONG OldProtect
1323 );
1324
1325 NTSTATUS
1326 NTAPI
1327 MmWritePageSectionView(
1328     PMADDRESS_SPACE AddressSpace,
1329     PMEMORY_AREA MArea,
1330     PVOID Address,
1331     PMM_PAGEOP PageOp
1332 );
1333
1334 NTSTATUS
1335 NTAPI
1336 MmInitSectionImplementation(VOID);
1337
1338 NTSTATUS
1339 STDCALL
1340 MmCreateSection(
1341     OUT PSECTION_OBJECT *SectionObject,
1342     IN ACCESS_MASK DesiredAccess,
1343     IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
1344     IN PLARGE_INTEGER MaximumSize,
1345     IN ULONG SectionPageProtection,
1346     IN ULONG AllocationAttributes,
1347     IN HANDLE FileHandle OPTIONAL,
1348     IN PFILE_OBJECT File OPTIONAL
1349 );
1350
1351 NTSTATUS
1352 NTAPI
1353 MmNotPresentFaultSectionView(
1354     PMADDRESS_SPACE AddressSpace,
1355     MEMORY_AREA* MemoryArea,
1356     PVOID Address,
1357     BOOLEAN Locked
1358 );
1359
1360 NTSTATUS
1361 NTAPI
1362 MmPageOutSectionView(
1363     PMADDRESS_SPACE AddressSpace,
1364     PMEMORY_AREA MemoryArea,
1365     PVOID Address,
1366     struct _MM_PAGEOP *PageOp
1367 );
1368
1369 NTSTATUS
1370 NTAPI
1371 MmCreatePhysicalMemorySection(VOID);
1372
1373 NTSTATUS
1374 NTAPI
1375 MmAccessFaultSectionView(
1376     PMADDRESS_SPACE AddressSpace,
1377     MEMORY_AREA* MemoryArea,
1378     PVOID Address,
1379     BOOLEAN Locked
1380 );
1381
1382 VOID
1383 NTAPI
1384 MmFreeSectionSegments(PFILE_OBJECT FileObject);
1385
1386 /* mpw.c *********************************************************************/
1387
1388 NTSTATUS
1389 NTAPI
1390 MmInitMpwThread(VOID);
1391
1392 /* pager.c *******************************************************************/
1393
1394 BOOLEAN
1395 NTAPI
1396 MiIsPagerThread(VOID);
1397
1398 VOID
1399 NTAPI
1400 MiStartPagerThread(VOID);
1401
1402 VOID
1403 NTAPI
1404 MiStopPagerThread(VOID);
1405
1406 NTSTATUS
1407 FASTCALL
1408 MiQueryVirtualMemory(
1409     IN HANDLE ProcessHandle,
1410     IN PVOID Address,
1411     IN CINT VirtualMemoryInformationClass,
1412     OUT PVOID VirtualMemoryInformation,
1413     IN ULONG Length,
1414     OUT PULONG ResultLength
1415 );
1416
1417 #endif