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