ntoskrnl/include/internal/mm.h

   1 #pragma once
   2
   3 #include <internal/arch/mm.h>
   4
   5 /* TYPES *********************************************************************/
   6
   7 struct _EPROCESS;
   8
   9 extern PMMSUPPORT MmKernelAddressSpace;
  10 extern PFN_COUNT MiFreeSwapPages;
  11 extern PFN_COUNT MiUsedSwapPages;
  12 extern PFN_COUNT MmNumberOfPhysicalPages;
  13 extern UCHAR MmDisablePagingExecutive;
  14 extern PFN_NUMBER MmLowestPhysicalPage;
  15 extern PFN_NUMBER MmHighestPhysicalPage;
  16 extern PFN_NUMBER MmAvailablePages;
  17 extern PFN_NUMBER MmResidentAvailablePages;
  18 extern ULONG MmThrottleTop;
  19 extern ULONG MmThrottleBottom;
  20
  21 extern LIST_ENTRY MmLoadedUserImageList;
  22
  23 extern KMUTANT MmSystemLoadLock;
  24
  25 extern ULONG MmNumberOfPagingFiles;
  26
  27 extern PVOID MmUnloadedDrivers;
  28 extern PVOID MmLastUnloadedDrivers;
  29 extern PVOID MmTriageActionTaken;
  30 extern PVOID KernelVerifier;
  31 extern MM_DRIVER_VERIFIER_DATA MmVerifierData;
  32
  33 extern SIZE_T MmTotalCommitLimit;
  34 extern SIZE_T MmTotalCommittedPages;
  35 extern SIZE_T MmSharedCommit;
  36 extern SIZE_T MmDriverCommit;
  37 extern SIZE_T MmProcessCommit;
  38 extern SIZE_T MmPagedPoolCommit;
  39 extern SIZE_T MmPeakCommitment;
  40 extern SIZE_T MmtotalCommitLimitMaximum;
  41
  42 extern PVOID MiDebugMapping; // internal
  43 extern PMMPTE MmDebugPte; // internal
  44
  45 struct _KTRAP_FRAME;
  46 struct _EPROCESS;
  47 struct _MM_RMAP_ENTRY;
  48 typedef ULONG_PTR SWAPENTRY;
  49
  50 //
  51 // MmDbgCopyMemory Flags
  52 //
  53 #define MMDBG_COPY_WRITE            0x00000001
  54 #define MMDBG_COPY_PHYSICAL         0x00000002
  55 #define MMDBG_COPY_UNSAFE           0x00000004
  56 #define MMDBG_COPY_CACHED           0x00000008
  57 #define MMDBG_COPY_UNCACHED         0x00000010
  58 #define MMDBG_COPY_WRITE_COMBINED   0x00000020
  59
  60 //
  61 // Maximum chunk size per copy
  62 //
  63 #define MMDBG_COPY_MAX_SIZE         0x8
  64
  65 #if defined(_X86_) // intenal for marea.c
  66 #define MI_STATIC_MEMORY_AREAS              (14)
  67 #else
  68 #define MI_STATIC_MEMORY_AREAS              (13)
  69 #endif
  70
  71 #define MEMORY_AREA_SECTION_VIEW            (1)
  72 #define MEMORY_AREA_CACHE                   (2)
  73 #define MEMORY_AREA_OWNED_BY_ARM3           (15)
  74 #define MEMORY_AREA_STATIC                  (0x80000000)
  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_SYSTEM                           (2)
  96 #define MC_MAXIMUM                          (3)
  97
  98 #define PAGED_POOL_MASK                     1
  99 #define MUST_SUCCEED_POOL_MASK              2
 100 #define CACHE_ALIGNED_POOL_MASK             4
 101 #define QUOTA_POOL_MASK                     8
 102 #define SESSION_POOL_MASK                   32
 103 #define VERIFIER_POOL_MASK                  64
 104
 105 #define MAX_PAGING_FILES                    (16)
 106
 107 // FIXME: use ALIGN_UP_BY
 108 #define MM_ROUND_UP(x,s)                    \
 109     ((PVOID)(((ULONG_PTR)(x)+(s)-1) & ~((ULONG_PTR)(s)-1)))
 110
 111 #define MM_ROUND_DOWN(x,s)                  \
 112     ((PVOID)(((ULONG_PTR)(x)) & ~((ULONG_PTR)(s)-1)))
 113
 114 #define PAGE_FLAGS_VALID_FOR_SECTION \
 115     (PAGE_READONLY | \
 116      PAGE_READWRITE | \
 117      PAGE_WRITECOPY | \
 118      PAGE_EXECUTE | \
 119      PAGE_EXECUTE_READ | \
 120      PAGE_EXECUTE_READWRITE | \
 121      PAGE_EXECUTE_WRITECOPY | \
 122      PAGE_NOACCESS | \
 123      PAGE_NOCACHE)
 124
 125 #define PAGE_IS_READABLE                    \
 126     (PAGE_READONLY | \
 127     PAGE_READWRITE | \
 128     PAGE_WRITECOPY | \
 129     PAGE_EXECUTE_READ | \
 130     PAGE_EXECUTE_READWRITE | \
 131     PAGE_EXECUTE_WRITECOPY)
 132
 133 #define PAGE_IS_WRITABLE                    \
 134     (PAGE_READWRITE | \
 135     PAGE_WRITECOPY | \
 136     PAGE_EXECUTE_READWRITE | \
 137     PAGE_EXECUTE_WRITECOPY)
 138
 139 #define PAGE_IS_EXECUTABLE                  \
 140     (PAGE_EXECUTE | \
 141     PAGE_EXECUTE_READ | \
 142     PAGE_EXECUTE_READWRITE | \
 143     PAGE_EXECUTE_WRITECOPY)
 144
 145 #define PAGE_IS_WRITECOPY                   \
 146     (PAGE_WRITECOPY | \
 147     PAGE_EXECUTE_WRITECOPY)
 148
 149 //
 150 // Wait entry for marking pages that are being serviced
 151 //
 152 #define MM_WAIT_ENTRY            0x7ffffc00
 153
 154 #define InterlockedCompareExchangePte(PointerPte, Exchange, Comperand) \
 155     InterlockedCompareExchange((PLONG)(PointerPte), Exchange, Comperand)
 156
 157 #define InterlockedExchangePte(PointerPte, Value) \
 158     InterlockedExchange((PLONG)(PointerPte), Value)
 159
 160 typedef struct _MM_SECTION_SEGMENT
 161 {
 162     FAST_MUTEX Lock;            /* lock which protects the page directory */
 163         PFILE_OBJECT FileObject;
 164     LARGE_INTEGER RawLength;            /* length of the segment which is part of the mapped file */
 165     LARGE_INTEGER Length;                       /* absolute length of the segment */
 166     ULONG ReferenceCount;
 167         ULONG CacheCount;
 168     ULONG Protection;
 169     ULONG Flags;
 170     BOOLEAN WriteCopy;
 171         BOOLEAN Locked;
 172
 173         struct
 174         {
 175                 ULONGLONG FileOffset;           /* start offset into the file for image sections */
 176                 ULONG_PTR VirtualAddress;       /* start offset into the address range for image sections */
 177                 ULONG Characteristics;
 178         } Image;
 179
 180         LIST_ENTRY ListOfSegments;
 181         RTL_GENERIC_TABLE PageTable;
 182 } MM_SECTION_SEGMENT, *PMM_SECTION_SEGMENT;
 183
 184 typedef struct _MM_IMAGE_SECTION_OBJECT
 185 {
 186     SECTION_IMAGE_INFORMATION ImageInformation;
 187     PVOID BasedAddress;
 188     ULONG NrSegments;
 189     PMM_SECTION_SEGMENT Segments;
 190 } MM_IMAGE_SECTION_OBJECT, *PMM_IMAGE_SECTION_OBJECT;
 191
 192 typedef struct _ROS_SECTION_OBJECT
 193 {
 194     CSHORT Type;
 195     CSHORT Size;
 196     LARGE_INTEGER MaximumSize;
 197     ULONG SectionPageProtection;
 198     ULONG AllocationAttributes;
 199     PFILE_OBJECT FileObject;
 200     union
 201     {
 202         PMM_IMAGE_SECTION_OBJECT ImageSection;
 203         PMM_SECTION_SEGMENT Segment;
 204     };
 205 } ROS_SECTION_OBJECT, *PROS_SECTION_OBJECT;
 206
 207 #define MA_GetStartingAddress(_MemoryArea) ((_MemoryArea)->VadNode.StartingVpn << PAGE_SHIFT)
 208 #define MA_GetEndingAddress(_MemoryArea) (((_MemoryArea)->VadNode.EndingVpn + 1) << PAGE_SHIFT)
 209
 210 typedef struct _MEMORY_AREA
 211 {
 212     MMVAD VadNode;
 213
 214     ULONG Type;
 215     ULONG Protect;
 216     ULONG Flags;
 217     BOOLEAN DeleteInProgress;
 218     ULONG Magic;
 219     PVOID Vad;
 220     union
 221     {
 222         struct
 223         {
 224             ROS_SECTION_OBJECT* Section;
 225             LARGE_INTEGER ViewOffset;
 226             PMM_SECTION_SEGMENT Segment;
 227             LIST_ENTRY RegionListHead;
 228         } SectionData;
 229         struct
 230         {
 231             LIST_ENTRY RegionListHead;
 232         } VirtualMemoryData;
 233     } Data;
 234 } MEMORY_AREA, *PMEMORY_AREA;
 235
 236 typedef struct _MM_RMAP_ENTRY
 237 {
 238    struct _MM_RMAP_ENTRY* Next;
 239    PEPROCESS Process;
 240    PVOID Address;
 241 #if DBG
 242    PVOID Caller;
 243 #endif
 244 }
 245 MM_RMAP_ENTRY, *PMM_RMAP_ENTRY;
 246
 247 #if MI_TRACE_PFNS
 248 extern ULONG MI_PFN_CURRENT_USAGE;
 249 extern CHAR MI_PFN_CURRENT_PROCESS_NAME[16];
 250 #define MI_SET_USAGE(x)     MI_PFN_CURRENT_USAGE = x
 251 #define MI_SET_PROCESS2(x)  memcpy(MI_PFN_CURRENT_PROCESS_NAME, x, 16)
 252 #else
 253 #define MI_SET_USAGE(x)
 254 #define MI_SET_PROCESS2(x)
 255 #endif
 256
 257 typedef enum _MI_PFN_USAGES
 258 {
 259     MI_USAGE_NOT_SET = 0,
 260     MI_USAGE_PAGED_POOL,
 261     MI_USAGE_NONPAGED_POOL,
 262     MI_USAGE_NONPAGED_POOL_EXPANSION,
 263     MI_USAGE_KERNEL_STACK,
 264     MI_USAGE_KERNEL_STACK_EXPANSION,
 265     MI_USAGE_SYSTEM_PTE,
 266     MI_USAGE_VAD,
 267     MI_USAGE_PEB_TEB,
 268     MI_USAGE_SECTION,
 269     MI_USAGE_PAGE_TABLE,
 270     MI_USAGE_PAGE_DIRECTORY,
 271     MI_USAGE_LEGACY_PAGE_DIRECTORY,
 272     MI_USAGE_DRIVER_PAGE,
 273     MI_USAGE_CONTINOUS_ALLOCATION,
 274     MI_USAGE_MDL,
 275     MI_USAGE_DEMAND_ZERO,
 276     MI_USAGE_ZERO_LOOP,
 277     MI_USAGE_CACHE,
 278     MI_USAGE_PFN_DATABASE,
 279     MI_USAGE_BOOT_DRIVER,
 280     MI_USAGE_INIT_MEMORY,
 281     MI_USAGE_FREE_PAGE
 282 } MI_PFN_USAGES;
 283
 284 //
 285 // These two mappings are actually used by Windows itself, based on the ASSERTS
 286 //
 287 #define StartOfAllocation ReadInProgress
 288 #define EndOfAllocation WriteInProgress
 289
 290 typedef struct _MMPFNENTRY
 291 {
 292     USHORT Modified:1;
 293     USHORT ReadInProgress:1;                 // StartOfAllocation
 294     USHORT WriteInProgress:1;                // EndOfAllocation
 295     USHORT PrototypePte:1;
 296     USHORT PageColor:4;
 297     USHORT PageLocation:3;
 298     USHORT RemovalRequested:1;
 299     USHORT CacheAttribute:2;
 300     USHORT Rom:1;
 301     USHORT ParityError:1;
 302 } MMPFNENTRY;
 303
 304 // Mm internal
 305 typedef struct _MMPFN
 306 {
 307     union
 308     {
 309         PFN_NUMBER Flink;
 310         ULONG WsIndex;
 311         PKEVENT Event;
 312         NTSTATUS ReadStatus;
 313         SINGLE_LIST_ENTRY NextStackPfn;
 314
 315         // HACK for ROSPFN
 316         SWAPENTRY SwapEntry;
 317     } u1;
 318     PMMPTE PteAddress;
 319     union
 320     {
 321         PFN_NUMBER Blink;
 322         ULONG_PTR ShareCount;
 323     } u2;
 324     union
 325     {
 326         struct
 327         {
 328             USHORT ReferenceCount;
 329             MMPFNENTRY e1;
 330         };
 331         struct
 332         {
 333             USHORT ReferenceCount;
 334             USHORT ShortFlags;
 335         } e2;
 336     } u3;
 337     union
 338     {
 339         MMPTE OriginalPte;
 340         LONG AweReferenceCount;
 341
 342         // HACK for ROSPFN
 343         PMM_RMAP_ENTRY RmapListHead;
 344     };
 345     union
 346     {
 347         ULONG_PTR EntireFrame;
 348         struct
 349         {
 350             ULONG_PTR PteFrame:25;
 351             ULONG_PTR InPageError:1;
 352             ULONG_PTR VerifierAllocation:1;
 353             ULONG_PTR AweAllocation:1;
 354             ULONG_PTR Priority:3;
 355             ULONG_PTR MustBeCached:1;
 356         };
 357     } u4;
 358 #if MI_TRACE_PFNS
 359     MI_PFN_USAGES PfnUsage;
 360     CHAR ProcessName[16];
 361 #endif
 362
 363     // HACK until WS lists are supported
 364     MMWSLE Wsle;
 365 } MMPFN, *PMMPFN;
 366
 367 extern PMMPFN MmPfnDatabase;
 368
 369 typedef struct _MMPFNLIST
 370 {
 371     PFN_NUMBER Total;
 372     MMLISTS ListName;
 373     PFN_NUMBER Flink;
 374     PFN_NUMBER Blink;
 375 } MMPFNLIST, *PMMPFNLIST;
 376
 377 extern MMPFNLIST MmZeroedPageListHead;
 378 extern MMPFNLIST MmFreePageListHead;
 379 extern MMPFNLIST MmStandbyPageListHead;
 380 extern MMPFNLIST MmModifiedPageListHead;
 381 extern MMPFNLIST MmModifiedNoWritePageListHead;
 382
 383 typedef struct _MM_MEMORY_CONSUMER
 384 {
 385     ULONG PagesUsed;
 386     ULONG PagesTarget;
 387     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed);
 388 } MM_MEMORY_CONSUMER, *PMM_MEMORY_CONSUMER;
 389
 390 typedef struct _MM_REGION
 391 {
 392     ULONG Type;
 393     ULONG Protect;
 394     SIZE_T Length;
 395     LIST_ENTRY RegionListEntry;
 396 } MM_REGION, *PMM_REGION;
 397
 398 // Mm internal
 399 /* Entry describing free pool memory */
 400 typedef struct _MMFREE_POOL_ENTRY
 401 {
 402     LIST_ENTRY List;
 403     PFN_COUNT Size;
 404     ULONG Signature;
 405     struct _MMFREE_POOL_ENTRY *Owner;
 406 } MMFREE_POOL_ENTRY, *PMMFREE_POOL_ENTRY;
 407
 408 /* Signature of a freed block */
 409 #define MM_FREE_POOL_SIGNATURE 'ARM3'
 410
 411 /* Paged pool information */
 412 typedef struct _MM_PAGED_POOL_INFO
 413 {
 414     PRTL_BITMAP PagedPoolAllocationMap;
 415     PRTL_BITMAP EndOfPagedPoolBitmap;
 416     PMMPTE FirstPteForPagedPool;
 417     PMMPTE LastPteForPagedPool;
 418     PMMPDE NextPdeForPagedPoolExpansion;
 419     ULONG PagedPoolHint;
 420     SIZE_T PagedPoolCommit;
 421     SIZE_T AllocatedPagedPool;
 422 } MM_PAGED_POOL_INFO, *PMM_PAGED_POOL_INFO;
 423
 424 extern MM_MEMORY_CONSUMER MiMemoryConsumers[MC_MAXIMUM];
 425
 426 /* Page file information */
 427 typedef struct _MMPAGING_FILE
 428 {
 429     PFILE_OBJECT FileObject;
 430     HANDLE FileHandle;
 431     LARGE_INTEGER MaximumSize;
 432     LARGE_INTEGER CurrentSize;
 433     PFN_NUMBER FreePages;
 434     PFN_NUMBER UsedPages;
 435     PRTL_BITMAP AllocMap;
 436     KSPIN_LOCK AllocMapLock;
 437 }
 438 MMPAGING_FILE, *PMMPAGING_FILE;
 439
 440 extern PMMPAGING_FILE MmPagingFile[MAX_PAGING_FILES];
 441
 442 typedef VOID
 443 (*PMM_ALTER_REGION_FUNC)(
 444     PMMSUPPORT AddressSpace,
 445     PVOID BaseAddress,
 446     SIZE_T Length,
 447     ULONG OldType,
 448     ULONG OldProtect,
 449     ULONG NewType,
 450     ULONG NewProtect
 451 );
 452
 453 typedef VOID
 454 (*PMM_FREE_PAGE_FUNC)(
 455     PVOID Context,
 456     PMEMORY_AREA MemoryArea,
 457     PVOID Address,
 458     PFN_NUMBER Page,
 459     SWAPENTRY SwapEntry,
 460     BOOLEAN Dirty
 461 );
 462
 463 //
 464 // Mm copy support for Kd
 465 //
 466 NTSTATUS
 467 NTAPI
 468 MmDbgCopyMemory(
 469     IN ULONG64 Address,
 470     IN PVOID Buffer,
 471     IN ULONG Size,
 472     IN ULONG Flags
 473 );
 474
 475 //
 476 // Determines if a given address is a session address
 477 //
 478 BOOLEAN
 479 NTAPI
 480 MmIsSessionAddress(
 481     IN PVOID Address
 482 );
 483
 484 ULONG
 485 NTAPI
 486 MmGetSessionId(
 487     IN PEPROCESS Process
 488 );
 489
 490 ULONG
 491 NTAPI
 492 MmGetSessionIdEx(
 493     IN PEPROCESS Process
 494 );
 495
 496 /* marea.c *******************************************************************/
 497
 498 NTSTATUS
 499 NTAPI
 500 MmCreateMemoryArea(
 501     PMMSUPPORT AddressSpace,
 502     ULONG Type,
 503     PVOID *BaseAddress,
 504     SIZE_T Length,
 505     ULONG Protection,
 506     PMEMORY_AREA *Result,
 507     ULONG AllocationFlags,
 508     ULONG AllocationGranularity
 509 );
 510
 511 PMEMORY_AREA
 512 NTAPI
 513 MmLocateMemoryAreaByAddress(
 514     PMMSUPPORT AddressSpace,
 515     PVOID Address
 516 );
 517
 518 NTSTATUS
 519 NTAPI
 520 MmFreeMemoryArea(
 521     PMMSUPPORT AddressSpace,
 522     PMEMORY_AREA MemoryArea,
 523     PMM_FREE_PAGE_FUNC FreePage,
 524     PVOID FreePageContext
 525 );
 526
 527 VOID
 528 NTAPI
 529 MiRosCleanupMemoryArea(
 530     PEPROCESS Process,
 531     PMMVAD Vad);
 532
 533 PMEMORY_AREA
 534 NTAPI
 535 MmLocateMemoryAreaByRegion(
 536     PMMSUPPORT AddressSpace,
 537     PVOID Address,
 538     SIZE_T Length
 539 );
 540
 541 PVOID
 542 NTAPI
 543 MmFindGap(
 544     PMMSUPPORT AddressSpace,
 545     SIZE_T Length,
 546     ULONG_PTR Granularity,
 547     BOOLEAN TopDown
 548 );
 549
 550 VOID
 551 NTAPI
 552 MiRosCheckMemoryAreas(
 553    PMMSUPPORT AddressSpace);
 554
 555 VOID
 556 NTAPI
 557 MiCheckAllProcessMemoryAreas(VOID);
 558
 559 /* npool.c *******************************************************************/
 560
 561 VOID
 562 NTAPI
 563 MiInitializeNonPagedPool(VOID);
 564
 565 PVOID
 566 NTAPI
 567 MiAllocatePoolPages(
 568     IN POOL_TYPE PoolType,
 569     IN SIZE_T SizeInBytes
 570 );
 571
 572 POOL_TYPE
 573 NTAPI
 574 MmDeterminePoolType(
 575     IN PVOID VirtualAddress
 576 );
 577
 578 ULONG
 579 NTAPI
 580 MiFreePoolPages(
 581     IN PVOID StartingAddress
 582 );
 583
 584 /* pool.c *******************************************************************/
 585
 586 BOOLEAN
 587 NTAPI
 588 MiRaisePoolQuota(
 589     IN POOL_TYPE PoolType,
 590     IN ULONG CurrentMaxQuota,
 591     OUT PULONG NewMaxQuota
 592 );
 593
 594 /* mdl.c *********************************************************************/
 595
 596 VOID
 597 NTAPI
 598 MmBuildMdlFromPages(
 599     PMDL Mdl,
 600     PPFN_NUMBER Pages
 601 );
 602
 603 /* mminit.c ******************************************************************/
 604
 605 VOID
 606 NTAPI
 607 MmInit1(
 608     VOID
 609 );
 610
 611 BOOLEAN
 612 NTAPI
 613 MmInitSystem(IN ULONG Phase,
 614              IN PLOADER_PARAMETER_BLOCK LoaderBlock);
 615
 616
 617 /* pagefile.c ****************************************************************/
 618
 619 SWAPENTRY
 620 NTAPI
 621 MmAllocSwapPage(VOID);
 622
 623 VOID
 624 NTAPI
 625 MmFreeSwapPage(SWAPENTRY Entry);
 626
 627 VOID
 628 NTAPI
 629 MmInitPagingFile(VOID);
 630
 631 BOOLEAN
 632 NTAPI
 633 MmIsFileObjectAPagingFile(PFILE_OBJECT FileObject);
 634
 635 NTSTATUS
 636 NTAPI
 637 MmReadFromSwapPage(
 638     SWAPENTRY SwapEntry,
 639     PFN_NUMBER Page
 640 );
 641
 642 NTSTATUS
 643 NTAPI
 644 MmWriteToSwapPage(
 645     SWAPENTRY SwapEntry,
 646     PFN_NUMBER Page
 647 );
 648
 649 VOID
 650 NTAPI
 651 MmShowOutOfSpaceMessagePagingFile(VOID);
 652
 653 NTSTATUS
 654 NTAPI
 655 MiReadPageFile(
 656     _In_ PFN_NUMBER Page,
 657     _In_ ULONG PageFileIndex,
 658     _In_ ULONG_PTR PageFileOffset);
 659
 660 /* process.c ****************************************************************/
 661
 662 NTSTATUS
 663 NTAPI
 664 MmInitializeProcessAddressSpace(
 665     IN PEPROCESS Process,
 666     IN PEPROCESS Clone OPTIONAL,
 667     IN PVOID Section OPTIONAL,
 668     IN OUT PULONG Flags,
 669     IN POBJECT_NAME_INFORMATION *AuditName OPTIONAL
 670 );
 671
 672 NTSTATUS
 673 NTAPI
 674 MmCreatePeb(
 675     IN PEPROCESS Process,
 676     IN PINITIAL_PEB InitialPeb,
 677     OUT PPEB *BasePeb
 678 );
 679
 680 NTSTATUS
 681 NTAPI
 682 MmCreateTeb(
 683     IN PEPROCESS Process,
 684     IN PCLIENT_ID ClientId,
 685     IN PINITIAL_TEB InitialTeb,
 686     OUT PTEB* BaseTeb
 687 );
 688
 689 VOID
 690 NTAPI
 691 MmDeleteTeb(
 692     struct _EPROCESS *Process,
 693     PTEB Teb
 694 );
 695
 696 VOID
 697 NTAPI
 698 MmCleanProcessAddressSpace(IN PEPROCESS Process);
 699
 700 NTSTATUS
 701 NTAPI
 702 MmDeleteProcessAddressSpace(IN PEPROCESS Process);
 703
 704 ULONG
 705 NTAPI
 706 MmGetSessionLocaleId(VOID);
 707
 708 NTSTATUS
 709 NTAPI
 710 MmSetMemoryPriorityProcess(
 711     IN PEPROCESS Process,
 712     IN UCHAR MemoryPriority
 713 );
 714
 715 /* i386/pfault.c *************************************************************/
 716
 717 NTSTATUS
 718 NTAPI
 719 MmPageFault(
 720     ULONG Cs,
 721     PULONG Eip,
 722     PULONG Eax,
 723     ULONG Cr2,
 724     ULONG ErrorCode
 725 );
 726
 727 /* special.c *****************************************************************/
 728
 729 VOID
 730 NTAPI
 731 MiInitializeSpecialPool(VOID);
 732
 733 BOOLEAN
 734 NTAPI
 735 MmUseSpecialPool(
 736     IN SIZE_T NumberOfBytes,
 737     IN ULONG Tag);
 738
 739 BOOLEAN
 740 NTAPI
 741 MmIsSpecialPoolAddress(
 742     IN PVOID P);
 743
 744 BOOLEAN
 745 NTAPI
 746 MmIsSpecialPoolAddressFree(
 747     IN PVOID P);
 748
 749 PVOID
 750 NTAPI
 751 MmAllocateSpecialPool(
 752     IN SIZE_T NumberOfBytes,
 753     IN ULONG Tag,
 754     IN POOL_TYPE PoolType,
 755     IN ULONG SpecialType);
 756
 757 VOID
 758 NTAPI
 759 MmFreeSpecialPool(
 760     IN PVOID P);
 761
 762 /* mm.c **********************************************************************/
 763
 764 NTSTATUS
 765 NTAPI
 766 MmAccessFault(
 767     IN ULONG FaultCode,
 768     IN PVOID Address,
 769     IN KPROCESSOR_MODE Mode,
 770     IN PVOID TrapInformation
 771 );
 772
 773 /* kmap.c ********************************************************************/
 774
 775 NTSTATUS
 776 NTAPI
 777 MiCopyFromUserPage(
 778     PFN_NUMBER DestPage,
 779     const VOID *SrcAddress
 780 );
 781
 782 /* process.c *****************************************************************/
 783
 784 PVOID
 785 NTAPI
 786 MmCreateKernelStack(BOOLEAN GuiStack, UCHAR Node);
 787
 788 VOID
 789 NTAPI
 790 MmDeleteKernelStack(PVOID Stack,
 791                     BOOLEAN GuiStack);
 792
 793 /* balace.c ******************************************************************/
 794
 795 VOID
 796 NTAPI
 797 MmInitializeMemoryConsumer(
 798     ULONG Consumer,
 799     NTSTATUS (*Trim)(ULONG Target, ULONG Priority, PULONG NrFreed)
 800 );
 801
 802 VOID
 803 NTAPI
 804 MmInitializeBalancer(
 805     ULONG NrAvailablePages,
 806     ULONG NrSystemPages
 807 );
 808
 809 NTSTATUS
 810 NTAPI
 811 MmReleasePageMemoryConsumer(
 812     ULONG Consumer,
 813     PFN_NUMBER Page
 814 );
 815
 816 NTSTATUS
 817 NTAPI
 818 MmRequestPageMemoryConsumer(
 819     ULONG Consumer,
 820     BOOLEAN MyWait,
 821     PPFN_NUMBER AllocatedPage
 822 );
 823
 824 VOID
 825 NTAPI
 826 MiInitBalancerThread(VOID);
 827
 828 VOID
 829 NTAPI
 830 MmRebalanceMemoryConsumers(VOID);
 831
 832 /* rmap.c **************************************************************/
 833
 834 VOID
 835 NTAPI
 836 MmSetRmapListHeadPage(
 837     PFN_NUMBER Page,
 838     struct _MM_RMAP_ENTRY* ListHead
 839 );
 840
 841 struct _MM_RMAP_ENTRY*
 842 NTAPI
 843 MmGetRmapListHeadPage(PFN_NUMBER Page);
 844
 845 VOID
 846 NTAPI
 847 MmInsertRmap(
 848     PFN_NUMBER Page,
 849     struct _EPROCESS *Process,
 850     PVOID Address
 851 );
 852
 853 VOID
 854 NTAPI
 855 MmDeleteAllRmaps(
 856     PFN_NUMBER Page,
 857     PVOID Context,
 858     VOID (*DeleteMapping)(PVOID Context, struct _EPROCESS *Process, PVOID Address)
 859 );
 860
 861 VOID
 862 NTAPI
 863 MmDeleteRmap(
 864     PFN_NUMBER Page,
 865     struct _EPROCESS *Process,
 866     PVOID Address
 867 );
 868
 869 VOID
 870 NTAPI
 871 MmInitializeRmapList(VOID);
 872
 873 VOID
 874 NTAPI
 875 MmSetCleanAllRmaps(PFN_NUMBER Page);
 876
 877 VOID
 878 NTAPI
 879 MmSetDirtyAllRmaps(PFN_NUMBER Page);
 880
 881 BOOLEAN
 882 NTAPI
 883 MmIsDirtyPageRmap(PFN_NUMBER Page);
 884
 885 NTSTATUS
 886 NTAPI
 887 MmPageOutPhysicalAddress(PFN_NUMBER Page);
 888
 889 /* freelist.c **********************************************************/
 890
 891 FORCEINLINE
 892 KIRQL
 893 MiAcquirePfnLock(VOID)
 894 {
 895     return KeAcquireQueuedSpinLock(LockQueuePfnLock);
 896 }
 897
 898 FORCEINLINE
 899 VOID
 900 MiReleasePfnLock(
 901     _In_ KIRQL OldIrql)
 902 {
 903     KeReleaseQueuedSpinLock(LockQueuePfnLock, OldIrql);
 904 }
 905
 906 FORCEINLINE
 907 VOID
 908 MiAcquirePfnLockAtDpcLevel(VOID)
 909 {
 910     PKSPIN_LOCK_QUEUE LockQueue;
 911
 912     ASSERT(KeGetCurrentIrql() >= DISPATCH_LEVEL);
 913     LockQueue = &KeGetCurrentPrcb()->LockQueue[LockQueuePfnLock];
 914     KeAcquireQueuedSpinLockAtDpcLevel(LockQueue);
 915 }
 916
 917 FORCEINLINE
 918 VOID
 919 MiReleasePfnLockFromDpcLevel(VOID)
 920 {
 921     PKSPIN_LOCK_QUEUE LockQueue;
 922
 923     LockQueue = &KeGetCurrentPrcb()->LockQueue[LockQueuePfnLock];
 924     KeReleaseQueuedSpinLockFromDpcLevel(LockQueue);
 925     ASSERT(KeGetCurrentIrql() >= DISPATCH_LEVEL);
 926 }
 927
 928 #define MI_ASSERT_PFN_LOCK_HELD() ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL)
 929
 930 FORCEINLINE
 931 PMMPFN
 932 MiGetPfnEntry(IN PFN_NUMBER Pfn)
 933 {
 934     PMMPFN Page;
 935     extern RTL_BITMAP MiPfnBitMap;
 936
 937     /* Make sure the PFN number is valid */
 938     if (Pfn > MmHighestPhysicalPage) return NULL;
 939
 940     /* Make sure this page actually has a PFN entry */
 941     if ((MiPfnBitMap.Buffer) && !(RtlTestBit(&MiPfnBitMap, (ULONG)Pfn))) return NULL;
 942
 943     /* Get the entry */
 944     Page = &MmPfnDatabase[Pfn];
 945
 946     /* Return it */
 947     return Page;
 948 };
 949
 950 FORCEINLINE
 951 PFN_NUMBER
 952 MiGetPfnEntryIndex(IN PMMPFN Pfn1)
 953 {
 954     //
 955     // This will return the Page Frame Number (PFN) from the MMPFN
 956     //
 957     return Pfn1 - MmPfnDatabase;
 958 }
 959
 960 PFN_NUMBER
 961 NTAPI
 962 MmGetLRUNextUserPage(PFN_NUMBER PreviousPage);
 963
 964 PFN_NUMBER
 965 NTAPI
 966 MmGetLRUFirstUserPage(VOID);
 967
 968 VOID
 969 NTAPI
 970 MmInsertLRULastUserPage(PFN_NUMBER Page);
 971
 972 VOID
 973 NTAPI
 974 MmRemoveLRUUserPage(PFN_NUMBER Page);
 975
 976 VOID
 977 NTAPI
 978 MmDumpArmPfnDatabase(
 979    IN BOOLEAN StatusOnly
 980 );
 981
 982 VOID
 983 NTAPI
 984 MmZeroPageThread(
 985     VOID
 986 );
 987
 988 /* hypermap.c *****************************************************************/
 989
 990 extern PEPROCESS HyperProcess;
 991 extern KIRQL HyperIrql;
 992
 993 PVOID
 994 NTAPI
 995 MiMapPageInHyperSpace(IN PEPROCESS Process,
 996                       IN PFN_NUMBER Page,
 997                       IN PKIRQL OldIrql);
 998
 999 VOID
