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 MmInitMemoryAreas(VOID);
 396
 397 NTSTATUS
 398 NTAPI
 399 MmCreateMemoryArea(
 400     PMM_AVL_TABLE AddressSpace,
 401     ULONG Type,
 402     PVOID *BaseAddress,
 403     ULONG_PTR Length,
 404     ULONG Protection,
 405     PMEMORY_AREA *Result,
 406     BOOLEAN FixedAddress,
 407     ULONG AllocationFlags,
 408     PHYSICAL_ADDRESS BoundaryAddressMultiple OPTIONAL
 409 );
 410
 411 PMEMORY_AREA
 412 NTAPI
 413 MmLocateMemoryAreaByAddress(
 414     PMM_AVL_TABLE AddressSpace,
 415     PVOID Address
 416 );
 417
 418 ULONG_PTR
 419 NTAPI
 420 MmFindGapAtAddress(
 421     PMM_AVL_TABLE AddressSpace,
 422     PVOID Address
 423 );
 424
 425 NTSTATUS
 426 NTAPI
 427 MmFreeMemoryArea(
 428     PMM_AVL_TABLE AddressSpace,
 429     PMEMORY_AREA MemoryArea,
 430     PMM_FREE_PAGE_FUNC FreePage,
 431     PVOID FreePageContext
 432 );
 433
 434 NTSTATUS
 435 NTAPI
 436 MmFreeMemoryAreaByPtr(
 437     PMM_AVL_TABLE AddressSpace,
 438     PVOID BaseAddress,
 439     PMM_FREE_PAGE_FUNC FreePage,
 440     PVOID FreePageContext
 441 );
 442
 443 VOID
 444 NTAPI
 445 MmDumpMemoryAreas(PMM_AVL_TABLE AddressSpace);
 446
 447 PMEMORY_AREA
 448 NTAPI
 449 MmLocateMemoryAreaByRegion(
 450     PMM_AVL_TABLE AddressSpace,
 451     PVOID Address,
 452     ULONG_PTR Length
 453 );
 454
 455 PVOID
 456 NTAPI
 457 MmFindGap(
 458     PMM_AVL_TABLE AddressSpace,
 459     ULONG_PTR Length,
 460     ULONG_PTR Granularity,
 461     BOOLEAN TopDown
 462 );
 463
 464 VOID
 465 NTAPI
 466 MmReleaseMemoryAreaIfDecommitted(
 467     struct _EPROCESS *Process,
 468     PMM_AVL_TABLE AddressSpace,
 469     PVOID BaseAddress
 470 );
 471
 472 VOID
 473 NTAPI
 474 MmMapMemoryArea(PVOID BaseAddress,
 475                 ULONG Length,
 476                 ULONG Consumer,
 477                 ULONG Protection);
 478
 479 /* npool.c *******************************************************************/
 480
 481 VOID
 482 NTAPI
 483 MiDebugDumpNonPagedPool(BOOLEAN NewOnly);
 484
 485 VOID
 486 NTAPI
 487 MiDebugDumpNonPagedPoolStats(BOOLEAN NewOnly);
 488
 489 VOID
 490 NTAPI
 491 MiInitializeNonPagedPool(VOID);
 492
 493 PVOID
 494 NTAPI
 495 MiAllocatePoolPages(
 496     IN POOL_TYPE PoolType,
 497     IN SIZE_T SizeInBytes
 498 );
 499
 500 POOL_TYPE
 501 NTAPI
 502 MmDeterminePoolType(
 503     IN PVOID VirtualAddress
 504 );
 505
 506 ULONG
 507 NTAPI
 508 MiFreePoolPages(
 509     IN PVOID StartingAddress
 510 );
 511
 512 PVOID
 513 NTAPI
 514 MmGetMdlPageAddress(
 515     PMDL Mdl,
 516     PVOID Offset
 517 );
 518
 519 /* pool.c *******************************************************************/
 520
 521 PVOID
 522 NTAPI
 523 ExAllocateNonPagedPoolWithTag(
 524     POOL_TYPE type,
 525     ULONG size,
 526     ULONG Tag,
 527     PVOID Caller
 528 );
 529
 530 PVOID
 531 NTAPI
 532 ExAllocatePagedPoolWithTag(
 533     POOL_TYPE Type,
 534     ULONG size,
 535     ULONG Tag
 536 );
 537
 538 VOID
 539 NTAPI
 540 ExFreeNonPagedPool(PVOID block);
 541
 542 VOID
 543 NTAPI
 544 ExFreePagedPool(IN PVOID Block);
 545
 546 VOID
 547 NTAPI
 548 MmInitializePagedPool(VOID);
 549
 550 PVOID
 551 NTAPI
 552 MiAllocateSpecialPool(
 553     IN POOL_TYPE PoolType,
 554     IN SIZE_T NumberOfBytes,
 555     IN ULONG Tag,
 556     IN ULONG Underrun
 557 );
 558
 559 BOOLEAN
 560 NTAPI
 561 MiRaisePoolQuota(
 562     IN POOL_TYPE PoolType,
 563     IN ULONG CurrentMaxQuota,
 564     OUT PULONG NewMaxQuota
 565 );
 566
 567 /* mdl.c *********************************************************************/
 568
 569 VOID
 570 NTAPI
 571 MmBuildMdlFromPages(
 572     PMDL Mdl,
 573     PULONG Pages
 574 );
 575
 576 /* mminit.c ******************************************************************/
 577
 578 VOID
 579 NTAPI
 580 MiShutdownMemoryManager(VOID);
 581
 582 VOID
 583 NTAPI
 584 MmInit1(
 585     VOID
 586 );
 587
 588 BOOLEAN
 589 NTAPI
 590 MmInitSystem(IN ULONG Phase,
 591              IN PLOADER_PARAMETER_BLOCK LoaderBlock);
 592
 593 VOID
 594 NTAPI
 595 MiFreeInitMemory(VOID);
 596
 597 VOID
 598 NTAPI
 599 MmInitializeMdlImplementation(VOID);
 600
 601 /* pagefile.c ****************************************************************/
 602
 603 SWAPENTRY
 604 NTAPI
 605 MmAllocSwapPage(VOID);
 606
 607 VOID
 608 NTAPI
 609 MmDereserveSwapPages(ULONG Nr);
 610
 611 VOID
 612 NTAPI
 613 MmFreeSwapPage(SWAPENTRY Entry);
 614
 615 VOID
 616 NTAPI
 617 MmInitPagingFile(VOID);
 618
 619 NTSTATUS
 620 NTAPI
 621 MmReadFromSwapPage(
 622     SWAPENTRY SwapEntry,
 623     PFN_TYPE Page
 624 );
 625
 626 BOOLEAN
 627 NTAPI
 628 MmReserveSwapPages(ULONG Nr);
 629
 630 NTSTATUS
 631 NTAPI
 632 MmWriteToSwapPage(
 633     SWAPENTRY SwapEntry,
 634     PFN_TYPE Page
 635 );
 636
 637 NTSTATUS
 638 NTAPI
 639 MmDumpToPagingFile(
 640     ULONG BugCode,
 641     ULONG BugCodeParameter1,
 642     ULONG BugCodeParameter2,
 643     ULONG BugCodeParameter3,
 644     ULONG BugCodeParameter4,
 645     struct _KTRAP_FRAME* TrapFrame
 646 );
 647
 648 BOOLEAN
 649 NTAPI
 650 MmIsAvailableSwapPage(VOID);
 651
 652 VOID
 653 NTAPI
 654 MmShowOutOfSpaceMessagePagingFile(VOID);
 655
 656 /* process.c ****************************************************************/
 657
 658 NTSTATUS
 659 NTAPI
 660 MmInitializeProcessAddressSpace(
 661     IN PEPROCESS Process,
 662     IN PEPROCESS Clone OPTIONAL,
 663     IN PVOID Section OPTIONAL,
 664     IN OUT PULONG Flags,
 665     IN POBJECT_NAME_INFORMATION *AuditName OPTIONAL
 666 );
 667
 668 NTSTATUS
 669 NTAPI
 670 MmCreatePeb(struct _EPROCESS *Process);
 671
 672 PTEB
 673 NTAPI
 674 MmCreateTeb(
 675     struct _EPROCESS *Process,
 676     PCLIENT_ID ClientId,
 677     PINITIAL_TEB InitialTeb
 678 );
 679
 680 VOID
 681 NTAPI
 682 MmDeleteTeb(
 683     struct _EPROCESS *Process,
 684     PTEB Teb
 685 );
 686
 687 VOID
 688 NTAPI
 689 MmCleanProcessAddressSpace(IN PEPROCESS Process);
 690
 691 NTSTATUS
 692 NTAPI
 693 MmDeleteProcessAddressSpace(IN PEPROCESS Process);
 694
 695 ULONG
 696 NTAPI
 697 MmGetSessionLocaleId(VOID);
 698
 699 NTSTATUS
 700 NTAPI
 701 MmSetMemoryPriorityProcess(
 702     IN PEPROCESS Process,
 703     IN UCHAR MemoryPriority
 704 );
 705
 706 /* i386/pfault.c *************************************************************/
 707
 708 NTSTATUS
 709 NTAPI
 710 MmPageFault(
 711     ULONG Cs,
 712     PULONG Eip,
 713     PULONG Eax,
 714     ULONG Cr2,
 715     ULONG ErrorCode
 716 );
 717
 718 /* mm.c **********************************************************************/
 719
 720 NTSTATUS
 721 NTAPI
 722 MmAccessFault(
 723     IN BOOLEAN StoreInstruction,
 724     IN PVOID Address,
 725     IN KPROCESSOR_MODE Mode,
 726     IN PVOID TrapInformation
 727 );
 728
 729 /* anonmem.c *****************************************************************/
 730
 731 NTSTATUS
 732 NTAPI
 733 MmNotPresentFaultVirtualMemory(
 734     PMM_AVL_TABLE AddressSpace,
 735     MEMORY_AREA* MemoryArea,
 736     PVOID Address,
 737     BOOLEAN Locked
 738 );
 739
 740 NTSTATUS
 741 NTAPI
 742 MmPageOutVirtualMemory(
 743     PMM_AVL_TABLE AddressSpace,
 744     PMEMORY_AREA MemoryArea,
 745     PVOID Address,
 746     struct _MM_PAGEOP* PageOp
 747 );
 748
 749 NTSTATUS
 750 NTAPI
 751 MmQueryAnonMem(
 752     PMEMORY_AREA MemoryArea,
 753     PVOID Address,
 754     PMEMORY_BASIC_INFORMATION Info,
 755     PSIZE_T ResultLength
 756 );
 757
 758 VOID
 759 NTAPI
 760 MmFreeVirtualMemory(
 761     struct _EPROCESS* Process,
 762     PMEMORY_AREA MemoryArea
 763 );
 764
 765 NTSTATUS
 766 NTAPI
 767 MmProtectAnonMem(
 768     PMM_AVL_TABLE AddressSpace,
 769     PMEMORY_AREA MemoryArea,
 770     PVOID BaseAddress,
 771     ULONG Length,
 772     ULONG Protect,
 773     PULONG OldProtect
 774 );
 775
 776 NTSTATUS
 777 NTAPI
 778 MmWritePageVirtualMemory(
 779     PMM_AVL_TABLE AddressSpace,
 780     PMEMORY_AREA MArea,
 781     PVOID Address,
 782     PMM_PAGEOP PageOp
 783 );
 784
 785 /* kmap.c ********************************************************************/
 786
 787 PVOID
 788 NTAPI
 789 ExAllocatePage(VOID);
 790
 791 VOID
 792 NTAPI
 793 ExUnmapPage(PVOID Addr);
 794
 795 PVOID
 796 NTAPI
 797 ExAllocatePageWithPhysPage(PFN_TYPE Page);
 798
 799 NTSTATUS
 800 NTAPI
 801 MiCopyFromUserPage(
 802     PFN_TYPE Page,
 803     PVOID SourceAddress
 804 );
 805
 806 NTSTATUS
 807 NTAPI
 808 MiZeroPage(PFN_TYPE Page);
 809
 810 /* memsafe.s *****************************************************************/
 811
 812 PVOID
 813 FASTCALL
 814 MmSafeReadPtr(PVOID Source);
 815
 816 /* pageop.c ******************************************************************/
 817
 818 VOID
 819 NTAPI
 820 MmReleasePageOp(PMM_PAGEOP PageOp);
 821
 822 PMM_PAGEOP
 823 NTAPI
 824 MmGetPageOp(
 825     PMEMORY_AREA MArea,
 826     HANDLE Pid,
 827     PVOID Address,
 828     PMM_SECTION_SEGMENT Segment,
 829     ULONG Offset,
 830     ULONG OpType,
 831     BOOLEAN First
 832 );
 833
 834 PMM_PAGEOP
 835 NTAPI
 836 MmCheckForPageOp(
 837     PMEMORY_AREA MArea,
 838     HANDLE Pid,
 839     PVOID Address,
 840     PMM_SECTION_SEGMENT Segment,
 841     ULONG Offset
 842 );
 843
 844 VOID
 845 NTAPI
 846 MmInitializePageOp(VOID);
 847
 848 /* process.c *****************************************************************/
 849
 850 PVOID
 851 NTAPI
 852 MmCreateKernelStack(BOOLEAN GuiStack, UCHAR Node);
 853
 854 VOID
 855 NTAPI
 856 MmDeleteKernelStack(PVOID Stack,
 857                     BOOLEAN GuiStack);
 858
 859 /* balace.c ******************************************************************/
 860
 861 VOID
 862 NTAPI
 863 MmInitializeMemoryConsumer(
 864     ULONG Consumer,
 865     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed)
 866 );
 867
 868 VOID
 869 NTAPI
 870 MmInitializeBalancer(
 871     ULONG NrAvailablePages,
 872     ULONG NrSystemPages
 873 );
 874
 875 NTSTATUS
 876 NTAPI
 877 MmReleasePageMemoryConsumer(
 878     ULONG Consumer,
 879     PFN_TYPE Page
 880 );
 881
 882 NTSTATUS
 883 NTAPI
 884 MmRequestPageMemoryConsumer(
 885     ULONG Consumer,
 886     BOOLEAN MyWait,
 887     PPFN_TYPE AllocatedPage
 888 );
 889
 890 VOID
 891 NTAPI
 892 MiInitBalancerThread(VOID);
 893
 894 VOID
 895 NTAPI
 896 MmRebalanceMemoryConsumers(VOID);
 897
 898 /* rmap.c **************************************************************/
 899
 900 VOID
 901 NTAPI
 902 MmSetRmapListHeadPage(
 903     PFN_TYPE Page,
 904     struct _MM_RMAP_ENTRY* ListHead
 905 );
 906
 907 struct _MM_RMAP_ENTRY*
 908 NTAPI
 909 MmGetRmapListHeadPage(PFN_TYPE Page);
 910
 911 VOID
 912 NTAPI
 913 MmInsertRmap(
 914     PFN_TYPE Page,
 915     struct _EPROCESS *Process,
 916     PVOID Address
 917 );
 918
 919 VOID
 920 NTAPI
 921 MmDeleteAllRmaps(
 922     PFN_TYPE Page,
 923     PVOID Context,
 924     VOID (*DeleteMapping)(PVOID Context, struct _EPROCESS *Process, PVOID Address)
 925 );
 926
 927 VOID
 928 NTAPI
 929 MmDeleteRmap(
 930     PFN_TYPE Page,
 931     struct _EPROCESS *Process,
 932     PVOID Address
 933 );
 934
 935 VOID
 936 NTAPI
 937 MmInitializeRmapList(VOID);
 938
 939 VOID
 940 NTAPI
 941 MmSetCleanAllRmaps(PFN_TYPE Page);
 942
 943 VOID
 944 NTAPI
 945 MmSetDirtyAllRmaps(PFN_TYPE Page);
 946
 947 BOOLEAN
 948 NTAPI
 949 MmIsDirtyPageRmap(PFN_TYPE Page);
 950
 951 NTSTATUS
 952 NTAPI
 953 MmWritePagePhysicalAddress(PFN_TYPE Page);
 954
 955 NTSTATUS
 956 NTAPI
 957 MmPageOutPhysicalAddress(PFN_TYPE Page);
 958
 959 /* freelist.c **********************************************************/
 960
 961 #define ASSERT_PFN(x) ASSERT((x)->Flags.Type != 0)
 962
 963 FORCEINLINE
 964 PPHYSICAL_PAGE
 965 MiGetPfnEntry(IN PFN_TYPE Pfn)
 966 {
 967     PPHYSICAL_PAGE Page;
 968     extern PPHYSICAL_PAGE MmPageArray;
 969     extern ULONG MmPageArraySize;
 970
 971     /* Mark MmPageArraySize as unreferenced, otherwise it will appear as an unused variable on a Release build */
 972     UNREFERENCED_PARAMETER(MmPageArraySize);
 973
 974     /* Make sure the PFN number is valid */
 975     ASSERT(Pfn <= MmPageArraySize);
 976
 977     /* Get the entry */
 978     Page = &MmPageArray[Pfn];
 979
 980     /* Make sure it's valid */
 981     ASSERT_PFN(Page);
 982
 983     /* Return it */
 984     return Page;
 985 };
 986
 987 PFN_TYPE
 988 NTAPI
 989 MmGetLRUNextUserPage(PFN_TYPE PreviousPage);
 990
 991 PFN_TYPE
 992 NTAPI
 993 MmGetLRUFirstUserPage(VOID);
 994
 995 VOID
 996 NTAPI
 997 MmInsertLRULastUserPage(PFN_TYPE Page);
 998
 999 VOID
