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 struct _EPROCESS;
   9
  10 extern ULONG MiFreeSwapPages;
  11 extern ULONG MiUsedSwapPages;
  12 extern ULONG MmPagedPoolSize;
  13 extern ULONG MmTotalPagedPoolQuota;
  14 extern ULONG MmTotalNonPagedPoolQuota;
  15 extern PHYSICAL_ADDRESS MmSharedDataPagePhysicalAddress;
  16 extern ULONG MmNumberOfPhysicalPages;
  17
  18 extern PVOID MmPagedPoolBase;
  19 extern ULONG MmPagedPoolSize;
  20
  21 extern PMEMORY_ALLOCATION_DESCRIPTOR MiFreeDescriptor;
  22 extern MEMORY_ALLOCATION_DESCRIPTOR MiFreeDescriptorOrg;
  23 extern ULONG MmHighestPhysicalPage;
  24 extern PVOID MmPfnDatabase;
  25
  26 struct _KTRAP_FRAME;
  27 struct _EPROCESS;
  28 struct _MM_RMAP_ENTRY;
  29 struct _MM_PAGEOP;
  30 typedef ULONG SWAPENTRY;
  31 typedef ULONG PFN_TYPE, *PPFN_TYPE;
  32
  33 #define MEMORY_AREA_INVALID                 (0)
  34 #define MEMORY_AREA_SECTION_VIEW            (1)
  35 #define MEMORY_AREA_CONTINUOUS_MEMORY       (2)
  36 #define MEMORY_AREA_NO_CACHE                (3)
  37 #define MEMORY_AREA_IO_MAPPING              (4)
  38 #define MEMORY_AREA_SYSTEM                  (5)
  39 #define MEMORY_AREA_MDL_MAPPING             (7)
  40 #define MEMORY_AREA_VIRTUAL_MEMORY          (8)
  41 #define MEMORY_AREA_CACHE_SEGMENT           (9)
  42 #define MEMORY_AREA_SHARED_DATA             (10)
  43 #define MEMORY_AREA_KERNEL_STACK            (11)
  44 #define MEMORY_AREA_PAGED_POOL              (12)
  45 #define MEMORY_AREA_NO_ACCESS               (13)
  46 #define MEMORY_AREA_PEB_OR_TEB              (14)
  47
  48 #define MM_PHYSICAL_PAGE_MPW_PENDING        (0x8)
  49
  50 #define MM_CORE_DUMP_TYPE_NONE              (0x0)
  51 #define MM_CORE_DUMP_TYPE_MINIMAL           (0x1)
  52 #define MM_CORE_DUMP_TYPE_FULL              (0x2)
  53
  54 #define MM_PAGEOP_PAGEIN                    (1)
  55 #define MM_PAGEOP_PAGEOUT                   (2)
  56 #define MM_PAGEOP_PAGESYNCH                 (3)
  57 #define MM_PAGEOP_ACCESSFAULT               (4)
  58
  59 /* Number of list heads to use */
  60 #define MI_FREE_POOL_LISTS 4
  61
  62 /* Signature of free pool blocks */
  63 #define MM_FREE_POOL_TAG    TAG('F', 'r', 'p', 'l')
  64
  65 #define PAGE_TO_SECTION_PAGE_DIRECTORY_OFFSET(x) \
  66     ((x) / (4*1024*1024))
  67
  68 #define PAGE_TO_SECTION_PAGE_TABLE_OFFSET(x) \
  69     ((((x)) % (4*1024*1024)) / (4*1024))
  70
  71 #define NR_SECTION_PAGE_TABLES              1024
  72 #define NR_SECTION_PAGE_ENTRIES             1024
  73
  74 #define TEB_BASE                            0x7FFDE000
  75
  76 /* Although Microsoft says this isn't hardcoded anymore,
  77    they won't be able to change it. Stuff depends on it */
  78 #define MM_VIRTMEM_GRANULARITY              (64 * 1024)
  79
  80 #define STATUS_MM_RESTART_OPERATION         ((NTSTATUS)0xD0000001)
  81
  82 /*
  83  * Additional flags for protection attributes
  84  */
  85 #define PAGE_WRITETHROUGH                   (1024)
  86 #define PAGE_SYSTEM                         (2048)
  87
  88 #define SEC_PHYSICALMEMORY                  (0x80000000)
  89
  90 #define MM_PAGEFILE_SEGMENT                 (0x1)
  91 #define MM_DATAFILE_SEGMENT                 (0x2)
  92
  93 #define MC_CACHE                            (0)
  94 #define MC_USER                             (1)
  95 #define MC_PPOOL                            (2)
  96 #define MC_NPPOOL                           (3)
  97 #define MC_MAXIMUM                          (4)
  98
  99 #define PAGED_POOL_MASK                     1
 100 #define MUST_SUCCEED_POOL_MASK              2
 101 #define CACHE_ALIGNED_POOL_MASK             4
 102 #define QUOTA_POOL_MASK                     8
 103 #define SESSION_POOL_MASK                   32
 104 #define VERIFIER_POOL_MASK                  64
 105
 106 #define MM_PAGED_POOL_SIZE                  (100*1024*1024)
 107 #define MM_NONPAGED_POOL_SIZE               (100*1024*1024)
 108
 109 /*
 110  * Paged and non-paged pools are 8-byte aligned
 111  */
 112 #define MM_POOL_ALIGNMENT                   8
 113
 114 /*
 115  * Maximum size of the kmalloc area (this is totally arbitary)
 116  */
 117 #define MM_KERNEL_MAP_SIZE                  (16*1024*1024)
 118 #define MM_KERNEL_MAP_BASE                  (0xf0c00000)
 119
 120 /*
 121  * FIXME - different architectures have different cache line sizes...
 122  */
 123 #define MM_CACHE_LINE_SIZE                  32
 124
 125 #define MM_ROUND_UP(x,s)                    \
 126     ((PVOID)(((ULONG_PTR)(x)+(s)-1) & ~((ULONG_PTR)(s)-1)))
 127
 128 #define MM_ROUND_DOWN(x,s)                  \
 129     ((PVOID)(((ULONG_PTR)(x)) & ~((ULONG_PTR)(s)-1)))
 130
 131 #define PAGE_FLAGS_VALID_FROM_USER_MODE     \
 132     (PAGE_READONLY | \
 133     PAGE_READWRITE | \
 134     PAGE_WRITECOPY | \
 135     PAGE_EXECUTE | \
 136     PAGE_EXECUTE_READ | \
 137     PAGE_EXECUTE_READWRITE | \
 138     PAGE_EXECUTE_WRITECOPY | \
 139     PAGE_GUARD | \
 140     PAGE_NOACCESS | \
 141     PAGE_NOCACHE)
 142
 143 #define PAGE_IS_READABLE                    \
 144     (PAGE_READONLY | \
 145     PAGE_READWRITE | \
 146     PAGE_WRITECOPY | \
 147     PAGE_EXECUTE_READ | \
 148     PAGE_EXECUTE_READWRITE | \
 149     PAGE_EXECUTE_WRITECOPY)
 150
 151 #define PAGE_IS_WRITABLE                    \
 152     (PAGE_READWRITE | \
 153     PAGE_WRITECOPY | \
 154     PAGE_EXECUTE_READWRITE | \
 155     PAGE_EXECUTE_WRITECOPY)
 156
 157 #define PAGE_IS_EXECUTABLE                  \
 158     (PAGE_EXECUTE | \
 159     PAGE_EXECUTE_READ | \
 160     PAGE_EXECUTE_READWRITE | \
 161     PAGE_EXECUTE_WRITECOPY)
 162
 163 #define PAGE_IS_WRITECOPY                   \
 164     (PAGE_WRITECOPY | \
 165     PAGE_EXECUTE_WRITECOPY)
 166
 167 typedef struct
 168 {
 169     ULONG Entry[NR_SECTION_PAGE_ENTRIES];
 170 } SECTION_PAGE_TABLE, *PSECTION_PAGE_TABLE;
 171
 172 typedef struct
 173 {
 174     PSECTION_PAGE_TABLE PageTables[NR_SECTION_PAGE_TABLES];
 175 } SECTION_PAGE_DIRECTORY, *PSECTION_PAGE_DIRECTORY;
 176
 177 typedef struct _MM_SECTION_SEGMENT
 178 {
 179     LONG FileOffset;            /* start offset into the file for image sections */
 180     ULONG_PTR VirtualAddress;   /* dtart offset into the address range for image sections */
 181     ULONG RawLength;            /* length of the segment which is part of the mapped file */
 182     ULONG Length;                       /* absolute length of the segment */
 183     ULONG Protection;
 184     FAST_MUTEX Lock;            /* lock which protects the page directory */
 185     ULONG ReferenceCount;
 186     SECTION_PAGE_DIRECTORY PageDirectory;
 187     ULONG Flags;
 188     ULONG Characteristics;
 189     BOOLEAN WriteCopy;
 190 } MM_SECTION_SEGMENT, *PMM_SECTION_SEGMENT;
 191
 192 typedef struct _MM_IMAGE_SECTION_OBJECT
 193 {
 194     ULONG_PTR ImageBase;
 195     ULONG_PTR StackReserve;
 196     ULONG_PTR StackCommit;
 197     ULONG_PTR EntryPoint;
 198     USHORT Subsystem;
 199     USHORT ImageCharacteristics;
 200     USHORT MinorSubsystemVersion;
 201     USHORT MajorSubsystemVersion;
 202     USHORT Machine;
 203     BOOLEAN Executable;
 204     ULONG NrSegments;
 205     ULONG ImageSize;
 206     PMM_SECTION_SEGMENT Segments;
 207 } MM_IMAGE_SECTION_OBJECT, *PMM_IMAGE_SECTION_OBJECT;
 208
 209 typedef struct _ROS_SECTION_OBJECT
 210 {
 211     CSHORT Type;
 212     CSHORT Size;
 213     LARGE_INTEGER MaximumSize;
 214     ULONG SectionPageProtection;
 215     ULONG AllocationAttributes;
 216     PFILE_OBJECT FileObject;
 217     union
 218     {
 219         PMM_IMAGE_SECTION_OBJECT ImageSection;
 220         PMM_SECTION_SEGMENT Segment;
 221     };
 222 } ROS_SECTION_OBJECT, *PROS_SECTION_OBJECT;
 223
 224 typedef struct _MEMORY_AREA
 225 {
 226     PVOID StartingAddress;
 227     PVOID EndingAddress;
 228     struct _MEMORY_AREA *Parent;
 229     struct _MEMORY_AREA *LeftChild;
 230     struct _MEMORY_AREA *RightChild;
 231     ULONG Type;
 232     ULONG Protect;
 233     ULONG Flags;
 234     BOOLEAN DeleteInProgress;
 235     ULONG PageOpCount;
 236     union
 237     {
 238         struct
 239         {
 240             ROS_SECTION_OBJECT* Section;
 241             ULONG ViewOffset;
 242             PMM_SECTION_SEGMENT Segment;
 243             BOOLEAN WriteCopyView;
 244             LIST_ENTRY RegionListHead;
 245         } SectionData;
 246         struct
 247         {
 248             LIST_ENTRY RegionListHead;
 249         } VirtualMemoryData;
 250     } Data;
 251 } MEMORY_AREA, *PMEMORY_AREA;
 252
 253 typedef struct
 254 {
 255     ULONG NrTotalPages;
 256     ULONG NrSystemPages;
 257     ULONG NrUserPages;
 258     ULONG NrFreePages;
 259     ULONG NrDirtyPages;
 260     ULONG NrLockedPages;
 261     ULONG PagingRequestsInLastMinute;
 262     ULONG PagingRequestsInLastFiveMinutes;
 263     ULONG PagingRequestsInLastFifteenMinutes;
 264 } MM_STATS;
 265
 266 typedef struct _PHYSICAL_PAGE
 267 {
 268     union
 269     {
 270         struct
 271         {
 272             ULONG Type: 2;
 273             ULONG Consumer: 3;
 274             ULONG Zero: 1;
 275             ULONG StartOfAllocation: 1;
 276             ULONG EndOfAllocation: 1;
 277         }
 278         Flags;
 279         ULONG AllFlags;
 280     };
 281
 282     LIST_ENTRY ListEntry;
 283     ULONG ReferenceCount;
 284     SWAPENTRY SavedSwapEntry;
 285     ULONG LockCount;
 286     ULONG MapCount;
 287     struct _MM_RMAP_ENTRY* RmapListHead;
 288 }
 289 PHYSICAL_PAGE, *PPHYSICAL_PAGE;
 290
 291 extern MM_STATS MmStats;
 292
 293 typedef struct _MM_PAGEOP
 294 {
 295   /* Type of operation. */
 296   ULONG OpType;
 297   /* Number of threads interested in this operation. */
 298   ULONG ReferenceCount;
 299   /* Event that will be set when the operation is completed. */
 300   KEVENT CompletionEvent;
 301   /* Status of the operation once it is completed. */
 302   NTSTATUS Status;
 303   /* TRUE if the operation was abandoned. */
 304   BOOLEAN Abandoned;
 305   /* The memory area to be affected by the operation. */
 306   PMEMORY_AREA MArea;
 307   ULONG Hash;
 308   struct _MM_PAGEOP* Next;
 309   struct _ETHREAD* Thread;
 310   /*
 311    * These fields are used to identify the operation if it is against a
 312    * virtual memory area.
 313    */
 314   HANDLE Pid;
 315   PVOID Address;
 316   /*
 317    * These fields are used to identify the operation if it is against a
 318    * section mapping.
 319    */
 320   PMM_SECTION_SEGMENT Segment;
 321   ULONG Offset;
 322 } MM_PAGEOP, *PMM_PAGEOP;
 323
 324 typedef struct _MM_MEMORY_CONSUMER
 325 {
 326     ULONG PagesUsed;
 327     ULONG PagesTarget;
 328     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed);
 329 } MM_MEMORY_CONSUMER, *PMM_MEMORY_CONSUMER;
 330
 331 typedef struct _MM_REGION
 332 {
 333     ULONG Type;
 334     ULONG Protect;
 335     ULONG Length;
 336     LIST_ENTRY RegionListEntry;
 337 } MM_REGION, *PMM_REGION;
 338
 339 /* Entry describing free pool memory */
 340 typedef struct _MMFREE_POOL_ENTRY
 341 {
 342     LIST_ENTRY List;
 343     PFN_NUMBER Size;
 344     ULONG Signature;
 345     struct _MMFREE_POOL_ENTRY *Owner;
 346 } MMFREE_POOL_ENTRY, *PMMFREE_POOL_ENTRY;
 347
 348 /* Paged pool information */
 349 typedef struct _MM_PAGED_POOL_INFO
 350 {
 351     PRTL_BITMAP PagedPoolAllocationMap;
 352     PRTL_BITMAP EndOfPagedPoolBitmap;
 353     PMMPTE FirstPteForPagedPool;
 354     PMMPTE LastPteForPagedPool;
 355     PMMPTE NextPdeForPagedPoolExpansion;
 356     ULONG PagedPoolHint;
 357     SIZE_T PagedPoolCommit;
 358     SIZE_T AllocatedPagedPool;
 359 } MM_PAGED_POOL_INFO, *PMM_PAGED_POOL_INFO;
 360
 361 extern MM_MEMORY_CONSUMER MiMemoryConsumers[MC_MAXIMUM];
 362
 363 typedef VOID
 364 (*PMM_ALTER_REGION_FUNC)(
 365     PMM_AVL_TABLE AddressSpace,
 366     PVOID BaseAddress,
 367     ULONG Length,
 368     ULONG OldType,
 369     ULONG OldProtect,
 370     ULONG NewType,
 371     ULONG NewProtect
 372 );
 373
 374 typedef VOID
 375 (*PMM_FREE_PAGE_FUNC)(
 376     PVOID Context,
 377     PMEMORY_AREA MemoryArea,
 378     PVOID Address,
 379     PFN_TYPE Page,
 380     SWAPENTRY SwapEntry,
 381     BOOLEAN Dirty
 382 );
 383
 384 /* marea.c *******************************************************************/
 385
 386 NTSTATUS
 387 NTAPI
 388 MmInitMemoryAreas(VOID);
 389
 390 NTSTATUS
 391 NTAPI
 392 MmCreateMemoryArea(
 393     PMM_AVL_TABLE AddressSpace,
 394     ULONG Type,
 395     PVOID *BaseAddress,
 396     ULONG_PTR Length,
 397     ULONG Protection,
 398     PMEMORY_AREA *Result,
 399     BOOLEAN FixedAddress,
 400     ULONG AllocationFlags,
 401     PHYSICAL_ADDRESS BoundaryAddressMultiple OPTIONAL
 402 );
 403
 404 PMEMORY_AREA
 405 NTAPI
 406 MmLocateMemoryAreaByAddress(
 407     PMM_AVL_TABLE AddressSpace,
 408     PVOID Address
 409 );
 410
 411 ULONG_PTR
 412 NTAPI
 413 MmFindGapAtAddress(
 414     PMM_AVL_TABLE AddressSpace,
 415     PVOID Address
 416 );
 417
 418 NTSTATUS
 419 NTAPI
 420 MmFreeMemoryArea(
 421     PMM_AVL_TABLE AddressSpace,
 422     PMEMORY_AREA MemoryArea,
 423     PMM_FREE_PAGE_FUNC FreePage,
 424     PVOID FreePageContext
 425 );
 426
 427 NTSTATUS
 428 NTAPI
 429 MmFreeMemoryAreaByPtr(
 430     PMM_AVL_TABLE AddressSpace,
 431     PVOID BaseAddress,
 432     PMM_FREE_PAGE_FUNC FreePage,
 433     PVOID FreePageContext
 434 );
 435
 436 VOID
 437 NTAPI
 438 MmDumpMemoryAreas(PMM_AVL_TABLE AddressSpace);
 439
 440 PMEMORY_AREA
 441 NTAPI
 442 MmLocateMemoryAreaByRegion(
 443     PMM_AVL_TABLE AddressSpace,
 444     PVOID Address,
 445     ULONG_PTR Length
 446 );
 447
 448 PVOID
 449 NTAPI
 450 MmFindGap(
 451     PMM_AVL_TABLE AddressSpace,
 452     ULONG_PTR Length,
 453     ULONG_PTR Granularity,
 454     BOOLEAN TopDown
 455 );
 456
 457 VOID
 458 NTAPI
 459 MmReleaseMemoryAreaIfDecommitted(
 460     struct _EPROCESS *Process,
 461     PMM_AVL_TABLE AddressSpace,
 462     PVOID BaseAddress
 463 );
 464
 465 VOID
 466 NTAPI
 467 MmMapMemoryArea(PVOID BaseAddress,
 468                 ULONG Length,
 469                 ULONG Consumer,
 470                 ULONG Protection);
 471
 472 /* npool.c *******************************************************************/
 473
 474 VOID
 475 NTAPI
 476 MiDebugDumpNonPagedPool(BOOLEAN NewOnly);
 477
 478 VOID
 479 NTAPI
 480 MiDebugDumpNonPagedPoolStats(BOOLEAN NewOnly);
 481
 482 VOID
 483 NTAPI
 484 MiInitializeNonPagedPool(VOID);
 485
 486 PVOID
 487 NTAPI
 488 MiAllocatePoolPages(
 489     IN POOL_TYPE PoolType,
 490     IN SIZE_T SizeInBytes
 491 );
 492
 493 POOL_TYPE
 494 NTAPI
 495 MmDeterminePoolType(
 496     IN PVOID VirtualAddress
 497 );
 498
 499 ULONG
 500 NTAPI
 501 MiFreePoolPages(
 502     IN PVOID StartingAddress
 503 );
 504
 505 PVOID
 506 NTAPI
 507 MmGetMdlPageAddress(
 508     PMDL Mdl,
 509     PVOID Offset
 510 );
 511
 512 /* pool.c *******************************************************************/
 513
 514 PVOID
 515 NTAPI
 516 ExAllocateNonPagedPoolWithTag(
 517     POOL_TYPE type,
 518     ULONG size,
 519     ULONG Tag,
 520     PVOID Caller
 521 );
 522
 523 PVOID
 524 NTAPI
 525 ExAllocatePagedPoolWithTag(
 526     POOL_TYPE Type,
 527     ULONG size,
 528     ULONG Tag
 529 );
 530
 531 VOID
 532 NTAPI
 533 ExFreeNonPagedPool(PVOID block);
 534
 535 VOID
 536 NTAPI
 537 ExFreePagedPool(IN PVOID Block);
 538
 539 VOID
 540 NTAPI
 541 MmInitializePagedPool(VOID);
 542
 543 PVOID
 544 NTAPI
 545 MiAllocateSpecialPool(
 546     IN POOL_TYPE PoolType,
 547     IN SIZE_T NumberOfBytes,
 548     IN ULONG Tag,
 549     IN ULONG Underrun
 550 );
 551
 552 BOOLEAN
 553 NTAPI
 554 MiRaisePoolQuota(
 555     IN POOL_TYPE PoolType,
 556     IN ULONG CurrentMaxQuota,
 557     OUT PULONG NewMaxQuota
 558 );
 559
 560 /* mdl.c *********************************************************************/
 561
 562 VOID
 563 NTAPI
 564 MmBuildMdlFromPages(
 565     PMDL Mdl,
 566     PULONG Pages
 567 );
 568
 569 /* mminit.c ******************************************************************/
 570
 571 VOID
 572 NTAPI
 573 MiShutdownMemoryManager(VOID);
 574
 575 VOID
 576 NTAPI
 577 MmInit1(
 578     VOID
 579 );
 580
 581 BOOLEAN
 582 NTAPI
 583 MmInitSystem(IN ULONG Phase,
 584              IN PLOADER_PARAMETER_BLOCK LoaderBlock);
 585
 586 VOID
 587 NTAPI
 588 MiFreeInitMemory(VOID);
 589
 590 VOID
 591 NTAPI
 592 MmInitializeMdlImplementation(VOID);
 593
 594 /* pagefile.c ****************************************************************/
 595
 596 SWAPENTRY
 597 NTAPI
 598 MmAllocSwapPage(VOID);
 599
 600 VOID
 601 NTAPI
 602 MmDereserveSwapPages(ULONG Nr);
 603
 604 VOID
 605 NTAPI
 606 MmFreeSwapPage(SWAPENTRY Entry);
 607
 608 VOID
 609 NTAPI
 610 MmInitPagingFile(VOID);
 611
 612 NTSTATUS
 613 NTAPI
 614 MmReadFromSwapPage(
 615     SWAPENTRY SwapEntry,
 616     PFN_TYPE Page
 617 );
 618
 619 BOOLEAN
 620 NTAPI
 621 MmReserveSwapPages(ULONG Nr);
 622
 623 NTSTATUS
 624 NTAPI
 625 MmWriteToSwapPage(
 626     SWAPENTRY SwapEntry,
 627     PFN_TYPE Page
 628 );
 629
 630 NTSTATUS
 631 NTAPI
 632 MmDumpToPagingFile(
 633     ULONG BugCode,
 634     ULONG BugCodeParameter1,
 635     ULONG BugCodeParameter2,
 636     ULONG BugCodeParameter3,
 637     ULONG BugCodeParameter4,
 638     struct _KTRAP_FRAME* TrapFrame
 639 );
 640
 641 BOOLEAN
 642 NTAPI
 643 MmIsAvailableSwapPage(VOID);
 644
 645 VOID
 646 NTAPI
 647 MmShowOutOfSpaceMessagePagingFile(VOID);
 648
 649 /* process.c ****************************************************************/
 650
 651 NTSTATUS
 652 NTAPI
 653 MmInitializeProcessAddressSpace(
 654     IN PEPROCESS Process,
 655     IN PEPROCESS Clone OPTIONAL,
 656     IN PVOID Section OPTIONAL,
 657     IN OUT PULONG Flags,
 658     IN POBJECT_NAME_INFORMATION *AuditName OPTIONAL
 659 );
 660
 661 NTSTATUS
 662 NTAPI
 663 MmCreatePeb(struct _EPROCESS *Process);
 664
 665 PTEB
 666 NTAPI
 667 MmCreateTeb(
 668     struct _EPROCESS *Process,
 669     PCLIENT_ID ClientId,
 670     PINITIAL_TEB InitialTeb
 671 );
 672
 673 VOID
 674 NTAPI
 675 MmDeleteTeb(
 676     struct _EPROCESS *Process,
 677     PTEB Teb
 678 );
 679
 680 VOID
 681 NTAPI
 682 MmCleanProcessAddressSpace(IN PEPROCESS Process);
 683
 684 NTSTATUS
 685 NTAPI
 686 MmDeleteProcessAddressSpace(IN PEPROCESS Process);
 687
 688 ULONG
 689 NTAPI
 690 MmGetSessionLocaleId(VOID);
 691
 692 NTSTATUS
 693 NTAPI
 694 MmSetMemoryPriorityProcess(
 695     IN PEPROCESS Process,
 696     IN UCHAR MemoryPriority
 697 );
 698
 699 /* i386/pfault.c *************************************************************/
 700
 701 NTSTATUS
 702 NTAPI
 703 MmPageFault(
 704     ULONG Cs,
 705     PULONG Eip,
 706     PULONG Eax,
 707     ULONG Cr2,
 708     ULONG ErrorCode
 709 );
 710
 711 /* mm.c **********************************************************************/
 712
 713 NTSTATUS
 714 NTAPI
 715 MmAccessFault(
 716     IN BOOLEAN StoreInstruction,
 717     IN PVOID Address,
 718     IN KPROCESSOR_MODE Mode,
 719     IN PVOID TrapInformation
 720 );
 721
 722 /* anonmem.c *****************************************************************/
 723
 724 NTSTATUS
 725 NTAPI
 726 MmNotPresentFaultVirtualMemory(
 727     PMM_AVL_TABLE AddressSpace,
 728     MEMORY_AREA* MemoryArea,
 729     PVOID Address,
 730     BOOLEAN Locked
 731 );
 732
 733 NTSTATUS
 734 NTAPI
 735 MmPageOutVirtualMemory(
 736     PMM_AVL_TABLE AddressSpace,
 737     PMEMORY_AREA MemoryArea,
 738     PVOID Address,
 739     struct _MM_PAGEOP* PageOp
 740 );
 741
 742 NTSTATUS
 743 NTAPI
 744 MmQueryAnonMem(
 745     PMEMORY_AREA MemoryArea,
 746     PVOID Address,
 747     PMEMORY_BASIC_INFORMATION Info,
 748     PULONG ResultLength
 749 );
 750
 751 VOID
 752 NTAPI
 753 MmFreeVirtualMemory(
 754     struct _EPROCESS* Process,
 755     PMEMORY_AREA MemoryArea
 756 );
 757
 758 NTSTATUS
 759 NTAPI
 760 MmProtectAnonMem(
 761     PMM_AVL_TABLE AddressSpace,
 762     PMEMORY_AREA MemoryArea,
 763     PVOID BaseAddress,
 764     ULONG Length,
 765     ULONG Protect,
 766     PULONG OldProtect
 767 );
 768
 769 NTSTATUS
 770 NTAPI
 771 MmWritePageVirtualMemory(
 772     PMM_AVL_TABLE AddressSpace,
 773     PMEMORY_AREA MArea,
 774     PVOID Address,
 775     PMM_PAGEOP PageOp
 776 );
 777
 778 /* kmap.c ********************************************************************/
 779
 780 PVOID
 781 NTAPI
 782 ExAllocatePage(VOID);
 783
 784 VOID
 785 NTAPI
 786 ExUnmapPage(PVOID Addr);
 787
 788 PVOID
 789 NTAPI
 790 ExAllocatePageWithPhysPage(PFN_TYPE Page);
 791
 792 NTSTATUS
 793 NTAPI
 794 MiCopyFromUserPage(
 795     PFN_TYPE Page,
 796     PVOID SourceAddress
 797 );
 798
 799 NTSTATUS
 800 NTAPI
 801 MiZeroPage(PFN_TYPE Page);
 802
 803 /* memsafe.s *****************************************************************/
 804
 805 PVOID
 806 FASTCALL
 807 MmSafeReadPtr(PVOID Source);
 808
 809 /* pageop.c ******************************************************************/
 810
 811 VOID
 812 NTAPI
 813 MmReleasePageOp(PMM_PAGEOP PageOp);
 814
 815 PMM_PAGEOP
 816 NTAPI
 817 MmGetPageOp(
 818     PMEMORY_AREA MArea,
 819     HANDLE Pid,
 820     PVOID Address,
 821     PMM_SECTION_SEGMENT Segment,
 822     ULONG Offset,
 823     ULONG OpType,
 824     BOOLEAN First
 825 );
 826
 827 PMM_PAGEOP
 828 NTAPI
 829 MmCheckForPageOp(
 830     PMEMORY_AREA MArea,
 831     HANDLE Pid,
 832     PVOID Address,
 833     PMM_SECTION_SEGMENT Segment,
 834     ULONG Offset
 835 );
 836
 837 VOID
 838 NTAPI
 839 MmInitializePageOp(VOID);
 840
 841 /* process.c *****************************************************************/
 842
 843 PVOID
 844 NTAPI
 845 MmCreateKernelStack(BOOLEAN GuiStack, UCHAR Node);
 846
 847 VOID
 848 NTAPI
 849 MmDeleteKernelStack(PVOID Stack,
 850                     BOOLEAN GuiStack);
 851
 852 /* balace.c ******************************************************************/
 853
 854 VOID
 855 NTAPI
 856 MmInitializeMemoryConsumer(
 857     ULONG Consumer,
 858     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed)
 859 );
 860
 861 VOID
 862 NTAPI
 863 MmInitializeBalancer(
 864     ULONG NrAvailablePages,
 865     ULONG NrSystemPages
 866 );
 867
 868 NTSTATUS
 869 NTAPI
 870 MmReleasePageMemoryConsumer(
 871     ULONG Consumer,
 872     PFN_TYPE Page
 873 );
 874
 875 NTSTATUS
 876 NTAPI
 877 MmRequestPageMemoryConsumer(
 878     ULONG Consumer,
 879     BOOLEAN MyWait,
 880     PPFN_TYPE AllocatedPage
 881 );
 882
 883 VOID
 884 NTAPI
 885 MiInitBalancerThread(VOID);
 886
 887 VOID
 888 NTAPI
 889 MmRebalanceMemoryConsumers(VOID);
 890
 891 /* rmap.c **************************************************************/
 892
 893 VOID
 894 NTAPI
 895 MmSetRmapListHeadPage(
 896     PFN_TYPE Page,
 897     struct _MM_RMAP_ENTRY* ListHead
 898 );
 899
 900 struct _MM_RMAP_ENTRY*
 901 NTAPI
 902 MmGetRmapListHeadPage(PFN_TYPE Page);
 903
 904 VOID
 905 NTAPI
 906 MmInsertRmap(
 907     PFN_TYPE Page,
 908     struct _EPROCESS *Process,
 909     PVOID Address
 910 );
 911
 912 VOID
 913 NTAPI
 914 MmDeleteAllRmaps(
 915     PFN_TYPE Page,
 916     PVOID Context,
 917     VOID (*DeleteMapping)(PVOID Context, struct _EPROCESS *Process, PVOID Address)
 918 );
 919
 920 VOID
 921 NTAPI
 922 MmDeleteRmap(
 923     PFN_TYPE Page,
 924     struct _EPROCESS *Process,
 925     PVOID Address
 926 );
 927
 928 VOID
 929 NTAPI
 930 MmInitializeRmapList(VOID);
 931
 932 VOID
 933 NTAPI
 934 MmSetCleanAllRmaps(PFN_TYPE Page);
 935
 936 VOID
 937 NTAPI
 938 MmSetDirtyAllRmaps(PFN_TYPE Page);
 939
 940 BOOLEAN
 941 NTAPI
 942 MmIsDirtyPageRmap(PFN_TYPE Page);
 943
 944 NTSTATUS
 945 NTAPI
 946 MmWritePagePhysicalAddress(PFN_TYPE Page);
 947
 948 NTSTATUS
 949 NTAPI
 950 MmPageOutPhysicalAddress(PFN_TYPE Page);
 951
 952 /* freelist.c **********************************************************/
 953
 954 #define ASSERT_PFN(x) ASSERT((x)->Flags.Type != 0)
 955
 956 FORCEINLINE
 957 PPHYSICAL_PAGE
 958 MiGetPfnEntry(IN PFN_TYPE Pfn)
 959 {
 960     PPHYSICAL_PAGE Page;
 961     extern PPHYSICAL_PAGE MmPageArray;
 962     extern ULONG MmPageArraySize;
 963
 964     /* Mark MmPageArraySize as unreferenced, otherwise it will appear as an unused variable on a Release build */
 965     UNREFERENCED_PARAMETER(MmPageArraySize);
 966
 967     /* Make sure the PFN number is valid */
 968     ASSERT(Pfn <= MmPageArraySize);
 969
 970     /* Get the entry */
 971     Page = &MmPageArray[Pfn];
 972
 973     /* Make sure it's valid */
 974     ASSERT_PFN(Page);
 975
 976     /* Return it */
 977     return Page;
 978 };
 979
 980 PFN_TYPE
 981 NTAPI
 982 MmGetLRUNextUserPage(PFN_TYPE PreviousPage);
 983
 984 PFN_TYPE
 985 NTAPI
 986 MmGetLRUFirstUserPage(VOID);
 987
 988 VOID
 989 NTAPI
 990 MmInsertLRULastUserPage(PFN_TYPE Page);
 991
 992 VOID
 993 NTAPI
 994 MmRemoveLRUUserPage(PFN_TYPE Page);
 995
 996 VOID
 997 NTAPI
 998 MmLockPage(PFN_TYPE Page);
 999
