ntoskrnl/include/internal/mm.h

   1 /*
   2  * Higher level memory managment definitions
   3  */
   4
   5 #ifndef __INCLUDE_INTERNAL_MM_H
   6 #define __INCLUDE_INTERNAL_MM_H
   7
   8 #include <internal/ntoskrnl.h>
   9 #include <internal/arch/mm.h>
  10
  11 /* TYPES *********************************************************************/
  12
  13 struct _EPROCESS;
  14
  15 struct _MM_RMAP_ENTRY;
  16 struct _MM_PAGEOP;
  17 typedef ULONG SWAPENTRY;
  18
  19 #define MEMORY_AREA_INVALID              (0)
  20 #define MEMORY_AREA_SECTION_VIEW         (1)
  21 #define MEMORY_AREA_CONTINUOUS_MEMORY    (2)
  22 #define MEMORY_AREA_NO_CACHE             (3)
  23 #define MEMORY_AREA_IO_MAPPING           (4)
  24 #define MEMORY_AREA_SYSTEM               (5)
  25 #define MEMORY_AREA_MDL_MAPPING          (7)
  26 #define MEMORY_AREA_VIRTUAL_MEMORY       (8)
  27 #define MEMORY_AREA_CACHE_SEGMENT        (9)
  28 #define MEMORY_AREA_SHARED_DATA          (10)
  29 #define MEMORY_AREA_KERNEL_STACK         (11)
  30 #define MEMORY_AREA_PAGED_POOL           (12)
  31
  32 #define PAGE_TO_SECTION_PAGE_DIRECTORY_OFFSET(x) \
  33                           ((x) / (4*1024*1024))
  34 #define PAGE_TO_SECTION_PAGE_TABLE_OFFSET(x) \
  35                       ((((x)) % (4*1024*1024)) / (4*1024))
  36
  37 #define NR_SECTION_PAGE_TABLES           (1024)
  38 #define NR_SECTION_PAGE_ENTRIES          (1024)
  39
  40
  41 /*
  42  * Additional flags for protection attributes
  43  */
  44 #define PAGE_WRITETHROUGH                       (1024)
  45 #define PAGE_SYSTEM                             (2048)
  46 #define PAGE_FLAGS_VALID_FROM_USER_MODE               (PAGE_READONLY | \
  47                                                  PAGE_READWRITE | \
  48                                                  PAGE_WRITECOPY | \
  49                                                  PAGE_EXECUTE | \
  50                                                  PAGE_EXECUTE_READ | \
  51                                                  PAGE_EXECUTE_READWRITE | \
  52                                                  PAGE_EXECUTE_WRITECOPY | \
  53                                                  PAGE_GUARD | \
  54                                                  PAGE_NOACCESS | \
  55                                                  PAGE_NOCACHE)
  56
  57 typedef struct
  58 {
  59   ULONG Entry[NR_SECTION_PAGE_ENTRIES];
  60 } SECTION_PAGE_TABLE, *PSECTION_PAGE_TABLE;
  61
  62 typedef struct
  63 {
  64    PSECTION_PAGE_TABLE PageTables[NR_SECTION_PAGE_TABLES];
  65 } SECTION_PAGE_DIRECTORY, *PSECTION_PAGE_DIRECTORY;
  66
  67 #define SEC_PHYSICALMEMORY     (0x80000000)
  68
  69 #define MM_PAGEFILE_SEGMENT    (0x1)
  70 #define MM_DATAFILE_SEGMENT    (0x2)
  71
  72 #define MM_SECTION_SEGMENT_BSS (0x1)
  73
  74 typedef struct _MM_SECTION_SEGMENT
  75 {
  76   ULONG FileOffset;
  77   ULONG Protection;
  78   ULONG Attributes;
  79   ULONG Length;
  80   ULONG RawLength;
  81   KMUTEX Lock;
  82   ULONG ReferenceCount;
  83   SECTION_PAGE_DIRECTORY PageDirectory;
  84   ULONG Flags;
  85   PVOID VirtualAddress;
  86   ULONG Characteristics;
  87   BOOLEAN WriteCopy;
  88 } MM_SECTION_SEGMENT, *PMM_SECTION_SEGMENT;
  89
  90 typedef struct
  91 {
  92   CSHORT Type;
  93   CSHORT Size;
  94   LARGE_INTEGER MaximumSize;
  95   ULONG SectionPageProtection;
  96   ULONG AllocationAttributes;
  97   PFILE_OBJECT FileObject;
  98   LIST_ENTRY ViewListHead;
  99   KSPIN_LOCK ViewListLock;
 100   KMUTEX Lock;
 101   ULONG NrSegments;
 102   PMM_SECTION_SEGMENT Segments;
 103   PVOID ImageBase;
 104   PVOID EntryPoint;
 105   ULONG StackReserve;
 106   ULONG StackCommit;
 107   ULONG Subsystem;
 108   ULONG MinorSubsystemVersion;
 109   ULONG MajorSubsystemVersion;
 110   ULONG ImageCharacteristics;
 111   USHORT Machine;
 112   BOOLEAN Executable;
 113 } SECTION_OBJECT, *PSECTION_OBJECT;
 114
 115 typedef struct
 116 {
 117   ULONG Type;
 118   PVOID BaseAddress;
 119   ULONG Length;
 120   ULONG Attributes;
 121   LIST_ENTRY Entry;
 122   ULONG LockCount;
 123   struct _EPROCESS* Process;
 124   BOOLEAN DeleteInProgress;
 125   ULONG PageOpCount;
 126   union
 127   {
 128     struct
 129     {
 130       SECTION_OBJECT* Section;
 131       ULONG ViewOffset;
 132       LIST_ENTRY ViewListEntry;
 133       PMM_SECTION_SEGMENT Segment;
 134       BOOLEAN WriteCopyView;
 135       LIST_ENTRY RegionListHead;
 136     } SectionData;
 137     struct
 138     {
 139       LIST_ENTRY RegionListHead;
 140     } VirtualMemoryData;
 141   } Data;
 142 } MEMORY_AREA, *PMEMORY_AREA;
 143
 144 typedef struct _MADDRESS_SPACE
 145 {
 146   LIST_ENTRY MAreaListHead;
 147   FAST_MUTEX Lock;
 148   ULONG LowestAddress;
 149   struct _EPROCESS* Process;
 150   PUSHORT PageTableRefCountTable;
 151   ULONG PageTableRefCountTableSize;
 152 } MADDRESS_SPACE, *PMADDRESS_SPACE;
 153
 154 /* FUNCTIONS */
 155
 156 VOID MmLockAddressSpace(PMADDRESS_SPACE AddressSpace);
 157 VOID MmUnlockAddressSpace(PMADDRESS_SPACE AddressSpace);
 158 VOID MmInitializeKernelAddressSpace(VOID);
 159 PMADDRESS_SPACE MmGetCurrentAddressSpace(VOID);
 160 PMADDRESS_SPACE MmGetKernelAddressSpace(VOID);
 161 NTSTATUS MmInitializeAddressSpace(struct _EPROCESS* Process,
 162                                   PMADDRESS_SPACE AddressSpace);
 163 NTSTATUS MmDestroyAddressSpace(PMADDRESS_SPACE AddressSpace);
 164 PVOID STDCALL MmAllocateSection (IN ULONG Length);
 165 NTSTATUS MmCreateMemoryArea(struct _EPROCESS* Process,
 166                             PMADDRESS_SPACE AddressSpace,
 167                             ULONG Type,
 168                             PVOID* BaseAddress,
 169                             ULONG Length,
 170                             ULONG Attributes,
 171                             MEMORY_AREA** Result,
 172                             BOOL FixedAddress);
 173 MEMORY_AREA* MmOpenMemoryAreaByAddress(PMADDRESS_SPACE AddressSpace,
 174                                        PVOID Address);
 175 NTSTATUS MmInitMemoryAreas(VOID);
 176 VOID ExInitNonPagedPool(ULONG BaseAddress);
 177 NTSTATUS MmFreeMemoryArea(PMADDRESS_SPACE AddressSpace,
 178                           PVOID BaseAddress,
 179                           ULONG Length,
 180                           VOID (*FreePage)(PVOID Context, MEMORY_AREA* MemoryArea,
 181                                            PVOID Address, PHYSICAL_ADDRESS PhysAddr, SWAPENTRY SwapEntry,
 182                                            BOOLEAN Dirty),
 183                           PVOID FreePageContext);
 184 VOID MmDumpMemoryAreas(PLIST_ENTRY ListHead);
 185 NTSTATUS MmLockMemoryArea(MEMORY_AREA* MemoryArea);
 186 NTSTATUS MmUnlockMemoryArea(MEMORY_AREA* MemoryArea);
 187 NTSTATUS MmInitSectionImplementation(VOID);
 188
 189 #define MM_LOWEST_USER_ADDRESS (4096)
 190
 191 PMEMORY_AREA MmSplitMemoryArea(struct _EPROCESS* Process,
 192                                PMADDRESS_SPACE AddressSpace,
 193                                PMEMORY_AREA OriginalMemoryArea,
 194                                PVOID BaseAddress,
 195                                ULONG Length,
 196                                ULONG NewType,
 197                                ULONG NewAttributes);
 198 PVOID
 199 MmInitializePageList(PVOID FirstPhysKernelAddress,
 200                      PVOID LastPhysKernelAddress,
 201                      ULONG MemorySizeInPages,
 202                      ULONG LastKernelBase,
 203                      PADDRESS_RANGE BIOSMemoryMap,
 204                      ULONG AddressRangeCount);
 205 PHYSICAL_ADDRESS
 206 MmAllocPage(ULONG Consumer, SWAPENTRY SavedSwapEntry);
 207 VOID MmDereferencePage(PHYSICAL_ADDRESS PhysicalAddress);
 208 VOID MmReferencePage(PHYSICAL_ADDRESS PhysicalAddress);
 209 VOID MmDeletePageTable(struct _EPROCESS* Process,
 210                        PVOID Address);
 211 NTSTATUS MmCopyMmInfo(struct _EPROCESS* Src,
 212                       struct _EPROCESS* Dest);
 213 NTSTATUS MmReleaseMmInfo(struct _EPROCESS* Process);
 214 NTSTATUS Mmi386ReleaseMmInfo(struct _EPROCESS* Process);
 215 VOID
 216 MmDeleteVirtualMapping(struct _EPROCESS* Process,
 217                        PVOID Address,
 218                        BOOL FreePage,
 219                        BOOL* WasDirty,
 220                        PHYSICAL_ADDRESS* PhysicalPage);
 221
 222 #define MM_PAGE_CLEAN     (0)
 223 #define MM_PAGE_DIRTY     (1)
 224
 225 VOID MmBuildMdlFromPages(PMDL Mdl, PULONG Pages);
 226 PVOID MmGetMdlPageAddress(PMDL Mdl, PVOID Offset);
 227 VOID MiShutdownMemoryManager(VOID);
 228 PHYSICAL_ADDRESS
 229 MmGetPhysicalAddressForProcess(struct _EPROCESS* Process,
 230                                PVOID Address);
 231 NTSTATUS STDCALL
 232 MmUnmapViewOfSection(struct _EPROCESS* Process, PVOID BaseAddress);
 233 VOID MmInitPagingFile(VOID);
 234
 235 /* FIXME: it should be in ddk/mmfuncs.h */
 236 NTSTATUS
 237 STDCALL
 238 MmCreateSection (
 239         OUT     PSECTION_OBJECT         * SectionObject,
 240         IN      ACCESS_MASK             DesiredAccess,
 241         IN      POBJECT_ATTRIBUTES      ObjectAttributes        OPTIONAL,
 242         IN      PLARGE_INTEGER          MaximumSize,
 243         IN      ULONG                   SectionPageProtection,
 244         IN      ULONG                   AllocationAttributes,
 245         IN      HANDLE                  FileHandle              OPTIONAL,
 246         IN      PFILE_OBJECT            File                    OPTIONAL
 247         );
 248
 249 NTSTATUS MmPageFault(ULONG Cs,
 250                      PULONG Eip,
 251                      PULONG Eax,
 252                      ULONG Cr2,
 253                      ULONG ErrorCode);
 254
 255 NTSTATUS
 256 MmAccessFault(KPROCESSOR_MODE Mode,
 257               ULONG Address,
 258               BOOLEAN FromMdl);
 259 NTSTATUS
 260 MmNotPresentFault(KPROCESSOR_MODE Mode,
 261                   ULONG Address,
 262                   BOOLEAN FromMdl);
 263 NTSTATUS
 264 MmNotPresentFaultVirtualMemory(PMADDRESS_SPACE AddressSpace,
 265                                MEMORY_AREA* MemoryArea,
 266                                PVOID Address,
 267                                BOOLEAN Locked);
 268 NTSTATUS
 269 MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
 270                              MEMORY_AREA* MemoryArea,
 271                              PVOID Address,
 272                              BOOLEAN Locked);
 273 NTSTATUS MmWaitForPage(PVOID Page);
 274 VOID MmClearWaitPage(PVOID Page);
 275 VOID MmSetWaitPage(PVOID Page);
 276 BOOLEAN MmIsDirtyPage(struct _EPROCESS* Process, PVOID Address);
 277 BOOLEAN MmIsPageTablePresent(PVOID PAddress);
 278 NTSTATUS
 279 MmPageOutVirtualMemory(PMADDRESS_SPACE AddressSpace,
 280                        PMEMORY_AREA MemoryArea,
 281                        PVOID Address,
 282                        struct _MM_PAGEOP* PageOp);
 283 NTSTATUS
 284 MmPageOutSectionView(PMADDRESS_SPACE AddressSpace,
 285                        PMEMORY_AREA MemoryArea,
 286                        PVOID Address,
 287                        struct _MM_PAGEOP* PageOp);
 288 MEMORY_AREA* MmOpenMemoryAreaByRegion(PMADDRESS_SPACE AddressSpace,
 289                                       PVOID Address,
 290                                       ULONG Length);
 291 PVOID MmFindGap(PMADDRESS_SPACE AddressSpace, ULONG Length);
 292 VOID ExUnmapPage(PVOID Addr);
 293 PVOID ExAllocatePage(VOID);
 294
 295 VOID MmInitPagingFile(VOID);
 296 BOOLEAN MmReserveSwapPages(ULONG Nr);
 297 VOID MmDereserveSwapPages(ULONG Nr);
 298 SWAPENTRY MmAllocSwapPage(VOID);
 299 VOID MmFreeSwapPage(SWAPENTRY Entry);
 300
 301 VOID MmInit1(ULONG FirstKernelPhysAddress,
 302              ULONG LastKernelPhysAddress,
 303              ULONG LastKernelAddress,
 304        PADDRESS_RANGE BIOSMemoryMap,
 305        ULONG AddressRangeCount);
 306 VOID MmInit2(VOID);
 307 VOID MmInit3(VOID);
 308 NTSTATUS MmInitPagerThread(VOID);
 309
 310 VOID MmInitKernelMap(PVOID BaseAddress);
 311 NTSTATUS MmCreatePageTable(PVOID PAddress);
 312
 313 typedef struct
 314 {
 315    ULONG NrTotalPages;
 316    ULONG NrSystemPages;
 317    ULONG NrReservedPages;
 318    ULONG NrUserPages;
 319    ULONG NrFreePages;
 320    ULONG NrDirtyPages;
 321    ULONG NrLockedPages;
 322    ULONG PagingRequestsInLastMinute;
 323    ULONG PagingRequestsInLastFiveMinutes;
 324    ULONG PagingRequestsInLastFifteenMinutes;
 325 } MM_STATS;
 326
 327 extern MM_STATS MmStats;
 328
 329 PVOID
 330 MmGetDirtyPagesFromWorkingSet(struct _EPROCESS* Process);
 331 NTSTATUS
 332 MmWriteToSwapPage(SWAPENTRY SwapEntry, PMDL Mdl);
 333 NTSTATUS
 334 MmReadFromSwapPage(SWAPENTRY SwapEntry, PMDL Mdl);
 335 VOID
 336 MmSetFlagsPage(PHYSICAL_ADDRESS PhysicalAddress, ULONG Flags);
 337 ULONG
 338 MmGetFlagsPage(PHYSICAL_ADDRESS PhysicalAddress);
 339 VOID MmSetSavedSwapEntryPage(PHYSICAL_ADDRESS PhysicalAddress,
 340                              SWAPENTRY SavedSwapEntry);
 341 SWAPENTRY MmGetSavedSwapEntryPage(PHYSICAL_ADDRESS PhysicalAddress);
 342 VOID MmSetCleanPage(struct _EPROCESS* Process, PVOID Address);
 343 VOID MmLockPage(PHYSICAL_ADDRESS PhysicalPage);
 344 VOID MmUnlockPage(PHYSICAL_ADDRESS PhysicalPage);
 345
 346 NTSTATUS MmSafeCopyFromUser(PVOID Dest, PVOID Src, ULONG Count);
 347 NTSTATUS MmSafeCopyToUser(PVOID Dest, PVOID Src, ULONG Count);
 348 NTSTATUS
 349 MmCreatePhysicalMemorySection(VOID);
 350 PHYSICAL_ADDRESS
 351 MmGetContinuousPages(ULONG NumberOfBytes,
 352                      PHYSICAL_ADDRESS HighestAcceptableAddress,
 353                      ULONG Alignment);
 354
 355 #define MM_PHYSICAL_PAGE_MPW_PENDING     (0x8)
 356
 357 NTSTATUS
 358 MmAccessFaultSectionView(PMADDRESS_SPACE AddressSpace,
 359                          MEMORY_AREA* MemoryArea,
 360                          PVOID Address,
 361                          BOOLEAN Locked);
 362 ULONG
 363 MmGetPageProtect(struct _EPROCESS* Process, PVOID Address);
 364 PVOID
 365 ExAllocatePageWithPhysPage(PHYSICAL_ADDRESS PhysPage);
 366 ULONG
 367 MmGetReferenceCountPage(PHYSICAL_ADDRESS PhysicalAddress);
 368 BOOLEAN
 369 MmIsUsablePage(PHYSICAL_ADDRESS PhysicalAddress);
 370
 371 #define MM_PAGEOP_PAGEIN        (1)
 372 #define MM_PAGEOP_PAGEOUT       (2)
 373 #define MM_PAGEOP_PAGESYNCH     (3)
 374 #define MM_PAGEOP_ACCESSFAULT   (4)
 375
 376 typedef struct _MM_PAGEOP
 377 {
 378   /* Type of operation. */
 379   ULONG OpType;
 380   /* Number of threads interested in this operation. */
 381   ULONG ReferenceCount;
 382   /* Event that will be set when the operation is completed. */
 383   KEVENT CompletionEvent;
 384   /* Status of the operation once it is completed. */
 385   NTSTATUS Status;
 386   /* TRUE if the operation was abandoned. */
 387   BOOLEAN Abandoned;
 388   /* The memory area to be affected by the operation. */
 389   PMEMORY_AREA MArea;
 390   ULONG Hash;
 391   struct _MM_PAGEOP* Next;
 392   struct _ETHREAD* Thread;
 393   /*
 394    * These fields are used to identify the operation if it is against a
 395    * virtual memory area.
 396    */
 397   ULONG Pid;
 398   PVOID Address;
 399   /*
 400    * These fields are used to identify the operation if it is against a
 401    * section mapping.
 402    */
 403   PMM_SECTION_SEGMENT Segment;
 404   ULONG Offset;
 405 } MM_PAGEOP, *PMM_PAGEOP;
 406
 407 VOID
 408 MmReleasePageOp(PMM_PAGEOP PageOp);
 409
 410 PMM_PAGEOP
 411 MmGetPageOp(PMEMORY_AREA MArea, ULONG Pid, PVOID Address,
 412             PMM_SECTION_SEGMENT Segment, ULONG Offset, ULONG OpType);
 413 PMM_PAGEOP
 414 MmCheckForPageOp(PMEMORY_AREA MArea, ULONG Pid, PVOID Address,
 415                  PMM_SECTION_SEGMENT Segment, ULONG Offset);
 416 VOID
 417 MmInitializePageOp(VOID);
 418 VOID
 419 MiDebugDumpNonPagedPool(BOOLEAN NewOnly);
 420 VOID
 421 MiDebugDumpNonPagedPoolStats(BOOLEAN NewOnly);
 422 VOID
 423 MmMarkPageMapped(PHYSICAL_ADDRESS PhysicalAddress);
 424 VOID
 425 MmMarkPageUnmapped(PHYSICAL_ADDRESS PhysicalAddress);
 426 VOID
 427 MmFreeSectionSegments(PFILE_OBJECT FileObject);
 428
 429 typedef struct _MM_IMAGE_SECTION_OBJECT
 430 {
 431   ULONG NrSegments;
 432   MM_SECTION_SEGMENT Segments[0];
 433 } MM_IMAGE_SECTION_OBJECT, *PMM_IMAGE_SECTION_OBJECT;
 434
 435 VOID
 436 MmFreeVirtualMemory(struct _EPROCESS* Process, PMEMORY_AREA MemoryArea);
 437 NTSTATUS
 438 MiCopyFromUserPage(PHYSICAL_ADDRESS DestPhysPage, PVOID SourceAddress);
 439 NTSTATUS
 440 MiZeroPage(PHYSICAL_ADDRESS PhysPage);
 441 BOOLEAN
 442 MmIsAccessedAndResetAccessPage(struct _EPROCESS* Process, PVOID Address);
 443
 444 #define STATUS_MM_RESTART_OPERATION       ((NTSTATUS)0xD0000001)
 445
 446 NTSTATUS
 447 MmCreateVirtualMappingForKernel(PVOID Address,
 448                                 ULONG flProtect,
 449                                 PHYSICAL_ADDRESS PhysicalAddress);
 450 NTSTATUS MmCommitPagedPoolAddress(PVOID Address);
 451 NTSTATUS MmCreateVirtualMapping(struct _EPROCESS* Process,
 452                                 PVOID Address,
 453                                 ULONG flProtect,
 454                                 PHYSICAL_ADDRESS PhysicalAddress,
 455                                 BOOLEAN MayWait);
 456 NTSTATUS
 457 MmCreateVirtualMappingUnsafe(struct _EPROCESS* Process,
 458                              PVOID Address,
 459                              ULONG flProtect,
 460                              PHYSICAL_ADDRESS PhysicalAddress,
 461                              BOOLEAN MayWait);
 462
 463 VOID MmSetPageProtect(struct _EPROCESS* Process,
 464                       PVOID Address,
 465                       ULONG flProtect);
 466 BOOLEAN MmIsPagePresent(struct _EPROCESS* Process,
 467                         PVOID Address);
 468
 469 /* Memory balancing. */
 470 VOID
 471 MmInitializeMemoryConsumer(ULONG Consumer,
 472                            NTSTATUS (*Trim)(ULONG Target, ULONG Priority,
 473                                             PULONG NrFreed));
 474 VOID
 475 MmInitializeBalancer(ULONG NrAvailablePages);
 476 NTSTATUS
 477 MmReleasePageMemoryConsumer(ULONG Consumer, PHYSICAL_ADDRESS Page);
 478 NTSTATUS
 479 MmRequestPageMemoryConsumer(ULONG Consumer, BOOLEAN CanWait,
 480                             PHYSICAL_ADDRESS* AllocatedPage);
 481
 482 #define MC_CACHE          (0)
 483 #define MC_USER           (1)
 484 #define MC_PPOOL          (2)
 485 #define MC_NPPOOL         (3)
 486 #define MC_MAXIMUM        (4)
 487
 488 VOID
 489 MmSetRmapListHeadPage(PHYSICAL_ADDRESS PhysicalAddress,
 490                       struct _MM_RMAP_ENTRY* ListHead);
 491 struct _MM_RMAP_ENTRY*
 492 MmGetRmapListHeadPage(PHYSICAL_ADDRESS PhysicalAddress);
 493 VOID
 494 MmInsertRmap(PHYSICAL_ADDRESS PhysicalAddress, PEPROCESS Process,
 495              PVOID Address);
 496 VOID
 497 MmDeleteAllRmaps(PHYSICAL_ADDRESS PhysicalAddress, PVOID Context,
 498                  VOID (*DeleteMapping)(PVOID Context, PEPROCESS Process, PVOID Address));
 499 VOID
 500 MmDeleteRmap(PHYSICAL_ADDRESS PhysicalAddress, PEPROCESS Process,
 501              PVOID Address);
 502 VOID
 503 MmInitializeRmapList(VOID);
 504 PHYSICAL_ADDRESS
 505 MmGetLRUNextUserPage(PHYSICAL_ADDRESS PreviousPhysicalAddress);
 506 PHYSICAL_ADDRESS
 507 MmGetLRUFirstUserPage(VOID);
 508 NTSTATUS
 509 MmPageOutPhysicalAddress(PHYSICAL_ADDRESS PhysicalAddress);
 510 NTSTATUS
 511 MmTrimUserMemory(ULONG Target, ULONG Priority, PULONG NrFreedPages);
 512
 513 VOID
 514 MmDisableVirtualMapping(PEPROCESS Process, PVOID Address, BOOL* WasDirty, PHYSICAL_ADDRESS* PhysicalAddr);
 515 VOID MmEnableVirtualMapping(PEPROCESS Process, PVOID Address);
 516 VOID
 517 MmDeletePageFileMapping(PEPROCESS Process, PVOID Address,
 518                         SWAPENTRY* SwapEntry);
 519 NTSTATUS
 520 MmCreatePageFileMapping(PEPROCESS Process,
 521                         PVOID Address,
 522                         SWAPENTRY SwapEntry);
 523 BOOLEAN MmIsPageSwapEntry(PEPROCESS Process, PVOID Address);
 524 VOID
 525 MmTransferOwnershipPage(PHYSICAL_ADDRESS PhysicalAddress, ULONG NewConsumer);
 526 VOID MmSetDirtyPage(PEPROCESS Process, PVOID Address);
 527 VOID
 528 MmInitializeMdlImplementation(VOID);
 529 extern PHYSICAL_ADDRESS MmSharedDataPagePhysicalAddress;
 530 struct _KTRAP_FRAME;
 531 NTSTATUS STDCALL
 532 MmDumpToPagingFile(ULONG BugCode,
 533                    ULONG BugCodeParameter1,
 534                    ULONG BugCodeParameter2,
 535                    ULONG BugCodeParameter3,
 536                    ULONG BugCodeParameter4,
 537                    struct _KTRAP_FRAME* TrapFrame);
 538
 539 typedef VOID (*PMM_ALTER_REGION_FUNC)(PMADDRESS_SPACE AddressSpace,
 540                                       PVOID BaseAddress, ULONG Length,
 541                                       ULONG OldType, ULONG OldProtect,
 542                                       ULONG NewType, ULONG NewProtect);
 543
 544 typedef struct _MM_REGION
 545 {
 546    ULONG Type;
 547    ULONG Protect;
 548    ULONG Length;
 549    LIST_ENTRY RegionListEntry;
 550 } MM_REGION, *PMM_REGION;
 551
 552 NTSTATUS
 553 MmAlterRegion(PMADDRESS_SPACE AddressSpace, PVOID BaseAddress,
 554               PLIST_ENTRY RegionListHead, PVOID StartAddress, ULONG Length,
 555               ULONG NewType, ULONG NewProtect,
 556               PMM_ALTER_REGION_FUNC AlterFunc);
 557 VOID
 558 MmInitialiseRegion(PLIST_ENTRY RegionListHead, ULONG Length, ULONG Type,
 559                    ULONG Protect);
 560 PMM_REGION
 561 MmFindRegion(PVOID BaseAddress, PLIST_ENTRY RegionListHead, PVOID Address,
 562              PVOID* RegionBaseAddress);
 563 NTSTATUS STDCALL
 564 MmQueryAnonMem(PMEMORY_AREA MemoryArea,
 565                PVOID Address,
 566                PMEMORY_BASIC_INFORMATION Info,
 567                PULONG ResultLength);
 568 NTSTATUS STDCALL
 569 MmQuerySectionView(PMEMORY_AREA MemoryArea,
 570                    PVOID Address,
 571                    PMEMORY_BASIC_INFORMATION Info,
 572                    PULONG ResultLength);
 573 NTSTATUS
 574 MmProtectAnonMem(PMADDRESS_SPACE AddressSpace,
 575                  PMEMORY_AREA MemoryArea,
 576                  PVOID BaseAddress,
 577                  ULONG Length,
 578                  ULONG Protect,
 579                  PULONG OldProtect);
 580 NTSTATUS
 581 MmProtectSectionView(PMADDRESS_SPACE AddressSpace,
 582                      PMEMORY_AREA MemoryArea,
 583                      PVOID BaseAddress,
 584                      ULONG Length,
 585                      ULONG Protect,
 586                      PULONG OldProtect);
 587 NTSTATUS
 588 MmWritePageSectionView(PMADDRESS_SPACE AddressSpace,
 589                        PMEMORY_AREA MArea,
 590                        PVOID Address,
 591                        PMM_PAGEOP PageOp);
 592 NTSTATUS
 593 MmWritePageVirtualMemory(PMADDRESS_SPACE AddressSpace,
 594                          PMEMORY_AREA MArea,
 595                          PVOID Address,
 596                          PMM_PAGEOP PageOp);
 597 VOID
 598 MmSetCleanAllRmaps(PHYSICAL_ADDRESS PhysicalAddress);
 599 VOID
 600 MmSetDirtyAllRmaps(PHYSICAL_ADDRESS PhysicalAddress);
 601 NTSTATUS
 602 MmWritePagePhysicalAddress(PHYSICAL_ADDRESS PhysicalAddress);
 603 BOOL
 604 MmIsDirtyPageRmap(PHYSICAL_ADDRESS PhysicalAddress);
 605 NTSTATUS MmInitMpwThread(VOID);
 606 BOOLEAN
 607 MmIsAvailableSwapPage(VOID);
 608 VOID
 609 MmShowOutOfSpaceMessagePagingFile(VOID);
 610
 611 #endif