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