reactos/ntoskrnl/include/internal/mm.h

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