2 * PROJECT: ReactOS Kernel
3 * LICENSE: BSD - See COPYING.ARM in the top level directory
4 * FILE: ntoskrnl/mm/ARM3/i386/init.c
5 * PURPOSE: ARM Memory Manager Initialization for x86
6 * PROGRAMMERS: ReactOS Portable Systems Group
9 /* INCLUDES *******************************************************************/
16 #define MODULE_INVOLVED_IN_ARM3
17 #include "../../ARM3/miarm.h"
19 /* GLOBALS ********************************************************************/
22 // These are all registry-configurable, but by default, the memory manager will
23 // figure out the most appropriate values.
25 ULONG MmMaximumNonPagedPoolPercent
;
26 ULONG MmSizeOfNonPagedPoolInBytes
;
27 ULONG MmMaximumNonPagedPoolInBytes
;
30 // These numbers describe the discrete equation components of the nonpaged
31 // pool sizing algorithm.
33 // They are described on http://support.microsoft.com/default.aspx/kb/126402/ja
34 // along with the algorithm that uses them, which is implemented later below.
36 ULONG MmMinimumNonPagedPoolSize
= 256 * 1024;
37 ULONG MmMinAdditionNonPagedPoolPerMb
= 32 * 1024;
38 ULONG MmDefaultMaximumNonPagedPool
= 1024 * 1024;
39 ULONG MmMaxAdditionNonPagedPoolPerMb
= 400 * 1024;
42 // The memory layout (and especially variable names) of the NT kernel mode
43 // components can be a bit hard to twig, especially when it comes to the non
46 // There are really two components to the non-paged pool:
48 // - The initial nonpaged pool, sized dynamically up to a maximum.
49 // - The expansion nonpaged pool, sized dynamically up to a maximum.
51 // The initial nonpaged pool is physically continuous for performance, and
52 // immediately follows the PFN database, typically sharing the same PDE. It is
53 // a very small resource (32MB on a 1GB system), and capped at 128MB.
55 // Right now we call this the "ARM³ Nonpaged Pool" and it begins somewhere after
56 // the PFN database (which starts at 0xB0000000).
58 // The expansion nonpaged pool, on the other hand, can grow much bigger (400MB
59 // for a 1GB system). On ARM³ however, it is currently capped at 128MB.
61 // The address where the initial nonpaged pool starts is aptly named
62 // MmNonPagedPoolStart, and it describes a range of MmSizeOfNonPagedPoolInBytes
65 // Expansion nonpaged pool starts at an address described by the variable called
66 // MmNonPagedPoolExpansionStart, and it goes on for MmMaximumNonPagedPoolInBytes
67 // minus MmSizeOfNonPagedPoolInBytes bytes, always reaching MmNonPagedPoolEnd
68 // (because of the way it's calculated) at 0xFFBE0000.
70 // Initial nonpaged pool is allocated and mapped early-on during boot, but what
71 // about the expansion nonpaged pool? It is instead composed of special pages
72 // which belong to what are called System PTEs. These PTEs are the matter of a
73 // later discussion, but they are also considered part of the "nonpaged" OS, due
74 // to the fact that they are never paged out -- once an address is described by
75 // a System PTE, it is always valid, until the System PTE is torn down.
77 // System PTEs are actually composed of two "spaces", the system space proper,
78 // and the nonpaged pool expansion space. The latter, as we've already seen,
79 // begins at MmNonPagedPoolExpansionStart. Based on the number of System PTEs
80 // that the system will support, the remaining address space below this address
81 // is used to hold the system space PTEs. This address, in turn, is held in the
82 // variable named MmNonPagedSystemStart, which itself is never allowed to go
83 // below 0xEB000000 (thus creating an upper bound on the number of System PTEs).
85 // This means that 330MB are reserved for total nonpaged system VA, on top of
86 // whatever the initial nonpaged pool allocation is.
88 // The following URLs, valid as of April 23rd, 2008, support this evidence:
90 // http://www.cs.miami.edu/~burt/journal/NT/memory.html
91 // http://www.ditii.com/2007/09/28/windows-memory-management-x86-virtual-address-space/
93 PVOID MmNonPagedSystemStart
;
94 PVOID MmNonPagedPoolStart
;
95 PVOID MmNonPagedPoolExpansionStart
;
96 PVOID MmNonPagedPoolEnd
= MI_NONPAGED_POOL_END
;
99 // Old ReactOS Mm nonpaged pool
101 extern PVOID MiNonPagedPoolStart
;
102 extern ULONG MiNonPagedPoolLength
;
105 // This is where paged pool starts by default
107 PVOID MmPagedPoolStart
= MI_PAGED_POOL_START
;
108 PVOID MmPagedPoolEnd
;
111 // And this is its default size
113 ULONG MmSizeOfPagedPoolInBytes
= MI_MIN_INIT_PAGED_POOLSIZE
;
114 PFN_NUMBER MmSizeOfPagedPoolInPages
= MI_MIN_INIT_PAGED_POOLSIZE
/ PAGE_SIZE
;
117 // Session space starts at 0xBFFFFFFF and grows downwards
118 // By default, it includes an 8MB image area where we map win32k and video card
119 // drivers, followed by a 4MB area containing the session's working set. This is
120 // then followed by a 20MB mapped view area and finally by the session's paged
121 // pool, by default 16MB.
123 // On a normal system, this results in session space occupying the region from
124 // 0xBD000000 to 0xC0000000
126 // See miarm.h for the defines that determine the sizing of this region. On an
127 // NT system, some of these can be configured through the registry, but we don't
130 PVOID MiSessionSpaceEnd
; // 0xC0000000
131 PVOID MiSessionImageEnd
; // 0xC0000000
132 PVOID MiSessionImageStart
; // 0xBF800000
133 PVOID MiSessionViewStart
; // 0xBE000000
134 PVOID MiSessionPoolEnd
; // 0xBE000000
135 PVOID MiSessionPoolStart
; // 0xBD000000
136 PVOID MmSessionBase
; // 0xBD000000
138 ULONG MmSessionViewSize
;
139 ULONG MmSessionPoolSize
;
140 ULONG MmSessionImageSize
;
143 // The system view space, on the other hand, is where sections that are memory
144 // mapped into "system space" end up.
146 // By default, it is a 16MB region.
148 PVOID MiSystemViewStart
;
149 ULONG MmSystemViewSize
;
152 // A copy of the system page directory (the page directory associated with the
153 // System process) is kept (double-mapped) by the manager in order to lazily
154 // map paged pool PDEs into external processes when they fault on a paged pool
157 PFN_NUMBER MmSystemPageDirectory
;
158 PMMPTE MmSystemPagePtes
;
161 // Windows NT seems to choose between 7000, 11000 and 50000
162 // On systems with more than 32MB, this number is then doubled, and further
163 // aligned up to a PDE boundary (4MB).
165 ULONG MmNumberOfSystemPtes
;
168 // This is how many pages the PFN database will take up
169 // In Windows, this includes the Quark Color Table, but not in ARM³
171 ULONG MxPfnAllocation
;
174 // Unlike the old ReactOS Memory Manager, ARM³ (and Windows) does not keep track
175 // of pages that are not actually valid physical memory, such as ACPI reserved
176 // regions, BIOS address ranges, or holes in physical memory address space which
177 // could indicate device-mapped I/O memory.
179 // In fact, the lack of a PFN entry for a page usually indicates that this is
180 // I/O space instead.
182 // A bitmap, called the PFN bitmap, keeps track of all page frames by assigning
183 // a bit to each. If the bit is set, then the page is valid physical RAM.
185 RTL_BITMAP MiPfnBitMap
;
188 // This structure describes the different pieces of RAM-backed address space
190 PPHYSICAL_MEMORY_DESCRIPTOR MmPhysicalMemoryBlock
;
193 // Before we have a PFN database, memory comes straight from our physical memory
194 // blocks, which is nice because it's guaranteed contiguous and also because once
195 // we take a page from here, the system doesn't see it anymore.
196 // However, once the fun is over, those pages must be re-integrated back into
197 // PFN society life, and that requires us keeping a copy of the original layout
198 // so that we can parse it later.
200 PMEMORY_ALLOCATION_DESCRIPTOR MxFreeDescriptor
;
201 MEMORY_ALLOCATION_DESCRIPTOR MxOldFreeDescriptor
;
204 // This is where we keep track of the most basic physical layout markers
206 ULONG MmNumberOfPhysicalPages
, MmHighestPhysicalPage
, MmLowestPhysicalPage
= -1;
209 // The total number of pages mapped by the boot loader, which include the kernel
210 // HAL, boot drivers, registry, NLS files and other loader data structures is
211 // kept track of here. This depends on "LoaderPagesSpanned" being correct when
212 // coming from the loader.
214 // This number is later aligned up to a PDE boundary.
216 ULONG MmBootImageSize
;
219 // These three variables keep track of the core separation of address space that
220 // exists between kernel mode and user mode.
222 ULONG MmUserProbeAddress
;
223 PVOID MmHighestUserAddress
;
224 PVOID MmSystemRangeStart
;
226 /* PRIVATE FUNCTIONS **********************************************************/
229 // In Bavaria, this is probably a hate crime
233 MiSyncARM3WithROS(IN PVOID AddressStart
,
237 // Puerile piece of junk-grade carbonized horseshit puss sold to the lowest bidder
239 ULONG Pde
= ADDR_TO_PDE_OFFSET(AddressStart
);
240 while (Pde
<= ADDR_TO_PDE_OFFSET(AddressEnd
))
243 // This both odious and heinous
245 extern ULONG MmGlobalKernelPageDirectory
[1024];
246 MmGlobalKernelPageDirectory
[Pde
] = ((PULONG
)PDE_BASE
)[Pde
];
253 MxGetNextPage(IN PFN_NUMBER PageCount
)
258 // Make sure we have enough pages
260 if (PageCount
> MxFreeDescriptor
->PageCount
)
265 KeBugCheckEx(INSTALL_MORE_MEMORY
,
266 MmNumberOfPhysicalPages
,
267 MxFreeDescriptor
->PageCount
,
268 MxOldFreeDescriptor
.PageCount
,
273 // Use our lowest usable free pages
275 Pfn
= MxFreeDescriptor
->BasePage
;
276 MxFreeDescriptor
->BasePage
+= PageCount
;
277 MxFreeDescriptor
->PageCount
-= PageCount
;
281 PPHYSICAL_MEMORY_DESCRIPTOR
283 MmInitializeMemoryLimits(IN PLOADER_PARAMETER_BLOCK LoaderBlock
,
284 IN PBOOLEAN IncludeType
)
286 PLIST_ENTRY NextEntry
;
287 ULONG Run
= 0, InitialRuns
= 0;
288 PFN_NUMBER NextPage
= -1, PageCount
= 0;
289 PPHYSICAL_MEMORY_DESCRIPTOR Buffer
, NewBuffer
;
290 PMEMORY_ALLOCATION_DESCRIPTOR MdBlock
;
293 // Scan the memory descriptors
295 NextEntry
= LoaderBlock
->MemoryDescriptorListHead
.Flink
;
296 while (NextEntry
!= &LoaderBlock
->MemoryDescriptorListHead
)
299 // For each one, increase the memory allocation estimate
302 NextEntry
= NextEntry
->Flink
;
306 // Allocate the maximum we'll ever need
308 Buffer
= ExAllocatePoolWithTag(NonPagedPool
,
309 sizeof(PHYSICAL_MEMORY_DESCRIPTOR
) +
310 sizeof(PHYSICAL_MEMORY_RUN
) *
313 if (!Buffer
) return NULL
;
316 // For now that's how many runs we have
318 Buffer
->NumberOfRuns
= InitialRuns
;
321 // Now loop through the descriptors again
323 NextEntry
= LoaderBlock
->MemoryDescriptorListHead
.Flink
;
324 while (NextEntry
!= &LoaderBlock
->MemoryDescriptorListHead
)
327 // Grab each one, and check if it's one we should include
329 MdBlock
= CONTAINING_RECORD(NextEntry
,
330 MEMORY_ALLOCATION_DESCRIPTOR
,
332 if ((MdBlock
->MemoryType
< LoaderMaximum
) &&
333 (IncludeType
[MdBlock
->MemoryType
]))
336 // Add this to our running total
338 PageCount
+= MdBlock
->PageCount
;
341 // Check if the next page is described by the next descriptor
343 if (MdBlock
->BasePage
== NextPage
)
346 // Combine it into the same physical run
348 ASSERT(MdBlock
->PageCount
!= 0);
349 Buffer
->Run
[Run
- 1].PageCount
+= MdBlock
->PageCount
;
350 NextPage
+= MdBlock
->PageCount
;
355 // Otherwise just duplicate the descriptor's contents
357 Buffer
->Run
[Run
].BasePage
= MdBlock
->BasePage
;
358 Buffer
->Run
[Run
].PageCount
= MdBlock
->PageCount
;
359 NextPage
= Buffer
->Run
[Run
].BasePage
+ Buffer
->Run
[Run
].PageCount
;
362 // And in this case, increase the number of runs
369 // Try the next descriptor
371 NextEntry
= MdBlock
->ListEntry
.Flink
;
375 // We should not have been able to go past our initial estimate
377 ASSERT(Run
<= Buffer
->NumberOfRuns
);
380 // Our guess was probably exaggerated...
382 if (InitialRuns
> Run
)
385 // Allocate a more accurately sized buffer
387 NewBuffer
= ExAllocatePoolWithTag(NonPagedPool
,
388 sizeof(PHYSICAL_MEMORY_DESCRIPTOR
) +
389 sizeof(PHYSICAL_MEMORY_RUN
) *
395 // Copy the old buffer into the new, then free it
397 RtlCopyMemory(NewBuffer
->Run
,
399 sizeof(PHYSICAL_MEMORY_RUN
) * Run
);
403 // Now use the new buffer
410 // Write the final numbers, and return it
412 Buffer
->NumberOfRuns
= Run
;
413 Buffer
->NumberOfPages
= PageCount
;
419 MiBuildPagedPool(VOID
)
421 PMMPTE PointerPte
, PointerPde
;
422 MMPTE TempPte
= HyperTemplatePte
;
423 PFN_NUMBER PageFrameIndex
;
425 ULONG Size
, BitMapSize
;
428 // Get the page frame number for the system page directory
430 PointerPte
= MiAddressToPte(PDE_BASE
);
431 MmSystemPageDirectory
= PFN_FROM_PTE(PointerPte
);
434 // Allocate a system PTE which will hold a copy of the page directory
436 PointerPte
= MiReserveSystemPtes(1, SystemPteSpace
);
438 MmSystemPagePtes
= MiPteToAddress(PointerPte
);
441 // Make this system PTE point to the system page directory.
442 // It is now essentially double-mapped. This will be used later for lazy
443 // evaluation of PDEs accross process switches, similarly to how the Global
444 // page directory array in the old ReactOS Mm is used (but in a less hacky
447 TempPte
= HyperTemplatePte
;
448 TempPte
.u
.Hard
.PageFrameNumber
= MmSystemPageDirectory
;
449 ASSERT(PointerPte
->u
.Hard
.Valid
== 0);
450 ASSERT(TempPte
.u
.Hard
.Valid
== 1);
451 *PointerPte
= TempPte
;
454 // Let's get back to paged pool work: size it up.
455 // By default, it should be twice as big as nonpaged pool.
457 MmSizeOfPagedPoolInBytes
= 2 * MmMaximumNonPagedPoolInBytes
;
458 if (MmSizeOfPagedPoolInBytes
> ((ULONG_PTR
)MmNonPagedSystemStart
-
459 (ULONG_PTR
)MmPagedPoolStart
))
462 // On the other hand, we have limited VA space, so make sure that the VA
463 // for paged pool doesn't overflow into nonpaged pool VA. Otherwise, set
464 // whatever maximum is possible.
466 MmSizeOfPagedPoolInBytes
= (ULONG_PTR
)MmNonPagedSystemStart
-
467 (ULONG_PTR
)MmPagedPoolStart
;
471 // Get the size in pages and make sure paged pool is at least 32MB.
473 Size
= MmSizeOfPagedPoolInBytes
;
474 if (Size
< MI_MIN_INIT_PAGED_POOLSIZE
) Size
= MI_MIN_INIT_PAGED_POOLSIZE
;
475 Size
= BYTES_TO_PAGES(Size
);
478 // Now check how many PTEs will be required for these many pages.
480 Size
= (Size
+ (1024 - 1)) / 1024;
483 // Recompute the page-aligned size of the paged pool, in bytes and pages.
485 MmSizeOfPagedPoolInBytes
= Size
* PAGE_SIZE
* 1024;
486 MmSizeOfPagedPoolInPages
= MmSizeOfPagedPoolInBytes
>> PAGE_SHIFT
;
489 // Let's be really sure this doesn't overflow into nonpaged system VA
491 ASSERT((MmSizeOfPagedPoolInBytes
+ (ULONG_PTR
)MmPagedPoolStart
) <=
492 (ULONG_PTR
)MmNonPagedSystemStart
);
495 // This is where paged pool ends
497 MmPagedPoolEnd
= (PVOID
)(((ULONG_PTR
)MmPagedPoolStart
+
498 MmSizeOfPagedPoolInBytes
) - 1);
501 // So now get the PDE for paged pool and zero it out
503 PointerPde
= MiAddressToPde(MmPagedPoolStart
);
504 RtlZeroMemory(PointerPde
,
505 (1 + MiAddressToPde(MmPagedPoolEnd
) - PointerPde
) * sizeof(MMPTE
));
508 // Next, get the first and last PTE
510 PointerPte
= MiAddressToPte(MmPagedPoolStart
);
511 MmPagedPoolInfo
.FirstPteForPagedPool
= PointerPte
;
512 MmPagedPoolInfo
.LastPteForPagedPool
= MiAddressToPte(MmPagedPoolEnd
);
515 // Lock the PFN database
517 OldIrql
= KeAcquireQueuedSpinLock(LockQueuePfnLock
);
520 // Allocate a page and map the first paged pool PDE
522 PageFrameIndex
= MmAllocPage(MC_NPPOOL
, 0);
523 TempPte
.u
.Hard
.PageFrameNumber
= PageFrameIndex
;
524 ASSERT(PointerPde
->u
.Hard
.Valid
== 0);
525 ASSERT(TempPte
.u
.Hard
.Valid
== 1);
526 *PointerPde
= TempPte
;
529 // Release the PFN database lock
531 KeReleaseQueuedSpinLock(LockQueuePfnLock
, OldIrql
);
534 // We only have one PDE mapped for now... at fault time, additional PDEs
535 // will be allocated to handle paged pool growth. This is where they'll have
538 MmPagedPoolInfo
.NextPdeForPagedPoolExpansion
= PointerPde
+ 1;
541 // We keep track of each page via a bit, so check how big the bitmap will
542 // have to be (make sure to align our page count such that it fits nicely
543 // into a 4-byte aligned bitmap.
545 // We'll also allocate the bitmap header itself part of the same buffer.
548 ASSERT(Size
== MmSizeOfPagedPoolInPages
);
549 BitMapSize
= sizeof(RTL_BITMAP
) + (((Size
+ 31) / 32) * sizeof(ULONG
));
552 // Allocate the allocation bitmap, which tells us which regions have not yet
553 // been mapped into memory
555 MmPagedPoolInfo
.PagedPoolAllocationMap
= ExAllocatePoolWithTag(NonPagedPool
,
558 ASSERT(MmPagedPoolInfo
.PagedPoolAllocationMap
);
561 // Initialize it such that at first, only the first page's worth of PTEs is
562 // marked as allocated (incidentially, the first PDE we allocated earlier).
564 RtlInitializeBitMap(MmPagedPoolInfo
.PagedPoolAllocationMap
,
565 (PULONG
)(MmPagedPoolInfo
.PagedPoolAllocationMap
+ 1),
567 RtlSetAllBits(MmPagedPoolInfo
.PagedPoolAllocationMap
);
568 RtlClearBits(MmPagedPoolInfo
.PagedPoolAllocationMap
, 0, 1024);
571 // We have a second bitmap, which keeps track of where allocations end.
572 // Given the allocation bitmap and a base address, we can therefore figure
573 // out which page is the last page of that allocation, and thus how big the
574 // entire allocation is.
576 MmPagedPoolInfo
.EndOfPagedPoolBitmap
= ExAllocatePoolWithTag(NonPagedPool
,
579 ASSERT(MmPagedPoolInfo
.EndOfPagedPoolBitmap
);
580 RtlInitializeBitMap(MmPagedPoolInfo
.EndOfPagedPoolBitmap
,
581 (PULONG
)(MmPagedPoolInfo
.EndOfPagedPoolBitmap
+ 1),
585 // Since no allocations have been made yet, there are no bits set as the end
587 RtlClearAllBits(MmPagedPoolInfo
.EndOfPagedPoolBitmap
);
590 // Initialize paged pool.
592 //InitializePool(PagedPool, 0);
597 MmArmInitSystem(IN ULONG Phase
,
598 IN PLOADER_PARAMETER_BLOCK LoaderBlock
)
600 PLIST_ENTRY NextEntry
;
601 PMEMORY_ALLOCATION_DESCRIPTOR MdBlock
;
604 PHYSICAL_ADDRESS BoundaryAddressMultiple
;
605 PFN_NUMBER PageFrameIndex
;
606 PMMPTE StartPde
, EndPde
, PointerPte
, LastPte
;
607 MMPTE TempPde
= HyperTemplatePte
, TempPte
= HyperTemplatePte
;
608 PVOID NonPagedPoolExpansionVa
, BaseAddress
;
611 BOOLEAN IncludeType
[LoaderMaximum
];
614 PPHYSICAL_MEMORY_RUN Run
;
615 PFN_NUMBER FreePage
, FreePageCount
, PagesLeft
, BasePage
, PageCount
;
616 BoundaryAddressMultiple
.QuadPart
= 0;
621 // Define the basic user vs. kernel address space separation
623 MmSystemRangeStart
= (PVOID
)KSEG0_BASE
;
624 MmUserProbeAddress
= (ULONG_PTR
)MmSystemRangeStart
- 0x10000;
625 MmHighestUserAddress
= (PVOID
)(MmUserProbeAddress
- 1);
628 // Get the size of the boot loader's image allocations and then round
629 // that region up to a PDE size, so that any PDEs we might create for
630 // whatever follows are separate from the PDEs that boot loader might've
631 // already created (and later, we can blow all that away if we want to).
633 MmBootImageSize
= KeLoaderBlock
->Extension
->LoaderPagesSpanned
;
634 MmBootImageSize
*= PAGE_SIZE
;
635 MmBootImageSize
= (MmBootImageSize
+ (4 * 1024 * 1024) - 1) & ~((4 * 1024 * 1024) - 1);
636 ASSERT((MmBootImageSize
% (4 * 1024 * 1024)) == 0);
639 // Set the size of session view, pool, and image
641 MmSessionSize
= MI_SESSION_SIZE
;
642 MmSessionViewSize
= MI_SESSION_VIEW_SIZE
;
643 MmSessionPoolSize
= MI_SESSION_POOL_SIZE
;
644 MmSessionImageSize
= MI_SESSION_IMAGE_SIZE
;
647 // Set the size of system view
649 MmSystemViewSize
= MI_SYSTEM_VIEW_SIZE
;
652 // This is where it all ends
654 MiSessionImageEnd
= (PVOID
)PTE_BASE
;
657 // This is where we will load Win32k.sys and the video driver
659 MiSessionImageStart
= (PVOID
)((ULONG_PTR
)MiSessionImageEnd
-
663 // So the view starts right below the session working set (itself below
666 MiSessionViewStart
= (PVOID
)((ULONG_PTR
)MiSessionImageEnd
-
668 MI_SESSION_WORKING_SET_SIZE
-
672 // Session pool follows
674 MiSessionPoolEnd
= MiSessionViewStart
;
675 MiSessionPoolStart
= (PVOID
)((ULONG_PTR
)MiSessionPoolEnd
-
679 // And it all begins here
681 MmSessionBase
= MiSessionPoolStart
;
684 // Sanity check that our math is correct
686 ASSERT((ULONG_PTR
)MmSessionBase
+ MmSessionSize
== PTE_BASE
);
689 // Session space ends wherever image session space ends
691 MiSessionSpaceEnd
= MiSessionImageEnd
;
694 // System view space ends at session space, so now that we know where
695 // this is, we can compute the base address of system view space itself.
697 MiSystemViewStart
= (PVOID
)((ULONG_PTR
)MmSessionBase
-
701 // Set CR3 for the system process
703 PointerPte
= MiAddressToPde(PTE_BASE
);
704 PageFrameIndex
= PFN_FROM_PTE(PointerPte
) << PAGE_SHIFT
;
705 PsGetCurrentProcess()->Pcb
.DirectoryTableBase
[0] = PageFrameIndex
;
708 // Blow away user-mode
710 StartPde
= MiAddressToPde(0);
711 EndPde
= MiAddressToPde(KSEG0_BASE
);
712 RtlZeroMemory(StartPde
, (EndPde
- StartPde
) * sizeof(MMPTE
));
715 // Loop the memory descriptors
717 NextEntry
= LoaderBlock
->MemoryDescriptorListHead
.Flink
;
718 while (NextEntry
!= &LoaderBlock
->MemoryDescriptorListHead
)
721 // Get the memory block
723 MdBlock
= CONTAINING_RECORD(NextEntry
,
724 MEMORY_ALLOCATION_DESCRIPTOR
,
728 // Skip invisible memory
730 if ((MdBlock
->MemoryType
!= LoaderFirmwarePermanent
) &&
731 (MdBlock
->MemoryType
!= LoaderSpecialMemory
) &&
732 (MdBlock
->MemoryType
!= LoaderHALCachedMemory
) &&
733 (MdBlock
->MemoryType
!= LoaderBBTMemory
))
736 // Check if BURNMEM was used
738 if (MdBlock
->MemoryType
!= LoaderBad
)
741 // Count this in the total of pages
743 MmNumberOfPhysicalPages
+= MdBlock
->PageCount
;
747 // Check if this is the new lowest page
749 if (MdBlock
->BasePage
< MmLowestPhysicalPage
)
752 // Update the lowest page
754 MmLowestPhysicalPage
= MdBlock
->BasePage
;
758 // Check if this is the new highest page
760 PageFrameIndex
= MdBlock
->BasePage
+ MdBlock
->PageCount
;
761 if (PageFrameIndex
> MmHighestPhysicalPage
)
764 // Update the highest page
766 MmHighestPhysicalPage
= PageFrameIndex
- 1;
770 // Check if this is free memory
772 if ((MdBlock
->MemoryType
== LoaderFree
) ||
773 (MdBlock
->MemoryType
== LoaderLoadedProgram
) ||
774 (MdBlock
->MemoryType
== LoaderFirmwareTemporary
) ||
775 (MdBlock
->MemoryType
== LoaderOsloaderStack
))
778 // Check if this is the largest memory descriptor
780 if (MdBlock
->PageCount
> FreePages
)
785 FreePages
= MdBlock
->PageCount
;
786 MxFreeDescriptor
= MdBlock
;
794 NextEntry
= MdBlock
->ListEntry
.Flink
;
798 // Save original values of the free descriptor, since it'll be
799 // altered by early allocations
801 MxOldFreeDescriptor
= *MxFreeDescriptor
;
804 // Check if this is a machine with less than 19MB of RAM
806 if (MmNumberOfPhysicalPages
< MI_MIN_PAGES_FOR_SYSPTE_TUNING
)
809 // Use the very minimum of system PTEs
811 MmNumberOfSystemPtes
= 7000;
816 // Use the default, but check if we have more than 32MB of RAM
818 MmNumberOfSystemPtes
= 11000;
819 if (MmNumberOfPhysicalPages
> MI_MIN_PAGES_FOR_SYSPTE_BOOST
)
822 // Double the amount of system PTEs
824 MmNumberOfSystemPtes
<<= 1;
828 DPRINT("System PTE count has been tuned to %d (%d bytes)\n",
829 MmNumberOfSystemPtes
, MmNumberOfSystemPtes
* PAGE_SIZE
);
832 // Check if this is a machine with less than 256MB of RAM, and no overide
834 if ((MmNumberOfPhysicalPages
<= MI_MIN_PAGES_FOR_NONPAGED_POOL_TUNING
) &&
835 !(MmSizeOfNonPagedPoolInBytes
))
838 // Force the non paged pool to be 2MB so we can reduce RAM usage
840 MmSizeOfNonPagedPoolInBytes
= 2 * 1024 * 1024;
844 // Check if the user gave a ridicuously large nonpaged pool RAM size
846 if ((MmSizeOfNonPagedPoolInBytes
>> PAGE_SHIFT
) >
847 (MmNumberOfPhysicalPages
* 7 / 8))
850 // More than 7/8ths of RAM was dedicated to nonpaged pool, ignore!
852 MmSizeOfNonPagedPoolInBytes
= 0;
856 // Check if no registry setting was set, or if the setting was too low
858 if (MmSizeOfNonPagedPoolInBytes
< MmMinimumNonPagedPoolSize
)
861 // Start with the minimum (256 KB) and add 32 KB for each MB above 4
863 MmSizeOfNonPagedPoolInBytes
= MmMinimumNonPagedPoolSize
;
864 MmSizeOfNonPagedPoolInBytes
+= (MmNumberOfPhysicalPages
- 1024) /
865 256 * MmMinAdditionNonPagedPoolPerMb
;
869 // Check if the registy setting or our dynamic calculation was too high
871 if (MmSizeOfNonPagedPoolInBytes
> MI_MAX_INIT_NONPAGED_POOL_SIZE
)
874 // Set it to the maximum
876 MmSizeOfNonPagedPoolInBytes
= MI_MAX_INIT_NONPAGED_POOL_SIZE
;
880 // Check if a percentage cap was set through the registry
882 if (MmMaximumNonPagedPoolPercent
)
885 // Don't feel like supporting this right now
891 // Page-align the nonpaged pool size
893 MmSizeOfNonPagedPoolInBytes
&= ~(PAGE_SIZE
- 1);
896 // Now, check if there was a registry size for the maximum size
898 if (!MmMaximumNonPagedPoolInBytes
)
901 // Start with the default (1MB) and add 400 KB for each MB above 4
903 MmMaximumNonPagedPoolInBytes
= MmDefaultMaximumNonPagedPool
;
904 MmMaximumNonPagedPoolInBytes
+= (MmNumberOfPhysicalPages
- 1024) /
905 256 * MmMaxAdditionNonPagedPoolPerMb
;
909 // Don't let the maximum go too high
911 if (MmMaximumNonPagedPoolInBytes
> MI_MAX_NONPAGED_POOL_SIZE
)
914 // Set it to the upper limit
916 MmMaximumNonPagedPoolInBytes
= MI_MAX_NONPAGED_POOL_SIZE
;
920 // Calculate the number of bytes, and then convert to pages
922 MxPfnAllocation
= (MmHighestPhysicalPage
+ 1) * sizeof(MMPFN
);
923 MxPfnAllocation
>>= PAGE_SHIFT
;
926 // We have to add one to the count here, because in the process of
927 // shifting down to the page size, we actually ended up getting the
928 // lower aligned size (so say, 0x5FFFF bytes is now 0x5F pages).
929 // Later on, we'll shift this number back into bytes, which would cause
930 // us to end up with only 0x5F000 bytes -- when we actually want to have
936 // Now calculate the nonpaged pool expansion VA region
938 MmNonPagedPoolStart
= (PVOID
)((ULONG_PTR
)MmNonPagedPoolEnd
-
939 MmMaximumNonPagedPoolInBytes
+
940 MmSizeOfNonPagedPoolInBytes
);
941 MmNonPagedPoolStart
= (PVOID
)PAGE_ALIGN(MmNonPagedPoolStart
);
942 NonPagedPoolExpansionVa
= MmNonPagedPoolStart
;
943 DPRINT("NP Pool has been tuned to: %d bytes and %d bytes\n",
944 MmSizeOfNonPagedPoolInBytes
, MmMaximumNonPagedPoolInBytes
);
947 // Now calculate the nonpaged system VA region, which includes the
948 // nonpaged pool expansion (above) and the system PTEs. Note that it is
949 // then aligned to a PDE boundary (4MB).
951 MmNonPagedSystemStart
= (PVOID
)((ULONG_PTR
)MmNonPagedPoolStart
-
952 (MmNumberOfSystemPtes
+ 1) * PAGE_SIZE
);
953 MmNonPagedSystemStart
= (PVOID
)((ULONG_PTR
)MmNonPagedSystemStart
&
954 ~((4 * 1024 * 1024) - 1));
957 // Don't let it go below the minimum
959 if (MmNonPagedSystemStart
< (PVOID
)0xEB000000)
962 // This is a hard-coded limit in the Windows NT address space
964 MmNonPagedSystemStart
= (PVOID
)0xEB000000;
967 // Reduce the amount of system PTEs to reach this point
969 MmNumberOfSystemPtes
= ((ULONG_PTR
)MmNonPagedPoolStart
-
970 (ULONG_PTR
)MmNonPagedSystemStart
) >>
972 MmNumberOfSystemPtes
--;
973 ASSERT(MmNumberOfSystemPtes
> 1000);
977 // Normally, the PFN database should start after the loader images.
978 // This is already the case in ReactOS, but for now we want to co-exist
979 // with the old memory manager, so we'll create a "Shadow PFN Database"
980 // instead, and arbitrarly start it at 0xB0000000.
982 MmPfnDatabase
= (PVOID
)0xB0000000;
983 ASSERT(((ULONG_PTR
)MmPfnDatabase
& ((4 * 1024 * 1024) - 1)) == 0);
986 // Non paged pool comes after the PFN database
988 MmNonPagedPoolStart
= (PVOID
)((ULONG_PTR
)MmPfnDatabase
+
989 (MxPfnAllocation
<< PAGE_SHIFT
));
992 // Now we actually need to get these many physical pages. Nonpaged pool
993 // is actually also physically contiguous (but not the expansion)
995 PageFrameIndex
= MxGetNextPage(MxPfnAllocation
+
996 (MmSizeOfNonPagedPoolInBytes
>> PAGE_SHIFT
));
997 ASSERT(PageFrameIndex
!= 0);
998 DPRINT("PFN DB PA PFN begins at: %lx\n", PageFrameIndex
);
999 DPRINT("NP PA PFN begins at: %lx\n", PageFrameIndex
+ MxPfnAllocation
);
1002 // Now we need some pages to create the page tables for the NP system VA
1003 // which includes system PTEs and expansion NP
1005 StartPde
= MiAddressToPde(MmNonPagedSystemStart
);
1006 EndPde
= MiAddressToPde((PVOID
)((ULONG_PTR
)MmNonPagedPoolEnd
- 1));
1007 while (StartPde
<= EndPde
)
1012 ASSERT(StartPde
->u
.Hard
.Valid
== 0);
1017 TempPde
.u
.Hard
.PageFrameNumber
= MxGetNextPage(1);
1018 ASSERT(TempPde
.u
.Hard
.Valid
== 1);
1019 *StartPde
= TempPde
;
1022 // Zero out the page table
1024 PointerPte
= MiPteToAddress(StartPde
);
1025 RtlZeroMemory(PointerPte
, PAGE_SIZE
);
1034 // Now we need pages for the page tables which will map initial NP
1036 StartPde
= MiAddressToPde(MmPfnDatabase
);
1037 EndPde
= MiAddressToPde((PVOID
)((ULONG_PTR
)MmNonPagedPoolStart
+
1038 MmSizeOfNonPagedPoolInBytes
- 1));
1039 while (StartPde
<= EndPde
)
1044 ASSERT(StartPde
->u
.Hard
.Valid
== 0);
1049 TempPde
.u
.Hard
.PageFrameNumber
= MxGetNextPage(1);
1050 ASSERT(TempPde
.u
.Hard
.Valid
== 1);
1051 *StartPde
= TempPde
;
1054 // Zero out the page table
1056 PointerPte
= MiPteToAddress(StartPde
);
1057 RtlZeroMemory(PointerPte
, PAGE_SIZE
);
1066 // Now remember where the expansion starts
1068 MmNonPagedPoolExpansionStart
= NonPagedPoolExpansionVa
;
1071 // Last step is to actually map the nonpaged pool
1073 PointerPte
= MiAddressToPte(MmNonPagedPoolStart
);
1074 LastPte
= MiAddressToPte((PVOID
)((ULONG_PTR
)MmNonPagedPoolStart
+
1075 MmSizeOfNonPagedPoolInBytes
- 1));
1076 while (PointerPte
<= LastPte
)
1079 // Use one of our contigous pages
1081 TempPte
.u
.Hard
.PageFrameNumber
= PageFrameIndex
++;
1082 ASSERT(PointerPte
->u
.Hard
.Valid
== 0);
1083 ASSERT(TempPte
.u
.Hard
.Valid
== 1);
1084 *PointerPte
++ = TempPte
;
1088 // ReactOS requires a memory area to keep the initial NP area off-bounds
1090 BaseAddress
= MmNonPagedPoolStart
;
1091 Status
= MmCreateMemoryArea(MmGetKernelAddressSpace(),
1092 MEMORY_AREA_SYSTEM
| MEMORY_AREA_STATIC
,
1094 MmSizeOfNonPagedPoolInBytes
,
1099 BoundaryAddressMultiple
);
1100 ASSERT(Status
== STATUS_SUCCESS
);
1103 // And we need one more for the system NP
1105 BaseAddress
= MmNonPagedSystemStart
;
1106 Status
= MmCreateMemoryArea(MmGetKernelAddressSpace(),
1107 MEMORY_AREA_SYSTEM
| MEMORY_AREA_STATIC
,
1109 (ULONG_PTR
)MmNonPagedPoolEnd
-
1110 (ULONG_PTR
)MmNonPagedSystemStart
,
1115 BoundaryAddressMultiple
);
1116 ASSERT(Status
== STATUS_SUCCESS
);
1119 // Sanity check: make sure we have properly defined the system PTE space
1121 ASSERT(MiAddressToPte(MmNonPagedSystemStart
) <
1122 MiAddressToPte(MmNonPagedPoolExpansionStart
));
1125 // Now go ahead and initialize the ARM³ nonpaged pool
1127 MiInitializeArmPool();
1130 // Get current page data, since we won't be using MxGetNextPage as it
1131 // would corrupt our state
1133 FreePage
= MxFreeDescriptor
->BasePage
;
1134 FreePageCount
= MxFreeDescriptor
->PageCount
;
1138 // Loop the memory descriptors
1140 NextEntry
= KeLoaderBlock
->MemoryDescriptorListHead
.Flink
;
1141 while (NextEntry
!= &KeLoaderBlock
->MemoryDescriptorListHead
)
1144 // Get the descriptor
1146 MdBlock
= CONTAINING_RECORD(NextEntry
,
1147 MEMORY_ALLOCATION_DESCRIPTOR
,
1149 if ((MdBlock
->MemoryType
== LoaderFirmwarePermanent
) ||
1150 (MdBlock
->MemoryType
== LoaderBBTMemory
) ||
1151 (MdBlock
->MemoryType
== LoaderSpecialMemory
))
1154 // These pages are not part of the PFN database
1156 NextEntry
= MdBlock
->ListEntry
.Flink
;
1161 // Next, check if this is our special free descriptor we've found
1163 if (MdBlock
== MxFreeDescriptor
)
1166 // Use the real numbers instead
1168 BasePage
= MxOldFreeDescriptor
.BasePage
;
1169 PageCount
= MxOldFreeDescriptor
.PageCount
;
1174 // Use the descriptor's numbers
1176 BasePage
= MdBlock
->BasePage
;
1177 PageCount
= MdBlock
->PageCount
;
1181 // Get the PTEs for this range
1183 PointerPte
= MiAddressToPte(&MmPfnDatabase
[BasePage
]);
1184 LastPte
= MiAddressToPte(((ULONG_PTR
)&MmPfnDatabase
[BasePage
+ PageCount
]) - 1);
1185 DPRINT("MD Type: %lx Base: %lx Count: %lx\n", MdBlock
->MemoryType
, BasePage
, PageCount
);
1190 while (PointerPte
<= LastPte
)
1193 // We'll only touch PTEs that aren't already valid
1195 if (PointerPte
->u
.Hard
.Valid
== 0)
1198 // Use the next free page
1200 TempPte
.u
.Hard
.PageFrameNumber
= FreePage
;
1201 ASSERT(FreePageCount
!= 0);
1204 // Consume free pages
1213 KeBugCheckEx(INSTALL_MORE_MEMORY
,
1214 MmNumberOfPhysicalPages
,
1216 MxOldFreeDescriptor
.PageCount
,
1221 // Write out this PTE
1224 ASSERT(PointerPte
->u
.Hard
.Valid
== 0);
1225 ASSERT(TempPte
.u
.Hard
.Valid
== 1);
1226 *PointerPte
= TempPte
;
1231 RtlZeroMemory(MiPteToAddress(PointerPte
), PAGE_SIZE
);
1241 // Do the next address range
1243 NextEntry
= MdBlock
->ListEntry
.Flink
;
1247 // Now update the free descriptors to consume the pages we used up during
1248 // the PFN allocation loop
1250 MxFreeDescriptor
->BasePage
= FreePage
;
1251 MxFreeDescriptor
->PageCount
= FreePageCount
;
1253 else if (Phase
== 1) // IN BETWEEN, THE PFN DATABASE IS NOW CREATED
1256 // Reset the descriptor back so we can create the correct memory blocks
1258 *MxFreeDescriptor
= MxOldFreeDescriptor
;
1261 // Initialize the nonpaged pool
1263 InitializePool(NonPagedPool
, 0);
1266 // We PDE-aligned the nonpaged system start VA, so haul some extra PTEs!
1268 PointerPte
= MiAddressToPte(MmNonPagedSystemStart
);
1269 OldCount
= MmNumberOfSystemPtes
;
1270 MmNumberOfSystemPtes
= MiAddressToPte(MmNonPagedPoolExpansionStart
) -
1272 MmNumberOfSystemPtes
--;
1273 DPRINT("Final System PTE count: %d (%d bytes)\n",
1274 MmNumberOfSystemPtes
, MmNumberOfSystemPtes
* PAGE_SIZE
);
1277 // Create the system PTE space
1279 MiInitializeSystemPtes(PointerPte
, MmNumberOfSystemPtes
, SystemPteSpace
);
1282 // Get the PDE For hyperspace
1284 StartPde
= MiAddressToPde(HYPER_SPACE
);
1287 // Allocate a page for it and create it
1289 PageFrameIndex
= MmAllocPage(MC_SYSTEM
, 0);
1290 TempPde
.u
.Hard
.PageFrameNumber
= PageFrameIndex
;
1291 TempPde
.u
.Hard
.Global
= FALSE
; // Hyperspace is local!
1292 ASSERT(StartPde
->u
.Hard
.Valid
== 0);
1293 ASSERT(TempPde
.u
.Hard
.Valid
== 1);
1294 *StartPde
= TempPde
;
1297 // Zero out the page table now
1299 PointerPte
= MiAddressToPte(HYPER_SPACE
);
1300 RtlZeroMemory(PointerPte
, PAGE_SIZE
);
1303 // Setup the mapping PTEs
1305 MmFirstReservedMappingPte
= MiAddressToPte(MI_MAPPING_RANGE_START
);
1306 MmLastReservedMappingPte
= MiAddressToPte(MI_MAPPING_RANGE_END
);
1307 MmFirstReservedMappingPte
->u
.Hard
.PageFrameNumber
= MI_HYPERSPACE_PTES
;
1310 // Reserve system PTEs for zeroing PTEs and clear them
1312 MiFirstReservedZeroingPte
= MiReserveSystemPtes(MI_ZERO_PTES
,
1314 RtlZeroMemory(MiFirstReservedZeroingPte
, MI_ZERO_PTES
* sizeof(MMPTE
));
1317 // Set the counter to maximum to boot with
1319 MiFirstReservedZeroingPte
->u
.Hard
.PageFrameNumber
= MI_ZERO_PTES
- 1;
1322 // Sync us up with ReactOS Mm
1324 MiSyncARM3WithROS(MmNonPagedSystemStart
, (PVOID
)((ULONG_PTR
)MmNonPagedPoolEnd
- 1));
1325 MiSyncARM3WithROS(MmPfnDatabase
, (PVOID
)((ULONG_PTR
)MmNonPagedPoolStart
+ MmSizeOfNonPagedPoolInBytes
- 1));
1326 MiSyncARM3WithROS((PVOID
)HYPER_SPACE
, (PVOID
)(HYPER_SPACE
+ PAGE_SIZE
- 1));
1328 else // NOW WE HAVE NONPAGED POOL
1331 // Instantiate memory that we don't consider RAM/usable
1332 // We use the same exclusions that Windows does, in order to try to be
1333 // compatible with WinLDR-style booting
1335 for (i
= 0; i
< LoaderMaximum
; i
++) IncludeType
[i
] = TRUE
;
1336 IncludeType
[LoaderBad
] = FALSE
;
1337 IncludeType
[LoaderFirmwarePermanent
] = FALSE
;
1338 IncludeType
[LoaderSpecialMemory
] = FALSE
;
1339 IncludeType
[LoaderBBTMemory
] = FALSE
;
1342 // Build the physical memory block
1344 MmPhysicalMemoryBlock
= MmInitializeMemoryLimits(LoaderBlock
,
1348 // Allocate enough buffer for the PFN bitmap
1349 // Align it up to a 32-bit boundary
1351 Bitmap
= ExAllocatePoolWithTag(NonPagedPool
,
1352 (((MmHighestPhysicalPage
+ 1) + 31) / 32) * 4,
1359 KeBugCheckEx(INSTALL_MORE_MEMORY
,
1360 MmNumberOfPhysicalPages
,
1361 MmLowestPhysicalPage
,
1362 MmHighestPhysicalPage
,
1367 // Initialize it and clear all the bits to begin with
1369 RtlInitializeBitMap(&MiPfnBitMap
,
1371 MmHighestPhysicalPage
+ 1);
1372 RtlClearAllBits(&MiPfnBitMap
);
1375 // Loop physical memory runs
1377 for (i
= 0; i
< MmPhysicalMemoryBlock
->NumberOfRuns
; i
++)
1382 Run
= &MmPhysicalMemoryBlock
->Run
[i
];
1383 DPRINT("PHYSICAL RAM [0x%08p to 0x%08p]\n",
1384 Run
->BasePage
<< PAGE_SHIFT
,
1385 (Run
->BasePage
+ Run
->PageCount
) << PAGE_SHIFT
);
1388 // Make sure it has pages inside it
1393 // Set the bits in the PFN bitmap
1395 RtlSetBits(&MiPfnBitMap
, Run
->BasePage
, Run
->PageCount
);
1400 // Size up paged pool and build the shadow system page directory
1405 // Print the memory layout
1407 DPRINT1(" 0x%p - 0x%p\t%s\n",
1409 (ULONG_PTR
)MmSystemRangeStart
+ MmBootImageSize
,
1410 "Boot Loaded Image");
1411 DPRINT1(" 0x%p - 0x%p\t%s\n",
1412 MiNonPagedPoolStart
,
1413 (ULONG_PTR
)MiNonPagedPoolStart
+ MiNonPagedPoolLength
,
1415 DPRINT1(" 0x%p - 0x%p\t%s\n",
1417 (ULONG_PTR
)MmPagedPoolBase
+ MmPagedPoolSize
,
1419 DPRINT1(" 0x%p - 0x%p\t%s\n",
1421 (ULONG_PTR
)MmPfnDatabase
+ (MxPfnAllocation
<< PAGE_SHIFT
),
1423 DPRINT1(" 0x%p - 0x%p\t%s\n",
1424 MmNonPagedPoolStart
,
1425 (ULONG_PTR
)MmNonPagedPoolStart
+ MmSizeOfNonPagedPoolInBytes
,
1426 "ARM³ Non Paged Pool");
1427 DPRINT1(" 0x%p - 0x%p\t%s\n",
1429 (ULONG_PTR
)MiSystemViewStart
+ MmSystemViewSize
,
1430 "System View Space");
1431 DPRINT1(" 0x%p - 0x%p\t%s\n",
1435 DPRINT1(" 0x%p - 0x%p\t%s\n",
1438 DPRINT1(" 0x%p - 0x%p\t%s\n",
1439 PDE_BASE
, HYPER_SPACE
,
1440 "Page Directories");
1441 DPRINT1(" 0x%p - 0x%p\t%s\n",
1442 HYPER_SPACE
, HYPER_SPACE
+ (4 * 1024 * 1024),
1444 DPRINT1(" 0x%p - 0x%p\t%s\n",
1446 (ULONG_PTR
)MmPagedPoolStart
+ MmSizeOfPagedPoolInBytes
,
1448 DPRINT1(" 0x%p - 0x%p\t%s\n",
1449 MmNonPagedSystemStart
, MmNonPagedPoolExpansionStart
,
1450 "System PTE Space");
1451 DPRINT1(" 0x%p - 0x%p\t%s\n",
1452 MmNonPagedPoolExpansionStart
, MmNonPagedPoolEnd
,
1453 "Non Paged Pool Expansion PTE Space");
1457 // Always return success for now
1459 return STATUS_SUCCESS
;