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