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 MmTotalPagedPoolQuota;
  17 extern ULONG MmTotalNonPagedPoolQuota;
  18
  19 struct _EPROCESS;
  20
  21 struct _MM_RMAP_ENTRY;
  22 struct _MM_PAGEOP;
  23 typedef ULONG SWAPENTRY;
  24
  25 typedef ULONG PFN_TYPE, *PPFN_TYPE;
  26
  27 #define MEMORY_AREA_INVALID              (0)
  28 #define MEMORY_AREA_SECTION_VIEW         (1)
  29 #define MEMORY_AREA_CONTINUOUS_MEMORY    (2)
  30 #define MEMORY_AREA_NO_CACHE             (3)
  31 #define MEMORY_AREA_IO_MAPPING           (4)
  32 #define MEMORY_AREA_SYSTEM               (5)
  33 #define MEMORY_AREA_MDL_MAPPING          (7)
  34 #define MEMORY_AREA_VIRTUAL_MEMORY       (8)
  35 #define MEMORY_AREA_CACHE_SEGMENT        (9)
  36 #define MEMORY_AREA_SHARED_DATA          (10)
  37 #define MEMORY_AREA_KERNEL_STACK         (11)
  38 #define MEMORY_AREA_PAGED_POOL           (12)
  39 #define MEMORY_AREA_NO_ACCESS            (13)
  40
  41 #define PAGE_TO_SECTION_PAGE_DIRECTORY_OFFSET(x) \
  42                           ((x) / (4*1024*1024))
  43 #define PAGE_TO_SECTION_PAGE_TABLE_OFFSET(x) \
  44                       ((((x)) % (4*1024*1024)) / (4*1024))
  45
  46 #define NR_SECTION_PAGE_TABLES           (1024)
  47 #define NR_SECTION_PAGE_ENTRIES          (1024)
  48
  49 #ifndef __USE_W32API
  50 #define MM_LOWEST_USER_ADDRESS (PVOID)0x10000
  51 #endif
  52
  53 #define MM_VIRTMEM_GRANULARITY (64 * 1024) /* Although Microsoft says this isn't hardcoded anymore,
  54                                               they won't be able to change it. Stuff depends on it */
  55
  56 #define STATUS_MM_RESTART_OPERATION       ((NTSTATUS)0xD0000001)
  57
  58 /*
  59  * Additional flags for protection attributes
  60  */
  61 #define PAGE_WRITETHROUGH                       (1024)
  62 #define PAGE_SYSTEM                             (2048)
  63 #define PAGE_FLAGS_VALID_FROM_USER_MODE               (PAGE_READONLY | \
  64                                                  PAGE_READWRITE | \
  65                                                  PAGE_WRITECOPY | \
  66                                                  PAGE_EXECUTE | \
  67                                                  PAGE_EXECUTE_READ | \
  68                                                  PAGE_EXECUTE_READWRITE | \
  69                                                  PAGE_EXECUTE_WRITECOPY | \
  70                                                  PAGE_GUARD | \
  71                                                  PAGE_NOACCESS | \
  72                                                  PAGE_NOCACHE)
  73
  74 #define PAGE_IS_READABLE (PAGE_READONLY | \
  75                           PAGE_READWRITE | \
  76                           PAGE_WRITECOPY | \
  77                           PAGE_EXECUTE_READ | \
  78                           PAGE_EXECUTE_READWRITE | \
  79                           PAGE_EXECUTE_WRITECOPY)
  80
  81 #define PAGE_IS_WRITABLE (PAGE_READWRITE | \
  82                           PAGE_WRITECOPY | \
  83                           PAGE_EXECUTE_READWRITE | \
  84                           PAGE_EXECUTE_WRITECOPY)
  85
  86 #define PAGE_IS_EXECUTABLE (PAGE_EXECUTE | \
  87                             PAGE_EXECUTE_READ | \
  88                             PAGE_EXECUTE_READWRITE | \
  89                             PAGE_EXECUTE_WRITECOPY)
  90
  91 #define PAGE_IS_WRITECOPY (PAGE_WRITECOPY | \
  92                            PAGE_EXECUTE_WRITECOPY)
  93
  94 typedef struct
  95 {
  96   ULONG Entry[NR_SECTION_PAGE_ENTRIES];
  97 } SECTION_PAGE_TABLE, *PSECTION_PAGE_TABLE;
  98
  99 typedef struct
 100 {
 101    PSECTION_PAGE_TABLE PageTables[NR_SECTION_PAGE_TABLES];
 102 } SECTION_PAGE_DIRECTORY, *PSECTION_PAGE_DIRECTORY;
 103
 104 #define SEC_PHYSICALMEMORY     (0x80000000)
 105
 106 #define MM_PAGEFILE_SEGMENT    (0x1)
 107 #define MM_DATAFILE_SEGMENT    (0x2)
 108
 109 typedef struct _MM_SECTION_SEGMENT
 110 {
 111   LONGLONG FileOffset;
 112   ULONG_PTR VirtualAddress;
 113   ULONG RawLength;
 114   ULONG Length;
 115   ULONG Protection;
 116   FAST_MUTEX Lock;
 117   ULONG ReferenceCount;
 118   SECTION_PAGE_DIRECTORY PageDirectory;
 119   ULONG Flags;
 120   ULONG Characteristics;
 121   BOOLEAN WriteCopy;
 122 } MM_SECTION_SEGMENT, *PMM_SECTION_SEGMENT;
 123
 124 typedef struct _MM_IMAGE_SECTION_OBJECT
 125 {
 126   ULONG_PTR ImageBase;
 127   ULONG_PTR StackReserve;
 128   ULONG_PTR StackCommit;
 129   ULONG_PTR EntryPoint;
 130   ULONG Subsystem;
 131   ULONG ImageCharacteristics;
 132   USHORT MinorSubsystemVersion;
 133   USHORT MajorSubsystemVersion;
 134   USHORT Machine;
 135   BOOLEAN Executable;
 136   ULONG NrSegments;
 137   PMM_SECTION_SEGMENT Segments;
 138 } MM_IMAGE_SECTION_OBJECT, *PMM_IMAGE_SECTION_OBJECT;
 139
 140 typedef struct _SECTION_OBJECT
 141 {
 142   CSHORT Type;
 143   CSHORT Size;
 144   LARGE_INTEGER MaximumSize;
 145   ULONG SectionPageProtection;
 146   ULONG AllocationAttributes;
 147   PFILE_OBJECT FileObject;
 148   LIST_ENTRY ViewListHead;
 149   KSPIN_LOCK ViewListLock;
 150   union
 151   {
 152     PMM_IMAGE_SECTION_OBJECT ImageSection;
 153     PMM_SECTION_SEGMENT Segment;
 154   };
 155 } SECTION_OBJECT;
 156
 157 #ifndef __USE_W32API
 158
 159 typedef struct _SECTION_OBJECT *PSECTION_OBJECT;
 160
 161 typedef struct _EPROCESS_QUOTA_BLOCK {
 162 KSPIN_LOCK      QuotaLock;
 163 ULONG           ReferenceCount;
 164 ULONG           QuotaPeakPoolUsage[2];
 165 ULONG           QuotaPoolUsage[2];
 166 ULONG           QuotaPoolLimit[2];
 167 ULONG           PeakPagefileUsage;
 168 ULONG           PagefileUsage;
 169 ULONG           PagefileLimit;
 170 } EPROCESS_QUOTA_BLOCK, *PEPROCESS_QUOTA_BLOCK;
 171
 172 /*
 173  * header mess....
 174  */
 175
 176 typedef struct _PAGEFAULT_HISTORY
 177 {
 178     ULONG                                 CurrentIndex;
 179     ULONG                                 MaxIndex;
 180     KSPIN_LOCK                            SpinLock;
 181     PVOID                                 Reserved;
 182     struct _PROCESS_WS_WATCH_INFORMATION  WatchInfo[1];
 183 } PAGEFAULT_HISTORY, *PPAGEFAULT_HISTORY;
 184
 185 #endif /* __USE_W32API */
 186
 187 typedef struct _MEMORY_AREA
 188 {
 189   PVOID StartingAddress;
 190   PVOID EndingAddress;
 191   struct _MEMORY_AREA *Parent;
 192   struct _MEMORY_AREA *LeftChild;
 193   struct _MEMORY_AREA *RightChild;
 194   ULONG Type;
 195   ULONG Attributes;
 196   ULONG LockCount;
 197   struct _EPROCESS* Process; /* FIXME: We don't need this! */
 198   BOOLEAN DeleteInProgress;
 199   ULONG PageOpCount;
 200   union
 201   {
 202     struct
 203     {
 204       SECTION_OBJECT* Section;
 205       ULONG ViewOffset;
 206       LIST_ENTRY ViewListEntry;
 207       PMM_SECTION_SEGMENT Segment;
 208       BOOLEAN WriteCopyView;
 209       LIST_ENTRY RegionListHead;
 210     } SectionData;
 211     struct
 212     {
 213       LIST_ENTRY RegionListHead;
 214     } VirtualMemoryData;
 215   } Data;
 216 } MEMORY_AREA, *PMEMORY_AREA;
 217
 218 typedef struct _MADDRESS_SPACE
 219 {
 220   PMEMORY_AREA MemoryAreaRoot;
 221   FAST_MUTEX Lock;
 222   PVOID LowestAddress;
 223   struct _EPROCESS* Process;
 224   PUSHORT PageTableRefCountTable;
 225   ULONG PageTableRefCountTableSize;
 226 } MADDRESS_SPACE, *PMADDRESS_SPACE;
 227
 228 typedef struct _KNODE {
 229    ULONG ProcessorMask;
 230    ULONG Color;
 231    ULONG MmShiftedColor;
 232    ULONG FreeCount[2];
 233    SLIST_HEADER DeadStackList;
 234    SLIST_HEADER PfnDereferenceSListHead;
 235    struct _SINGLE_LIST_ENTRY *PfnDeferredList;
 236    UCHAR Seed;
 237    UCHAR NodeNumber;
 238    ULONG Flags;
 239 } KNODE, *PKNODE;
 240
 241 #ifndef __USE_W32API
 242 /* VARIABLES */
 243
 244 #ifdef __NTOSKRNL__
 245 extern PVOID EXPORTED MmSystemRangeStart;
 246 #else
 247 extern PVOID IMPORTED MmSystemRangeStart;
 248 #endif
 249
 250 #endif /* __USE_W32API */
 251
 252 typedef struct
 253 {
 254    ULONG NrTotalPages;
 255    ULONG NrSystemPages;
 256    ULONG NrReservedPages;
 257    ULONG NrUserPages;
 258    ULONG NrFreePages;
 259    ULONG NrDirtyPages;
 260    ULONG NrLockedPages;
 261    ULONG PagingRequestsInLastMinute;
 262    ULONG PagingRequestsInLastFiveMinutes;
 263    ULONG PagingRequestsInLastFifteenMinutes;
 264 } MM_STATS;
 265
 266 extern MM_STATS MmStats;
 267
 268 #define MM_PHYSICAL_PAGE_MPW_PENDING     (0x8)
 269
 270 #define MM_PAGEOP_PAGEIN        (1)
 271 #define MM_PAGEOP_PAGEOUT       (2)
 272 #define MM_PAGEOP_PAGESYNCH     (3)
 273 #define MM_PAGEOP_ACCESSFAULT   (4)
 274
 275 typedef struct _MM_PAGEOP
 276 {
 277   /* Type of operation. */
 278   ULONG OpType;
 279   /* Number of threads interested in this operation. */
 280   ULONG ReferenceCount;
 281   /* Event that will be set when the operation is completed. */
 282   KEVENT CompletionEvent;
 283   /* Status of the operation once it is completed. */
 284   NTSTATUS Status;
 285   /* TRUE if the operation was abandoned. */
 286   BOOLEAN Abandoned;
 287   /* The memory area to be affected by the operation. */
 288   PMEMORY_AREA MArea;
 289   ULONG Hash;
 290   struct _MM_PAGEOP* Next;
 291   struct _ETHREAD* Thread;
 292   /*
 293    * These fields are used to identify the operation if it is against a
 294    * virtual memory area.
 295    */
 296   ULONG Pid;
 297   PVOID Address;
 298   /*
 299    * These fields are used to identify the operation if it is against a
 300    * section mapping.
 301    */
 302   PMM_SECTION_SEGMENT Segment;
 303   ULONG Offset;
 304 } MM_PAGEOP, *PMM_PAGEOP;
 305
 306 #define MC_CACHE          (0)
 307 #define MC_USER           (1)
 308 #define MC_PPOOL          (2)
 309 #define MC_NPPOOL         (3)
 310 #define MC_MAXIMUM        (4)
 311
 312 typedef struct _MM_MEMORY_CONSUMER
 313 {
 314    ULONG PagesUsed;
 315    ULONG PagesTarget;
 316    NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed);
 317 }
 318 MM_MEMORY_CONSUMER, *PMM_MEMORY_CONSUMER;
 319
 320 extern MM_MEMORY_CONSUMER MiMemoryConsumers[MC_MAXIMUM];
 321
 322 extern PHYSICAL_ADDRESS MmSharedDataPagePhysicalAddress;
 323 struct _KTRAP_FRAME;
 324
 325 typedef VOID (*PMM_ALTER_REGION_FUNC)(PMADDRESS_SPACE AddressSpace,
 326                                       PVOID BaseAddress, ULONG Length,
 327                                       ULONG OldType, ULONG OldProtect,
 328                                       ULONG NewType, ULONG NewProtect);
 329
 330 typedef struct _MM_REGION
 331 {
 332    ULONG Type;
 333    ULONG Protect;
 334    ULONG Length;
 335    LIST_ENTRY RegionListEntry;
 336 } MM_REGION, *PMM_REGION;
 337
 338 typedef VOID (*PMM_FREE_PAGE_FUNC)(PVOID Context, PMEMORY_AREA MemoryArea,
 339                                    PVOID Address, PFN_TYPE Page,
 340                                    SWAPENTRY SwapEntry, BOOLEAN Dirty);
 341
 342 /* FUNCTIONS */
 343
 344 /* aspace.c ******************************************************************/
 345
 346 VOID MmLockAddressSpace(PMADDRESS_SPACE AddressSpace);
 347
 348 VOID MmUnlockAddressSpace(PMADDRESS_SPACE AddressSpace);
 349
 350 VOID MmInitializeKernelAddressSpace(VOID);
 351
 352 PMADDRESS_SPACE MmGetCurrentAddressSpace(VOID);
 353
 354 PMADDRESS_SPACE MmGetKernelAddressSpace(VOID);
 355
 356 NTSTATUS MmInitializeAddressSpace(struct _EPROCESS* Process,
 357                                   PMADDRESS_SPACE AddressSpace);
 358
 359 NTSTATUS MmDestroyAddressSpace(PMADDRESS_SPACE AddressSpace);
 360
 361 /* marea.c *******************************************************************/
 362
 363 NTSTATUS INIT_FUNCTION
 364 MmInitMemoryAreas(VOID);
 365
 366 NTSTATUS STDCALL
 367 MmCreateMemoryArea(
 368    struct _EPROCESS* Process,
 369    PMADDRESS_SPACE AddressSpace,
 370    ULONG Type,
 371    PVOID *BaseAddress,
 372    ULONG_PTR Length,
 373    ULONG Attributes,
 374    PMEMORY_AREA *Result,
 375    BOOLEAN FixedAddress,
 376    BOOLEAN TopDown,
 377    PHYSICAL_ADDRESS BoundaryAddressMultiple OPTIONAL);
 378
 379 PMEMORY_AREA STDCALL
 380 MmLocateMemoryAreaByAddress(
 381    PMADDRESS_SPACE AddressSpace,
 382    PVOID Address);
 383
 384 ULONG_PTR STDCALL
 385 MmFindGapAtAddress(
 386    PMADDRESS_SPACE AddressSpace,
 387    PVOID Address);
 388
 389 NTSTATUS STDCALL
 390 MmFreeMemoryArea(
 391    PMADDRESS_SPACE AddressSpace,
 392    PMEMORY_AREA MemoryArea,
 393    PMM_FREE_PAGE_FUNC FreePage,
 394    PVOID FreePageContext);
 395
 396 NTSTATUS STDCALL
 397 MmFreeMemoryAreaByPtr(
 398    PMADDRESS_SPACE AddressSpace,
 399    PVOID BaseAddress,
 400    PMM_FREE_PAGE_FUNC FreePage,
 401    PVOID FreePageContext);
 402
 403 VOID STDCALL
 404 MmDumpMemoryAreas(PMADDRESS_SPACE AddressSpace);
 405
 406 PMEMORY_AREA STDCALL
 407 MmLocateMemoryAreaByRegion(
 408    PMADDRESS_SPACE AddressSpace,
 409    PVOID Address,
 410    ULONG_PTR Length);
 411
 412 PVOID STDCALL
 413 MmFindGap(
 414    PMADDRESS_SPACE AddressSpace,
 415    ULONG_PTR Length,
 416    ULONG_PTR Granularity,
 417    BOOLEAN TopDown);
 418
 419 VOID STDCALL
 420 MmReleaseMemoryAreaIfDecommitted(
 421    PEPROCESS Process,
 422    PMADDRESS_SPACE AddressSpace,
 423    PVOID BaseAddress);
 424
 425 /* npool.c *******************************************************************/
 426
 427 VOID MiDebugDumpNonPagedPool(BOOLEAN NewOnly);
 428
 429 VOID MiDebugDumpNonPagedPoolStats(BOOLEAN NewOnly);
 430
 431 VOID MiInitializeNonPagedPool(VOID);
 432
 433 PVOID MmGetMdlPageAddress(PMDL Mdl, PVOID Offset);
 434
 435 /* pool.c *******************************************************************/
 436
 437 BOOLEAN
 438 STDCALL
 439 MiRaisePoolQuota(
 440     IN POOL_TYPE PoolType,
 441     IN ULONG CurrentMaxQuota,
 442     OUT PULONG NewMaxQuota
 443     );
 444
 445 /* mdl.c *********************************************************************/
 446
 447 VOID MmBuildMdlFromPages(PMDL Mdl, PULONG Pages);
 448
 449 /* mminit.c ******************************************************************/
 450
 451 VOID MiShutdownMemoryManager(VOID);
 452
 453 VOID MmInit1(ULONG FirstKernelPhysAddress,
 454              ULONG LastKernelPhysAddress,
 455              ULONG LastKernelAddress,
 456              PADDRESS_RANGE BIOSMemoryMap,
 457              ULONG AddressRangeCount,
 458              ULONG MaxMemInMeg);
 459
 460 VOID MmInit2(VOID);
 461
 462 VOID MmInit3(VOID);
 463
 464 VOID MiFreeInitMemory(VOID);
 465
 466 VOID MmInitializeMdlImplementation(VOID);
 467
 468 /* pagefile.c ****************************************************************/
 469
 470 SWAPENTRY MmAllocSwapPage(VOID);
 471
 472 VOID MmDereserveSwapPages(ULONG Nr);
 473
 474 VOID MmFreeSwapPage(SWAPENTRY Entry);
 475
 476 VOID MmInitPagingFile(VOID);
 477
 478 NTSTATUS MmReadFromSwapPage(SWAPENTRY SwapEntry, PFN_TYPE Page);
 479
 480 BOOLEAN MmReserveSwapPages(ULONG Nr);
 481
 482 NTSTATUS MmWriteToSwapPage(SWAPENTRY SwapEntry, PFN_TYPE Page);
 483
 484 NTSTATUS STDCALL
 485 MmDumpToPagingFile(ULONG BugCode,
 486                    ULONG BugCodeParameter1,
 487                    ULONG BugCodeParameter2,
 488                    ULONG BugCodeParameter3,
 489                    ULONG BugCodeParameter4,
 490                    struct _KTRAP_FRAME* TrapFrame);
 491
 492 BOOLEAN MmIsAvailableSwapPage(VOID);
 493
 494 VOID MmShowOutOfSpaceMessagePagingFile(VOID);
 495
 496 /* i386/pfault.c *************************************************************/
 497
 498 NTSTATUS MmPageFault(ULONG Cs,
 499                      PULONG Eip,
 500                      PULONG Eax,
 501                      ULONG Cr2,
 502                      ULONG ErrorCode);
 503
 504 /* mm.c **********************************************************************/
 505
 506 NTSTATUS MmAccessFault(KPROCESSOR_MODE Mode,
 507                        ULONG Address,
 508                        BOOLEAN FromMdl);
 509
 510 NTSTATUS MmNotPresentFault(KPROCESSOR_MODE Mode,
 511                            ULONG Address,
 512                            BOOLEAN FromMdl);
 513
 514 /* anonmem.c *****************************************************************/
 515
 516 NTSTATUS MmNotPresentFaultVirtualMemory(PMADDRESS_SPACE AddressSpace,
 517                                         MEMORY_AREA* MemoryArea,
 518                                         PVOID Address,
 519                                         BOOLEAN Locked);
 520
 521 NTSTATUS MmPageOutVirtualMemory(PMADDRESS_SPACE AddressSpace,
 522                                 PMEMORY_AREA MemoryArea,
 523                                 PVOID Address,
 524                                 struct _MM_PAGEOP* PageOp);
 525 NTSTATUS STDCALL
 526 MmQueryAnonMem(PMEMORY_AREA MemoryArea,
 527                PVOID Address,
 528                PMEMORY_BASIC_INFORMATION Info,
 529                PULONG ResultLength);
 530
 531 VOID MmFreeVirtualMemory(struct _EPROCESS* Process, PMEMORY_AREA MemoryArea);
 532
 533 NTSTATUS MmProtectAnonMem(PMADDRESS_SPACE AddressSpace,
 534                           PMEMORY_AREA MemoryArea,
 535                           PVOID BaseAddress,
 536                           ULONG Length,
 537                           ULONG Protect,
 538                           PULONG OldProtect);
 539
 540 NTSTATUS MmWritePageVirtualMemory(PMADDRESS_SPACE AddressSpace,
 541                                   PMEMORY_AREA MArea,
 542                                   PVOID Address,
 543                                   PMM_PAGEOP PageOp);
 544
 545 /* kmap.c ********************************************************************/
 546
 547 PVOID ExAllocatePage(VOID);
 548
 549 VOID ExUnmapPage(PVOID Addr);
 550
 551 VOID MiInitKernelMap(VOID);
 552
 553 PVOID ExAllocatePageWithPhysPage(PFN_TYPE Page);
 554
 555 NTSTATUS MiCopyFromUserPage(PFN_TYPE Page, PVOID SourceAddress);
 556
 557 NTSTATUS MiZeroPage(PFN_TYPE Page);
 558
 559 /* memsafe.s *****************************************************************/
 560
 561 NTSTATUS MmSafeCopyFromUser(PVOID Dest, const VOID *Src, ULONG Count);
 562
 563 NTSTATUS MmSafeCopyToUser(PVOID Dest, const VOID *Src, ULONG Count);
 564
 565 /* pageop.c ******************************************************************/
 566
 567 VOID
 568 MmReleasePageOp(PMM_PAGEOP PageOp);
 569
 570 PMM_PAGEOP
 571 MmGetPageOp(PMEMORY_AREA MArea, ULONG Pid, PVOID Address,
 572             PMM_SECTION_SEGMENT Segment, ULONG Offset, ULONG OpType, BOOL First);
 573 PMM_PAGEOP
 574 MmCheckForPageOp(PMEMORY_AREA MArea, ULONG Pid, PVOID Address,
 575                  PMM_SECTION_SEGMENT Segment, ULONG Offset);
 576 VOID
 577 MmInitializePageOp(VOID);
 578
 579 /* balace.c ******************************************************************/
 580
 581 VOID MmInitializeMemoryConsumer(ULONG Consumer,
 582                                 NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed));
 583
 584 VOID MmInitializeBalancer(ULONG NrAvailablePages, ULONG NrSystemPages);
 585
 586 NTSTATUS MmReleasePageMemoryConsumer(ULONG Consumer, PFN_TYPE Page);
 587
 588 NTSTATUS MmRequestPageMemoryConsumer(ULONG Consumer, BOOLEAN MyWait, PPFN_TYPE AllocatedPage);
 589
 590 VOID MiInitBalancerThread(VOID);
 591
 592 VOID MmRebalanceMemoryConsumers(VOID);
 593
 594 /* rmap.c **************************************************************/
 595
 596 VOID MmSetRmapListHeadPage(PFN_TYPE Page, struct _MM_RMAP_ENTRY* ListHead);
 597
 598 struct _MM_RMAP_ENTRY* MmGetRmapListHeadPage(PFN_TYPE Page);
 599
 600 VOID MmInsertRmap(PFN_TYPE Page, PEPROCESS Process, PVOID Address);
 601
 602 VOID MmDeleteAllRmaps(PFN_TYPE Page, PVOID Context,
 603                       VOID (*DeleteMapping)(PVOID Context, PEPROCESS Process, PVOID Address));
 604
 605 VOID MmDeleteRmap(PFN_TYPE Page, PEPROCESS Process, PVOID Address);
 606
 607 VOID MmInitializeRmapList(VOID);
 608
 609 VOID MmSetCleanAllRmaps(PFN_TYPE Page);
 610
 611 VOID MmSetDirtyAllRmaps(PFN_TYPE Page);
 612
 613 BOOL MmIsDirtyPageRmap(PFN_TYPE Page);
 614
 615 NTSTATUS MmWritePagePhysicalAddress(PFN_TYPE Page);
 616
 617 NTSTATUS MmPageOutPhysicalAddress(PFN_TYPE Page);
 618
 619 /* freelist.c **********************************************************/
 620
 621 PFN_TYPE MmGetLRUNextUserPage(PFN_TYPE PreviousPage);
 622
 623 PFN_TYPE MmGetLRUFirstUserPage(VOID);
 624
 625 VOID MmSetLRULastPage(PFN_TYPE Page);
 626
 627 VOID MmLockPage(PFN_TYPE Page);
 628
 629 VOID MmUnlockPage(PFN_TYPE Page);
 630
 631 ULONG MmGetLockCountPage(PFN_TYPE Page);
 632
 633 PVOID MmInitializePageList(PVOID FirstPhysKernelAddress,
 634                            PVOID LastPhysKernelAddress,
 635                            ULONG MemorySizeInPages,
 636                            ULONG LastKernelBase,
 637                            PADDRESS_RANGE BIOSMemoryMap,
 638                            ULONG AddressRangeCount);
 639
 640 PFN_TYPE MmGetContinuousPages(ULONG NumberOfBytes,
 641                               PHYSICAL_ADDRESS LowestAcceptableAddress,
 642                               PHYSICAL_ADDRESS HighestAcceptableAddress,
 643                               ULONG Alignment);
 644
 645 NTSTATUS MmInitZeroPageThread(VOID);
 646
 647 /* i386/page.c *********************************************************/
 648
 649 NTSTATUS MmCreateVirtualMappingForKernel(PVOID Address,
 650                                          ULONG flProtect,
 651                                          PPFN_TYPE Pages,
 652                                          ULONG PageCount);
 653
 654 NTSTATUS MmCommitPagedPoolAddress(PVOID Address, BOOLEAN Locked);
 655
 656 NTSTATUS MmCreateVirtualMapping(struct _EPROCESS* Process,
 657                                 PVOID Address,
 658                                 ULONG flProtect,
 659                                 PPFN_TYPE Pages,
 660                                 ULONG PageCount);
 661
 662 NTSTATUS MmCreateVirtualMappingUnsafe(struct _EPROCESS* Process,
 663                                       PVOID Address,
 664                                       ULONG flProtect,
 665                                       PPFN_TYPE Pages,
 666                                       ULONG PageCount);
 667
 668 ULONG MmGetPageProtect(struct _EPROCESS* Process, PVOID Address);
 669
 670 VOID MmSetPageProtect(struct _EPROCESS* Process,
 671                       PVOID Address,
 672                       ULONG flProtect);
 673
 674 BOOLEAN MmIsPagePresent(struct _EPROCESS* Process,
 675                         PVOID Address);
 676
 677 VOID MmInitGlobalKernelPageDirectory(VOID);
 678
 679 VOID MmDisableVirtualMapping(PEPROCESS Process, PVOID Address, BOOL* WasDirty, PPFN_TYPE Page);
 680
 681 VOID MmEnableVirtualMapping(PEPROCESS Process, PVOID Address);
 682
 683 VOID MmRawDeleteVirtualMapping(PVOID Address);
 684
 685 VOID MmDeletePageFileMapping(PEPROCESS Process, PVOID Address, SWAPENTRY* SwapEntry);
 686
 687 NTSTATUS MmCreatePageFileMapping(PEPROCESS Process, PVOID Address, SWAPENTRY SwapEntry);
 688
 689 BOOLEAN MmIsPageSwapEntry(PEPROCESS Process, PVOID Address);
 690
 691 VOID MmTransferOwnershipPage(PFN_TYPE Page, ULONG NewConsumer);
 692
 693 VOID MmSetDirtyPage(PEPROCESS Process, PVOID Address);
 694
 695 PFN_TYPE MmAllocPage(ULONG Consumer, SWAPENTRY SavedSwapEntry);
 696
 697 VOID MmDereferencePage(PFN_TYPE Page);
 698
 699 VOID MmReferencePage(PFN_TYPE Page);
 700
 701 BOOLEAN MmIsAccessedAndResetAccessPage(struct _EPROCESS* Process, PVOID Address);
 702
 703 ULONG MmGetReferenceCountPage(PFN_TYPE Page);
 704
 705 BOOLEAN MmIsUsablePage(PFN_TYPE Page);
 706
 707 VOID MmSetFlagsPage(PFN_TYPE Page, ULONG Flags);
 708
 709 ULONG MmGetFlagsPage(PFN_TYPE Page);
 710
 711 VOID MmSetSavedSwapEntryPage(PFN_TYPE Page, SWAPENTRY SavedSwapEntry);
 712
 713 SWAPENTRY MmGetSavedSwapEntryPage(PFN_TYPE Page);
 714
 715 VOID MmSetCleanPage(struct _EPROCESS* Process, PVOID Address);
 716
 717 NTSTATUS MmCreatePageTable(PVOID PAddress);
 718
 719 VOID MmDeletePageTable(struct _EPROCESS* Process, PVOID Address);
 720
 721 PFN_TYPE MmGetPfnForProcess(struct _EPROCESS* Process, PVOID Address);
 722
 723 NTSTATUS MmCopyMmInfo(struct _EPROCESS* Src, struct _EPROCESS* Dest);
 724
 725 NTSTATUS MmReleaseMmInfo(struct _EPROCESS* Process);
 726
 727 NTSTATUS Mmi386ReleaseMmInfo(struct _EPROCESS* Process);
 728
 729 VOID MmDeleteVirtualMapping(struct _EPROCESS* Process,
 730                             PVOID Address,
 731                             BOOL FreePage,
 732                             BOOL* WasDirty,
 733                             PPFN_TYPE Page);
 734
 735 BOOLEAN MmIsDirtyPage(struct _EPROCESS* Process, PVOID Address);
 736
 737 VOID MmMarkPageMapped(PFN_TYPE Page);
 738
 739 VOID MmMarkPageUnmapped(PFN_TYPE Page);
 740
 741 VOID MmUpdatePageDir(PEPROCESS Process, PVOID Address, ULONG Size);
 742
 743 VOID MiInitPageDirectoryMap(VOID);
 744
 745 ULONG MiGetUserPageDirectoryCount(VOID);
 746
 747 /* wset.c ********************************************************************/
 748
 749 NTSTATUS MmTrimUserMemory(ULONG Target, ULONG Priority, PULONG NrFreedPages);
 750
 751 /* region.c ************************************************************/
 752
 753 NTSTATUS MmAlterRegion(PMADDRESS_SPACE AddressSpace, PVOID BaseAddress,
 754                        PLIST_ENTRY RegionListHead, PVOID StartAddress, ULONG Length,
 755                        ULONG NewType, ULONG NewProtect,
 756                        PMM_ALTER_REGION_FUNC AlterFunc);
 757
 758 VOID MmInitialiseRegion(PLIST_ENTRY RegionListHead, ULONG Length, ULONG Type,
 759                         ULONG Protect);
 760
 761 PMM_REGION MmFindRegion(PVOID BaseAddress, PLIST_ENTRY RegionListHead, PVOID Address,
 762                         PVOID* RegionBaseAddress);
 763
 764 /* section.c *****************************************************************/
 765
 766 PVOID STDCALL
 767 MmAllocateSection (IN ULONG Length, PVOID BaseAddress);
 768
 769 NTSTATUS STDCALL
 770 MmQuerySectionView(PMEMORY_AREA MemoryArea,
 771                    PVOID Address,
 772                    PMEMORY_BASIC_INFORMATION Info,
 773                    PULONG ResultLength);
 774
 775 NTSTATUS
 776 MmProtectSectionView(PMADDRESS_SPACE AddressSpace,
 777                      PMEMORY_AREA MemoryArea,
 778                      PVOID BaseAddress,
 779                      ULONG Length,
 780                      ULONG Protect,
 781                      PULONG OldProtect);
 782
 783 NTSTATUS
 784 MmWritePageSectionView(PMADDRESS_SPACE AddressSpace,
 785                        PMEMORY_AREA MArea,
 786                        PVOID Address,
 787                        PMM_PAGEOP PageOp);
 788
 789 NTSTATUS MmInitSectionImplementation(VOID);
 790
 791 NTSTATUS STDCALL
 792 MmUnmapViewOfSection(struct _EPROCESS* Process, PVOID BaseAddress);
 793
 794 /* FIXME: it should be in ddk/mmfuncs.h */
 795 NTSTATUS STDCALL
 796 MmCreateSection (OUT    PSECTION_OBJECT         * SectionObject,
 797                  IN     ACCESS_MASK             DesiredAccess,
 798                  IN     POBJECT_ATTRIBUTES      ObjectAttributes        OPTIONAL,
 799                  IN     PLARGE_INTEGER          MaximumSize,
 800                  IN     ULONG                   SectionPageProtection,
 801                  IN     ULONG                   AllocationAttributes,
 802                  IN     HANDLE                  FileHandle              OPTIONAL,
 803                  IN     PFILE_OBJECT            File                    OPTIONAL);
 804
 805 NTSTATUS
 806 MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
 807                              MEMORY_AREA* MemoryArea,
 808                              PVOID Address,
 809                              BOOLEAN Locked);
 810
 811 NTSTATUS
 812 MmPageOutSectionView(PMADDRESS_SPACE AddressSpace,
 813                        PMEMORY_AREA MemoryArea,
 814                        PVOID Address,
 815                        struct _MM_PAGEOP* PageOp);
 816
 817 NTSTATUS
 818 MmCreatePhysicalMemorySection(VOID);
 819
 820 NTSTATUS
 821 MmAccessFaultSectionView(PMADDRESS_SPACE AddressSpace,
 822                          MEMORY_AREA* MemoryArea,
 823                          PVOID Address,
 824                          BOOLEAN Locked);
 825
 826 VOID
 827 MmFreeSectionSegments(PFILE_OBJECT FileObject);
 828
 829 /* mpw.c *********************************************************************/
 830
 831 NTSTATUS MmInitMpwThread(VOID);
 832
 833 /* pager.c *******************************************************************/
 834
 835 BOOLEAN MiIsPagerThread(VOID);
 836
 837 VOID MiStartPagerThread(VOID);
 838
 839 VOID MiStopPagerThread(VOID);
 840
 841 #endif