include/ndk/mmtypes.h

   1 /*++ NDK Version: 0098
   2
   3 Copyright (c) Alex Ionescu.  All rights reserved.
   4
   5 Header Name:
   6
   7     mmtypes.h
   8
   9 Abstract:
  10
  11     Type definitions for the Memory Manager
  12
  13 Author:
  14
  15     Alex Ionescu (alexi@tinykrnl.org) - Updated - 27-Feb-2006
  16
  17 --*/
  18
  19 #ifndef _MMTYPES_H
  20 #define _MMTYPES_H
  21
  22 //
  23 // Dependencies
  24 //
  25 #include <umtypes.h>
  26 #include <arch/mmtypes.h>
  27 #include <extypes.h>
  28
  29 //
  30 // Page-Rounding Macros
  31 //
  32 #define PAGE_ROUND_DOWN(x)                                  \
  33     (((ULONG_PTR)(x))&(~(PAGE_SIZE-1)))
  34 #define PAGE_ROUND_UP(x)                                    \
  35     ( (((ULONG_PTR)(x)) + PAGE_SIZE-1)  & (~(PAGE_SIZE-1)) )
  36 #ifdef NTOS_MODE_USER
  37 #define ROUND_TO_PAGES(Size)                                \
  38     (((ULONG_PTR)(Size) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))
  39 #endif
  40 #define ROUND_TO_ALLOCATION_GRANULARITY(Size)               \
  41     (((ULONG_PTR)(Size) + MM_ALLOCATION_GRANULARITY - 1)    \
  42     & ~(MM_ALLOCATION_GRANULARITY - 1))
  43
  44 //
  45 // PFN Identity Uses
  46 //
  47 #define MMPFNUSE_PROCESSPRIVATE                             0
  48 #define MMPFNUSE_FILE                                       1
  49 #define MMPFNUSE_PAGEFILEMAPPED                             2
  50 #define MMPFNUSE_PAGETABLE                                  3
  51 #define MMPFNUSE_PAGEDPOOL                                  4
  52 #define MMPFNUSE_NONPAGEDPOOL                               5
  53 #define MMPFNUSE_SYSTEMPTE                                  6
  54 #define MMPFNUSE_SESSIONPRIVATE                             7
  55 #define MMPFNUSE_METAFILE                                   8
  56 #define MMPFNUSE_AWEPAGE                                    9
  57 #define MMPFNUSE_DRIVERLOCKPAGE                             10
  58 #define MMPFNUSE_KERNELSTACK                                11
  59
  60 //
  61 // Lock/Unlock Virtuam Memory Flags
  62 //
  63 #define MAP_PROCESS                                         1
  64 #define MAP_SYSTEM                                          2
  65
  66 //
  67 // Flags for ProcessExecutionOptions
  68 //
  69 #define MEM_EXECUTE_OPTION_DISABLE                          0x1
  70 #define MEM_EXECUTE_OPTION_ENABLE                           0x2
  71 #define MEM_EXECUTE_OPTION_DISABLE_THUNK_EMULATION          0x4
  72 #define MEM_EXECUTE_OPTION_PERMANENT                        0x8
  73 #define MEM_EXECUTE_OPTION_EXECUTE_DISPATCH_ENABLE          0x10
  74 #define MEM_EXECUTE_OPTION_IMAGE_DISPATCH_ENABLE            0x20
  75 #define MEM_EXECUTE_OPTION_VALID_FLAGS                      0x3F
  76
  77 #ifndef NTOS_MODE_USER
  78 //
  79 // Virtual Memory Flags
  80 //
  81 #define MEM_WRITE_WATCH                                     0x200000
  82 #define MEM_PHYSICAL                                        0x400000
  83 #define MEM_ROTATE                                          0x800000
  84 #define MEM_IMAGE                                           SEC_IMAGE
  85 #define MEM_DOS_LIM                                         0x40000000
  86
  87 //
  88 // Section Flags for NtCreateSection
  89 //
  90 #define SEC_NO_CHANGE                                       0x400000
  91 #define SEC_FILE                                            0x800000
  92 #define SEC_IMAGE                                           0x1000000
  93 #define SEC_PROTECTED_IMAGE                                 0x2000000
  94 #define SEC_RESERVE                                         0x4000000
  95 #define SEC_COMMIT                                          0x8000000
  96 #define SEC_NOCACHE                                         0x10000000
  97 #define SEC_WRITECOMBINE                                    0x40000000
  98 #define SEC_LARGE_PAGES                                     0x80000000
  99 #else
 100 #define SEC_BASED                                           0x200000
 101
 102 //
 103 // Section Inherit Flags for NtCreateSection
 104 //
 105 typedef enum _SECTION_INHERIT
 106 {
 107     ViewShare = 1,
 108     ViewUnmap = 2
 109 } SECTION_INHERIT;
 110
 111 //
 112 // Pool Types
 113 //
 114 typedef enum _POOL_TYPE
 115 {
 116     NonPagedPool,
 117     PagedPool,
 118     NonPagedPoolMustSucceed,
 119     DontUseThisType,
 120     NonPagedPoolCacheAligned,
 121     PagedPoolCacheAligned,
 122     NonPagedPoolCacheAlignedMustS,
 123     MaxPoolType,
 124     NonPagedPoolSession = 32,
 125     PagedPoolSession,
 126     NonPagedPoolMustSucceedSession,
 127     DontUseThisTypeSession,
 128     NonPagedPoolCacheAlignedSession,
 129     PagedPoolCacheAlignedSession,
 130     NonPagedPoolCacheAlignedMustSSession
 131 } POOL_TYPE;
 132 #endif
 133
 134 //
 135 // Memory Manager Page Lists
 136 //
 137 typedef enum _MMLISTS
 138 {
 139    ZeroedPageList = 0,
 140    FreePageList = 1,
 141    StandbyPageList = 2,
 142    ModifiedPageList = 3,
 143    ModifiedNoWritePageList = 4,
 144    BadPageList = 5,
 145    ActiveAndValid = 6,
 146    TransitionPage = 7
 147 } MMLISTS;
 148
 149 //
 150 // Per Processor Non Paged Lookaside List IDs
 151 //
 152 typedef enum _PP_NPAGED_LOOKASIDE_NUMBER
 153 {
 154     LookasideSmallIrpList = 0,
 155     LookasideLargeIrpList = 1,
 156     LookasideMdlList = 2,
 157     LookasideCreateInfoList = 3,
 158     LookasideNameBufferList = 4,
 159     LookasideTwilightList = 5,
 160     LookasideCompletionList = 6,
 161     LookasideMaximumList = 7
 162 } PP_NPAGED_LOOKASIDE_NUMBER;
 163
 164 //
 165 // Memory Information Classes for NtQueryVirtualMemory
 166 //
 167 typedef enum _MEMORY_INFORMATION_CLASS
 168 {
 169     MemoryBasicInformation,
 170     MemoryWorkingSetList,
 171     MemorySectionName,
 172     MemoryBasicVlmInformation
 173 } MEMORY_INFORMATION_CLASS;
 174
 175 //
 176 // Section Information Clasess for NtQuerySection
 177 //
 178 typedef enum _SECTION_INFORMATION_CLASS
 179 {
 180     SectionBasicInformation,
 181     SectionImageInformation,
 182 } SECTION_INFORMATION_CLASS;
 183
 184 //
 185 // Kinds of VADs
 186 //
 187 typedef enum _MI_VAD_TYPE
 188 {
 189     VadNone,
 190     VadDevicePhysicalMemory,
 191     VadImageMap,
 192     VadAwe,
 193     VadWriteWatch,
 194     VadLargePages,
 195     VadRotatePhysical,
 196     VadLargePageSection
 197 } MI_VAD_TYPE, *PMI_VAD_TYPE;
 198
 199 #ifdef NTOS_MODE_USER
 200
 201 //
 202 // Virtual Memory Counters
 203 //
 204 typedef struct _VM_COUNTERS
 205 {
 206     SIZE_T PeakVirtualSize;
 207     SIZE_T VirtualSize;
 208     ULONG PageFaultCount;
 209     SIZE_T PeakWorkingSetSize;
 210     SIZE_T WorkingSetSize;
 211     SIZE_T QuotaPeakPagedPoolUsage;
 212     SIZE_T QuotaPagedPoolUsage;
 213     SIZE_T QuotaPeakNonPagedPoolUsage;
 214     SIZE_T QuotaNonPagedPoolUsage;
 215     SIZE_T PagefileUsage;
 216     SIZE_T PeakPagefileUsage;
 217 } VM_COUNTERS, *PVM_COUNTERS;
 218
 219 typedef struct _VM_COUNTERS_EX
 220 {
 221     SIZE_T PeakVirtualSize;
 222     SIZE_T VirtualSize;
 223     ULONG PageFaultCount;
 224     SIZE_T PeakWorkingSetSize;
 225     SIZE_T WorkingSetSize;
 226     SIZE_T QuotaPeakPagedPoolUsage;
 227     SIZE_T QuotaPagedPoolUsage;
 228     SIZE_T QuotaPeakNonPagedPoolUsage;
 229     SIZE_T QuotaNonPagedPoolUsage;
 230     SIZE_T PagefileUsage;
 231     SIZE_T PeakPagefileUsage;
 232     SIZE_T PrivateUsage;
 233 } VM_COUNTERS_EX, *PVM_COUNTERS_EX;
 234 #endif
 235
 236 //
 237 // Sub-Information Types for PFN Identity
 238 //
 239 typedef struct _MEMORY_FRAME_INFORMATION
 240 {
 241     ULONGLONG UseDescription:4;
 242     ULONGLONG ListDescription:3;
 243     ULONGLONG Reserved0:1;
 244     ULONGLONG Pinned:1;
 245     ULONGLONG DontUse:48;
 246     ULONGLONG Priority:3;
 247     ULONGLONG Reserved:4;
 248 } MEMORY_FRAME_INFORMATION, *PMEMORY_FRAME_INFORMATION;
 249
 250 typedef struct _FILEOFFSET_INFORMATION
 251 {
 252     ULONGLONG DontUse:9;
 253     ULONGLONG Offset:48;
 254     ULONGLONG Reserved:7;
 255 } FILEOFFSET_INFORMATION, *PFILEOFFSET_INFORMATION;
 256
 257 typedef struct _PAGEDIR_INFORMATION
 258 {
 259     ULONGLONG DontUse:9;
 260     ULONGLONG PageDirectoryBase:48;
 261     ULONGLONG Reserved:7;
 262 } PAGEDIR_INFORMATION, *PPAGEDIR_INFORMATION;
 263
 264 typedef struct _UNIQUE_PROCESS_INFORMATION
 265 {
 266     ULONGLONG DontUse:9;
 267     ULONGLONG UniqueProcessKey:48;
 268     ULONGLONG Reserved:7;
 269 } UNIQUE_PROCESS_INFORMATION, *PUNIQUE_PROCESS_INFORMATION;
 270
 271 //
 272 // PFN Identity Data Structure
 273 //
 274 typedef struct _MMPFN_IDENTITY
 275 {
 276     union
 277     {
 278         MEMORY_FRAME_INFORMATION e1;
 279         FILEOFFSET_INFORMATION e2;
 280         PAGEDIR_INFORMATION e3;
 281         UNIQUE_PROCESS_INFORMATION e4;
 282     } u1;
 283     SIZE_T PageFrameIndex;
 284     union
 285     {
 286         struct
 287         {
 288             ULONG Image:1;
 289             ULONG Mismatch:1;
 290         } e1;
 291         PVOID FileObject;
 292         PVOID UniqueFileObjectKey;
 293         PVOID ProtoPteAddress;
 294         PVOID VirtualAddress;
 295     } u2;
 296 } MMPFN_IDENTITY, *PMMPFN_IDENTITY;
 297
 298 //
 299 // List of Working Sets
 300 //
 301 typedef struct _MEMORY_WORKING_SET_LIST
 302 {
 303     ULONG NumberOfPages;
 304     ULONG WorkingSetList[1];
 305 } MEMORY_WORKING_SET_LIST, *PMEMORY_WORKING_SET_LIST;
 306
 307 //
 308 // Memory Information Structures for NtQueryVirtualMemory
 309 //
 310 typedef struct
 311 {
 312     UNICODE_STRING SectionFileName;
 313     WCHAR NameBuffer[ANYSIZE_ARRAY];
 314 } MEMORY_SECTION_NAME, *PMEMORY_SECTION_NAME;
 315
 316 //
 317 // Section Information Structures for NtQuerySection
 318 //
 319 typedef struct _SECTION_BASIC_INFORMATION
 320 {
 321     PVOID           BaseAddress;
 322     ULONG           Attributes;
 323     LARGE_INTEGER   Size;
 324 } SECTION_BASIC_INFORMATION, *PSECTION_BASIC_INFORMATION;
 325
 326 typedef struct _SECTION_IMAGE_INFORMATION
 327 {
 328     PVOID TransferAddress;
 329     ULONG ZeroBits;
 330     SIZE_T MaximumStackSize;
 331     SIZE_T CommittedStackSize;
 332     ULONG SubSystemType;
 333     union
 334     {
 335         struct
 336         {
 337             USHORT SubSystemMinorVersion;
 338             USHORT SubSystemMajorVersion;
 339         };
 340         ULONG SubSystemVersion;
 341     };
 342     ULONG GpValue;
 343     USHORT ImageCharacteristics;
 344     USHORT DllCharacteristics;
 345     USHORT Machine;
 346     UCHAR ImageContainsCode;
 347     UCHAR Spare1;
 348     ULONG LoaderFlags;
 349     ULONG ImageFileSize;
 350     ULONG Reserved[1];
 351 } SECTION_IMAGE_INFORMATION, *PSECTION_IMAGE_INFORMATION;
 352
 353 #ifndef NTOS_MODE_USER
 354
 355 //
 356 // PTE Structures
 357 //
 358 typedef struct _MMPTE
 359 {
 360     union
 361     {
 362         ULONG_PTR Long;
 363         HARDWARE_PTE Flush;
 364         MMPTE_HARDWARE Hard;
 365         MMPTE_PROTOTYPE Proto;
 366         MMPTE_SOFTWARE Soft;
 367         MMPTE_TRANSITION Trans;
 368         MMPTE_SUBSECTION Subsect;
 369         MMPTE_LIST List;
 370     } u;
 371 } MMPTE, *PMMPTE;
 372
 373 //
 374 // Section Extension Information
 375 //
 376 typedef struct _MMEXTEND_INFO
 377 {
 378     ULONGLONG CommittedSize;
 379     ULONG ReferenceCount;
 380 } MMEXTEND_INFO, *PMMEXTEND_INFO;
 381
 382 //
 383 // Segment and Segment Flags
 384 //
 385 typedef struct _SEGMENT_FLAGS
 386 {
 387     ULONG TotalNumberOfPtes4132:10;
 388     ULONG ExtraSharedWowSubsections:1;
 389     ULONG LargePages:1;
 390     ULONG Spare:20;
 391 } SEGMENT_FLAGS, *PSEGMENT_FLAGS;
 392
 393 typedef struct _SEGMENT
 394 {
 395     struct _CONTROL_AREA *ControlArea;
 396     ULONG TotalNumberOfPtes;
 397     ULONG NonExtendedPtes;
 398     ULONG Spare0;
 399     ULONGLONG SizeOfSegment;
 400     MMPTE SegmentPteTemplate;
 401     ULONG NumberOfCommittedPages;
 402     PMMEXTEND_INFO ExtendInfo;
 403     SEGMENT_FLAGS SegmentFlags;
 404     PVOID BasedAddress;
 405     union
 406     {
 407         SIZE_T ImageCommitment;
 408         PEPROCESS CreatingProcess;
 409     } u1;
 410     union
 411     {
 412         PSECTION_IMAGE_INFORMATION ImageInformation;
 413         PVOID FirstMappedVa;
 414     } u2;
 415     PMMPTE PrototypePte;
 416     MMPTE ThePtes[1];
 417 } SEGMENT, *PSEGMENT;
 418
 419 typedef struct _MAPPED_FILE_SEGMENT
 420 {
 421     struct _CONTROL_AREA *ControlArea;
 422     ULONG TotalNumberOfPtes;
 423     ULONG NonExtendedPtes;
 424     ULONG Spare0;
 425     UINT64 SizeOfSegment;
 426     MMPTE SegmentPteTemplate;
 427     SIZE_T NumberOfCommittedPages;
 428     PMMEXTEND_INFO ExtendInfo;
 429     SEGMENT_FLAGS SegmentFlags;
 430     PVOID BasedAddress;
 431     struct _MSUBSECTION *LastSubsectionHint;
 432 } MAPPED_FILE_SEGMENT, *PMAPPED_FILE_SEGMENT;
 433
 434 //
 435 // Event Counter Structure
 436 //
 437 typedef struct _EVENT_COUNTER
 438 {
 439     SLIST_ENTRY ListEntry;
 440     ULONG RefCount;
 441     KEVENT Event;
 442 } EVENT_COUNTER, *PEVENT_COUNTER;
 443
 444 //
 445 // Flags
 446 //
 447 typedef struct _MMSECTION_FLAGS
 448 {
 449     ULONG BeingDeleted:1;
 450     ULONG BeingCreated:1;
 451     ULONG BeingPurged:1;
 452     ULONG NoModifiedWriting:1;
 453     ULONG FailAllIo:1;
 454     ULONG Image:1;
 455     ULONG Based:1;
 456     ULONG File:1;
 457     ULONG Networked:1;
 458     ULONG NoCache:1;
 459     ULONG PhysicalMemory:1;
 460     ULONG CopyOnWrite:1;
 461     ULONG Reserve:1;
 462     ULONG Commit:1;
 463     ULONG FloppyMedia:1;
 464     ULONG WasPurged:1;
 465     ULONG UserReference:1;
 466     ULONG GlobalMemory:1;
 467     ULONG DeleteOnClose:1;
 468     ULONG FilePointerNull:1;
 469     ULONG DebugSymbolsLoaded:1;
 470     ULONG SetMappedFileIoComplete:1;
 471     ULONG CollidedFlush:1;
 472     ULONG NoChange:1;
 473     ULONG filler0:1;
 474     ULONG ImageMappedInSystemSpace:1;
 475     ULONG UserWritable:1;
 476     ULONG Accessed:1;
 477     ULONG GlobalOnlyPerSession:1;
 478     ULONG Rom:1;
 479     ULONG WriteCombined:1;
 480     ULONG filler:1;
 481 } MMSECTION_FLAGS, *PMMSECTION_FLAGS;
 482
 483 typedef struct _MMSUBSECTION_FLAGS
 484 {
 485     ULONG ReadOnly:1;
 486     ULONG ReadWrite:1;
 487     ULONG SubsectionStatic:1;
 488     ULONG GlobalMemory:1;
 489     ULONG Protection:5;
 490     ULONG Spare:1;
 491     ULONG StartingSector4132:10;
 492     ULONG SectorEndOffset:12;
 493 } MMSUBSECTION_FLAGS, *PMMSUBSECTION_FLAGS;
 494
 495 typedef struct _MMSUBSECTION_FLAGS2
 496 {
 497     ULONG SubsectionAccessed:1;
 498     ULONG SubsectionConverted:1;
 499     ULONG Reserved:30;
 500 } MMSUBSECTION_FLAGS2;
 501
 502 //
 503 // Control Area Structures
 504 //
 505 typedef struct _CONTROL_AREA
 506 {
 507     PSEGMENT Segment;
 508     LIST_ENTRY DereferenceList;
 509     ULONG NumberOfSectionReferences;
 510     ULONG NumberOfPfnReferences;
 511     ULONG NumberOfMappedViews;
 512     ULONG NumberOfSystemCacheViews;
 513     ULONG NumberOfUserReferences;
 514     union
 515     {
 516         ULONG LongFlags;
 517         MMSECTION_FLAGS Flags;
 518     } u;
 519     PFILE_OBJECT FilePointer;
 520     PEVENT_COUNTER WaitingForDeletion;
 521     USHORT ModifiedWriteCount;
 522     USHORT FlushInProgressCount;
 523     ULONG WritableUserReferences;
 524     ULONG QuadwordPad;
 525 } CONTROL_AREA, *PCONTROL_AREA;
 526
 527 typedef struct _LARGE_CONTROL_AREA
 528 {
 529     PSEGMENT Segment;
 530     LIST_ENTRY DereferenceList;
 531     ULONG NumberOfSectionReferences;
 532     ULONG NumberOfPfnReferences;
 533     ULONG NumberOfMappedViews;
 534     ULONG NumberOfSystemCacheViews;
 535     ULONG NumberOfUserReferences;
 536     union
 537     {
 538         ULONG LongFlags;
 539         MMSECTION_FLAGS Flags;
 540     } u;
 541     PFILE_OBJECT FilePointer;
 542     PEVENT_COUNTER WaitingForDeletion;
 543     USHORT ModifiedWriteCount;
 544     USHORT FlushInProgressCount;
 545     ULONG WritableUserReferences;
 546     ULONG QuadwordPad;
 547     ULONG StartingFrame;
 548     LIST_ENTRY UserGlobalList;
 549     ULONG SessionId;
 550 } LARGE_CONTROL_AREA, *PLARGE_CONTROL_AREA;
 551
 552 //
 553 // Subsection and Mapped Subsection
 554 //
 555 typedef struct _SUBSECTION
 556 {
 557     PCONTROL_AREA ControlArea;
 558     union
 559     {
 560         ULONG LongFlags;
 561         MMSUBSECTION_FLAGS SubsectionFlags;
 562     } u;
 563     ULONG StartingSector;
 564     ULONG NumberOfFullSectors;
 565     PMMPTE SubsectionBase;
 566     ULONG UnusedPtes;
 567     ULONG PtesInSubsection;
 568     struct _SUBSECTION *NextSubsection;
 569 } SUBSECTION, *PSUBSECTION;
 570
 571 typedef struct _MSUBSECTION
 572 {
 573     PCONTROL_AREA ControlArea;
 574     union
 575     {
 576         ULONG LongFlags;
 577         MMSUBSECTION_FLAGS SubsectionFlags;
 578     } u;
 579     ULONG StartingSector;
 580     ULONG NumberOfFullSectors;
 581     PMMPTE SubsectionBase;
 582     ULONG UnusedPtes;
 583     ULONG PtesInSubsection;
 584     struct _SUBSECTION *NextSubsection;
 585     LIST_ENTRY DereferenceList;
 586     ULONG_PTR NumberOfMappedViews;
 587     union
 588     {
 589         ULONG LongFlags2;
 590         MMSUBSECTION_FLAGS2 SubsectionFlags2;
 591     } u2;
 592 } MSUBSECTION, *PMSUBSECTION;
 593
 594 //
 595 // Segment Object
 596 //
 597 typedef struct _SEGMENT_OBJECT
 598 {
 599     PVOID BaseAddress;
 600     ULONG TotalNumberOfPtes;
 601     LARGE_INTEGER SizeOfSegment;
 602     ULONG NonExtendedPtes;
 603     ULONG ImageCommitment;
 604     PCONTROL_AREA ControlArea;
 605     PSUBSECTION Subsection;
 606     PLARGE_CONTROL_AREA LargeControlArea;
 607     PMMSECTION_FLAGS MmSectionFlags;
 608     PMMSUBSECTION_FLAGS MmSubSectionFlags;
 609 } SEGMENT_OBJECT, *PSEGMENT_OBJECT;
 610
 611 //
 612 // Section Object
 613 //
 614 typedef struct _SECTION_OBJECT
 615 {
 616     PVOID StartingVa;
 617     PVOID EndingVa;
 618     PVOID LeftChild;
 619     PVOID RightChild;
 620     PSEGMENT_OBJECT Segment;
 621 } SECTION_OBJECT, *PSECTION_OBJECT;
 622
 623 //
 624 // Generic Address Range Structure
 625 //
 626 typedef struct _ADDRESS_RANGE
 627 {
 628     ULONG BaseAddrLow;
 629     ULONG BaseAddrHigh;
 630     ULONG LengthLow;
 631     ULONG LengthHigh;
 632     ULONG Type;
 633 } ADDRESS_RANGE, *PADDRESS_RANGE;
 634
 635 //
 636 // Node in Memory Manager's AVL Table
 637 //
 638 typedef struct _MMADDRESS_NODE
 639 {
 640     union
 641     {
 642         LONG_PTR Balance:2;
 643         struct _MMADDRESS_NODE *Parent;
 644     } u1;
 645     struct _MMADDRESS_NODE *LeftChild;
 646     struct _MMADDRESS_NODE *RightChild;
 647     ULONG_PTR StartingVpn;
 648     ULONG_PTR EndingVpn;
 649 } MMADDRESS_NODE, *PMMADDRESS_NODE;
 650
 651 //
 652 // Memory Manager AVL Table for VADs and other descriptors
 653 //
 654 typedef struct _MM_AVL_TABLE
 655 {
 656     MMADDRESS_NODE BalancedRoot;
 657     ULONG_PTR DepthOfTree:5;
 658     ULONG_PTR Unused:3;
 659 #ifdef _WIN64
 660     ULONG_PTR NumberGenericTableElements:56;
 661 #else
 662     ULONG_PTR NumberGenericTableElements:24;
 663 #endif
 664     PVOID NodeHint;
 665     PVOID NodeFreeHint;
 666 } MM_AVL_TABLE, *PMM_AVL_TABLE;
 667
 668 //
 669 // Virtual Adress List used in VADs
 670 //
 671 typedef struct _MMADDRESS_LIST
 672 {
 673     ULONG_PTR StartVpn;
 674     ULONG_PTR EndVpn;
 675 } MMADDRESS_LIST, *PMMADDRESS_LIST;
 676
 677 //
 678 // Flags used in the VAD
 679 //
 680 typedef struct _MMVAD_FLAGS
 681 {
 682 #ifdef _WIN64
 683     ULONG_PTR CommitCharge:51;
 684 #else
 685     ULONG_PTR CommitCharge:19;
 686 #endif
 687     ULONG_PTR NoChange:1;
 688     ULONG_PTR VadType:3;
 689     ULONG_PTR MemCommit:1;
 690     ULONG_PTR Protection:5;
 691     ULONG_PTR Spare:2;
 692     ULONG_PTR PrivateMemory:1;
 693 } MMVAD_FLAGS, *PMMVAD_FLAGS;
 694
 695 //
 696 // Extended flags used in the VAD
 697 //
 698 typedef struct _MMVAD_FLAGS2
 699 {
 700     ULONG FileOffset:24;
 701     ULONG SecNoChange:1;
 702     ULONG OneSecured:1;
 703     ULONG MultipleSecured:1;
 704     ULONG ReadOnly:1;
 705     ULONG LongVad:1;
 706     ULONG ExtendableFile:1;
 707     ULONG Inherit:1;
 708     ULONG CopyOnWrite:1;
 709 } MMVAD_FLAGS2, *PMMVAD_FLAGS2;
 710
 711 //
 712 // Virtual Address Descriptor (VAD) Structure
 713 //
 714 typedef struct _MMVAD
 715 {
 716     union
 717     {
 718         LONG_PTR Balance:2;
 719         struct _MMVAD *Parent;
 720     } u1;
 721     struct _MMVAD *LeftChild;
 722     struct _MMVAD *RightChild;
 723     ULONG_PTR StartingVpn;
 724     ULONG_PTR EndingVpn;
 725     union
 726     {
 727         ULONG_PTR LongFlags;
 728         MMVAD_FLAGS VadFlags;
 729     } u;
 730     PCONTROL_AREA ControlArea;
 731     PMMPTE FirstPrototypePte;
 732     PMMPTE LastContiguousPte;
 733     union
 734     {
 735         ULONG LongFlags2;
 736         MMVAD_FLAGS2 VadFlags2;
 737     } u2;
 738 } MMVAD, *PMMVAD;
 739
 740 //
 741 // Long VAD used in section and private allocations
 742 //
 743 typedef struct _MMVAD_LONG
 744 {
 745     union
 746     {
 747         LONG_PTR Balance:2;
 748         PMMVAD Parent;
 749     } u1;
 750     PMMVAD LeftChild;
 751     PMMVAD RightChild;
 752     ULONG_PTR StartingVpn;
 753     ULONG_PTR EndingVpn;
 754     union
 755     {
 756         ULONG_PTR LongFlags;
 757         MMVAD_FLAGS VadFlags;
 758     } u;
 759     PCONTROL_AREA ControlArea;
 760     PMMPTE FirstPrototypePte;
 761     PMMPTE LastContiguousPte;
 762     union
 763     {
 764         ULONG LongFlags2;
 765         MMVAD_FLAGS2 VadFlags2;
 766     } u2;
 767     union
 768     {
 769         LIST_ENTRY List;
 770         MMADDRESS_LIST Secured;
 771     } u3;
 772     union
 773     {
 774         PVOID Banked;
 775         PMMEXTEND_INFO ExtendedInfo;
 776     } u4;
 777 } MMVAD_LONG, *PMMVAD_LONG;
 778
 779 //
 780 // Short VAD used in virtual memory allocations
 781 //
 782 typedef struct _MMVAD_SHORT
 783 {
 784     union
 785     {
 786         LONG_PTR Balance:2;
 787         PMMVAD Parent;
 788     } u1;
 789     PMMVAD LeftChild;
 790     PMMVAD RightChild;
 791     ULONG_PTR StartingVpn;
 792     ULONG_PTR EndingVpn;
 793     union
 794     {
 795         ULONG_PTR LongFlags;
 796         MMVAD_FLAGS VadFlags;
 797     } u;
 798 } MMVAD_SHORT, *PMMVAD_SHORT;
 799
 800 //
 801 // Actual Section Object
 802 //
 803 typedef struct _SECTION
 804 {
 805     MMADDRESS_NODE Address;
 806     PSEGMENT Segment;
 807     LARGE_INTEGER SizeOfSection;
 808     union
 809     {
 810         ULONG LongFlags;
 811         MMSECTION_FLAGS Flags;
 812     } u;
 813     ULONG InitialPageProtection;
 814 } SECTION, *PSECTION;
 815
 816 //
 817 // Memory Manager Working Set Structures
 818 //
 819 typedef struct _MMWSLENTRY
 820 {
 821     ULONG Valid:1;
 822     ULONG LockedInWs:1;
 823     ULONG LockedInMemory:1;
 824     ULONG Protection:5;
 825     ULONG Hashed:1;
 826     ULONG Direct:1;
 827     ULONG Age:2;
 828     ULONG VirtualPageNumber:20;
 829 } MMWSLENTRY, *PMMWSLENTRY;
 830
 831 typedef struct _MMWSLE
 832 {
 833     union
 834     {
 835         PVOID VirtualAddress;
 836         ULONG Long;
 837         MMWSLENTRY e1;
 838     } u1;
 839 } MMWSLE, *PMMWSLE;
 840
 841 typedef struct _MMWSLE_HASH
 842 {
 843     PVOID Key;
 844     ULONG Index;
 845 } MMWSLE_HASH, *PMMWSLE_HASH;
 846
 847 typedef struct _MMWSL
 848 {
 849     ULONG FirstFree;
 850     ULONG FirstDynamic;
 851     ULONG LastEntry;
 852     ULONG NextSlot;
 853     PMMWSLE Wsle;
 854     ULONG LastInitializedWsle;
 855     ULONG NonDirectCount;
 856     PMMWSLE_HASH HashTable;
 857     ULONG HashTableSize;
 858     ULONG NumberOfCommittedPageTables;
 859     PVOID HashTableStart;
 860     PVOID HighestPermittedHashAddress;
 861     ULONG NumberOfImageWaiters;
 862     ULONG VadBitMapHint;
 863     USHORT UsedPageTableEntries[768];
 864     ULONG CommittedPageTables[24];
 865 } MMWSL, *PMMWSL;
 866
 867 //
 868 // Flags for Memory Support Structure
 869 //
 870 typedef struct _MMSUPPORT_FLAGS
 871 {
 872     ULONG SessionSpace:1;
 873     ULONG BeingTrimmed:1;
 874     ULONG SessionLeader:1;
 875     ULONG TrimHard:1;
 876     ULONG MaximumWorkingSetHard:1;
 877     ULONG ForceTrim:1;
 878     ULONG MinimumWorkingSetHard:1;
 879     ULONG Available0:1;
 880     ULONG MemoryPriority:8;
 881     ULONG GrowWsleHash:1;
 882     ULONG AcquiredUnsafe:1;
 883     ULONG Available:14;
 884 } MMSUPPORT_FLAGS, *PMMSUPPORT_FLAGS;
 885
 886 //
 887 // Per-Process Memory Manager Data
 888 //
 889 typedef struct _MMSUPPORT
 890 {
 891 #if (NTDDI_VERSION >= NTDDI_WS03)
 892     LIST_ENTRY WorkingSetExpansionLinks;
 893 #endif
 894 #if (NTDDI_VERSION >= NTDDI_LONGHORN)
 895     USHORT LastTrimpStamp;
 896     USHORT NextPageColor;
 897 #else
 898     LARGE_INTEGER LastTrimTime;
 899 #endif
 900     MMSUPPORT_FLAGS Flags;
 901     ULONG PageFaultCount;
 902     ULONG PeakWorkingSetSize;
 903 #if (NTDDI_VERSION >= NTDDI_LONGHORN)
 904     ULONG Spare0;
 905 #else
 906     ULONG GrowthSinceLastEstimate;
 907 #endif
 908     ULONG MinimumWorkingSetSize;
 909     ULONG MaximumWorkingSetSize;
 910     PMMWSL VmWorkingSetList;
 911 #if (NTDDI_VERSION < NTDDI_WS03)
 912     LIST_ENTRY WorkingSetExpansionLinks;
 913 #endif
 914     ULONG Claim;
 915 #if (NTDDI_VERSION >= NTDDI_LONGHORN)
 916     ULONG Spare;
 917     ULONG WorkingSetPrivateSize;
 918     ULONG WorkingSetSizeOverhead;
 919 #else
 920     ULONG NextEstimationSlot;
 921     ULONG NextAgingSlot;
 922     ULONG EstimatedAvailable;
 923 #endif
 924     ULONG WorkingSetSize;
 925 #if (NTDDI_VERSION >= NTDDI_LONGHORN)
 926     PKEVENT ExitEvent;
 927 #endif
 928     EX_PUSH_LOCK WorkingSetMutex;
 929 #if (NTDDI_VERSION >= NTDDI_LONGHORN)
 930     PVOID AccessLog;
 931 #endif
 932 } MMSUPPORT, *PMMSUPPORT;
 933
 934 //
 935 // Memory Information Types
 936 //
 937 typedef struct _MEMORY_BASIC_INFORMATION
 938 {
 939     PVOID BaseAddress;
 940     PVOID AllocationBase;
 941     ULONG AllocationProtect;
 942     SIZE_T RegionSize;
 943     ULONG State;
 944     ULONG Protect;
 945     ULONG Type;
 946 } MEMORY_BASIC_INFORMATION,*PMEMORY_BASIC_INFORMATION;
 947
 948 //
 949 // Driver Verifier Data
 950 //
 951 typedef struct _MM_DRIVER_VERIFIER_DATA
 952 {
 953     ULONG Level;
 954     ULONG RaiseIrqls;
 955     ULONG AcquireSpinLocks;
 956     ULONG SynchronizeExecutions;
 957     ULONG AllocationsAttempted;
 958     ULONG AllocationsSucceeded;
 959     ULONG AllocationsSucceededSpecialPool;
 960     ULONG AllocationsWithNoTag;
 961     ULONG TrimRequests;
 962     ULONG Trims;
 963     ULONG AllocationsFailed;
 964     ULONG AllocationsFailedDeliberately;
 965     ULONG Loads;
 966     ULONG Unloads;
 967     ULONG UnTrackedPool;
 968     ULONG UserTrims;
 969     ULONG CurrentPagedPoolAllocations;
 970     ULONG CurrentNonPagedPoolAllocations;
 971     ULONG PeakPagedPoolAllocations;
 972     ULONG PeakNonPagedPoolAllocations;
 973     ULONG PagedBytes;
 974     ULONG NonPagedBytes;
 975     ULONG PeakPagedBytes;
 976     ULONG PeakNonPagedBytes;
 977     ULONG BurstAllocationsFailedDeliberately;
 978     ULONG SessionTrims;
 979     ULONG Reserved[2];
 980 } MM_DRIVER_VERIFIER_DATA, *PMM_DRIVER_VERIFIER_DATA;
 981
 982 //
 983 // Internal Driver Verifier Table Data
 984 //
 985 typedef struct _DRIVER_SPECIFIED_VERIFIER_THUNKS
 986 {
 987     LIST_ENTRY ListEntry;
 988     struct _LDR_DATA_TABLE_ENTRY *DataTableEntry;
 989     ULONG NumberOfThunks;
 990 } DRIVER_SPECIFIED_VERIFIER_THUNKS, *PDRIVER_SPECIFIED_VERIFIER_THUNKS;
 991
 992 #ifdef __cplusplus
 993 extern "C" {
 994 #endif
 995
 996 //
 997 // Default heap size values.  For user mode, these values are copied to a new
 998 // process's PEB by the kernel in MmCreatePeb.  In kernel mode, RtlCreateHeap
 999 // reads these variables directly.
1000 //
1001 // These variables should be considered "const"; they are written only once,
1002 // during MmInitSystem.
1003 //
1004 extern SIZE_T MmHeapSegmentReserve;
1005 extern SIZE_T MmHeapSegmentCommit;
1006 extern SIZE_T MmHeapDeCommitTotalFreeThreshold;
1007 extern SIZE_T MmHeapDeCommitFreeBlockThreshold;
1008
1009 //
1010 // Section Object Type
1011 //
1012 extern POBJECT_TYPE NTSYSAPI MmSectionObjectType;
1013
1014 #ifdef __cplusplus
1015 }; // extern "C"
1016 #endif
1017
1018 #endif // !NTOS_MODE_USER
1019
1020 #endif // _MMTYPES_H