reactos/ntoskrnl/include/internal/mm.h

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