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 VOID MmLockPagedPool(VOID);
 371 VOID MmUnlockPagedPool(VOID);
 372
 373 /* aspace.c ******************************************************************/
 374
 375 VOID MmLockAddressSpace(PMADDRESS_SPACE AddressSpace);
 376
 377 VOID MmUnlockAddressSpace(PMADDRESS_SPACE AddressSpace);
 378
 379 VOID MmInitializeKernelAddressSpace(VOID);
 380
 381 PMADDRESS_SPACE MmGetCurrentAddressSpace(VOID);
 382
 383 PMADDRESS_SPACE MmGetKernelAddressSpace(VOID);
 384
 385 NTSTATUS MmInitializeAddressSpace(struct _EPROCESS* Process,
 386                                   PMADDRESS_SPACE AddressSpace);
 387
 388 NTSTATUS MmDestroyAddressSpace(PMADDRESS_SPACE AddressSpace);
 389
 390 /* marea.c *******************************************************************/
 391
 392 NTSTATUS INIT_FUNCTION
 393 MmInitMemoryAreas(VOID);
 394
 395 NTSTATUS STDCALL
 396 MmCreateMemoryArea(
 397    struct _EPROCESS* Process,
 398    PMADDRESS_SPACE AddressSpace,
 399    ULONG Type,
 400    PVOID *BaseAddress,
 401    ULONG_PTR Length,
 402    ULONG Attributes,
 403    PMEMORY_AREA *Result,
 404    BOOLEAN FixedAddress,
 405    BOOLEAN TopDown,
 406    PHYSICAL_ADDRESS BoundaryAddressMultiple OPTIONAL);
 407
 408 PMEMORY_AREA STDCALL
 409 MmLocateMemoryAreaByAddress(
 410    PMADDRESS_SPACE AddressSpace,
 411    PVOID Address);
 412
 413 ULONG_PTR STDCALL
 414 MmFindGapAtAddress(
 415    PMADDRESS_SPACE AddressSpace,
 416    PVOID Address);
 417
 418 NTSTATUS STDCALL
 419 MmFreeMemoryArea(
 420    PMADDRESS_SPACE AddressSpace,
 421    PMEMORY_AREA MemoryArea,
 422    PMM_FREE_PAGE_FUNC FreePage,
 423    PVOID FreePageContext);
 424
 425 NTSTATUS STDCALL
 426 MmFreeMemoryAreaByPtr(
 427    PMADDRESS_SPACE AddressSpace,
 428    PVOID BaseAddress,
 429    PMM_FREE_PAGE_FUNC FreePage,
 430    PVOID FreePageContext);
 431
 432 VOID STDCALL
 433 MmDumpMemoryAreas(PMADDRESS_SPACE AddressSpace);
 434
 435 PMEMORY_AREA STDCALL
 436 MmLocateMemoryAreaByRegion(
 437    PMADDRESS_SPACE AddressSpace,
 438    PVOID Address,
 439    ULONG_PTR Length);
 440
 441 PVOID STDCALL
 442 MmFindGap(
 443    PMADDRESS_SPACE AddressSpace,
 444    ULONG_PTR Length,
 445    ULONG_PTR Granularity,
 446    BOOLEAN TopDown);
 447
 448 VOID STDCALL
 449 MmReleaseMemoryAreaIfDecommitted(
 450    PEPROCESS Process,
 451    PMADDRESS_SPACE AddressSpace,
 452    PVOID BaseAddress);
 453
 454 /* npool.c *******************************************************************/
 455
 456 VOID MiDebugDumpNonPagedPool(BOOLEAN NewOnly);
 457
 458 VOID MiDebugDumpNonPagedPoolStats(BOOLEAN NewOnly);
 459
 460 VOID MiInitializeNonPagedPool(VOID);
 461
 462 PVOID MmGetMdlPageAddress(PMDL Mdl, PVOID Offset);
 463
 464 /* pool.c *******************************************************************/
 465
 466 BOOLEAN
 467 STDCALL
 468 MiRaisePoolQuota(
 469     IN POOL_TYPE PoolType,
 470     IN ULONG CurrentMaxQuota,
 471     OUT PULONG NewMaxQuota
 472     );
 473
 474 /* mdl.c *********************************************************************/
 475
 476 VOID MmBuildMdlFromPages(PMDL Mdl, PULONG Pages);
 477
 478 /* mminit.c ******************************************************************/
 479
 480 VOID MiShutdownMemoryManager(VOID);
 481
 482 VOID MmInit1(ULONG_PTR FirstKernelPhysAddress,
 483              ULONG_PTR LastKernelPhysAddress,
 484              ULONG_PTR LastKernelAddress,
 485              PADDRESS_RANGE BIOSMemoryMap,
 486              ULONG AddressRangeCount,
 487              ULONG MaxMemInMeg);
 488
 489 VOID MmInit2(VOID);
 490
 491 VOID MmInit3(VOID);
 492
 493 VOID MiFreeInitMemory(VOID);
 494
 495 VOID MmInitializeMdlImplementation(VOID);
 496
 497 /* pagefile.c ****************************************************************/
 498
 499 SWAPENTRY MmAllocSwapPage(VOID);
 500
 501 VOID MmDereserveSwapPages(ULONG Nr);
 502
 503 VOID MmFreeSwapPage(SWAPENTRY Entry);
 504
 505 VOID MmInitPagingFile(VOID);
 506
 507 NTSTATUS MmReadFromSwapPage(SWAPENTRY SwapEntry, PFN_TYPE Page);
 508
 509 BOOLEAN MmReserveSwapPages(ULONG Nr);
 510
 511 NTSTATUS MmWriteToSwapPage(SWAPENTRY SwapEntry, PFN_TYPE Page);
 512
 513 NTSTATUS STDCALL
 514 MmDumpToPagingFile(ULONG BugCode,
 515                    ULONG BugCodeParameter1,
 516                    ULONG BugCodeParameter2,
 517                    ULONG BugCodeParameter3,
 518                    ULONG BugCodeParameter4,
 519                    struct _KTRAP_FRAME* TrapFrame);
 520
 521 BOOLEAN MmIsAvailableSwapPage(VOID);
 522
 523 VOID MmShowOutOfSpaceMessagePagingFile(VOID);
 524
 525 /* process.c ****************************************************************/
 526
 527 NTSTATUS
 528 STDCALL
 529 MmCreateProcessAddressSpace(IN struct _EPROCESS* Process,
 530                             IN PSECTION_OBJECT Section OPTIONAL);
 531
 532 NTSTATUS
 533 STDCALL
 534 MmCreatePeb(PEPROCESS Process);
 535
 536 struct _TEB*
 537 STDCALL
 538 MmCreateTeb(PEPROCESS Process,
 539             PCLIENT_ID ClientId,
 540             PINITIAL_TEB InitialTeb);
 541
 542 VOID
 543 STDCALL
 544 MmDeleteTeb(PEPROCESS Process,
 545             struct _TEB* Teb);
 546
 547 /* i386/pfault.c *************************************************************/
 548
 549 NTSTATUS MmPageFault(ULONG Cs,
 550                      PULONG Eip,
 551                      PULONG Eax,
 552                      ULONG Cr2,
 553                      ULONG ErrorCode);
 554
 555 /* mm.c **********************************************************************/
 556
 557 NTSTATUS MmAccessFault(KPROCESSOR_MODE Mode,
 558                        ULONG_PTR Address,
 559                        BOOLEAN FromMdl);
 560
 561 NTSTATUS MmNotPresentFault(KPROCESSOR_MODE Mode,
 562                            ULONG_PTR Address,
 563                            BOOLEAN FromMdl);
 564
 565 /* anonmem.c *****************************************************************/
 566
 567 NTSTATUS MmNotPresentFaultVirtualMemory(PMADDRESS_SPACE AddressSpace,
 568                                         MEMORY_AREA* MemoryArea,
 569                                         PVOID Address,
 570                                         BOOLEAN Locked);
 571
 572 NTSTATUS MmPageOutVirtualMemory(PMADDRESS_SPACE AddressSpace,
 573                                 PMEMORY_AREA MemoryArea,
 574                                 PVOID Address,
 575                                 struct _MM_PAGEOP* PageOp);
 576 NTSTATUS STDCALL
 577 MmQueryAnonMem(PMEMORY_AREA MemoryArea,
 578                PVOID Address,
 579                PMEMORY_BASIC_INFORMATION Info,
 580                PULONG ResultLength);
 581
 582 VOID MmFreeVirtualMemory(struct _EPROCESS* Process, PMEMORY_AREA MemoryArea);
 583
 584 NTSTATUS MmProtectAnonMem(PMADDRESS_SPACE AddressSpace,
 585                           PMEMORY_AREA MemoryArea,
 586                           PVOID BaseAddress,
 587                           ULONG Length,
 588                           ULONG Protect,
 589                           PULONG OldProtect);
 590
 591 NTSTATUS MmWritePageVirtualMemory(PMADDRESS_SPACE AddressSpace,
 592                                   PMEMORY_AREA MArea,
 593                                   PVOID Address,
 594                                   PMM_PAGEOP PageOp);
 595
 596 /* kmap.c ********************************************************************/
 597
 598 PVOID ExAllocatePage(VOID);
 599
 600 VOID ExUnmapPage(PVOID Addr);
 601
 602 PVOID ExAllocatePageWithPhysPage(PFN_TYPE Page);
 603
 604 NTSTATUS MiCopyFromUserPage(PFN_TYPE Page, PVOID SourceAddress);
 605
 606 NTSTATUS MiZeroPage(PFN_TYPE Page);
 607
 608 /* memsafe.s *****************************************************************/
 609
 610 NTSTATUS MmSafeCopyFromUser(PVOID Dest, const VOID *Src, ULONG Count);
 611
 612 NTSTATUS MmSafeCopyToUser(PVOID Dest, const VOID *Src, ULONG Count);
 613
 614 PVOID FASTCALL MmSafeReadPtr(PVOID Source);
 615
 616 /* pageop.c ******************************************************************/
 617
 618 VOID
 619 MmReleasePageOp(PMM_PAGEOP PageOp);
 620
 621 PMM_PAGEOP
 622 MmGetPageOp(PMEMORY_AREA MArea, HANDLE Pid, PVOID Address,
 623             PMM_SECTION_SEGMENT Segment, ULONG Offset, ULONG OpType, BOOL First);
 624 PMM_PAGEOP
 625 MmCheckForPageOp(PMEMORY_AREA MArea, HANDLE Pid, PVOID Address,
 626                  PMM_SECTION_SEGMENT Segment, ULONG Offset);
 627 VOID
 628 MmInitializePageOp(VOID);
 629
 630 /* process.c *****************************************************************/
 631
 632 PVOID
 633 STDCALL
 634 MmCreateKernelStack(BOOLEAN GuiStack);
 635
 636 VOID
 637 STDCALL
 638 MmDeleteKernelStack(PVOID Stack,
 639                     BOOLEAN GuiStack);
 640
 641 /* balace.c ******************************************************************/
 642
 643 VOID MmInitializeMemoryConsumer(ULONG Consumer,
 644                                 NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed));
 645
 646 VOID MmInitializeBalancer(ULONG NrAvailablePages, ULONG NrSystemPages);
 647
 648 NTSTATUS MmReleasePageMemoryConsumer(ULONG Consumer, PFN_TYPE Page);
 649
 650 NTSTATUS MmRequestPageMemoryConsumer(ULONG Consumer, BOOLEAN MyWait, PPFN_TYPE AllocatedPage);
 651
 652 VOID MiInitBalancerThread(VOID);
 653
 654 VOID MmRebalanceMemoryConsumers(VOID);
 655
 656 /* rmap.c **************************************************************/
 657
 658 VOID MmSetRmapListHeadPage(PFN_TYPE Page, struct _MM_RMAP_ENTRY* ListHead);
 659
 660 struct _MM_RMAP_ENTRY* MmGetRmapListHeadPage(PFN_TYPE Page);
 661
 662 VOID MmInsertRmap(PFN_TYPE Page, PEPROCESS Process, PVOID Address);
 663
 664 VOID MmDeleteAllRmaps(PFN_TYPE Page, PVOID Context,
 665                       VOID (*DeleteMapping)(PVOID Context, PEPROCESS Process, PVOID Address));
 666
 667 VOID MmDeleteRmap(PFN_TYPE Page, PEPROCESS Process, PVOID Address);
 668
 669 VOID MmInitializeRmapList(VOID);
 670
 671 VOID MmSetCleanAllRmaps(PFN_TYPE Page);
 672
 673 VOID MmSetDirtyAllRmaps(PFN_TYPE Page);
 674
 675 BOOL MmIsDirtyPageRmap(PFN_TYPE Page);
 676
 677 NTSTATUS MmWritePagePhysicalAddress(PFN_TYPE Page);
 678
 679 NTSTATUS MmPageOutPhysicalAddress(PFN_TYPE Page);
 680
 681 /* freelist.c **********************************************************/
 682
 683 PFN_TYPE MmGetLRUNextUserPage(PFN_TYPE PreviousPage);
 684
 685 PFN_TYPE MmGetLRUFirstUserPage(VOID);
 686
 687 VOID MmSetLRULastPage(PFN_TYPE Page);
 688
 689 VOID MmLockPage(PFN_TYPE Page);
 690 VOID MmLockPageUnsafe(PFN_TYPE Page);
 691
 692 VOID MmUnlockPage(PFN_TYPE Page);
 693
 694 ULONG MmGetLockCountPage(PFN_TYPE Page);
 695
 696 PVOID MmInitializePageList(ULONG_PTR FirstPhysKernelAddress,
 697                            ULONG_PTR LastPhysKernelAddress,
 698                            ULONG MemorySizeInPages,
 699                            ULONG_PTR LastKernelBase,
 700                            PADDRESS_RANGE BIOSMemoryMap,
 701                            ULONG AddressRangeCount);
 702
 703 PFN_TYPE MmGetContinuousPages(ULONG NumberOfBytes,
 704                               PHYSICAL_ADDRESS LowestAcceptableAddress,
 705                               PHYSICAL_ADDRESS HighestAcceptableAddress,
 706                               ULONG Alignment);
 707
 708 NTSTATUS MmInitZeroPageThread(VOID);
 709
 710 /* i386/page.c *********************************************************/
 711
 712 PVOID MmCreateHyperspaceMapping(PFN_TYPE Page);
 713
 714 PFN_TYPE MmChangeHyperspaceMapping(PVOID Address, PFN_TYPE Page);
 715
 716 PFN_TYPE MmDeleteHyperspaceMapping(PVOID Address);
 717
 718 NTSTATUS MmCreateVirtualMappingForKernel(PVOID Address,
 719                                          ULONG flProtect,
 720                                          PPFN_TYPE Pages,
 721                                          ULONG PageCount);
 722
 723 NTSTATUS MmCommitPagedPoolAddress(PVOID Address, BOOLEAN Locked);
 724
 725 NTSTATUS MmCreateVirtualMapping(struct _EPROCESS* Process,
 726                                 PVOID Address,
 727                                 ULONG flProtect,
 728                                 PPFN_TYPE Pages,
 729                                 ULONG PageCount);
 730
 731 NTSTATUS MmCreateVirtualMappingUnsafe(struct _EPROCESS* Process,
 732                                       PVOID Address,
 733                                       ULONG flProtect,
 734                                       PPFN_TYPE Pages,
 735                                       ULONG PageCount);
 736
 737 ULONG MmGetPageProtect(struct _EPROCESS* Process, PVOID Address);
 738
 739 VOID MmSetPageProtect(struct _EPROCESS* Process,
 740                       PVOID Address,
 741                       ULONG flProtect);
 742
 743 BOOLEAN MmIsPagePresent(struct _EPROCESS* Process,
 744                         PVOID Address);
 745
 746 VOID MmInitGlobalKernelPageDirectory(VOID);
 747
 748 VOID MmDisableVirtualMapping(PEPROCESS Process, PVOID Address, BOOL* WasDirty, PPFN_TYPE Page);
 749
 750 VOID MmEnableVirtualMapping(PEPROCESS Process, PVOID Address);
 751
 752 VOID MmRawDeleteVirtualMapping(PVOID Address);
 753
 754 VOID MmDeletePageFileMapping(PEPROCESS Process, PVOID Address, SWAPENTRY* SwapEntry);
 755
 756 NTSTATUS MmCreatePageFileMapping(PEPROCESS Process, PVOID Address, SWAPENTRY SwapEntry);
 757
 758 BOOLEAN MmIsPageSwapEntry(PEPROCESS Process, PVOID Address);
 759
 760 VOID MmTransferOwnershipPage(PFN_TYPE Page, ULONG NewConsumer);
 761
 762 VOID MmSetDirtyPage(PEPROCESS Process, PVOID Address);
 763
 764 PFN_TYPE MmAllocPage(ULONG Consumer, SWAPENTRY SavedSwapEntry);
 765
 766 LONG MmAllocPagesSpecifyRange(ULONG Consumer,
 767                               PHYSICAL_ADDRESS LowestAddress,
 768                               PHYSICAL_ADDRESS HighestAddress,
 769                               ULONG NumberOfPages,
 770                               PPFN_TYPE Pages);
 771
 772 VOID MmDereferencePage(PFN_TYPE Page);
 773
 774 VOID MmReferencePage(PFN_TYPE Page);
 775 VOID MmReferencePageUnsafe(PFN_TYPE Page);
 776
 777 BOOLEAN MmIsAccessedAndResetAccessPage(struct _EPROCESS* Process, PVOID Address);
 778
 779 ULONG MmGetReferenceCountPage(PFN_TYPE Page);
 780
 781 BOOLEAN MmIsUsablePage(PFN_TYPE Page);
 782
 783 VOID MmSetFlagsPage(PFN_TYPE Page, ULONG Flags);
 784
 785 ULONG MmGetFlagsPage(PFN_TYPE Page);
 786
 787 VOID MmSetSavedSwapEntryPage(PFN_TYPE Page, SWAPENTRY SavedSwapEntry);
 788
 789 SWAPENTRY MmGetSavedSwapEntryPage(PFN_TYPE Page);
 790
 791 VOID MmSetCleanPage(struct _EPROCESS* Process, PVOID Address);
 792
 793 NTSTATUS MmCreatePageTable(PVOID PAddress);
 794
 795 VOID MmDeletePageTable(struct _EPROCESS* Process, PVOID Address);
 796
 797 PFN_TYPE MmGetPfnForProcess(struct _EPROCESS* Process, PVOID Address);
 798
 799 NTSTATUS
 800 STDCALL
 801 MmCopyMmInfo(struct _EPROCESS* Src,
 802              struct _EPROCESS* Dest,
 803              PPHYSICAL_ADDRESS DirectoryTableBase);
 804
 805 NTSTATUS MmReleaseMmInfo(struct _EPROCESS* Process);
 806
 807 NTSTATUS Mmi386ReleaseMmInfo(struct _EPROCESS* Process);
 808
 809 VOID MmDeleteVirtualMapping(struct _EPROCESS* Process,
 810                             PVOID Address,
 811                             BOOL FreePage,
 812                             BOOL* WasDirty,
 813                             PPFN_TYPE Page);
 814
 815 BOOLEAN MmIsDirtyPage(struct _EPROCESS* Process, PVOID Address);
 816
 817 VOID MmMarkPageMapped(PFN_TYPE Page);
 818
 819 VOID MmMarkPageUnmapped(PFN_TYPE Page);
 820
 821 VOID MmUpdatePageDir(PEPROCESS Process, PVOID Address, ULONG Size);
 822
 823 VOID MiInitPageDirectoryMap(VOID);
 824
 825 ULONG MiGetUserPageDirectoryCount(VOID);
 826
 827 /* wset.c ********************************************************************/
 828
 829 NTSTATUS MmTrimUserMemory(ULONG Target, ULONG Priority, PULONG NrFreedPages);
 830
 831 /* region.c ************************************************************/
 832
 833 NTSTATUS MmAlterRegion(PMADDRESS_SPACE AddressSpace, PVOID BaseAddress,
 834                        PLIST_ENTRY RegionListHead, PVOID StartAddress, ULONG Length,
 835                        ULONG NewType, ULONG NewProtect,
 836                        PMM_ALTER_REGION_FUNC AlterFunc);
 837
 838 VOID MmInitialiseRegion(PLIST_ENTRY RegionListHead, ULONG Length, ULONG Type,
 839                         ULONG Protect);
 840
 841 PMM_REGION MmFindRegion(PVOID BaseAddress, PLIST_ENTRY RegionListHead, PVOID Address,
 842                         PVOID* RegionBaseAddress);
 843
 844 /* section.c *****************************************************************/
 845
 846 PVOID STDCALL
 847 MmAllocateSection (IN ULONG Length, PVOID BaseAddress);
 848
 849 NTSTATUS STDCALL
 850 MmQuerySectionView(PMEMORY_AREA MemoryArea,
 851                    PVOID Address,
 852                    PMEMORY_BASIC_INFORMATION Info,
 853                    PULONG ResultLength);
 854
 855 NTSTATUS
 856 MmProtectSectionView(PMADDRESS_SPACE AddressSpace,
 857                      PMEMORY_AREA MemoryArea,
 858                      PVOID BaseAddress,
 859                      ULONG Length,
 860                      ULONG Protect,
 861                      PULONG OldProtect);
 862
 863 NTSTATUS
 864 MmWritePageSectionView(PMADDRESS_SPACE AddressSpace,
 865                        PMEMORY_AREA MArea,
 866                        PVOID Address,
 867                        PMM_PAGEOP PageOp);
 868
 869 NTSTATUS MmInitSectionImplementation(VOID);
 870
 871 NTSTATUS STDCALL
 872 MmUnmapViewOfSection(struct _EPROCESS* Process, PVOID BaseAddress);
 873
 874 /* FIXME: it should be in ddk/mmfuncs.h */
 875 NTSTATUS STDCALL
 876 MmCreateSection (OUT    PSECTION_OBJECT         * SectionObject,
 877                  IN     ACCESS_MASK             DesiredAccess,
 878                  IN     POBJECT_ATTRIBUTES      ObjectAttributes        OPTIONAL,
 879                  IN     PLARGE_INTEGER          MaximumSize,
 880                  IN     ULONG                   SectionPageProtection,
 881                  IN     ULONG                   AllocationAttributes,
 882                  IN     HANDLE                  FileHandle              OPTIONAL,
 883                  IN     PFILE_OBJECT            File                    OPTIONAL);
 884
 885 NTSTATUS
 886 MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
 887                              MEMORY_AREA* MemoryArea,
 888                              PVOID Address,
 889                              BOOLEAN Locked);
 890
 891 NTSTATUS
 892 MmPageOutSectionView(PMADDRESS_SPACE AddressSpace,
 893                        PMEMORY_AREA MemoryArea,
 894                        PVOID Address,
 895                        struct _MM_PAGEOP* PageOp);
 896
 897 NTSTATUS
 898 MmCreatePhysicalMemorySection(VOID);
 899
 900 NTSTATUS
 901 MmAccessFaultSectionView(PMADDRESS_SPACE AddressSpace,
 902                          MEMORY_AREA* MemoryArea,
 903                          PVOID Address,
 904                          BOOLEAN Locked);
 905
 906 VOID
 907 MmFreeSectionSegments(PFILE_OBJECT FileObject);
 908
 909 /* mpw.c *********************************************************************/
 910
 911 NTSTATUS MmInitMpwThread(VOID);
 912
 913 /* pager.c *******************************************************************/
 914
 915 BOOLEAN MiIsPagerThread(VOID);
 916
 917 VOID MiStartPagerThread(VOID);
 918
 919 VOID MiStopPagerThread(VOID);
 920
 921 #endif