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_ENTRY {
 162     ULONG Usage;
 163     ULONG Limit;
 164     ULONG Peak;
 165     ULONG Return;
 166 } EPROCESS_QUOTA_ENTRY, *PEPROCESS_QUOTA_ENTRY;
 167
 168 typedef struct _EPROCESS_QUOTA_BLOCK {
 169     EPROCESS_QUOTA_ENTRY    QuotaEntry[3];
 170     LIST_ENTRY              QuotaList;
 171     ULONG                   ReferenceCount;
 172     ULONG                   ProcessCount;
 173 } EPROCESS_QUOTA_BLOCK, *PEPROCESS_QUOTA_BLOCK;
 174
 175 /*
 176  * header mess....
 177  */
 178
 179 typedef struct _PAGEFAULT_HISTORY
 180 {
 181     ULONG                                 CurrentIndex;
 182     ULONG                                 MaxIndex;
 183     KSPIN_LOCK                            SpinLock;
 184     PVOID                                 Reserved;
 185     struct _PROCESS_WS_WATCH_INFORMATION  WatchInfo[1];
 186 } PAGEFAULT_HISTORY, *PPAGEFAULT_HISTORY;
 187
 188 #endif /* __USE_W32API */
 189
 190 typedef struct _MEMORY_AREA
 191 {
 192   PVOID StartingAddress;
 193   PVOID EndingAddress;
 194   struct _MEMORY_AREA *Parent;
 195   struct _MEMORY_AREA *LeftChild;
 196   struct _MEMORY_AREA *RightChild;
 197   ULONG Type;
 198   ULONG Attributes;
 199   ULONG LockCount;
 200   struct _EPROCESS* Process; /* FIXME: We don't need this! */
 201   BOOLEAN DeleteInProgress;
 202   ULONG PageOpCount;
 203   union
 204   {
 205     struct
 206     {
 207       SECTION_OBJECT* Section;
 208       ULONG ViewOffset;
 209       LIST_ENTRY ViewListEntry;
 210       PMM_SECTION_SEGMENT Segment;
 211       BOOLEAN WriteCopyView;
 212       LIST_ENTRY RegionListHead;
 213     } SectionData;
 214     struct
 215     {
 216       LIST_ENTRY RegionListHead;
 217     } VirtualMemoryData;
 218   } Data;
 219 } MEMORY_AREA, *PMEMORY_AREA;
 220
 221 typedef struct _MADDRESS_SPACE
 222 {
 223   PMEMORY_AREA MemoryAreaRoot;
 224   FAST_MUTEX Lock;
 225   PVOID LowestAddress;
 226   struct _EPROCESS* Process;
 227   PUSHORT PageTableRefCountTable;
 228   ULONG PageTableRefCountTableSize;
 229 } MADDRESS_SPACE, *PMADDRESS_SPACE;
 230
 231 typedef struct _KNODE {
 232    ULONG ProcessorMask;
 233    ULONG Color;
 234    ULONG MmShiftedColor;
 235    ULONG FreeCount[2];
 236    SLIST_HEADER DeadStackList;
 237    SLIST_HEADER PfnDereferenceSListHead;
 238    struct _SINGLE_LIST_ENTRY *PfnDeferredList;
 239    UCHAR Seed;
 240    UCHAR NodeNumber;
 241    ULONG Flags;
 242 } KNODE, *PKNODE;
 243
 244 #ifndef __USE_W32API
 245 /* VARIABLES */
 246
 247 #ifdef __NTOSKRNL__
 248 extern PVOID EXPORTED MmSystemRangeStart;
 249 #else
 250 extern PVOID IMPORTED MmSystemRangeStart;
 251 #endif
 252
 253 #endif /* __USE_W32API */
 254
 255 typedef struct
 256 {
 257    ULONG NrTotalPages;
 258    ULONG NrSystemPages;
 259    ULONG NrReservedPages;
 260    ULONG NrUserPages;
 261    ULONG NrFreePages;
 262    ULONG NrDirtyPages;
 263    ULONG NrLockedPages;
 264    ULONG PagingRequestsInLastMinute;
 265    ULONG PagingRequestsInLastFiveMinutes;
 266    ULONG PagingRequestsInLastFifteenMinutes;
 267 } MM_STATS;
 268
 269 extern MM_STATS MmStats;
 270
 271 #define MM_PHYSICAL_PAGE_MPW_PENDING     (0x8)
 272
 273 #define MM_PAGEOP_PAGEIN        (1)
 274 #define MM_PAGEOP_PAGEOUT       (2)
 275 #define MM_PAGEOP_PAGESYNCH     (3)
 276 #define MM_PAGEOP_ACCESSFAULT   (4)
 277
 278 typedef struct _MM_PAGEOP
 279 {
 280   /* Type of operation. */
 281   ULONG OpType;
 282   /* Number of threads interested in this operation. */
 283   ULONG ReferenceCount;
 284   /* Event that will be set when the operation is completed. */
 285   KEVENT CompletionEvent;
 286   /* Status of the operation once it is completed. */
 287   NTSTATUS Status;
 288   /* TRUE if the operation was abandoned. */
 289   BOOLEAN Abandoned;
 290   /* The memory area to be affected by the operation. */
 291   PMEMORY_AREA MArea;
 292   ULONG Hash;
 293   struct _MM_PAGEOP* Next;
 294   struct _ETHREAD* Thread;
 295   /*
 296    * These fields are used to identify the operation if it is against a
 297    * virtual memory area.
 298    */
 299   HANDLE Pid;
 300   PVOID Address;
 301   /*
 302    * These fields are used to identify the operation if it is against a
 303    * section mapping.
 304    */
 305   PMM_SECTION_SEGMENT Segment;
 306   ULONG Offset;
 307 } MM_PAGEOP, *PMM_PAGEOP;
 308
 309 #define MC_CACHE          (0)
 310 #define MC_USER           (1)
 311 #define MC_PPOOL          (2)
 312 #define MC_NPPOOL         (3)
 313 #define MC_MAXIMUM        (4)
 314
 315 typedef struct _MM_MEMORY_CONSUMER
 316 {
 317    ULONG PagesUsed;
 318    ULONG PagesTarget;
 319    NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed);
 320 }
 321 MM_MEMORY_CONSUMER, *PMM_MEMORY_CONSUMER;
 322
 323 extern MM_MEMORY_CONSUMER MiMemoryConsumers[MC_MAXIMUM];
 324
 325 extern PHYSICAL_ADDRESS MmSharedDataPagePhysicalAddress;
 326 struct _KTRAP_FRAME;
 327
 328 typedef VOID (*PMM_ALTER_REGION_FUNC)(PMADDRESS_SPACE AddressSpace,
 329                                       PVOID BaseAddress, ULONG Length,
 330                                       ULONG OldType, ULONG OldProtect,
 331                                       ULONG NewType, ULONG NewProtect);
 332
 333 typedef struct _MM_REGION
 334 {
 335    ULONG Type;
 336    ULONG Protect;
 337    ULONG Length;
 338    LIST_ENTRY RegionListEntry;
 339 } MM_REGION, *PMM_REGION;
 340
 341 typedef VOID (*PMM_FREE_PAGE_FUNC)(PVOID Context, PMEMORY_AREA MemoryArea,
 342                                    PVOID Address, PFN_TYPE Page,
 343                                    SWAPENTRY SwapEntry, BOOLEAN Dirty);
 344
 345 /* FUNCTIONS */
 346
 347 /* aspace.c ******************************************************************/
 348
 349 VOID MmLockAddressSpace(PMADDRESS_SPACE AddressSpace);
 350
 351 VOID MmUnlockAddressSpace(PMADDRESS_SPACE AddressSpace);
 352
 353 VOID MmInitializeKernelAddressSpace(VOID);
 354
 355 PMADDRESS_SPACE MmGetCurrentAddressSpace(VOID);
 356
 357 PMADDRESS_SPACE MmGetKernelAddressSpace(VOID);
 358
 359 NTSTATUS MmInitializeAddressSpace(struct _EPROCESS* Process,
 360                                   PMADDRESS_SPACE AddressSpace);
 361
 362 NTSTATUS MmDestroyAddressSpace(PMADDRESS_SPACE AddressSpace);
 363
 364 /* marea.c *******************************************************************/
 365
 366 NTSTATUS INIT_FUNCTION
 367 MmInitMemoryAreas(VOID);
 368
 369 NTSTATUS STDCALL
 370 MmCreateMemoryArea(
 371    struct _EPROCESS* Process,
 372    PMADDRESS_SPACE AddressSpace,
 373    ULONG Type,
 374    PVOID *BaseAddress,
 375    ULONG_PTR Length,
 376    ULONG Attributes,
 377    PMEMORY_AREA *Result,
 378    BOOLEAN FixedAddress,
 379    BOOLEAN TopDown,
 380    PHYSICAL_ADDRESS BoundaryAddressMultiple OPTIONAL);
 381
 382 PMEMORY_AREA STDCALL
 383 MmLocateMemoryAreaByAddress(
 384    PMADDRESS_SPACE AddressSpace,
 385    PVOID Address);
 386
 387 ULONG_PTR STDCALL
 388 MmFindGapAtAddress(
 389    PMADDRESS_SPACE AddressSpace,
 390    PVOID Address);
 391
 392 NTSTATUS STDCALL
 393 MmFreeMemoryArea(
 394    PMADDRESS_SPACE AddressSpace,
 395    PMEMORY_AREA MemoryArea,
 396    PMM_FREE_PAGE_FUNC FreePage,
 397    PVOID FreePageContext);
 398
 399 NTSTATUS STDCALL
 400 MmFreeMemoryAreaByPtr(
 401    PMADDRESS_SPACE AddressSpace,
 402    PVOID BaseAddress,
 403    PMM_FREE_PAGE_FUNC FreePage,
 404    PVOID FreePageContext);
 405
 406 VOID STDCALL
 407 MmDumpMemoryAreas(PMADDRESS_SPACE AddressSpace);
 408
 409 PMEMORY_AREA STDCALL
 410 MmLocateMemoryAreaByRegion(
 411    PMADDRESS_SPACE AddressSpace,
 412    PVOID Address,
 413    ULONG_PTR Length);
 414
 415 PVOID STDCALL
 416 MmFindGap(
 417    PMADDRESS_SPACE AddressSpace,
 418    ULONG_PTR Length,
 419    ULONG_PTR Granularity,
 420    BOOLEAN TopDown);
 421
 422 VOID STDCALL
 423 MmReleaseMemoryAreaIfDecommitted(
 424    PEPROCESS Process,
 425    PMADDRESS_SPACE AddressSpace,
 426    PVOID BaseAddress);
 427
 428 /* npool.c *******************************************************************/
 429
 430 VOID MiDebugDumpNonPagedPool(BOOLEAN NewOnly);
 431
 432 VOID MiDebugDumpNonPagedPoolStats(BOOLEAN NewOnly);
 433
 434 VOID MiInitializeNonPagedPool(VOID);
 435
 436 PVOID MmGetMdlPageAddress(PMDL Mdl, PVOID Offset);
 437
 438 /* pool.c *******************************************************************/
 439
 440 BOOLEAN
 441 STDCALL
 442 MiRaisePoolQuota(
 443     IN POOL_TYPE PoolType,
 444     IN ULONG CurrentMaxQuota,
 445     OUT PULONG NewMaxQuota
 446     );
 447
 448 /* mdl.c *********************************************************************/
 449
 450 VOID MmBuildMdlFromPages(PMDL Mdl, PULONG Pages);
 451
 452 /* mminit.c ******************************************************************/
 453
 454 VOID MiShutdownMemoryManager(VOID);
 455
 456 VOID MmInit1(ULONG_PTR FirstKernelPhysAddress,
 457              ULONG_PTR LastKernelPhysAddress,
 458              ULONG_PTR LastKernelAddress,
 459              PADDRESS_RANGE BIOSMemoryMap,
 460              ULONG AddressRangeCount,
 461              ULONG MaxMemInMeg);
 462
 463 VOID MmInit2(VOID);
 464
 465 VOID MmInit3(VOID);
 466
 467 VOID MiFreeInitMemory(VOID);
 468
 469 VOID MmInitializeMdlImplementation(VOID);
 470
 471 /* pagefile.c ****************************************************************/
 472
 473 SWAPENTRY MmAllocSwapPage(VOID);
 474
 475 VOID MmDereserveSwapPages(ULONG Nr);
 476
 477 VOID MmFreeSwapPage(SWAPENTRY Entry);
 478
 479 VOID MmInitPagingFile(VOID);
 480
 481 NTSTATUS MmReadFromSwapPage(SWAPENTRY SwapEntry, PFN_TYPE Page);
 482
 483 BOOLEAN MmReserveSwapPages(ULONG Nr);
 484
 485 NTSTATUS MmWriteToSwapPage(SWAPENTRY SwapEntry, PFN_TYPE Page);
 486
 487 NTSTATUS STDCALL
 488 MmDumpToPagingFile(ULONG BugCode,
 489                    ULONG BugCodeParameter1,
 490                    ULONG BugCodeParameter2,
 491                    ULONG BugCodeParameter3,
 492                    ULONG BugCodeParameter4,
 493                    struct _KTRAP_FRAME* TrapFrame);
 494
 495 BOOLEAN MmIsAvailableSwapPage(VOID);
 496
 497 VOID MmShowOutOfSpaceMessagePagingFile(VOID);
 498
 499 /* i386/pfault.c *************************************************************/
 500
 501 NTSTATUS MmPageFault(ULONG Cs,
 502                      PULONG Eip,
 503                      PULONG Eax,
 504                      ULONG Cr2,
 505                      ULONG ErrorCode);
 506
 507 /* mm.c **********************************************************************/
 508
 509 NTSTATUS MmAccessFault(KPROCESSOR_MODE Mode,
 510                        ULONG_PTR Address,
 511                        BOOLEAN FromMdl);
 512
 513 NTSTATUS MmNotPresentFault(KPROCESSOR_MODE Mode,
 514                            ULONG_PTR Address,
 515                            BOOLEAN FromMdl);
 516
 517 /* anonmem.c *****************************************************************/
 518
 519 NTSTATUS MmNotPresentFaultVirtualMemory(PMADDRESS_SPACE AddressSpace,
 520                                         MEMORY_AREA* MemoryArea,
 521                                         PVOID Address,
 522                                         BOOLEAN Locked);
 523
 524 NTSTATUS MmPageOutVirtualMemory(PMADDRESS_SPACE AddressSpace,
 525                                 PMEMORY_AREA MemoryArea,
 526                                 PVOID Address,
 527                                 struct _MM_PAGEOP* PageOp);
 528 NTSTATUS STDCALL
 529 MmQueryAnonMem(PMEMORY_AREA MemoryArea,
 530                PVOID Address,
 531                PMEMORY_BASIC_INFORMATION Info,
 532                PULONG ResultLength);
 533
 534 VOID MmFreeVirtualMemory(struct _EPROCESS* Process, PMEMORY_AREA MemoryArea);
 535
 536 NTSTATUS MmProtectAnonMem(PMADDRESS_SPACE AddressSpace,
 537                           PMEMORY_AREA MemoryArea,
 538                           PVOID BaseAddress,
 539                           ULONG Length,
 540                           ULONG Protect,
 541                           PULONG OldProtect);
 542
 543 NTSTATUS MmWritePageVirtualMemory(PMADDRESS_SPACE AddressSpace,
 544                                   PMEMORY_AREA MArea,
 545                                   PVOID Address,
 546                                   PMM_PAGEOP PageOp);
 547
 548 /* kmap.c ********************************************************************/
 549
 550 PVOID ExAllocatePage(VOID);
 551
 552 VOID ExUnmapPage(PVOID Addr);
 553
 554 PVOID ExAllocatePageWithPhysPage(PFN_TYPE Page);
 555
 556 NTSTATUS MiCopyFromUserPage(PFN_TYPE Page, PVOID SourceAddress);
 557
 558 NTSTATUS MiZeroPage(PFN_TYPE Page);
 559
 560 /* memsafe.s *****************************************************************/
 561
 562 NTSTATUS MmSafeCopyFromUser(PVOID Dest, const VOID *Src, ULONG Count);
 563
 564 NTSTATUS MmSafeCopyToUser(PVOID Dest, const VOID *Src, ULONG Count);
 565
 566 PVOID FASTCALL MmSafeReadPtr(PVOID Source);
 567
 568 /* pageop.c ******************************************************************/
 569
 570 VOID
 571 MmReleasePageOp(PMM_PAGEOP PageOp);
 572
 573 PMM_PAGEOP
 574 MmGetPageOp(PMEMORY_AREA MArea, HANDLE Pid, PVOID Address,
 575             PMM_SECTION_SEGMENT Segment, ULONG Offset, ULONG OpType, BOOL First);
 576 PMM_PAGEOP
 577 MmCheckForPageOp(PMEMORY_AREA MArea, HANDLE Pid, PVOID Address,
 578                  PMM_SECTION_SEGMENT Segment, ULONG Offset);
 579 VOID
 580 MmInitializePageOp(VOID);
 581
 582 /* balace.c ******************************************************************/
 583
 584 VOID MmInitializeMemoryConsumer(ULONG Consumer,
 585                                 NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed));
 586
 587 VOID MmInitializeBalancer(ULONG NrAvailablePages, ULONG NrSystemPages);
 588
 589 NTSTATUS MmReleasePageMemoryConsumer(ULONG Consumer, PFN_TYPE Page);
 590
 591 NTSTATUS MmRequestPageMemoryConsumer(ULONG Consumer, BOOLEAN MyWait, PPFN_TYPE AllocatedPage);
 592
 593 VOID MiInitBalancerThread(VOID);
 594
 595 VOID MmRebalanceMemoryConsumers(VOID);
 596
 597 /* rmap.c **************************************************************/
 598
 599 VOID MmSetRmapListHeadPage(PFN_TYPE Page, struct _MM_RMAP_ENTRY* ListHead);
 600
 601 struct _MM_RMAP_ENTRY* MmGetRmapListHeadPage(PFN_TYPE Page);
 602
 603 VOID MmInsertRmap(PFN_TYPE Page, PEPROCESS Process, PVOID Address);
 604
 605 VOID MmDeleteAllRmaps(PFN_TYPE Page, PVOID Context,
 606                       VOID (*DeleteMapping)(PVOID Context, PEPROCESS Process, PVOID Address));
 607
 608 VOID MmDeleteRmap(PFN_TYPE Page, PEPROCESS Process, PVOID Address);
 609
 610 VOID MmInitializeRmapList(VOID);
 611
 612 VOID MmSetCleanAllRmaps(PFN_TYPE Page);
 613
 614 VOID MmSetDirtyAllRmaps(PFN_TYPE Page);
 615
 616 BOOL MmIsDirtyPageRmap(PFN_TYPE Page);
 617
 618 NTSTATUS MmWritePagePhysicalAddress(PFN_TYPE Page);
 619
 620 NTSTATUS MmPageOutPhysicalAddress(PFN_TYPE Page);
 621
 622 /* freelist.c **********************************************************/
 623
 624 PFN_TYPE MmGetLRUNextUserPage(PFN_TYPE PreviousPage);
 625
 626 PFN_TYPE MmGetLRUFirstUserPage(VOID);
 627
 628 VOID MmSetLRULastPage(PFN_TYPE Page);
 629
 630 VOID MmLockPage(PFN_TYPE Page);
 631
 632 VOID MmUnlockPage(PFN_TYPE Page);
 633
 634 ULONG MmGetLockCountPage(PFN_TYPE Page);
 635
 636 PVOID MmInitializePageList(ULONG_PTR FirstPhysKernelAddress,
 637                            ULONG_PTR LastPhysKernelAddress,
 638                            ULONG MemorySizeInPages,
 639                            ULONG_PTR LastKernelBase,
 640                            PADDRESS_RANGE BIOSMemoryMap,
 641                            ULONG AddressRangeCount);
 642
 643 PFN_TYPE MmGetContinuousPages(ULONG NumberOfBytes,
 644                               PHYSICAL_ADDRESS LowestAcceptableAddress,
 645                               PHYSICAL_ADDRESS HighestAcceptableAddress,
 646                               ULONG Alignment);
 647
 648 NTSTATUS MmInitZeroPageThread(VOID);
 649
 650 /* i386/page.c *********************************************************/
 651
 652 PVOID MmCreateHyperspaceMapping(PFN_TYPE Page);
 653
 654 PFN_TYPE MmChangeHyperspaceMapping(PVOID Address, PFN_TYPE Page);
 655
 656 PFN_TYPE MmDeleteHyperspaceMapping(PVOID Address);
 657
 658 NTSTATUS MmCreateVirtualMappingForKernel(PVOID Address,
 659                                          ULONG flProtect,
 660                                          PPFN_TYPE Pages,
 661                                          ULONG PageCount);
 662
 663 NTSTATUS MmCommitPagedPoolAddress(PVOID Address, BOOLEAN Locked);
 664
 665 NTSTATUS MmCreateVirtualMapping(struct _EPROCESS* Process,
 666                                 PVOID Address,
 667                                 ULONG flProtect,
 668                                 PPFN_TYPE Pages,
 669                                 ULONG PageCount);
 670
 671 NTSTATUS MmCreateVirtualMappingUnsafe(struct _EPROCESS* Process,
 672                                       PVOID Address,
 673                                       ULONG flProtect,
 674                                       PPFN_TYPE Pages,
 675                                       ULONG PageCount);
 676
 677 ULONG MmGetPageProtect(struct _EPROCESS* Process, PVOID Address);
 678
 679 VOID MmSetPageProtect(struct _EPROCESS* Process,
 680                       PVOID Address,
 681                       ULONG flProtect);
 682
 683 BOOLEAN MmIsPagePresent(struct _EPROCESS* Process,
 684                         PVOID Address);
 685
 686 VOID MmInitGlobalKernelPageDirectory(VOID);
 687
 688 VOID MmDisableVirtualMapping(PEPROCESS Process, PVOID Address, BOOL* WasDirty, PPFN_TYPE Page);
 689
 690 VOID MmEnableVirtualMapping(PEPROCESS Process, PVOID Address);
 691
 692 VOID MmRawDeleteVirtualMapping(PVOID Address);
 693
 694 VOID MmDeletePageFileMapping(PEPROCESS Process, PVOID Address, SWAPENTRY* SwapEntry);
 695
 696 NTSTATUS MmCreatePageFileMapping(PEPROCESS Process, PVOID Address, SWAPENTRY SwapEntry);
 697
 698 BOOLEAN MmIsPageSwapEntry(PEPROCESS Process, PVOID Address);
 699
 700 VOID MmTransferOwnershipPage(PFN_TYPE Page, ULONG NewConsumer);
 701
 702 VOID MmSetDirtyPage(PEPROCESS Process, PVOID Address);
 703
 704 PFN_TYPE MmAllocPage(ULONG Consumer, SWAPENTRY SavedSwapEntry);
 705
 706 LONG MmAllocPagesSpecifyRange(ULONG Consumer,
 707                               PHYSICAL_ADDRESS LowestAddress,
 708                               PHYSICAL_ADDRESS HighestAddress,
 709                               ULONG NumberOfPages,
 710                               PPFN_TYPE Pages);
 711
 712 VOID MmDereferencePage(PFN_TYPE Page);
 713
 714 VOID MmReferencePage(PFN_TYPE Page);
 715
 716 BOOLEAN MmIsAccessedAndResetAccessPage(struct _EPROCESS* Process, PVOID Address);
 717
 718 ULONG MmGetReferenceCountPage(PFN_TYPE Page);
 719
 720 BOOLEAN MmIsUsablePage(PFN_TYPE Page);
 721
 722 VOID MmSetFlagsPage(PFN_TYPE Page, ULONG Flags);
 723
 724 ULONG MmGetFlagsPage(PFN_TYPE Page);
 725
 726 VOID MmSetSavedSwapEntryPage(PFN_TYPE Page, SWAPENTRY SavedSwapEntry);
 727
 728 SWAPENTRY MmGetSavedSwapEntryPage(PFN_TYPE Page);
 729
 730 VOID MmSetCleanPage(struct _EPROCESS* Process, PVOID Address);
 731
 732 NTSTATUS MmCreatePageTable(PVOID PAddress);
 733
 734 VOID MmDeletePageTable(struct _EPROCESS* Process, PVOID Address);
 735
 736 PFN_TYPE MmGetPfnForProcess(struct _EPROCESS* Process, PVOID Address);
 737
 738 NTSTATUS MmCopyMmInfo(struct _EPROCESS* Src, struct _EPROCESS* Dest);
 739
 740 NTSTATUS MmReleaseMmInfo(struct _EPROCESS* Process);
 741
 742 NTSTATUS Mmi386ReleaseMmInfo(struct _EPROCESS* Process);
 743
 744 VOID MmDeleteVirtualMapping(struct _EPROCESS* Process,
 745                             PVOID Address,
 746                             BOOL FreePage,
 747                             BOOL* WasDirty,
 748                             PPFN_TYPE Page);
 749
 750 BOOLEAN MmIsDirtyPage(struct _EPROCESS* Process, PVOID Address);
 751
 752 VOID MmMarkPageMapped(PFN_TYPE Page);
 753
 754 VOID MmMarkPageUnmapped(PFN_TYPE Page);
 755
 756 VOID MmUpdatePageDir(PEPROCESS Process, PVOID Address, ULONG Size);
 757
 758 VOID MiInitPageDirectoryMap(VOID);
 759
 760 ULONG MiGetUserPageDirectoryCount(VOID);
 761
 762 /* wset.c ********************************************************************/
 763
 764 NTSTATUS MmTrimUserMemory(ULONG Target, ULONG Priority, PULONG NrFreedPages);
 765
 766 /* region.c ************************************************************/
 767
 768 NTSTATUS MmAlterRegion(PMADDRESS_SPACE AddressSpace, PVOID BaseAddress,
 769                        PLIST_ENTRY RegionListHead, PVOID StartAddress, ULONG Length,
 770                        ULONG NewType, ULONG NewProtect,
 771                        PMM_ALTER_REGION_FUNC AlterFunc);
 772
 773 VOID MmInitialiseRegion(PLIST_ENTRY RegionListHead, ULONG Length, ULONG Type,
 774                         ULONG Protect);
 775
 776 PMM_REGION MmFindRegion(PVOID BaseAddress, PLIST_ENTRY RegionListHead, PVOID Address,
 777                         PVOID* RegionBaseAddress);
 778
 779 /* section.c *****************************************************************/
 780
 781 PVOID STDCALL
 782 MmAllocateSection (IN ULONG Length, PVOID BaseAddress);
 783
 784 NTSTATUS STDCALL
 785 MmQuerySectionView(PMEMORY_AREA MemoryArea,
 786                    PVOID Address,
 787                    PMEMORY_BASIC_INFORMATION Info,
 788                    PULONG ResultLength);
 789
 790 NTSTATUS
 791 MmProtectSectionView(PMADDRESS_SPACE AddressSpace,
 792                      PMEMORY_AREA MemoryArea,
 793                      PVOID BaseAddress,
 794                      ULONG Length,
 795                      ULONG Protect,
 796                      PULONG OldProtect);
 797
 798 NTSTATUS
 799 MmWritePageSectionView(PMADDRESS_SPACE AddressSpace,
 800                        PMEMORY_AREA MArea,
 801                        PVOID Address,
 802                        PMM_PAGEOP PageOp);
 803
 804 NTSTATUS MmInitSectionImplementation(VOID);
 805
 806 NTSTATUS STDCALL
 807 MmUnmapViewOfSection(struct _EPROCESS* Process, PVOID BaseAddress);
 808
 809 /* FIXME: it should be in ddk/mmfuncs.h */
 810 NTSTATUS STDCALL
 811 MmCreateSection (OUT    PSECTION_OBJECT         * SectionObject,
 812                  IN     ACCESS_MASK             DesiredAccess,
 813                  IN     POBJECT_ATTRIBUTES      ObjectAttributes        OPTIONAL,
 814                  IN     PLARGE_INTEGER          MaximumSize,
 815                  IN     ULONG                   SectionPageProtection,
 816                  IN     ULONG                   AllocationAttributes,
 817                  IN     HANDLE                  FileHandle              OPTIONAL,
 818                  IN     PFILE_OBJECT            File                    OPTIONAL);
 819
 820 NTSTATUS
 821 MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
 822                              MEMORY_AREA* MemoryArea,
 823                              PVOID Address,
 824                              BOOLEAN Locked);
 825
 826 NTSTATUS
 827 MmPageOutSectionView(PMADDRESS_SPACE AddressSpace,
 828                        PMEMORY_AREA MemoryArea,
 829                        PVOID Address,
 830                        struct _MM_PAGEOP* PageOp);
 831
 832 NTSTATUS
 833 MmCreatePhysicalMemorySection(VOID);
 834
 835 NTSTATUS
 836 MmAccessFaultSectionView(PMADDRESS_SPACE AddressSpace,
 837                          MEMORY_AREA* MemoryArea,
 838                          PVOID Address,
 839                          BOOLEAN Locked);
 840
 841 VOID
 842 MmFreeSectionSegments(PFILE_OBJECT FileObject);
 843
 844 /* mpw.c *********************************************************************/
 845
 846 NTSTATUS MmInitMpwThread(VOID);
 847
 848 /* pager.c *******************************************************************/
 849
 850 BOOLEAN MiIsPagerThread(VOID);
 851
 852 VOID MiStartPagerThread(VOID);
 853
 854 VOID MiStopPagerThread(VOID);
 855
 856 #endif