reactos/ntoskrnl/mm/ARM3/miarm.h

   1 /*
   2  * PROJECT:         ReactOS Kernel
   3  * LICENSE:         BSD - See COPYING.ARM in the top level directory
   4  * FILE:            ntoskrnl/mm/ARM3/miarm.h
   5  * PURPOSE:         ARM Memory Manager Header
   6  * PROGRAMMERS:     ReactOS Portable Systems Group
   7  */
   8
   9 #ifndef _M_AMD64
  10
  11 #define MI_MIN_PAGES_FOR_NONPAGED_POOL_TUNING   ((255 * _1MB) >> PAGE_SHIFT)
  12 #define MI_MIN_PAGES_FOR_SYSPTE_TUNING          ((19 * _1MB) >> PAGE_SHIFT)
  13 #define MI_MIN_PAGES_FOR_SYSPTE_BOOST           ((32 * _1MB) >> PAGE_SHIFT)
  14 #define MI_MAX_INIT_NONPAGED_POOL_SIZE          (128 * _1MB)
  15 #define MI_MAX_NONPAGED_POOL_SIZE               (128 * _1MB)
  16 #define MI_MAX_FREE_PAGE_LISTS                  4
  17
  18 #define MI_MIN_INIT_PAGED_POOLSIZE              (32 * _1MB)
  19
  20 #define MI_SESSION_VIEW_SIZE                    (20 * _1MB)
  21 #define MI_SESSION_POOL_SIZE                    (16 * _1MB)
  22 #define MI_SESSION_IMAGE_SIZE                   (8 * _1MB)
  23 #define MI_SESSION_WORKING_SET_SIZE             (4 * _1MB)
  24 #define MI_SESSION_SIZE                         (MI_SESSION_VIEW_SIZE + \
  25                                                  MI_SESSION_POOL_SIZE + \
  26                                                  MI_SESSION_IMAGE_SIZE + \
  27                                                  MI_SESSION_WORKING_SET_SIZE)
  28
  29 #define MI_SYSTEM_VIEW_SIZE                     (16 * _1MB)
  30
  31 #define MI_SYSTEM_CACHE_WS_START                (PVOID)0xC0C00000
  32 #define MI_PAGED_POOL_START                     (PVOID)0xE1000000
  33 #define MI_NONPAGED_POOL_END                    (PVOID)0xFFBE0000
  34 #define MI_DEBUG_MAPPING                        (PVOID)0xFFBFF000
  35
  36 #define MI_SYSTEM_PTE_BASE                      (PVOID)MiAddressToPte(NULL)
  37
  38 #define MI_MIN_SECONDARY_COLORS                 8
  39 #define MI_SECONDARY_COLORS                     64
  40 #define MI_MAX_SECONDARY_COLORS                 1024
  41
  42 #define MI_MIN_ALLOCATION_FRAGMENT              (4 * _1KB)
  43 #define MI_ALLOCATION_FRAGMENT                  (64 * _1KB)
  44 #define MI_MAX_ALLOCATION_FRAGMENT              (2  * _1MB)
  45
  46 #define MM_HIGHEST_VAD_ADDRESS \
  47     (PVOID)((ULONG_PTR)MM_HIGHEST_USER_ADDRESS - (16 * PAGE_SIZE))
  48
  49 /* The range 0x10000->0x7FEFFFFF is reserved for the ROSMM MAREA Allocator */
  50 #define MI_LOWEST_VAD_ADDRESS                   (PVOID)0x7FF00000
  51
  52 #endif /* !_M_AMD64 */
  53
  54 /* Make the code cleaner with some definitions for size multiples */
  55 #define _1KB (1024u)
  56 #define _1MB (1024 * _1KB)
  57 #define _1GB (1024 * _1MB)
  58
  59 /* Area mapped by a PDE */
  60 #define PDE_MAPPED_VA  (PTE_COUNT * PAGE_SIZE)
  61
  62 /* Size of a page table */
  63 #define PT_SIZE  (PTE_COUNT * sizeof(MMPTE))
  64
  65 /* Architecture specific count of PDEs in a directory, and count of PTEs in a PT */
  66 #ifdef _M_IX86
  67 #define PD_COUNT  1
  68 #define PDE_COUNT 1024
  69 #define PTE_COUNT 1024
  70 #elif _M_ARM
  71 #define PD_COUNT  1
  72 #define PDE_COUNT 4096
  73 #define PTE_COUNT 256
  74 #else
  75 #define PD_COUNT  PPE_PER_PAGE
  76 #define PDE_COUNT PDE_PER_PAGE
  77 #define PTE_COUNT PTE_PER_PAGE
  78 #endif
  79
  80 #ifdef _M_IX86
  81 #define IMAGE_FILE_MACHINE_NATIVE   IMAGE_FILE_MACHINE_I386
  82 #elif _M_ARM
  83 #define IMAGE_FILE_MACHINE_NATIVE   IMAGE_FILE_MACHINE_ARM
  84 #elif _M_AMD64
  85 #define IMAGE_FILE_MACHINE_NATIVE   IMAGE_FILE_MACHINE_AMD64
  86 #else
  87 #error Define these please!
  88 #endif
  89
  90 //
  91 // Protection Bits part of the internal memory manager Protection Mask
  92 // Taken from http://www.reactos.org/wiki/Techwiki:Memory_management_in_the_Windows_XP_kernel
  93 // and public assertions.
  94 //
  95 #define MM_ZERO_ACCESS         0
  96 #define MM_READONLY            1
  97 #define MM_EXECUTE             2
  98 #define MM_EXECUTE_READ        3
  99 #define MM_READWRITE           4
 100 #define MM_WRITECOPY           5
 101 #define MM_EXECUTE_READWRITE   6
 102 #define MM_EXECUTE_WRITECOPY   7
 103 #define MM_NOCACHE             8
 104 #define MM_DECOMMIT            0x10
 105 #define MM_NOACCESS            (MM_DECOMMIT | MM_NOCACHE)
 106
 107 //
 108 // Specific PTE Definitions that map to the Memory Manager's Protection Mask Bits
 109 // The Memory Manager's definition define the attributes that must be preserved
 110 // and these PTE definitions describe the attributes in the hardware sense. This
 111 // helps deal with hardware differences between the actual boolean expression of
 112 // the argument.
 113 //
 114 // For example, in the logical attributes, we want to express read-only as a flag
 115 // but on x86, it is writability that must be set. On the other hand, on x86, just
 116 // like in the kernel, it is disabling the caches that requires a special flag,
 117 // while on certain architectures such as ARM, it is enabling the cache which
 118 // requires a flag.
 119 //
 120 #if defined(_M_IX86) || defined(_M_AMD64)
 121 //
 122 // Access Flags
 123 //
 124 #define PTE_READONLY            0
 125 #define PTE_EXECUTE             0 // Not worrying about NX yet
 126 #define PTE_EXECUTE_READ        0 // Not worrying about NX yet
 127 #define PTE_READWRITE           0x2
 128 #define PTE_WRITECOPY           0x200
 129 #define PTE_EXECUTE_READWRITE   0x0
 130 #define PTE_EXECUTE_WRITECOPY   0x200
 131 #define PTE_PROTOTYPE           0x400
 132 //
 133 // Cache flags
 134 //
 135 #define PTE_ENABLE_CACHE        0
 136 #define PTE_DISABLE_CACHE       0x10
 137 #define PTE_WRITECOMBINED_CACHE 0x10
 138 #elif defined(_M_ARM)
 139 #else
 140 #error Define these please!
 141 #endif
 142 static const
 143 ULONG
 144 MmProtectToPteMask[32] =
 145 {
 146     //
 147     // These are the base MM_ protection flags
 148     //
 149     0,
 150     PTE_READONLY            | PTE_ENABLE_CACHE,
 151     PTE_EXECUTE             | PTE_ENABLE_CACHE,
 152     PTE_EXECUTE_READ        | PTE_ENABLE_CACHE,
 153     PTE_READWRITE           | PTE_ENABLE_CACHE,
 154     PTE_WRITECOPY           | PTE_ENABLE_CACHE,
 155     PTE_EXECUTE_READWRITE   | PTE_ENABLE_CACHE,
 156     PTE_EXECUTE_WRITECOPY   | PTE_ENABLE_CACHE,
 157     //
 158     // These OR in the MM_NOCACHE flag
 159     //
 160     0,
 161     PTE_READONLY            | PTE_DISABLE_CACHE,
 162     PTE_EXECUTE             | PTE_DISABLE_CACHE,
 163     PTE_EXECUTE_READ        | PTE_DISABLE_CACHE,
 164     PTE_READWRITE           | PTE_DISABLE_CACHE,
 165     PTE_WRITECOPY           | PTE_DISABLE_CACHE,
 166     PTE_EXECUTE_READWRITE   | PTE_DISABLE_CACHE,
 167     PTE_EXECUTE_WRITECOPY   | PTE_DISABLE_CACHE,
 168     //
 169     // These OR in the MM_DECOMMIT flag, which doesn't seem supported on x86/64/ARM
 170     //
 171     0,
 172     PTE_READONLY            | PTE_ENABLE_CACHE,
 173     PTE_EXECUTE             | PTE_ENABLE_CACHE,
 174     PTE_EXECUTE_READ        | PTE_ENABLE_CACHE,
 175     PTE_READWRITE           | PTE_ENABLE_CACHE,
 176     PTE_WRITECOPY           | PTE_ENABLE_CACHE,
 177     PTE_EXECUTE_READWRITE   | PTE_ENABLE_CACHE,
 178     PTE_EXECUTE_WRITECOPY   | PTE_ENABLE_CACHE,
 179     //
 180     // These OR in the MM_NOACCESS flag, which seems to enable WriteCombining?
 181     //
 182     0,
 183     PTE_READONLY            | PTE_WRITECOMBINED_CACHE,
 184     PTE_EXECUTE             | PTE_WRITECOMBINED_CACHE,
 185     PTE_EXECUTE_READ        | PTE_WRITECOMBINED_CACHE,
 186     PTE_READWRITE           | PTE_WRITECOMBINED_CACHE,
 187     PTE_WRITECOPY           | PTE_WRITECOMBINED_CACHE,
 188     PTE_EXECUTE_READWRITE   | PTE_WRITECOMBINED_CACHE,
 189     PTE_EXECUTE_WRITECOPY   | PTE_WRITECOMBINED_CACHE,
 190 };
 191
 192 //
 193 // Assertions for session images, addresses, and PTEs
 194 //
 195 #define MI_IS_SESSION_IMAGE_ADDRESS(Address) \
 196     (((Address) >= MiSessionImageStart) && ((Address) < MiSessionImageEnd))
 197
 198 #define MI_IS_SESSION_ADDRESS(Address) \
 199     (((Address) >= MmSessionBase) && ((Address) < MiSessionSpaceEnd))
 200
 201 #define MI_IS_SESSION_PTE(Pte) \
 202     ((((PMMPTE)Pte) >= MiSessionBasePte) && (((PMMPTE)Pte) < MiSessionLastPte))
 203
 204 #define MI_IS_PAGE_TABLE_ADDRESS(Address) \
 205     (((PVOID)(Address) >= (PVOID)PTE_BASE) && ((PVOID)(Address) <= (PVOID)PTE_TOP))
 206
 207 #define MI_IS_SYSTEM_PAGE_TABLE_ADDRESS(Address) \
 208     (((Address) >= (PVOID)MiAddressToPte(MmSystemRangeStart)) && ((Address) <= (PVOID)PTE_TOP))
 209
 210 #define MI_IS_PAGE_TABLE_OR_HYPER_ADDRESS(Address) \
 211     (((PVOID)(Address) >= (PVOID)PTE_BASE) && ((PVOID)(Address) <= (PVOID)MmHyperSpaceEnd))
 212
 213 //
 214 // Corresponds to MMPTE_SOFTWARE.Protection
 215 //
 216 #ifdef _M_IX86
 217 #define MM_PTE_SOFTWARE_PROTECTION_BITS   5
 218 #elif _M_ARM
 219 #define MM_PTE_SOFTWARE_PROTECTION_BITS   5
 220 #elif _M_AMD64
 221 #define MM_PTE_SOFTWARE_PROTECTION_BITS   5
 222 #else
 223 #error Define these please!
 224 #endif
 225
 226 //
 227 // Creates a software PTE with the given protection
 228 //
 229 #define MI_MAKE_SOFTWARE_PTE(p, x)          ((p)->u.Long = (x << MM_PTE_SOFTWARE_PROTECTION_BITS))
 230
 231 //
 232 // Marks a PTE as deleted
 233 //
 234 #define MI_SET_PFN_DELETED(x)               ((x)->PteAddress = (PMMPTE)((ULONG_PTR)(x)->PteAddress | 1))
 235 #define MI_IS_PFN_DELETED(x)                ((ULONG_PTR)((x)->PteAddress) & 1)
 236
 237 //
 238 // Special values for LoadedImports
 239 //
 240 #define MM_SYSLDR_NO_IMPORTS   (PVOID)0xFFFFFFFE
 241 #define MM_SYSLDR_BOOT_LOADED  (PVOID)0xFFFFFFFF
 242 #define MM_SYSLDR_SINGLE_ENTRY 0x1
 243
 244 //
 245 // PFN List Sentinel
 246 //
 247 #define LIST_HEAD 0xFFFFFFFF
 248
 249 //
 250 // Special IRQL value (found in assertions)
 251 //
 252 #define MM_NOIRQL (KIRQL)0xFFFFFFFF
 253
 254 //
 255 // FIXFIX: These should go in ex.h after the pool merge
 256 //
 257 #ifdef _M_AMD64
 258 #define POOL_BLOCK_SIZE 16
 259 #else
 260 #define POOL_BLOCK_SIZE  8
 261 #endif
 262 #define POOL_LISTS_PER_PAGE (PAGE_SIZE / POOL_BLOCK_SIZE)
 263 #define BASE_POOL_TYPE_MASK 1
 264 #define POOL_MAX_ALLOC (PAGE_SIZE - (sizeof(POOL_HEADER) + POOL_BLOCK_SIZE))
 265
 266 typedef struct _POOL_DESCRIPTOR
 267 {
 268     POOL_TYPE PoolType;
 269     ULONG PoolIndex;
 270     ULONG RunningAllocs;
 271     ULONG RunningDeAllocs;
 272     ULONG TotalPages;
 273     ULONG TotalBigPages;
 274     ULONG Threshold;
 275     PVOID LockAddress;
 276     PVOID PendingFrees;
 277     LONG PendingFreeDepth;
 278     SIZE_T TotalBytes;
 279     SIZE_T Spare0;
 280     LIST_ENTRY ListHeads[POOL_LISTS_PER_PAGE];
 281 } POOL_DESCRIPTOR, *PPOOL_DESCRIPTOR;
 282
 283 typedef struct _POOL_HEADER
 284 {
 285     union
 286     {
 287         struct
 288         {
 289 #ifdef _M_AMD64
 290             ULONG PreviousSize:8;
 291             ULONG PoolIndex:8;
 292             ULONG BlockSize:8;
 293             ULONG PoolType:8;
 294 #else
 295             USHORT PreviousSize:9;
 296             USHORT PoolIndex:7;
 297             USHORT BlockSize:9;
 298             USHORT PoolType:7;
 299 #endif
 300         };
 301         ULONG Ulong1;
 302     };
 303 #ifdef _M_AMD64
 304     ULONG PoolTag;
 305 #endif
 306     union
 307     {
 308 #ifdef _M_AMD64
 309         PEPROCESS ProcessBilled;
 310 #else
 311         ULONG PoolTag;
 312 #endif
 313         struct
 314         {
 315             USHORT AllocatorBackTraceIndex;
 316             USHORT PoolTagHash;
 317         };
 318     };
 319 } POOL_HEADER, *PPOOL_HEADER;
 320
 321 C_ASSERT(sizeof(POOL_HEADER) == POOL_BLOCK_SIZE);
 322 C_ASSERT(POOL_BLOCK_SIZE == sizeof(LIST_ENTRY));
 323
 324 extern ULONG ExpNumberOfPagedPools;
 325 extern POOL_DESCRIPTOR NonPagedPoolDescriptor;
 326 extern PPOOL_DESCRIPTOR ExpPagedPoolDescriptor[16 + 1];
 327 extern PVOID PoolTrackTable;
 328
 329 //
 330 // END FIXFIX
 331 //
 332
 333 typedef struct _MI_LARGE_PAGE_DRIVER_ENTRY
 334 {
 335     LIST_ENTRY Links;
 336     UNICODE_STRING BaseName;
 337 } MI_LARGE_PAGE_DRIVER_ENTRY, *PMI_LARGE_PAGE_DRIVER_ENTRY;
 338
 339 typedef enum _MMSYSTEM_PTE_POOL_TYPE
 340 {
 341     SystemPteSpace,
 342     NonPagedPoolExpansion,
 343     MaximumPtePoolTypes
 344 } MMSYSTEM_PTE_POOL_TYPE;
 345
 346 typedef enum _MI_PFN_CACHE_ATTRIBUTE
 347 {
 348     MiNonCached,
 349     MiCached,
 350     MiWriteCombined,
 351     MiNotMapped
 352 } MI_PFN_CACHE_ATTRIBUTE, *PMI_PFN_CACHE_ATTRIBUTE;
 353
 354 typedef struct _PHYSICAL_MEMORY_RUN
 355 {
 356     ULONG BasePage;
 357     ULONG PageCount;
 358 } PHYSICAL_MEMORY_RUN, *PPHYSICAL_MEMORY_RUN;
 359
 360 typedef struct _PHYSICAL_MEMORY_DESCRIPTOR
 361 {
 362     ULONG NumberOfRuns;
 363     ULONG NumberOfPages;
 364     PHYSICAL_MEMORY_RUN Run[1];
 365 } PHYSICAL_MEMORY_DESCRIPTOR, *PPHYSICAL_MEMORY_DESCRIPTOR;
 366
 367 typedef struct _MMCOLOR_TABLES
 368 {
 369     PFN_NUMBER Flink;
 370     PVOID Blink;
 371     PFN_NUMBER Count;
 372 } MMCOLOR_TABLES, *PMMCOLOR_TABLES;
 373
 374 typedef struct _MI_LARGE_PAGE_RANGES
 375 {
 376     PFN_NUMBER StartFrame;
 377     PFN_NUMBER LastFrame;
 378 } MI_LARGE_PAGE_RANGES, *PMI_LARGE_PAGE_RANGES;
 379
 380 extern MMPTE HyperTemplatePte;
 381 extern MMPDE ValidKernelPde;
 382 extern MMPTE ValidKernelPte;
 383 extern MMPDE DemandZeroPde;
 384 extern MMPTE PrototypePte;
 385 extern BOOLEAN MmLargeSystemCache;
 386 extern BOOLEAN MmZeroPageFile;
 387 extern BOOLEAN MmProtectFreedNonPagedPool;
 388 extern BOOLEAN MmTrackLockedPages;
 389 extern BOOLEAN MmTrackPtes;
 390 extern BOOLEAN MmDynamicPfn;
 391 extern BOOLEAN MmMirroring;
 392 extern BOOLEAN MmMakeLowMemory;
 393 extern BOOLEAN MmEnforceWriteProtection;
 394 extern SIZE_T MmAllocationFragment;
 395 extern ULONG MmConsumedPoolPercentage;
 396 extern ULONG MmVerifyDriverBufferType;
 397 extern ULONG MmVerifyDriverLevel;
 398 extern WCHAR MmVerifyDriverBuffer[512];
 399 extern WCHAR MmLargePageDriverBuffer[512];
 400 extern LIST_ENTRY MiLargePageDriverList;
 401 extern BOOLEAN MiLargePageAllDrivers;
 402 extern ULONG MmVerifyDriverBufferLength;
 403 extern ULONG MmLargePageDriverBufferLength;
 404 extern SIZE_T MmSizeOfNonPagedPoolInBytes;
 405 extern SIZE_T MmMaximumNonPagedPoolInBytes;
 406 extern PFN_NUMBER MmMaximumNonPagedPoolInPages;
 407 extern PFN_NUMBER MmSizeOfPagedPoolInPages;
 408 extern PVOID MmNonPagedSystemStart;
 409 extern PVOID MmNonPagedPoolStart;
 410 extern PVOID MmNonPagedPoolExpansionStart;
 411 extern PVOID MmNonPagedPoolEnd;
 412 extern SIZE_T MmSizeOfPagedPoolInBytes;
 413 extern PVOID MmPagedPoolStart;
 414 extern PVOID MmPagedPoolEnd;
 415 extern PVOID MmSessionBase;
 416 extern SIZE_T MmSessionSize;
 417 extern PMMPTE MmFirstReservedMappingPte, MmLastReservedMappingPte;
 418 extern PMMPTE MiFirstReservedZeroingPte;
 419 extern MI_PFN_CACHE_ATTRIBUTE MiPlatformCacheAttributes[2][MmMaximumCacheType];
 420 extern PPHYSICAL_MEMORY_DESCRIPTOR MmPhysicalMemoryBlock;
 421 extern SIZE_T MmBootImageSize;
 422 extern PMMPTE MmSystemPtesStart[MaximumPtePoolTypes];
 423 extern PMMPTE MmSystemPtesEnd[MaximumPtePoolTypes];
 424 extern PMEMORY_ALLOCATION_DESCRIPTOR MxFreeDescriptor;
 425 extern MEMORY_ALLOCATION_DESCRIPTOR MxOldFreeDescriptor;
 426 extern ULONG_PTR MxPfnAllocation;
 427 extern MM_PAGED_POOL_INFO MmPagedPoolInfo;
 428 extern RTL_BITMAP MiPfnBitMap;
 429 extern KGUARDED_MUTEX MmPagedPoolMutex;
 430 extern PVOID MmPagedPoolStart;
 431 extern PVOID MmPagedPoolEnd;
 432 extern PVOID MmNonPagedSystemStart;
 433 extern PVOID MiSystemViewStart;
 434 extern SIZE_T MmSystemViewSize;
 435 extern PVOID MmSessionBase;
 436 extern PVOID MiSessionSpaceEnd;
 437 extern PMMPTE MiSessionImagePteStart;
 438 extern PMMPTE MiSessionImagePteEnd;
 439 extern PMMPTE MiSessionBasePte;
 440 extern PMMPTE MiSessionLastPte;
 441 extern SIZE_T MmSizeOfPagedPoolInBytes;
 442 extern PMMPTE MmSystemPagePtes;
 443 extern PVOID MmSystemCacheStart;
 444 extern PVOID MmSystemCacheEnd;
 445 extern MMSUPPORT MmSystemCacheWs;
 446 extern SIZE_T MmAllocatedNonPagedPool;
 447 extern ULONG_PTR MmSubsectionBase;
 448 extern ULONG MmSpecialPoolTag;
 449 extern PVOID MmHyperSpaceEnd;
 450 extern PMMWSL MmSystemCacheWorkingSetList;
 451 extern SIZE_T MmMinimumNonPagedPoolSize;
 452 extern ULONG MmMinAdditionNonPagedPoolPerMb;
 453 extern SIZE_T MmDefaultMaximumNonPagedPool;
 454 extern ULONG MmMaxAdditionNonPagedPoolPerMb;
 455 extern ULONG MmSecondaryColors;
 456 extern ULONG MmSecondaryColorMask;
 457 extern ULONG_PTR MmNumberOfSystemPtes;
 458 extern ULONG MmMaximumNonPagedPoolPercent;
 459 extern ULONG MmLargeStackSize;
 460 extern PMMCOLOR_TABLES MmFreePagesByColor[FreePageList + 1];
 461 extern ULONG MmProductType;
 462 extern MM_SYSTEMSIZE MmSystemSize;
 463 extern PKEVENT MiLowMemoryEvent;
 464 extern PKEVENT MiHighMemoryEvent;
 465 extern PKEVENT MiLowPagedPoolEvent;
 466 extern PKEVENT MiHighPagedPoolEvent;
 467 extern PKEVENT MiLowNonPagedPoolEvent;
 468 extern PKEVENT MiHighNonPagedPoolEvent;
 469 extern PFN_NUMBER MmLowMemoryThreshold;
 470 extern PFN_NUMBER MmHighMemoryThreshold;
 471 extern PFN_NUMBER MiLowPagedPoolThreshold;
 472 extern PFN_NUMBER MiHighPagedPoolThreshold;
 473 extern PFN_NUMBER MiLowNonPagedPoolThreshold;
 474 extern PFN_NUMBER MiHighNonPagedPoolThreshold;
 475 extern PFN_NUMBER MmMinimumFreePages;
 476 extern PFN_NUMBER MmPlentyFreePages;
 477 extern PFN_NUMBER MiExpansionPoolPagesInitialCharge;
 478 extern PFN_NUMBER MmResidentAvailablePages;
 479 extern PFN_NUMBER MmResidentAvailableAtInit;
 480 extern ULONG MmTotalFreeSystemPtes[MaximumPtePoolTypes];
 481 extern PFN_NUMBER MmTotalSystemDriverPages;
 482 extern PVOID MiSessionImageStart;
 483 extern PVOID MiSessionImageEnd;
 484 extern PMMPTE MiHighestUserPte;
 485 extern PMMPDE MiHighestUserPde;
 486 extern PFN_NUMBER MmSystemPageDirectory[PD_COUNT];
 487 extern PMMPTE MmSharedUserDataPte;
 488 extern LIST_ENTRY MmProcessList;
 489
 490 #define MI_PFN_TO_PFNENTRY(x)     (&MmPfnDatabase[1][x])
 491 #define MI_PFNENTRY_TO_PFN(x)     (x - MmPfnDatabase[1])
 492
 493 //
 494 // Figures out the hardware bits for a PTE
 495 //
 496 ULONG
 497 FORCEINLINE
 498 MiDetermineUserGlobalPteMask(IN PMMPTE PointerPte)
 499 {
 500     MMPTE TempPte;
 501
 502     /* Start fresh */
 503     TempPte.u.Long = 0;
 504
 505     /* Make it valid and accessed */
 506     TempPte.u.Hard.Valid = TRUE;
 507     TempPte.u.Hard.Accessed = TRUE;
 508
 509     /* Is this for user-mode? */
 510     if ((PointerPte <= MiHighestUserPte) ||
 511         ((PointerPte >= MiAddressToPde(NULL)) && (PointerPte <= MiHighestUserPde)))
 512     {
 513         /* Set the owner bit */
 514         TempPte.u.Hard.Owner = TRUE;
 515     }
 516
 517     /* FIXME: We should also set the global bit */
 518
 519     /* Return the protection */
 520     return TempPte.u.Long;
 521 }
 522
 523 //
 524 // Creates a valid kernel PTE with the given protection
 525 //
 526 FORCEINLINE
 527 VOID
 528 MI_MAKE_HARDWARE_PTE_KERNEL(IN PMMPTE NewPte,
 529                             IN PMMPTE MappingPte,
 530                             IN ULONG ProtectionMask,
 531                             IN PFN_NUMBER PageFrameNumber)
 532 {
 533     /* Only valid for kernel, non-session PTEs */
 534     ASSERT(MappingPte > MiHighestUserPte);
 535     ASSERT(!MI_IS_SESSION_PTE(MappingPte));
 536     ASSERT((MappingPte < (PMMPTE)PDE_BASE) || (MappingPte > (PMMPTE)PDE_TOP));
 537
 538     /* Start fresh */
 539     *NewPte = ValidKernelPte;
 540
 541     /* Set the protection and page */
 542     NewPte->u.Hard.PageFrameNumber = PageFrameNumber;
 543     NewPte->u.Long |= MmProtectToPteMask[ProtectionMask];
 544 }
 545
 546 //
 547 // Creates a valid PTE with the given protection
 548 //
 549 FORCEINLINE
 550 VOID
 551 MI_MAKE_HARDWARE_PTE(IN PMMPTE NewPte,
 552                      IN PMMPTE MappingPte,
 553                      IN ULONG ProtectionMask,
 554                      IN PFN_NUMBER PageFrameNumber)
 555 {
 556     /* Set the protection and page */
 557     NewPte->u.Long = MiDetermineUserGlobalPteMask(MappingPte);
 558     NewPte->u.Long |= MmProtectToPteMask[ProtectionMask];
 559     NewPte->u.Hard.PageFrameNumber = PageFrameNumber;
 560 }
 561
 562 //
 563 // Creates a valid user PTE with the given protection
 564 //
 565 FORCEINLINE
 566 VOID
 567 MI_MAKE_HARDWARE_PTE_USER(IN PMMPTE NewPte,
 568                           IN PMMPTE MappingPte,
 569                           IN ULONG ProtectionMask,
 570                           IN PFN_NUMBER PageFrameNumber)
 571 {
 572     /* Only valid for kernel, non-session PTEs */
 573     ASSERT(MappingPte <= MiHighestUserPte);
 574
 575     /* Start fresh */
 576     *NewPte = ValidKernelPte;
 577
 578     /* Set the protection and page */
 579     NewPte->u.Hard.Owner = TRUE;
 580     NewPte->u.Hard.PageFrameNumber = PageFrameNumber;
 581     NewPte->u.Long |= MmProtectToPteMask[ProtectionMask];
 582 }
 583
 584 //
 585 // Returns if the page is physically resident (ie: a large page)
 586 // FIXFIX: CISC/x86 only?
 587 //
 588 FORCEINLINE
 589 BOOLEAN
 590 MI_IS_PHYSICAL_ADDRESS(IN PVOID Address)
 591 {
 592     PMMPDE PointerPde;
 593
 594     /* Large pages are never paged out, always physically resident */
 595     PointerPde = MiAddressToPde(Address);
 596     return ((PointerPde->u.Hard.LargePage) && (PointerPde->u.Hard.Valid));
 597 }
 598
 599 //
 600 // Writes a valid PTE
 601 //
 602 VOID
 603 FORCEINLINE
 604 MI_WRITE_VALID_PTE(IN PMMPTE PointerPte,
 605                    IN MMPTE TempPte)
 606 {
 607     /* Write the valid PTE */
 608     ASSERT(PointerPte->u.Hard.Valid == 0);
 609     ASSERT(TempPte.u.Hard.Valid == 1);
 610     *PointerPte = TempPte;
 611 }
 612
 613 //
 614 // Writes an invalid PTE
 615 //
 616 VOID
 617 FORCEINLINE
 618 MI_WRITE_INVALID_PTE(IN PMMPTE PointerPte,
 619                      IN MMPTE InvalidPte)
 620 {
 621     /* Write the invalid PTE */
 622     ASSERT(InvalidPte.u.Hard.Valid == 0);
 623     *PointerPte = InvalidPte;
 624 }
 625
 626 //
 627 // Checks if the thread already owns a working set
 628 //
 629 FORCEINLINE
 630 BOOLEAN
 631 MM_ANY_WS_LOCK_HELD(IN PETHREAD Thread)
 632 {
 633     /* If any of these are held, return TRUE */
 634     return ((Thread->OwnsProcessWorkingSetExclusive) ||
 635             (Thread->OwnsProcessWorkingSetShared) ||
 636             (Thread->OwnsSystemWorkingSetExclusive) ||
 637             (Thread->OwnsSystemWorkingSetShared) ||
 638             (Thread->OwnsSessionWorkingSetExclusive) ||
 639             (Thread->OwnsSessionWorkingSetShared));
 640 }
 641
 642 //
 643 // Checks if the process owns the working set lock
 644 //
 645 FORCEINLINE
 646 BOOLEAN
 647 MI_WS_OWNER(IN PEPROCESS Process)
 648 {
 649     /* Check if this process is the owner, and that the thread owns the WS */
 650     return ((KeGetCurrentThread()->ApcState.Process == &Process->Pcb) &&
 651             ((PsGetCurrentThread()->OwnsProcessWorkingSetExclusive) ||
 652              (PsGetCurrentThread()->OwnsProcessWorkingSetShared)));
 653 }
 654
 655 //
 656 // Locks the working set for the given process
 657 //
 658 FORCEINLINE
 659 VOID
 660 MiLockProcessWorkingSet(IN PEPROCESS Process,
 661                         IN PETHREAD Thread)
 662 {
 663     /* Shouldn't already be owning the process working set */
 664     ASSERT(Thread->OwnsProcessWorkingSetShared == FALSE);
 665     ASSERT(Thread->OwnsProcessWorkingSetExclusive == FALSE);
 666
 667     /* Block APCs, make sure that still nothing is already held */
 668     KeEnterGuardedRegion();
 669     ASSERT(!MM_ANY_WS_LOCK_HELD(Thread));
 670
 671     /* FIXME: Actually lock it (we can't because Vm is used by MAREAs) */
 672
 673     /* FIXME: This also can't be checked because Vm is used by MAREAs) */
 674     //ASSERT(Process->Vm.Flags.AcquiredUnsafe == 0);
 675
 676     /* Okay, now we can own it exclusively */
 677     ASSERT(Thread->OwnsProcessWorkingSetExclusive == FALSE);
 678     Thread->OwnsProcessWorkingSetExclusive = TRUE;
 679 }
 680
 681 //
 682 // Unlocks the working set for the given process
 683 //
 684 FORCEINLINE
 685 VOID
 686 MiUnlockProcessWorkingSet(IN PEPROCESS Process,
 687                           IN PETHREAD Thread)
 688 {
 689     /* Make sure this process really is owner, and it was a safe acquisition */
 690     ASSERT(MI_WS_OWNER(Process));
 691     /* This can't be checked because Vm is used by MAREAs) */
 692     //ASSERT(Process->Vm.Flags.AcquiredUnsafe == 0);
 693
 694     /* The thread doesn't own it anymore */
 695     ASSERT(Thread->OwnsProcessWorkingSetExclusive == TRUE);
 696     Thread->OwnsProcessWorkingSetExclusive = FALSE;
 697
 698     /* FIXME: Actually release it (we can't because Vm is used by MAREAs) */
 699
 700     /* Unblock APCs */
 701     KeLeaveGuardedRegion();
 702 }
 703
 704 //
 705 // Locks the working set
 706 //
 707 FORCEINLINE
 708 VOID
 709 MiLockWorkingSet(IN PETHREAD Thread,
 710                  IN PMMSUPPORT WorkingSet)
 711 {
 712     /* Block APCs */
 713     KeEnterGuardedRegion();
 714
 715     /* Working set should be in global memory */
 716     ASSERT(MI_IS_SESSION_ADDRESS((PVOID)WorkingSet) == FALSE);
 717
 718     /* Thread shouldn't already be owning something */
 719     ASSERT(!MM_ANY_WS_LOCK_HELD(Thread));
 720
 721     /* FIXME: Actually lock it (we can't because Vm is used by MAREAs) */
 722
 723     /* Which working set is this? */
 724     if (WorkingSet == &MmSystemCacheWs)
 725     {
 726         /* Own the system working set */
 727         ASSERT((Thread->OwnsSystemWorkingSetExclusive == FALSE) &&
 728                (Thread->OwnsSystemWorkingSetShared == FALSE));
 729         Thread->OwnsSystemWorkingSetExclusive = TRUE;
 730     }
 731     else if (WorkingSet->Flags.SessionSpace)
 732     {
 733         /* We don't implement this yet */
 734         UNIMPLEMENTED;
 735         while (TRUE);
 736     }
 737     else
 738     {
 739         /* Own the process working set */
 740         ASSERT((Thread->OwnsProcessWorkingSetExclusive == FALSE) &&
 741                (Thread->OwnsProcessWorkingSetShared == FALSE));
 742         Thread->OwnsProcessWorkingSetExclusive = TRUE;
 743     }
 744 }
 745
 746 //
 747 // Unlocks the working set
 748 //
 749 FORCEINLINE
 750 VOID
 751 MiUnlockWorkingSet(IN PETHREAD Thread,
 752                    IN PMMSUPPORT WorkingSet)
 753 {
 754     /* Working set should be in global memory */
 755     ASSERT(MI_IS_SESSION_ADDRESS((PVOID)WorkingSet) == FALSE);
 756
 757     /* Which working set is this? */
 758     if (WorkingSet == &MmSystemCacheWs)
 759     {
 760         /* Release the system working set */
 761         ASSERT((Thread->OwnsSystemWorkingSetExclusive == TRUE) ||
 762                (Thread->OwnsSystemWorkingSetShared == TRUE));
 763         Thread->OwnsSystemWorkingSetExclusive = FALSE;
 764     }
 765     else if (WorkingSet->Flags.SessionSpace)
 766     {
 767         /* We don't implement this yet */
 768         UNIMPLEMENTED;
 769         while (TRUE);
 770     }
 771     else
 772     {
 773         /* Release the process working set */
 774         ASSERT((Thread->OwnsProcessWorkingSetExclusive) ||
 775                (Thread->OwnsProcessWorkingSetShared));
 776         Thread->OwnsProcessWorkingSetExclusive = FALSE;
 777     }
 778
 779     /* FIXME: Actually release it (we can't because Vm is used by MAREAs) */
 780
 781     /* Unblock APCs */
 782     KeLeaveGuardedRegion();
 783 }
 784
 785 NTSTATUS
 786 NTAPI
 787 MmArmInitSystem(
 788     IN ULONG Phase,
 789     IN PLOADER_PARAMETER_BLOCK LoaderBlock
 790 );
 791
 792 NTSTATUS
 793 NTAPI
 794 MiInitMachineDependent(
 795     IN PLOADER_PARAMETER_BLOCK LoaderBlock
 796 );
 797
 798 VOID
 799 NTAPI
 800 MiComputeColorInformation(
 801     VOID
 802 );
 803
 804 VOID
 805 NTAPI
 806 MiMapPfnDatabase(
 807     IN PLOADER_PARAMETER_BLOCK LoaderBlock
 808 );
 809
 810 VOID
 811 NTAPI
 812 MiInitializeColorTables(
 813     VOID
 814 );
 815
 816 VOID
 817 NTAPI
 818 MiInitializePfnDatabase(
 819     IN PLOADER_PARAMETER_BLOCK LoaderBlock
 820 );
 821
 822 BOOLEAN
 823 NTAPI
 824 MiInitializeMemoryEvents(
 825     VOID
 826 );
 827
 828 PFN_NUMBER
 829 NTAPI
 830 MxGetNextPage(
 831     IN PFN_NUMBER PageCount
 832 );
 833
 834 PPHYSICAL_MEMORY_DESCRIPTOR
 835 NTAPI
 836 MmInitializeMemoryLimits(
 837     IN PLOADER_PARAMETER_BLOCK LoaderBlock,
 838     IN PBOOLEAN IncludeType
 839 );
 840
 841 PFN_NUMBER
 842 NTAPI
 843 MiPagesInLoaderBlock(
 844     IN PLOADER_PARAMETER_BLOCK LoaderBlock,
 845     IN PBOOLEAN IncludeType
 846 );
 847
 848 VOID
 849 FASTCALL
 850 MiSyncARM3WithROS(
 851     IN PVOID AddressStart,
 852     IN PVOID AddressEnd
 853 );
 854
 855 NTSTATUS
 856 NTAPI
 857 MmArmAccessFault(
 858     IN BOOLEAN StoreInstruction,
 859     IN PVOID Address,
 860     IN KPROCESSOR_MODE Mode,
 861     IN PVOID TrapInformation
 862 );
 863
 864 NTSTATUS
 865 FASTCALL
 866 MiCheckPdeForPagedPool(
 867     IN PVOID Address
 868 );
 869
 870 VOID
 871 NTAPI
 872 MiInitializeNonPagedPool(
 873     VOID
 874 );
 875
 876 VOID
 877 NTAPI
 878 MiInitializeNonPagedPoolThresholds(
 879     VOID
 880 );
 881
 882 VOID
 883 NTAPI
 884 MiInitializePoolEvents(
 885     VOID
 886 );
 887
 888 VOID                      //
 889 NTAPI                     //
 890 InitializePool(           //
 891     IN POOL_TYPE PoolType,// FIXFIX: This should go in ex.h after the pool merge
 892     IN ULONG Threshold    //
 893 );                        //
 894
 895 VOID
 896 NTAPI
 897 MiInitializeSystemPtes(
 898     IN PMMPTE StartingPte,
 899     IN ULONG NumberOfPtes,
 900     IN MMSYSTEM_PTE_POOL_TYPE PoolType
 901 );
 902
 903 PMMPTE
 904 NTAPI
 905 MiReserveSystemPtes(
 906     IN ULONG NumberOfPtes,
 907     IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType
 908 );
 909
 910 VOID
 911 NTAPI
 912 MiReleaseSystemPtes(
 913     IN PMMPTE StartingPte,
 914     IN ULONG NumberOfPtes,
 915     IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType
 916 );
 917
 918
 919 PFN_NUMBER
 920 NTAPI
 921 MiFindContiguousPages(
 922     IN PFN_NUMBER LowestPfn,
 923     IN PFN_NUMBER HighestPfn,
 924     IN PFN_NUMBER BoundaryPfn,
 925     IN PFN_NUMBER SizeInPages,
 926     IN MEMORY_CACHING_TYPE CacheType
 927 );
 928
 929 PVOID
 930 NTAPI
 931 MiCheckForContiguousMemory(
 932     IN PVOID BaseAddress,
 933     IN PFN_NUMBER BaseAddressPages,
 934     IN PFN_NUMBER SizeInPages,
 935     IN PFN_NUMBER LowestPfn,
 936     IN PFN_NUMBER HighestPfn,
 937     IN PFN_NUMBER BoundaryPfn,
 938     IN MI_PFN_CACHE_ATTRIBUTE CacheAttribute
 939 );
 940
 941 PMDL
 942 NTAPI
 943 MiAllocatePagesForMdl(
 944     IN PHYSICAL_ADDRESS LowAddress,
 945     IN PHYSICAL_ADDRESS HighAddress,
 946     IN PHYSICAL_ADDRESS SkipBytes,
 947     IN SIZE_T TotalBytes,
 948     IN MI_PFN_CACHE_ATTRIBUTE CacheAttribute,
 949     IN ULONG Flags
 950 );
 951
 952 PVOID
 953 NTAPI
 954 MiMapLockedPagesInUserSpace(
 955     IN PMDL Mdl,
 956     IN PVOID BaseVa,
 957     IN MEMORY_CACHING_TYPE CacheType,
 958     IN PVOID BaseAddress
 959 );
 960
 961 VOID
 962 NTAPI
 963 MiUnmapLockedPagesInUserSpace(
 964     IN PVOID BaseAddress,
 965     IN PMDL Mdl
 966 );
 967
 968 VOID
 969 NTAPI
 970 MiInsertInListTail(
 971     IN PMMPFNLIST ListHead,
 972     IN PMMPFN Entry
 973 );
 974
 975 VOID
 976 NTAPI
 977 MiInsertZeroListAtBack(
 978     IN PFN_NUMBER PageIndex
 979 );
 980
 981 VOID
 982 NTAPI
 983 MiUnlinkFreeOrZeroedPage(
 984     IN PMMPFN Entry
 985 );
 986
 987 PMMPFN
 988 NTAPI
 989 MiRemoveHeadList(
 990     IN PMMPFNLIST ListHead
 991 );
 992
 993 PFN_NUMBER
 994 NTAPI
 995 MiAllocatePfn(
 996     IN PMMPTE PointerPte,
 997     IN ULONG Protection
 998 );
 999
