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