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