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