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