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