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