1000 VOID
1001 NTAPI
1002 MmLockPageUnsafe(PFN_TYPE Page);
1003
1004 VOID
1005 NTAPI
1006 MmUnlockPage(PFN_TYPE Page);
1007
1008 ULONG
1009 NTAPI
1010 MmGetLockCountPage(PFN_TYPE Page);
1011
1012 FORCEINLINE
1013 KIRQL
1014 NTAPI
1015 MmAcquirePageListLock()
1016 {
1017         return KeAcquireQueuedSpinLock(LockQueuePfnLock);
1018 }
1019
1020 FORCEINLINE
1021 VOID
1022 NTAPI
1023 MmReleasePageListLock(KIRQL oldIrql)
1024 {
1025         KeReleaseQueuedSpinLock(LockQueuePfnLock, oldIrql);
1026 }
1027
1028 VOID
1029 NTAPI
1030 MmInitializePageList(
1031     VOID
1032 );
1033
1034 PFN_TYPE
1035 NTAPI
1036 MmGetContinuousPages(
1037     ULONG NumberOfBytes,
1038     PHYSICAL_ADDRESS LowestAcceptableAddress,
1039     PHYSICAL_ADDRESS HighestAcceptableAddress,
1040     PHYSICAL_ADDRESS BoundaryAddressMultiple
1041 );
1042
1043 NTSTATUS
1044 NTAPI
1045 MmZeroPageThreadMain(
1046     PVOID Context
1047 );
1048
1049 /* i386/page.c *********************************************************/
1050
1051 PVOID
1052 NTAPI
1053 MmCreateHyperspaceMapping(PFN_TYPE Page);
1054
1055 PFN_TYPE
1056 NTAPI
1057 MmChangeHyperspaceMapping(
1058     PVOID Address,
1059     PFN_TYPE Page
1060 );
1061
1062 PFN_TYPE
1063 NTAPI
1064 MmDeleteHyperspaceMapping(PVOID Address);
1065
1066 NTSTATUS
1067 NTAPI
1068 MmCreateVirtualMappingForKernel(
1069     PVOID Address,
1070     ULONG flProtect,
1071     PPFN_TYPE Pages,
1072     ULONG PageCount
1073 );
1074
1075 NTSTATUS
1076 NTAPI
1077 MmCommitPagedPoolAddress(
1078     PVOID Address,
1079     BOOLEAN Locked
1080 );
1081
1082 NTSTATUS
1083 NTAPI
1084 MmCreateVirtualMapping(
1085     struct _EPROCESS* Process,
1086     PVOID Address,
1087     ULONG flProtect,
1088     PPFN_TYPE Pages,
1089     ULONG PageCount
1090 );
1091
1092 NTSTATUS
1093 NTAPI
1094 MmCreateVirtualMappingUnsafe(
1095     struct _EPROCESS* Process,
1096     PVOID Address,
1097     ULONG flProtect,
1098     PPFN_TYPE Pages,
1099     ULONG PageCount
1100 );
1101
1102 ULONG
1103 NTAPI
1104 MmGetPageProtect(
1105     struct _EPROCESS* Process,
1106     PVOID Address);
1107
1108 VOID
1109 NTAPI
1110 MmSetPageProtect(
1111     struct _EPROCESS* Process,
1112     PVOID Address,
1113     ULONG flProtect
1114 );
1115
1116 BOOLEAN
1117 NTAPI
1118 MmIsPagePresent(
1119     struct _EPROCESS* Process,
1120     PVOID Address
1121 );
1122
1123 VOID
1124 NTAPI
1125 MmInitGlobalKernelPageDirectory(VOID);
1126
1127 VOID
1128 NTAPI
1129 MmDisableVirtualMapping(
1130     struct _EPROCESS *Process,
1131     PVOID Address,
1132     BOOLEAN* WasDirty,
1133     PPFN_TYPE Page
1134 );
1135
1136 VOID
1137 NTAPI
1138 MmEnableVirtualMapping(
1139     struct _EPROCESS *Process,
1140     PVOID Address
1141 );
1142
1143 VOID
1144 NTAPI
1145 MmRawDeleteVirtualMapping(PVOID Address);
1146
1147 VOID
1148 NTAPI
1149 MmDeletePageFileMapping(
1150     struct _EPROCESS *Process,
1151     PVOID Address,
1152     SWAPENTRY* SwapEntry
1153 );
1154
1155 NTSTATUS
1156 NTAPI
1157 MmCreatePageFileMapping(
1158     struct _EPROCESS *Process,
1159     PVOID Address,
1160     SWAPENTRY SwapEntry
1161 );
1162
1163 BOOLEAN
1164 NTAPI
1165 MmIsPageSwapEntry(
1166     struct _EPROCESS *Process,
1167     PVOID Address
1168 );
1169
1170 VOID
1171 NTAPI
1172 MmTransferOwnershipPage(
1173     PFN_TYPE Page,
1174     ULONG NewConsumer
1175 );
1176
1177 VOID
1178 NTAPI
1179 MmSetDirtyPage(
1180     struct _EPROCESS *Process,
1181     PVOID Address
1182 );
1183
1184 PFN_TYPE
1185 NTAPI
1186 MmAllocPage(
1187     ULONG Consumer,
1188     SWAPENTRY SavedSwapEntry
1189 );
1190
1191 LONG
1192 NTAPI
1193 MmAllocPagesSpecifyRange(
1194     ULONG Consumer,
1195     PHYSICAL_ADDRESS LowestAddress,
1196     PHYSICAL_ADDRESS HighestAddress,
1197     ULONG NumberOfPages,
1198     PPFN_TYPE Pages
1199 );
1200
1201 VOID
1202 NTAPI
1203 MmDereferencePage(PFN_TYPE Page);
1204
1205 VOID
1206 NTAPI
1207 MmReferencePage(PFN_TYPE Page);
1208
1209 VOID
1210 NTAPI
1211 MmReferencePageUnsafe(PFN_TYPE Page);
1212
1213 BOOLEAN
1214 NTAPI
1215 MmIsAccessedAndResetAccessPage(
1216     struct _EPROCESS *Process,
1217     PVOID Address
1218 );
1219
1220 ULONG
1221 NTAPI
1222 MmGetReferenceCountPage(PFN_TYPE Page);
1223
1224 BOOLEAN
1225 NTAPI
1226 MmIsPageInUse(PFN_TYPE Page);
1227
1228 VOID
1229 NTAPI
1230 MmSetFlagsPage(
1231     PFN_TYPE Page,
1232     ULONG Flags);
1233
1234 ULONG
1235 NTAPI
1236 MmGetFlagsPage(PFN_TYPE Page);
1237
1238 VOID
1239 NTAPI
1240 MmSetSavedSwapEntryPage(
1241     PFN_TYPE Page,
1242     SWAPENTRY SavedSwapEntry);
1243
1244 SWAPENTRY
1245 NTAPI
1246 MmGetSavedSwapEntryPage(PFN_TYPE Page);
1247
1248 VOID
1249 NTAPI
1250 MmSetCleanPage(
1251     struct _EPROCESS *Process,
1252     PVOID Address
1253 );
1254
1255 NTSTATUS
1256 NTAPI
1257 MmCreatePageTable(PVOID PAddress);
1258
1259 VOID
1260 NTAPI
1261 MmDeletePageTable(
1262     struct _EPROCESS *Process,
1263     PVOID Address
1264 );
1265
1266 PFN_TYPE
1267 NTAPI
1268 MmGetPfnForProcess(
1269     struct _EPROCESS *Process,
1270     PVOID Address
1271 );
1272
1273 BOOLEAN
1274 NTAPI
1275 MmCreateProcessAddressSpace(
1276     IN ULONG MinWs,
1277     IN PEPROCESS Dest,
1278     IN PULONG_PTR DirectoryTableBase
1279 );
1280
1281 NTSTATUS
1282 NTAPI
1283 MmInitializeHandBuiltProcess(
1284     IN PEPROCESS Process,
1285     IN PULONG_PTR DirectoryTableBase
1286 );
1287
1288
1289 NTSTATUS
1290 NTAPI
1291 MmInitializeHandBuiltProcess2(
1292     IN PEPROCESS Process
1293 );
1294
1295 NTSTATUS
1296 NTAPI
1297 MmReleaseMmInfo(struct _EPROCESS *Process);
1298
1299 NTSTATUS
1300 NTAPI
1301 Mmi386ReleaseMmInfo(struct _EPROCESS *Process);
1302
1303 VOID
1304 NTAPI
1305 MmDeleteVirtualMapping(
1306     struct _EPROCESS *Process,
1307     PVOID Address,
1308     BOOLEAN FreePage,
1309     BOOLEAN* WasDirty,
1310     PPFN_TYPE Page
1311 );
1312
1313 BOOLEAN
1314 NTAPI
1315 MmIsDirtyPage(
1316     struct _EPROCESS *Process,
1317     PVOID Address
1318 );
1319
1320 VOID
1321 NTAPI
1322 MmMarkPageMapped(PFN_TYPE Page);
1323
1324 VOID
1325 NTAPI
1326 MmMarkPageUnmapped(PFN_TYPE Page);
1327
1328 VOID
1329 NTAPI
1330 MmUpdatePageDir(
1331     struct _EPROCESS *Process,
1332     PVOID Address,
1333     ULONG Size
1334 );
1335
1336 VOID
1337 NTAPI
1338 MiInitPageDirectoryMap(VOID);
1339
1340 ULONG
1341 NTAPI
1342 MiGetUserPageDirectoryCount(VOID);
1343
1344 /* wset.c ********************************************************************/
1345
1346 NTSTATUS
1347 MmTrimUserMemory(
1348     ULONG Target,
1349     ULONG Priority,
1350     PULONG NrFreedPages
1351 );
1352
1353 /* region.c ************************************************************/
1354
1355 NTSTATUS
1356 NTAPI
1357 MmAlterRegion(
1358     PMM_AVL_TABLE AddressSpace,
1359     PVOID BaseAddress,
1360     PLIST_ENTRY RegionListHead,
1361     PVOID StartAddress,
1362     ULONG Length,
1363     ULONG NewType,
1364     ULONG NewProtect,
1365     PMM_ALTER_REGION_FUNC AlterFunc
1366 );
1367
1368 VOID
1369 NTAPI
1370 MmInitializeRegion(
1371     PLIST_ENTRY RegionListHead,
1372     SIZE_T Length,
1373     ULONG Type,
1374     ULONG Protect
1375 );
1376
1377 PMM_REGION
1378 NTAPI
1379 MmFindRegion(
1380     PVOID BaseAddress,
1381     PLIST_ENTRY RegionListHead,
1382     PVOID Address,
1383     PVOID* RegionBaseAddress
1384 );
1385
1386 /* section.c *****************************************************************/
1387
1388 PFILE_OBJECT
1389 NTAPI
1390 MmGetFileObjectForSection(
1391     IN PROS_SECTION_OBJECT Section
1392 );
1393 NTSTATUS
1394 NTAPI
1395 MmGetFileNameForAddress(
1396     IN PVOID Address,
1397     OUT PUNICODE_STRING ModuleName
1398 );
1399
1400 NTSTATUS
1401 NTAPI
1402 MmGetFileNameForSection(
1403     IN PROS_SECTION_OBJECT Section,
1404     OUT POBJECT_NAME_INFORMATION *ModuleName
1405 );
1406
1407 PVOID
1408 NTAPI
1409 MmAllocateSection(
1410     IN ULONG Length,
1411     PVOID BaseAddress
1412 );
1413
1414 NTSTATUS
1415 NTAPI
1416 MmQuerySectionView(
1417     PMEMORY_AREA MemoryArea,
1418     PVOID Address,
1419     PMEMORY_BASIC_INFORMATION Info,
1420     PULONG ResultLength
1421 );
1422
1423 NTSTATUS
1424 NTAPI
1425 MmProtectSectionView(
1426     PMM_AVL_TABLE AddressSpace,
1427     PMEMORY_AREA MemoryArea,
1428     PVOID BaseAddress,
1429     ULONG Length,
1430     ULONG Protect,
1431     PULONG OldProtect
1432 );
1433
1434 NTSTATUS
1435 NTAPI
1436 MmWritePageSectionView(
1437     PMM_AVL_TABLE AddressSpace,
1438     PMEMORY_AREA MArea,
1439     PVOID Address,
1440     PMM_PAGEOP PageOp
1441 );
1442
1443 NTSTATUS
1444 NTAPI
1445 MmInitSectionImplementation(VOID);
1446
1447 NTSTATUS
1448 NTAPI
1449 MmNotPresentFaultSectionView(
1450     PMM_AVL_TABLE AddressSpace,
1451     MEMORY_AREA* MemoryArea,
1452     PVOID Address,
1453     BOOLEAN Locked
1454 );
1455
1456 NTSTATUS
1457 NTAPI
1458 MmPageOutSectionView(
1459     PMM_AVL_TABLE AddressSpace,
1460     PMEMORY_AREA MemoryArea,
1461     PVOID Address,
1462     struct _MM_PAGEOP *PageOp
1463 );
1464
1465 NTSTATUS
1466 NTAPI
1467 MmCreatePhysicalMemorySection(VOID);
1468
1469 NTSTATUS
1470 NTAPI
1471 MmAccessFaultSectionView(
1472     PMM_AVL_TABLE AddressSpace,
1473     MEMORY_AREA* MemoryArea,
1474     PVOID Address,
1475     BOOLEAN Locked
1476 );
1477
1478 VOID
1479 NTAPI
1480 MmFreeSectionSegments(PFILE_OBJECT FileObject);
1481
1482 /* mpw.c *********************************************************************/
1483
1484 NTSTATUS
1485 NTAPI
1486 MmInitMpwThread(VOID);
1487
1488 NTSTATUS
1489 NTAPI
1490 MmInitBsmThread(VOID);
1491
1492 /* pager.c *******************************************************************/
1493
1494 BOOLEAN
1495 NTAPI
1496 MiIsPagerThread(VOID);
1497
1498 VOID
1499 NTAPI
1500 MiStartPagerThread(VOID);
1501
1502 VOID
1503 NTAPI
1504 MiStopPagerThread(VOID);
1505
1506 NTSTATUS
1507 FASTCALL
1508 MiQueryVirtualMemory(
1509     IN HANDLE ProcessHandle,
1510     IN PVOID Address,
1511     IN MEMORY_INFORMATION_CLASS VirtualMemoryInformationClass,
1512     OUT PVOID VirtualMemoryInformation,
1513     IN ULONG Length,
1514     OUT PULONG ResultLength
1515 );
1516
1517 /* sysldr.c ******************************************************************/
1518
1519 VOID
1520 NTAPI
1521 MiReloadBootLoadedDrivers(
1522     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1523 );
1524
1525 BOOLEAN
1526 NTAPI
1527 MiInitializeLoadedModuleList(
1528     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1529 );
1530
1531 NTSTATUS
1532 NTAPI
1533 MmLoadSystemImage(
1534     IN PUNICODE_STRING FileName,
1535     IN PUNICODE_STRING NamePrefix OPTIONAL,
1536     IN PUNICODE_STRING LoadedName OPTIONAL,
1537     IN ULONG Flags,
1538     OUT PVOID *ModuleObject,
1539     OUT PVOID *ImageBaseAddress
1540 );
1541
1542 NTSTATUS
1543 NTAPI
1544 MmUnloadSystemImage(
1545     IN PVOID ImageHandle
1546 );
1547
1548 NTSTATUS
1549 NTAPI
1550 MmCheckSystemImage(
1551     IN HANDLE ImageHandle,
1552     IN BOOLEAN PurgeSection
1553 );
1554
1555 /* ReactOS Mm Hack */
1556 VOID
1557 FASTCALL
1558 MiSyncThreadProcessViews(
1559     IN PKTHREAD NextThread
1560 );
1561
1562 extern PMM_AVL_TABLE MmKernelAddressSpace;
1563
1564 FORCEINLINE
1565 VOID
1566 MmLockAddressSpace(PMM_AVL_TABLE AddressSpace)
1567 {
1568     KeAcquireGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, VadRoot)->AddressCreationLock);
1569 }
1570
1571 FORCEINLINE
1572 VOID
1573 MmUnlockAddressSpace(PMM_AVL_TABLE AddressSpace)
1574 {
1575     KeReleaseGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, VadRoot)->AddressCreationLock);
1576 }
1577
1578 FORCEINLINE
1579 PEPROCESS
1580 MmGetAddressSpaceOwner(IN PMM_AVL_TABLE AddressSpace)
1581 {
1582     if (AddressSpace == MmKernelAddressSpace) return NULL;
1583     return CONTAINING_RECORD(AddressSpace, EPROCESS, VadRoot);
1584 }
1585
1586 FORCEINLINE
1587 PMM_AVL_TABLE
1588 MmGetCurrentAddressSpace(VOID)
1589 {
1590     return &((PEPROCESS)KeGetCurrentThread()->ApcState.Process)->VadRoot;
1591 }
1592
1593 FORCEINLINE
1594 PMM_AVL_TABLE
1595 MmGetKernelAddressSpace(VOID)
1596 {
1597     return MmKernelAddressSpace;
1598 }
1599
1600 #endif