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