1000 NTAPI
1001 MiUnmapPageInHyperSpace(IN PEPROCESS Process,
1002                         IN PVOID Address,
1003                         IN KIRQL OldIrql);
1004
1005 PVOID
1006 NTAPI
1007 MiMapPagesInZeroSpace(IN PMMPFN Pfn1,
1008                       IN PFN_NUMBER NumberOfPages);
1009
1010 VOID
1011 NTAPI
1012 MiUnmapPagesInZeroSpace(IN PVOID VirtualAddress,
1013                         IN PFN_NUMBER NumberOfPages);
1014
1015 //
1016 // ReactOS Compatibility Layer
1017 //
1018 FORCEINLINE
1019 PVOID
1020 MmCreateHyperspaceMapping(IN PFN_NUMBER Page)
1021 {
1022     HyperProcess = (PEPROCESS)KeGetCurrentThread()->ApcState.Process;
1023     return MiMapPageInHyperSpace(HyperProcess, Page, &HyperIrql);
1024 }
1025
1026 #define MmDeleteHyperspaceMapping(x) MiUnmapPageInHyperSpace(HyperProcess, x, HyperIrql);
1027
1028 /* i386/page.c *********************************************************/
1029
1030 NTSTATUS
1031 NTAPI
1032 MmCreateVirtualMapping(
1033     struct _EPROCESS* Process,
1034     PVOID Address,
1035     ULONG flProtect,
1036     PPFN_NUMBER Pages,
1037     ULONG PageCount
1038 );
1039
1040 NTSTATUS
1041 NTAPI
1042 MmCreateVirtualMappingUnsafe(
1043     struct _EPROCESS* Process,
1044     PVOID Address,
1045     ULONG flProtect,
1046     PPFN_NUMBER Pages,
1047     ULONG PageCount
1048 );
1049
1050 ULONG
1051 NTAPI
1052 MmGetPageProtect(
1053     struct _EPROCESS* Process,
1054     PVOID Address);
1055
1056 VOID
1057 NTAPI
1058 MmSetPageProtect(
1059     struct _EPROCESS* Process,
1060     PVOID Address,
1061     ULONG flProtect
1062 );
1063
1064 BOOLEAN
1065 NTAPI
1066 MmIsPagePresent(
1067     struct _EPROCESS* Process,
1068     PVOID Address
1069 );
1070
1071 BOOLEAN
1072 NTAPI
1073 MmIsDisabledPage(
1074     struct _EPROCESS* Process,
1075     PVOID Address
1076 );
1077
1078 VOID
1079 NTAPI
1080 MmInitGlobalKernelPageDirectory(VOID);
1081
1082 VOID
1083 NTAPI
1084 MmGetPageFileMapping(
1085         struct _EPROCESS *Process,
1086         PVOID Address,
1087         SWAPENTRY* SwapEntry);
1088
1089 VOID
1090 NTAPI
1091 MmDeletePageFileMapping(
1092     struct _EPROCESS *Process,
1093     PVOID Address,
1094     SWAPENTRY* SwapEntry
1095 );
1096
1097 NTSTATUS
1098 NTAPI
1099 MmCreatePageFileMapping(
1100     struct _EPROCESS *Process,
1101     PVOID Address,
1102     SWAPENTRY SwapEntry
1103 );
1104
1105 BOOLEAN
1106 NTAPI
1107 MmIsPageSwapEntry(
1108     struct _EPROCESS *Process,
1109     PVOID Address
1110 );
1111
1112 VOID
1113 NTAPI
1114 MmSetDirtyPage(
1115     struct _EPROCESS *Process,
1116     PVOID Address
1117 );
1118
1119 PFN_NUMBER
1120 NTAPI
1121 MmAllocPage(
1122     ULONG Consumer
1123 );
1124
1125 VOID
1126 NTAPI
1127 MmDereferencePage(PFN_NUMBER Page);
1128
1129 VOID
1130 NTAPI
1131 MmReferencePage(PFN_NUMBER Page);
1132
1133 ULONG
1134 NTAPI
1135 MmGetReferenceCountPage(PFN_NUMBER Page);
1136
1137 BOOLEAN
1138 NTAPI
1139 MmIsPageInUse(PFN_NUMBER Page);
1140
1141 VOID
1142 NTAPI
1143 MmSetSavedSwapEntryPage(
1144     PFN_NUMBER Page,
1145     SWAPENTRY SavedSwapEntry);
1146
1147 SWAPENTRY
1148 NTAPI
1149 MmGetSavedSwapEntryPage(PFN_NUMBER Page);
1150
1151 VOID
1152 NTAPI
1153 MmSetCleanPage(
1154     struct _EPROCESS *Process,
1155     PVOID Address
1156 );
1157
1158 VOID
1159 NTAPI
1160 MmDeletePageTable(
1161     struct _EPROCESS *Process,
1162     PVOID Address
1163 );
1164
1165 PFN_NUMBER
1166 NTAPI
1167 MmGetPfnForProcess(
1168     struct _EPROCESS *Process,
1169     PVOID Address
1170 );
1171
1172 BOOLEAN
1173 NTAPI
1174 MmCreateProcessAddressSpace(
1175     IN ULONG MinWs,
1176     IN PEPROCESS Dest,
1177     IN PULONG_PTR DirectoryTableBase
1178 );
1179
1180 NTSTATUS
1181 NTAPI
1182 MmInitializeHandBuiltProcess(
1183     IN PEPROCESS Process,
1184     IN PULONG_PTR DirectoryTableBase
1185 );
1186
1187
1188 NTSTATUS
1189 NTAPI
1190 MmInitializeHandBuiltProcess2(
1191     IN PEPROCESS Process
1192 );
1193
1194 NTSTATUS
1195 NTAPI
1196 MmSetExecuteOptions(IN ULONG ExecuteOptions);
1197
1198 NTSTATUS
1199 NTAPI
1200 MmGetExecuteOptions(IN PULONG ExecuteOptions);
1201
1202 VOID
1203 NTAPI
1204 MmDeleteVirtualMapping(
1205     struct _EPROCESS *Process,
1206     PVOID Address,
1207     BOOLEAN* WasDirty,
1208     PPFN_NUMBER Page
1209 );
1210
1211 BOOLEAN
1212 NTAPI
1213 MmIsDirtyPage(
1214     struct _EPROCESS *Process,
1215     PVOID Address
1216 );
1217
1218 /* wset.c ********************************************************************/
1219
1220 NTSTATUS
1221 MmTrimUserMemory(
1222     ULONG Target,
1223     ULONG Priority,
1224     PULONG NrFreedPages
1225 );
1226
1227 /* region.c ************************************************************/
1228
1229 NTSTATUS
1230 NTAPI
1231 MmAlterRegion(
1232     PMMSUPPORT AddressSpace,
1233     PVOID BaseAddress,
1234     PLIST_ENTRY RegionListHead,
1235     PVOID StartAddress,
1236     SIZE_T Length,
1237     ULONG NewType,
1238     ULONG NewProtect,
1239     PMM_ALTER_REGION_FUNC AlterFunc
1240 );
1241
1242 VOID
1243 NTAPI
1244 MmInitializeRegion(
1245     PLIST_ENTRY RegionListHead,
1246     SIZE_T Length,
1247     ULONG Type,
1248     ULONG Protect
1249 );
1250
1251 PMM_REGION
1252 NTAPI
1253 MmFindRegion(
1254     PVOID BaseAddress,
1255     PLIST_ENTRY RegionListHead,
1256     PVOID Address,
1257     PVOID* RegionBaseAddress
1258 );
1259
1260 /* section.c *****************************************************************/
1261
1262 VOID
1263 NTAPI
1264 MmGetImageInformation(
1265     OUT PSECTION_IMAGE_INFORMATION ImageInformation
1266 );
1267
1268 PFILE_OBJECT
1269 NTAPI
1270 MmGetFileObjectForSection(
1271     IN PVOID Section
1272 );
1273 NTSTATUS
1274 NTAPI
1275 MmGetFileNameForAddress(
1276     IN PVOID Address,
1277     OUT PUNICODE_STRING ModuleName
1278 );
1279
1280 NTSTATUS
1281 NTAPI
1282 MmGetFileNameForSection(
1283     IN PVOID Section,
1284     OUT POBJECT_NAME_INFORMATION *ModuleName
1285 );
1286
1287 NTSTATUS
1288 NTAPI
1289 MmQuerySectionView(
1290     PMEMORY_AREA MemoryArea,
1291     PVOID Address,
1292     PMEMORY_BASIC_INFORMATION Info,
1293     PSIZE_T ResultLength
1294 );
1295
1296 NTSTATUS
1297 NTAPI
1298 MmProtectSectionView(
1299     PMMSUPPORT AddressSpace,
1300     PMEMORY_AREA MemoryArea,
1301     PVOID BaseAddress,
1302     SIZE_T Length,
1303     ULONG Protect,
1304     PULONG OldProtect
1305 );
1306
1307 NTSTATUS
1308 NTAPI
1309 MmInitSectionImplementation(VOID);
1310
1311 NTSTATUS
1312 NTAPI
1313 MmNotPresentFaultSectionView(
1314     PMMSUPPORT AddressSpace,
1315     MEMORY_AREA* MemoryArea,
1316     PVOID Address,
1317     BOOLEAN Locked
1318 );
1319
1320 NTSTATUS
1321 NTAPI
1322 MmPageOutSectionView(
1323     PMMSUPPORT AddressSpace,
1324     PMEMORY_AREA MemoryArea,
1325     PVOID Address,
1326     ULONG_PTR Entry
1327 );
1328
1329 NTSTATUS
1330 NTAPI
1331 MmCreatePhysicalMemorySection(VOID);
1332
1333 NTSTATUS
1334 NTAPI
1335 MmAccessFaultSectionView(
1336     PMMSUPPORT AddressSpace,
1337     MEMORY_AREA* MemoryArea,
1338     PVOID Address
1339 );
1340
1341 VOID
1342 NTAPI
1343 MmFreeSectionSegments(PFILE_OBJECT FileObject);
1344
1345 /* sysldr.c ******************************************************************/
1346
1347 VOID
1348 NTAPI
1349 MiReloadBootLoadedDrivers(
1350     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1351 );
1352
1353 BOOLEAN
1354 NTAPI
1355 MiInitializeLoadedModuleList(
1356     IN PLOADER_PARAMETER_BLOCK LoaderBlock
1357 );
1358
1359 NTSTATUS
1360 NTAPI
1361 MmLoadSystemImage(
1362     IN PUNICODE_STRING FileName,
1363     IN PUNICODE_STRING NamePrefix OPTIONAL,
1364     IN PUNICODE_STRING LoadedName OPTIONAL,
1365     IN ULONG Flags,
1366     OUT PVOID *ModuleObject,
1367     OUT PVOID *ImageBaseAddress
1368 );
1369
1370 NTSTATUS
1371 NTAPI
1372 MmUnloadSystemImage(
1373     IN PVOID ImageHandle
1374 );
1375
1376 NTSTATUS
1377 NTAPI
1378 MmCheckSystemImage(
1379     IN HANDLE ImageHandle,
1380     IN BOOLEAN PurgeSection
1381 );
1382
1383 NTSTATUS
1384 NTAPI
1385 MmCallDllInitialize(
1386     IN PLDR_DATA_TABLE_ENTRY LdrEntry,
1387     IN PLIST_ENTRY ListHead
1388 );
1389
1390
1391 /* procsup.c *****************************************************************/
1392
1393 NTSTATUS
1394 NTAPI
1395 MmGrowKernelStack(
1396     IN PVOID StackPointer
1397 );
1398
1399
1400 FORCEINLINE
1401 VOID
1402 MmLockAddressSpace(PMMSUPPORT AddressSpace)
1403 {
1404     KeAcquireGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1405 }
1406
1407 FORCEINLINE
1408 VOID
1409 MmUnlockAddressSpace(PMMSUPPORT AddressSpace)
1410 {
1411     KeReleaseGuardedMutex(&CONTAINING_RECORD(AddressSpace, EPROCESS, Vm)->AddressCreationLock);
1412 }
1413
1414 FORCEINLINE
1415 PEPROCESS
1416 MmGetAddressSpaceOwner(IN PMMSUPPORT AddressSpace)
1417 {
1418     if (AddressSpace == MmKernelAddressSpace) return NULL;
1419     return CONTAINING_RECORD(AddressSpace, EPROCESS, Vm);
1420 }
1421
1422 FORCEINLINE
1423 PMMSUPPORT
1424 MmGetCurrentAddressSpace(VOID)
1425 {
1426     return &((PEPROCESS)KeGetCurrentThread()->ApcState.Process)->Vm;
1427 }
1428
1429 FORCEINLINE
1430 PMMSUPPORT
1431 MmGetKernelAddressSpace(VOID)
1432 {
1433     return MmKernelAddressSpace;
1434 }
1435
1436
1437 /* expool.c ******************************************************************/
1438
1439 VOID
1440 NTAPI
1441 ExpCheckPoolAllocation(
1442     PVOID P,
1443     POOL_TYPE PoolType,
1444     ULONG Tag);
1445
1446 VOID
1447 NTAPI
1448 ExReturnPoolQuota(
1449     IN PVOID P);
1450
1451
1452 /* mmsup.c *****************************************************************/
1453
1454 NTSTATUS
1455 NTAPI
1456 MmAdjustWorkingSetSize(
1457     IN SIZE_T WorkingSetMinimumInBytes,
1458     IN SIZE_T WorkingSetMaximumInBytes,
1459     IN ULONG SystemCache,
1460     IN BOOLEAN IncreaseOkay);
1461
1462
1463 /* session.c *****************************************************************/
1464
1465 _IRQL_requires_max_(APC_LEVEL)
1466 NTSTATUS
1467 NTAPI
1468 MmAttachSession(
1469     _Inout_ PVOID SessionEntry,
1470     _Out_ PKAPC_STATE ApcState);
1471
1472 _IRQL_requires_max_(APC_LEVEL)
1473 VOID
1474 NTAPI
1475 MmDetachSession(
1476     _Inout_ PVOID SessionEntry,
1477     _Out_ PKAPC_STATE ApcState);
1478
1479 VOID
1480 NTAPI
1481 MmQuitNextSession(
1482     _Inout_ PVOID SessionEntry);
1483
1484 PVOID
1485 NTAPI
1486 MmGetSessionById(
1487     _In_ ULONG SessionId);
1488
1489 _IRQL_requires_max_(APC_LEVEL)
1490 VOID
1491 NTAPI
1492 MmSetSessionLocaleId(
1493     _In_ LCID LocaleId);
1494
1495 /* shutdown.c *****************************************************************/
1496
1497 VOID
1498 MmShutdownSystem(IN ULONG Phase);
1499
1500 /* virtual.c *****************************************************************/
1501
1502 NTSTATUS
1503 NTAPI
1504 MmCopyVirtualMemory(IN PEPROCESS SourceProcess,
1505                     IN PVOID SourceAddress,
1506                     IN PEPROCESS TargetProcess,
1507                     OUT PVOID TargetAddress,
1508                     IN SIZE_T BufferSize,
1509                     IN KPROCESSOR_MODE PreviousMode,
1510                     OUT PSIZE_T ReturnSize);
1511