1000 NTAPI
1001 MmRemoveLRUUserPage(PFN_TYPE Page);
1002
1003 VOID
1004 NTAPI
1005 MmLockPage(PFN_TYPE Page);
1006
1007 VOID
1008 NTAPI
1009 MmLockPageUnsafe(PFN_TYPE Page);
1010
1011 VOID
1012 NTAPI
1013 MmUnlockPage(PFN_TYPE Page);
1014
1015 ULONG
1016 NTAPI
1017 MmGetLockCountPage(PFN_TYPE Page);
1018
1019 static
1020 __inline
1021 KIRQL
1022 NTAPI
1023 MmAcquirePageListLock()
1024 {
1025         return KeAcquireQueuedSpinLock(LockQueuePfnLock);
1026 }
1027
1028 FORCEINLINE
1029 VOID
1030 NTAPI
1031 MmReleasePageListLock(KIRQL oldIrql)
1032 {
1033         KeReleaseQueuedSpinLock(LockQueuePfnLock, oldIrql);
1034 }
1035
1036 VOID
1037 NTAPI
1038 MmInitializePageList(
1039     VOID
1040 );
1041
1042 PFN_TYPE
1043 NTAPI
1044 MmGetContinuousPages(
1045     ULONG NumberOfBytes,
1046     PHYSICAL_ADDRESS LowestAcceptableAddress,
1047     PHYSICAL_ADDRESS HighestAcceptableAddress,
1048     PHYSICAL_ADDRESS BoundaryAddressMultiple
1049 );
1050
1051 NTSTATUS
1052 NTAPI
1053 MmZeroPageThreadMain(
1054     PVOID Context
1055 );
1056
1057 /* i386/page.c *********************************************************/
1058
1059 PVOID
1060 NTAPI
1061 MmCreateHyperspaceMapping(PFN_TYPE Page);
1062
1063 PFN_TYPE
1064 NTAPI
1065 MmDeleteHyperspaceMapping(PVOID Address);
1066
1067 NTSTATUS
1068 NTAPI
1069 MmCreateVirtualMappingForKernel(
1070     PVOID Address,
1071     ULONG flProtect,
1072     PPFN_TYPE Pages,
1073     ULONG PageCount
1074 );
1075
1076 NTSTATUS
1077 NTAPI
1078 MmCommitPagedPoolAddress(
1079     PVOID Address,
1080     BOOLEAN Locked
1081 );
1082
1083 NTSTATUS
1084 NTAPI
1085 MmCreateVirtualMapping(
1086     struct _EPROCESS* Process,
1087     PVOID Address,
1088     ULONG flProtect,
1089     PPFN_TYPE Pages,
1090     ULONG PageCount
1091 );
1092
1093 NTSTATUS
1094 NTAPI
1095 MmCreateVirtualMappingUnsafe(
1096     struct _EPROCESS* Process,
1097     PVOID Address,
1098     ULONG flProtect,
1099     PPFN_TYPE Pages,
1100     ULONG PageCount
1101 );
1102
1103 ULONG
1104 NTAPI
1105 MmGetPageProtect(
1106     struct _EPROCESS* Process,
1107     PVOID Address);
1108
1109 VOID
1110 NTAPI
1111 MmSetPageProtect(
1112     struct _EPROCESS* Process,
1113     PVOID Address,
1114     ULONG flProtect
1115 );
1116
1117 BOOLEAN
1118 NTAPI
1119 MmIsPagePresent(
1120     struct _EPROCESS* Process,
1121     PVOID Address
1122 );
1123
1124 VOID
1125 NTAPI
1126 MmInitGlobalKernelPageDirectory(VOID);
1127
1128 VOID
1129 NTAPI
1130 MmDisableVirtualMapping(
1131     struct _EPROCESS *Process,
1132     PVOID Address,
1133     BOOLEAN* WasDirty,
1134     PPFN_TYPE Page
1135 );
1136
1137 VOID
1138 NTAPI
1139 MmEnableVirtualMapping(
1140     struct _EPROCESS *Process,
1141     PVOID Address
1142 );
1143
1144 VOID
1145 NTAPI
1146 MmRawDeleteVirtualMapping(PVOID Address);
1147
1148 VOID
1149 NTAPI
1150 MmDeletePageFileMapping(
1151     struct _EPROCESS *Process,
1152     PVOID Address,
1153     SWAPENTRY* SwapEntry
1154 );
1155
1156 NTSTATUS
1157 NTAPI
1158 MmCreatePageFileMapping(
1159     struct _EPROCESS *Process,
1160     PVOID Address,
1161     SWAPENTRY SwapEntry
1162 );
1163
1164 BOOLEAN
1165 NTAPI
1166 MmIsPageSwapEntry(
1167     struct _EPROCESS *Process,
1168     PVOID Address
1169 );
1170
1171 VOID
1172 NTAPI
1173 MmTransferOwnershipPage(
1174     PFN_TYPE Page,
1175     ULONG NewConsumer
1176 );
1177
1178 VOID
1179 NTAPI
1180 MmSetDirtyPage(
1181     struct _EPROCESS *Process,
1182     PVOID Address
1183 );
1184
1185 PFN_TYPE
1186 NTAPI
1187 MmAllocPage(
1188     ULONG Consumer,
1189     SWAPENTRY SavedSwapEntry
1190 );
1191
1192 LONG
1193 NTAPI
1194 MmAllocPagesSpecifyRange(
1195     ULONG Consumer,
1196     PHYSICAL_ADDRESS LowestAddress,
1197     PHYSICAL_ADDRESS HighestAddress,
1198     ULONG NumberOfPages,
1199     PPFN_TYPE Pages
1200 );
1201
1202 VOID
1203 NTAPI
1204 MmDereferencePage(PFN_TYPE Page);
1205
1206 VOID
1207 NTAPI
1208 MmReferencePage(PFN_TYPE Page);
1209
1210 VOID
1211 NTAPI
1212 MmReferencePageUnsafe(PFN_TYPE Page);
1213
1214 ULONG
1215 NTAPI
1216 MmGetReferenceCountPage(PFN_TYPE Page);
1217
1218 BOOLEAN
1219 NTAPI
1220 MmIsPageInUse(PFN_TYPE Page);
1221
1222 VOID
1223 NTAPI
1224 MmSetFlagsPage(
1225     PFN_TYPE Page,
1226     ULONG Flags);
1227
1228 ULONG
1229 NTAPI
1230 MmGetFlagsPage(PFN_TYPE Page);
1231
1232 VOID
1233 NTAPI
1234 MmSetSavedSwapEntryPage(
1235     PFN_TYPE Page,
1236     SWAPENTRY SavedSwapEntry);
1237
1238 SWAPENTRY
1239 NTAPI
1240 MmGetSavedSwapEntryPage(PFN_TYPE Page);
1241
1242 VOID
1243 NTAPI
1244 MmSetCleanPage(
1245     struct _EPROCESS *Process,
1246     PVOID Address
1247 );
1248
1249 NTSTATUS
1250 NTAPI
1251 MmCreatePageTable(PVOID PAddress);
1252
1253 VOID
1254 NTAPI
1255 MmDeletePageTable(
1256     struct _EPROCESS *Process,
1257     PVOID Address
1258 );
1259
1260 PFN_TYPE
1261 NTAPI
1262 MmGetPfnForProcess(
1263     struct _EPROCESS *Process,
1264     PVOID Address
1265 );
1266
1267 BOOLEAN
1268 NTAPI
1269 MmCreateProcessAddressSpace(
1270     IN ULONG MinWs,
1271     IN PEPROCESS Dest,
1272     IN PULONG_PTR DirectoryTableBase
1273 );
1274
1275 NTSTATUS
1276 NTAPI
1277 MmInitializeHandBuiltProcess(
1278     IN PEPROCESS Process,
1279     IN PULONG_PTR DirectoryTableBase
1280 );
1281
1282
1283 NTSTATUS
1284 NTAPI
1285 MmInitializeHandBuiltProcess2(
1286     IN PEPROCESS Process
1287 );
1288
1289 NTSTATUS
1290 NTAPI
1291 MmReleaseMmInfo(struct _EPROCESS *Process);
1292
1293 NTSTATUS
1294 NTAPI
1295 Mmi386ReleaseMmInfo(struct _EPROCESS *Process);
1296
1297 VOID
1298 NTAPI
1299 MmDeleteVirtualMapping(
1300     struct _EPROCESS *Process,
1301     PVOID Address,
1302     BOOLEAN FreePage,
1303     BOOLEAN* WasDirty,
1304     PPFN_TYPE Page
1305 );
1306
1307 BOOLEAN
1308 NTAPI
1309 MmIsDirtyPage(
1310     struct _EPROCESS *Process,
1311     PVOID Address
1312 );
1313
1314 VOID
1315 NTAPI
1316 MmMarkPageMapped(PFN_TYPE Page);
1317
1318 VOID
1319 NTAPI
1320 MmMarkPageUnmapped(PFN_TYPE Page);
1321
1322 VOID
1323 NTAPI
1324 MmUpdatePageDir(
1325     struct _EPROCESS *Process,
1326     PVOID Address,
1327     ULONG Size
1328 );
1329
1330 VOID
1331 NTAPI
1332 MiInitPageDirectoryMap(VOID);
1333
1334 ULONG
1335 NTAPI
1336 MiGetUserPageDirectoryCount(VOID);
1337
1338 /* wset.c ********************************************************************/
1339
1340 NTSTATUS
1341 MmTrimUserMemory(
1342     ULONG Target,
1343     ULONG Priority,
1344     PULONG NrFreedPages
1345 );
1346
1347 /* region.c ************************************************************/
1348
1349 NTSTATUS
1350 NTAPI
1351 MmAlterRegion(
1352     PMM_AVL_TABLE AddressSpace,
1353     PVOID BaseAddress,
1354     PLIST_ENTRY RegionListHead,
1355     PVOID StartAddress,
1356     ULONG Length,
1357     ULONG NewType,
1358     ULONG NewProtect,
1359     PMM_ALTER_REGION_FUNC AlterFunc
1360 );
1361
1362 VOID
1363 NTAPI
1364 MmInitializeRegion(
1365     PLIST_ENTRY RegionListHead,
1366     SIZE_T Length,
1367     ULONG Type,
1368     ULONG Protect
1369 );
1370
1371 PMM_REGION
1372 NTAPI
1373 MmFindRegion(
1374     PVOID BaseAddress,
1375     PLIST_ENTRY RegionListHead,
1376     PVOID Address,
1377     PVOID* RegionBaseAddress
1378 );
1379
1380 /* section.c *****************************************************************/
1381
1382 PFILE_OBJECT
1383 NTAPI
1384 MmGetFileObjectForSection(
1385     IN PROS_SECTION_OBJECT Section
1386 );
1387 NTSTATUS
1388 NTAPI
1389 MmGetFileNameForAddress(
1390     IN PVOID Address,
1391     OUT PUNICODE_STRING ModuleName
1392 );
1393
1394 NTSTATUS
1395 NTAPI
1396 MmGetFileNameForSection(
1397     IN PROS_SECTION_OBJECT Section,
1398     OUT POBJECT_NAME_INFORMATION *ModuleName
1399 );
1400
1401 PVOID
1402 NTAPI
1403 MmAllocateSection(
1404     IN ULONG Length,
1405     PVOID BaseAddress
1406 );
1407
1408 NTSTATUS
1409 NTAPI
1410 MmQuerySectionView(
1411     PMEMORY_AREA MemoryArea,
1412     PVOID Address,
1413     PMEMORY_BASIC_INFORMATION Info,
1414     PSIZE_T ResultLength
1415 );
1416
1417 NTSTATUS
1418 NTAPI
1419 MmProtectSectionView(
1420     PMM_AVL_TABLE AddressSpace,
1421     PMEMORY_AREA MemoryArea,
1422     PVOID BaseAddress,
1423     ULONG Length,
1424     ULONG Protect,
1425     PULONG OldProtect
1426 );
1427
1428 NTSTATUS
1429 NTAPI
1430 MmWritePageSectionView(
1431     PMM_AVL_TABLE AddressSpace,
1432     PMEMORY_AREA MArea,
1433     PVOID Address,
1434     PMM_PAGEOP PageOp
1435 );
1436
1437 NTSTATUS
1438 NTAPI
1439 MmInitSectionImplementation(VOID);
1440
1441 NTSTATUS
1442 NTAPI
1443 MmNotPresentFaultSectionView(
1444     PMM_AVL_TABLE AddressSpace,
1445     MEMORY_AREA* MemoryArea,
1446     PVOID Address,
1447     BOOLEAN Locked
1448 );
1449
1450 NTSTATUS
1451 NTAPI
1452 MmPageOutSectionView(
1453     PMM_AVL_TABLE AddressSpace,
1454     PMEMORY_AREA MemoryArea,
1455     PVOID Address,
1456     struct _MM_PAGEOP *PageOp
1457 );
1458
1459 NTSTATUS
1460 NTAPI
1461 MmCreatePhysicalMemorySection(VOID);
1462
1463 NTSTATUS
1464 NTAPI
1465 MmAccessFaultSectionView(
1466     PMM_AVL_TABLE AddressSpace,
1467     MEMORY_AREA* MemoryArea,
1468     PVOID Address,
1469     BOOLEAN Locked
1470 );
1471
1472 VOID
1473 NTAPI
1474 MmFreeSectionSegments(PFILE_OBJECT FileObject);
1475
1476 /* mpw.c *********************************************************************/
1477
1478 NTSTATUS
1479 NTAPI
1480 MmInitMpwThread(VOID);
1481
1482 NTSTATUS
1483 NTAPI
1484 MmInitBsmThread(VOID);
1485
1486 /* pager.c *******************************************************************/
1487
1488 BOOLEAN
1489 NTAPI
1490 MiIsPagerThread(VOID);
1491
1492 VOID
1493 NTAPI
1494 MiStartPagerThread(VOID);
1495
1496 VOID
1497 NTAPI
1498 MiStopPagerThread(VOID);
1499
1500 NTSTATUS
1501 FASTCALL
1502 MiQueryVirtualMemory(
1503     IN HANDLE ProcessHandle,
1504     IN PVOID Address,
1505     IN MEMORY_INFORMATION_CLASS VirtualMemoryInformationClass,
1506     OUT PVOID VirtualMemoryInformation,
1507     IN SIZE_T Length,
1508     OUT PSIZE_T ResultLength
1509 );
1510
1511 /* sysldr.c ******************************************************************/
1512
1513 VOID
1514 NTAPI
1515 MiReloadBootLoadedDrivers(
1516     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1517 );
1518
1519 BOOLEAN
1520 NTAPI
1521 MiInitializeLoadedModuleList(
1522     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1523 );
1524
1525 NTSTATUS
1526 NTAPI
1527 MmLoadSystemImage(
1528     IN PUNICODE_STRING FileName,
1529     IN PUNICODE_STRING NamePrefix OPTIONAL,
1530     IN PUNICODE_STRING LoadedName OPTIONAL,
1531     IN ULONG Flags,
1532     OUT PVOID *ModuleObject,
1533     OUT PVOID *ImageBaseAddress
1534 );
1535
1536 NTSTATUS
1537 NTAPI
1538 MmUnloadSystemImage(
1539     IN PVOID ImageHandle
1540 );
1541
1542 NTSTATUS
1543 NTAPI
1544 MmCheckSystemImage(
1545     IN HANDLE ImageHandle,
1546     IN BOOLEAN PurgeSection
1547 );
1548
1549 NTSTATUS
1550 NTAPI
1551 MmCallDllInitialize(
1552     IN PLDR_DATA_TABLE_ENTRY LdrEntry,
1553     IN PLIST_ENTRY ListHead
1554 );
1555
1556 /* ReactOS Mm Hacks */
1557 VOID
1558 FASTCALL
1559 MiSyncForProcessAttach(
1560     IN PKTHREAD NextThread,
1561     IN PEPROCESS Process
1562 );
1563
1564 VOID
1565 FASTCALL
1566 MiSyncForContextSwitch(
1567     IN PKTHREAD Thread
1568 );
1569
1570 extern PMM_AVL_TABLE MmKernelAddressSpace;
1571
1572 FORCEINLINE
1573 VOID
1574 MmLockAddressSpace(PMM_AVL_TABLE AddressSpace)
1575 {
1576     KeAcquireGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, VadRoot)->AddressCreationLock);
1577 }
1578
1579 FORCEINLINE
1580 VOID
1581 MmUnlockAddressSpace(PMM_AVL_TABLE AddressSpace)
1582 {
1583     KeReleaseGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, VadRoot)->AddressCreationLock);
1584 }
1585
1586 FORCEINLINE
1587 PEPROCESS
1588 MmGetAddressSpaceOwner(IN PMM_AVL_TABLE AddressSpace)
1589 {
1590     if (AddressSpace == MmKernelAddressSpace) return NULL;
1591     return CONTAINING_RECORD(AddressSpace, EPROCESS, VadRoot);
1592 }
1593
1594 FORCEINLINE
1595 PMM_AVL_TABLE
1596 MmGetCurrentAddressSpace(VOID)
1597 {
1598     return &((PEPROCESS)KeGetCurrentThread()->ApcState.Process)->VadRoot;
1599 }
1600
1601 FORCEINLINE
1602 PMM_AVL_TABLE
1603 MmGetKernelAddressSpace(VOID)
1604 {
1605     return MmKernelAddressSpace;
1606 }
1607
1608 #endif