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