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