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