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 VOID
1013 NTAPI
1014 MmInitializePageList(
1015     VOID
1016 );
1017
1018 PFN_TYPE
1019 NTAPI
1020 MmGetContinuousPages(
1021     ULONG NumberOfBytes,
1022     PHYSICAL_ADDRESS LowestAcceptableAddress,
1023     PHYSICAL_ADDRESS HighestAcceptableAddress,
1024     PHYSICAL_ADDRESS BoundaryAddressMultiple
1025 );
1026
1027 NTSTATUS
1028 NTAPI
1029 MmZeroPageThreadMain(
1030     PVOID Context
1031 );
1032
1033 /* i386/page.c *********************************************************/
1034
1035 PVOID
1036 NTAPI
1037 MmCreateHyperspaceMapping(PFN_TYPE Page);
1038
1039 PFN_TYPE
1040 NTAPI
1041 MmChangeHyperspaceMapping(
1042     PVOID Address,
1043     PFN_TYPE Page
1044 );
1045
1046 PFN_TYPE
1047 NTAPI
1048 MmDeleteHyperspaceMapping(PVOID Address);
1049
1050 NTSTATUS
1051 NTAPI
1052 MmCreateVirtualMappingForKernel(
1053     PVOID Address,
1054     ULONG flProtect,
1055     PPFN_TYPE Pages,
1056     ULONG PageCount
1057 );
1058
1059 NTSTATUS
1060 NTAPI
1061 MmCommitPagedPoolAddress(
1062     PVOID Address,
1063     BOOLEAN Locked
1064 );
1065
1066 NTSTATUS
1067 NTAPI
1068 MmCreateVirtualMapping(
1069     struct _EPROCESS* Process,
1070     PVOID Address,
1071     ULONG flProtect,
1072     PPFN_TYPE Pages,
1073     ULONG PageCount
1074 );
1075
1076 NTSTATUS
1077 NTAPI
1078 MmCreateVirtualMappingUnsafe(
1079     struct _EPROCESS* Process,
1080     PVOID Address,
1081     ULONG flProtect,
1082     PPFN_TYPE Pages,
1083     ULONG PageCount
1084 );
1085
1086 ULONG
1087 NTAPI
1088 MmGetPageProtect(
1089     struct _EPROCESS* Process,
1090     PVOID Address);
1091
1092 VOID
1093 NTAPI
1094 MmSetPageProtect(
1095     struct _EPROCESS* Process,
1096     PVOID Address,
1097     ULONG flProtect
1098 );
1099
1100 BOOLEAN
1101 NTAPI
1102 MmIsPagePresent(
1103     struct _EPROCESS* Process,
1104     PVOID Address
1105 );
1106
1107 VOID
1108 NTAPI
1109 MmInitGlobalKernelPageDirectory(VOID);
1110
1111 VOID
1112 NTAPI
1113 MmDisableVirtualMapping(
1114     struct _EPROCESS *Process,
1115     PVOID Address,
1116     BOOLEAN* WasDirty,
1117     PPFN_TYPE Page
1118 );
1119
1120 VOID
1121 NTAPI
1122 MmEnableVirtualMapping(
1123     struct _EPROCESS *Process,
1124     PVOID Address
1125 );
1126
1127 VOID
1128 NTAPI
1129 MmRawDeleteVirtualMapping(PVOID Address);
1130
1131 VOID
1132 NTAPI
1133 MmDeletePageFileMapping(
1134     struct _EPROCESS *Process,
1135     PVOID Address,
1136     SWAPENTRY* SwapEntry
1137 );
1138
1139 NTSTATUS
1140 NTAPI
1141 MmCreatePageFileMapping(
1142     struct _EPROCESS *Process,
1143     PVOID Address,
1144     SWAPENTRY SwapEntry
1145 );
1146
1147 BOOLEAN
1148 NTAPI
1149 MmIsPageSwapEntry(
1150     struct _EPROCESS *Process,
1151     PVOID Address
1152 );
1153
1154 VOID
1155 NTAPI
1156 MmTransferOwnershipPage(
1157     PFN_TYPE Page,
1158     ULONG NewConsumer
1159 );
1160
1161 VOID
1162 NTAPI
1163 MmSetDirtyPage(
1164     struct _EPROCESS *Process,
1165     PVOID Address
1166 );
1167
1168 PFN_TYPE
1169 NTAPI
1170 MmAllocPage(
1171     ULONG Consumer,
1172     SWAPENTRY SavedSwapEntry
1173 );
1174
1175 LONG
1176 NTAPI
1177 MmAllocPagesSpecifyRange(
1178     ULONG Consumer,
1179     PHYSICAL_ADDRESS LowestAddress,
1180     PHYSICAL_ADDRESS HighestAddress,
1181     ULONG NumberOfPages,
1182     PPFN_TYPE Pages
1183 );
1184
1185 VOID
1186 NTAPI
1187 MmDereferencePage(PFN_TYPE Page);
1188
1189 VOID
1190 NTAPI
1191 MmReferencePage(PFN_TYPE Page);
1192
1193 VOID
1194 NTAPI
1195 MmReferencePageUnsafe(PFN_TYPE Page);
1196
1197 BOOLEAN
1198 NTAPI
1199 MmIsAccessedAndResetAccessPage(
1200     struct _EPROCESS *Process,
1201     PVOID Address
1202 );
1203
1204 ULONG
1205 NTAPI
1206 MmGetReferenceCountPage(PFN_TYPE Page);
1207
1208 BOOLEAN
1209 NTAPI
1210 MmIsPageInUse(PFN_TYPE Page);
1211
1212 VOID
1213 NTAPI
1214 MmSetFlagsPage(
1215     PFN_TYPE Page,
1216     ULONG Flags);
1217
1218 ULONG
1219 NTAPI
1220 MmGetFlagsPage(PFN_TYPE Page);
1221
1222 VOID
1223 NTAPI
1224 MmSetSavedSwapEntryPage(
1225     PFN_TYPE Page,
1226     SWAPENTRY SavedSwapEntry);
1227
1228 SWAPENTRY
1229 NTAPI
1230 MmGetSavedSwapEntryPage(PFN_TYPE Page);
1231
1232 VOID
1233 NTAPI
1234 MmSetCleanPage(
1235     struct _EPROCESS *Process,
1236     PVOID Address
1237 );
1238
1239 NTSTATUS
1240 NTAPI
1241 MmCreatePageTable(PVOID PAddress);
1242
1243 VOID
1244 NTAPI
1245 MmDeletePageTable(
1246     struct _EPROCESS *Process,
1247     PVOID Address
1248 );
1249
1250 PFN_TYPE
1251 NTAPI
1252 MmGetPfnForProcess(
1253     struct _EPROCESS *Process,
1254     PVOID Address
1255 );
1256
1257 BOOLEAN
1258 NTAPI
1259 MmCreateProcessAddressSpace(
1260     IN ULONG MinWs,
1261     IN PEPROCESS Dest,
1262     IN PLARGE_INTEGER DirectoryTableBase
1263 );
1264
1265 NTSTATUS
1266 NTAPI
1267 MmInitializeHandBuiltProcess(
1268     IN PEPROCESS Process,
1269     IN PLARGE_INTEGER DirectoryTableBase
1270 );
1271
1272
1273 NTSTATUS
1274 NTAPI
1275 MmInitializeHandBuiltProcess2(
1276     IN PEPROCESS Process
1277 );
1278
1279 NTSTATUS
1280 NTAPI
1281 MmReleaseMmInfo(struct _EPROCESS *Process);
1282
1283 NTSTATUS
1284 NTAPI
1285 Mmi386ReleaseMmInfo(struct _EPROCESS *Process);
1286
1287 VOID
1288 NTAPI
1289 MmDeleteVirtualMapping(
1290     struct _EPROCESS *Process,
1291     PVOID Address,
1292     BOOLEAN FreePage,
1293     BOOLEAN* WasDirty,
1294     PPFN_TYPE Page
1295 );
1296
1297 BOOLEAN
1298 NTAPI
1299 MmIsDirtyPage(
1300     struct _EPROCESS *Process,
1301     PVOID Address
1302 );
1303
1304 VOID
1305 NTAPI
1306 MmMarkPageMapped(PFN_TYPE Page);
1307
1308 VOID
1309 NTAPI
1310 MmMarkPageUnmapped(PFN_TYPE Page);
1311
1312 VOID
1313 NTAPI
1314 MmUpdatePageDir(
1315     struct _EPROCESS *Process,
1316     PVOID Address,
1317     ULONG Size
1318 );
1319
1320 VOID
1321 NTAPI
1322 MiInitPageDirectoryMap(VOID);
1323
1324 ULONG
1325 NTAPI
1326 MiGetUserPageDirectoryCount(VOID);
1327
1328 /* wset.c ********************************************************************/
1329
1330 NTSTATUS
1331 MmTrimUserMemory(
1332     ULONG Target,
1333     ULONG Priority,
1334     PULONG NrFreedPages
1335 );
1336
1337 /* region.c ************************************************************/
1338
1339 NTSTATUS
1340 NTAPI
1341 MmAlterRegion(
1342     PMM_AVL_TABLE AddressSpace,
1343     PVOID BaseAddress,
1344     PLIST_ENTRY RegionListHead,
1345     PVOID StartAddress,
1346     ULONG Length,
1347     ULONG NewType,
1348     ULONG NewProtect,
1349     PMM_ALTER_REGION_FUNC AlterFunc
1350 );
1351
1352 VOID
1353 NTAPI
1354 MmInitializeRegion(
1355     PLIST_ENTRY RegionListHead,
1356     SIZE_T Length,
1357     ULONG Type,
1358     ULONG Protect
1359 );
1360
1361 PMM_REGION
1362 NTAPI
1363 MmFindRegion(
1364     PVOID BaseAddress,
1365     PLIST_ENTRY RegionListHead,
1366     PVOID Address,
1367     PVOID* RegionBaseAddress
1368 );
1369
1370 /* section.c *****************************************************************/
1371
1372 PFILE_OBJECT
1373 NTAPI
1374 MmGetFileObjectForSection(
1375     IN PROS_SECTION_OBJECT Section
1376 );
1377 NTSTATUS
1378 NTAPI
1379 MmGetFileNameForAddress(
1380     IN PVOID Address,
1381     OUT PUNICODE_STRING ModuleName
1382 );
1383
1384 NTSTATUS
1385 NTAPI
1386 MmGetFileNameForSection(
1387     IN PROS_SECTION_OBJECT Section,
1388     OUT POBJECT_NAME_INFORMATION *ModuleName
1389 );
1390
1391 PVOID
1392 NTAPI
1393 MmAllocateSection(
1394     IN ULONG Length,
1395     PVOID BaseAddress
1396 );
1397
1398 NTSTATUS
1399 NTAPI
1400 MmQuerySectionView(
1401     PMEMORY_AREA MemoryArea,
1402     PVOID Address,
1403     PMEMORY_BASIC_INFORMATION Info,
1404     PULONG ResultLength
1405 );
1406
1407 NTSTATUS
1408 NTAPI
1409 MmProtectSectionView(
1410     PMM_AVL_TABLE AddressSpace,
1411     PMEMORY_AREA MemoryArea,
1412     PVOID BaseAddress,
1413     ULONG Length,
1414     ULONG Protect,
1415     PULONG OldProtect
1416 );
1417
1418 NTSTATUS
1419 NTAPI
1420 MmWritePageSectionView(
1421     PMM_AVL_TABLE AddressSpace,
1422     PMEMORY_AREA MArea,
1423     PVOID Address,
1424     PMM_PAGEOP PageOp
1425 );
1426
1427 NTSTATUS
1428 NTAPI
1429 MmInitSectionImplementation(VOID);
1430
1431 NTSTATUS
1432 NTAPI
1433 MmNotPresentFaultSectionView(
1434     PMM_AVL_TABLE AddressSpace,
1435     MEMORY_AREA* MemoryArea,
1436     PVOID Address,
1437     BOOLEAN Locked
1438 );
1439
1440 NTSTATUS
1441 NTAPI
1442 MmPageOutSectionView(
1443     PMM_AVL_TABLE AddressSpace,
1444     PMEMORY_AREA MemoryArea,
1445     PVOID Address,
1446     struct _MM_PAGEOP *PageOp
1447 );
1448
1449 NTSTATUS
1450 NTAPI
1451 MmCreatePhysicalMemorySection(VOID);
1452
1453 NTSTATUS
1454 NTAPI
1455 MmAccessFaultSectionView(
1456     PMM_AVL_TABLE AddressSpace,
1457     MEMORY_AREA* MemoryArea,
1458     PVOID Address,
1459     BOOLEAN Locked
1460 );
1461
1462 VOID
1463 NTAPI
1464 MmFreeSectionSegments(PFILE_OBJECT FileObject);
1465
1466 /* mpw.c *********************************************************************/
1467
1468 NTSTATUS
1469 NTAPI
1470 MmInitMpwThread(VOID);
1471
1472 NTSTATUS
1473 NTAPI
1474 MmInitBsmThread(VOID);
1475
1476 /* pager.c *******************************************************************/
1477
1478 BOOLEAN
1479 NTAPI
1480 MiIsPagerThread(VOID);
1481
1482 VOID
1483 NTAPI
1484 MiStartPagerThread(VOID);
1485
1486 VOID
1487 NTAPI
1488 MiStopPagerThread(VOID);
1489
1490 NTSTATUS
1491 FASTCALL
1492 MiQueryVirtualMemory(
1493     IN HANDLE ProcessHandle,
1494     IN PVOID Address,
1495     IN MEMORY_INFORMATION_CLASS VirtualMemoryInformationClass,
1496     OUT PVOID VirtualMemoryInformation,
1497     IN ULONG Length,
1498     OUT PULONG ResultLength
1499 );
1500
1501 /* sysldr.c ******************************************************************/
1502
1503 VOID
1504 NTAPI
1505 MiReloadBootLoadedDrivers(
1506     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1507 );
1508
1509 BOOLEAN
1510 NTAPI
1511 MiInitializeLoadedModuleList(
1512     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1513 );
1514
1515 NTSTATUS
1516 NTAPI
1517 MmLoadSystemImage(
1518     IN PUNICODE_STRING FileName,
1519     IN PUNICODE_STRING NamePrefix OPTIONAL,
1520     IN PUNICODE_STRING LoadedName OPTIONAL,
1521     IN ULONG Flags,
1522     OUT PVOID *ModuleObject,
1523     OUT PVOID *ImageBaseAddress
1524 );
1525
1526 NTSTATUS
1527 NTAPI
1528 MmUnloadSystemImage(
1529     IN PVOID ImageHandle
1530 );
1531
1532 NTSTATUS
1533 NTAPI
1534 MmCheckSystemImage(
1535     IN HANDLE ImageHandle,
1536     IN BOOLEAN PurgeSection
1537 );
1538
1539 FORCEINLINE
1540 VOID
1541 NTAPI
1542 MiSyncThreadProcessViews(IN PVOID Process,
1543                          IN PVOID Address,
1544                          IN ULONG Size)
1545 {
1546     MmUpdatePageDir((PEPROCESS)Process, Address, Size);
1547 }
1548
1549
1550 extern PMM_AVL_TABLE MmKernelAddressSpace;
1551
1552 FORCEINLINE
1553 VOID
1554 MmLockAddressSpace(PMM_AVL_TABLE AddressSpace)
1555 {
1556     KeAcquireGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, VadRoot)->AddressCreationLock);
1557 }
1558
1559 FORCEINLINE
1560 VOID
1561 MmUnlockAddressSpace(PMM_AVL_TABLE AddressSpace)
1562 {
1563     KeReleaseGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, VadRoot)->AddressCreationLock);
1564 }
1565
1566 FORCEINLINE
1567 PEPROCESS
1568 MmGetAddressSpaceOwner(IN PMM_AVL_TABLE AddressSpace)
1569 {
1570     if (AddressSpace == MmKernelAddressSpace) return NULL;
1571     return CONTAINING_RECORD(AddressSpace, EPROCESS, VadRoot);
1572 }
1573
1574 FORCEINLINE
1575 PMM_AVL_TABLE
1576 MmGetCurrentAddressSpace(VOID)
1577 {
1578     return &((PEPROCESS)KeGetCurrentThread()->ApcState.Process)->VadRoot;
1579 }
1580
1581 FORCEINLINE
1582 PMM_AVL_TABLE
1583 MmGetKernelAddressSpace(VOID)
1584 {
1585     return MmKernelAddressSpace;
1586 }
1587
1588 #endif