1000 VOID
1001 NTAPI
1002 MiInitializePfn(
1003     IN PFN_NUMBER PageFrameIndex,
1004     IN PMMPTE PointerPte,
1005     IN BOOLEAN Modified
1006 );
1007
1008 VOID
1009 NTAPI
1010 MiInitializePfnForOtherProcess(
1011     IN PFN_NUMBER PageFrameIndex,
1012     IN PMMPTE PointerPte,
1013     IN PFN_NUMBER PteFrame
1014 );
1015
1016 VOID
1017 NTAPI
1018 MiDecrementShareCount(
1019     IN PMMPFN Pfn1,
1020     IN PFN_NUMBER PageFrameIndex
1021 );
1022
1023 PFN_NUMBER
1024 NTAPI
1025 MiRemoveAnyPage(
1026     IN ULONG Color
1027 );
1028
1029 PFN_NUMBER
1030 NTAPI
1031 MiRemoveZeroPage(
1032     IN ULONG Color
1033 );
1034
1035 VOID
1036 NTAPI
1037 MiZeroPhysicalPage(
1038     IN PFN_NUMBER PageFrameIndex
1039 );
1040
1041 VOID
1042 NTAPI
1043 MiInsertPageInFreeList(
1044     IN PFN_NUMBER PageFrameIndex
1045 );
1046
1047 PFN_NUMBER
1048 NTAPI
1049 MiDeleteSystemPageableVm(
1050     IN PMMPTE PointerPte,
1051     IN PFN_NUMBER PageCount,
1052     IN ULONG Flags,
1053     OUT PPFN_NUMBER ValidPages
1054 );
1055
1056 PLDR_DATA_TABLE_ENTRY
1057 NTAPI
1058 MiLookupDataTableEntry(
1059     IN PVOID Address
1060 );
1061
1062 VOID
1063 NTAPI
1064 MiInitializeDriverLargePageList(
1065     VOID
1066 );
1067
1068 VOID
1069 NTAPI
1070 MiInitializeLargePageSupport(
1071     VOID
1072 );
1073
1074 VOID
1075 NTAPI
1076 MiSyncCachedRanges(
1077     VOID
1078 );
1079
1080 BOOLEAN
1081 NTAPI
1082 MiIsPfnInUse(
1083     IN PMMPFN Pfn1
1084 );
1085
1086 PMMVAD
1087 NTAPI
1088 MiLocateAddress(
1089     IN PVOID VirtualAddress
1090 );
1091
1092 PMMADDRESS_NODE
1093 NTAPI
1094 MiCheckForConflictingNode(
1095     IN ULONG_PTR StartVpn,
1096     IN ULONG_PTR EndVpn,
1097     IN PMM_AVL_TABLE Table
1098 );
1099
1100 NTSTATUS
1101 NTAPI
1102 MiFindEmptyAddressRangeDownTree(
1103     IN SIZE_T Length,
1104     IN ULONG_PTR BoundaryAddress,
1105     IN ULONG_PTR Alignment,
1106     IN PMM_AVL_TABLE Table,
1107     OUT PULONG_PTR Base
1108 );
1109
1110 VOID
1111 NTAPI
1112 MiInsertNode(
1113     IN PMMADDRESS_NODE NewNode,
1114     IN PMM_AVL_TABLE Table
1115 );
1116
1117 VOID
1118 NTAPI
1119 MiRemoveNode(
1120     IN PMMADDRESS_NODE Node,
1121     IN PMM_AVL_TABLE Table
1122 );
1123
1124 /* EOF */