[tkreuzer] 44035: [MM] - Halfplement MmArmInitSystem, it's broken atm - Update some variable drfinitions from ULONG to ULONG_PTR - Add some amd64 specific constants
Author: tkreuzer Date: Mon Nov 9 07:46:31 2009 New Revision: 44035
URL: http://svn.reactos.org/svn/reactos?rev=44035&view=rev Log: [MM] - Halfplement MmArmInitSystem, it's broken atm - Update some variable drfinitions from ULONG to ULONG_PTR - Add some amd64 specific constants
Modified: branches/ros-amd64-bringup/reactos/ntoskrnl/mm/ARM3/miarm.h branches/ros-amd64-bringup/reactos/ntoskrnl/mm/amd64/init.c
Modified: branches/ros-amd64-bringup/reactos/ntoskrnl/mm/ARM3/miarm.h URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/reactos/ntoskr... ============================================================================== --- branches/ros-amd64-bringup/reactos/ntoskrnl/mm/ARM3/miarm.h [iso-8859-1] (original) +++ branches/ros-amd64-bringup/reactos/ntoskrnl/mm/ARM3/miarm.h [iso-8859-1] Mon Nov 9 07:46:31 2009 @@ -5,6 +5,8 @@ * PURPOSE: ARM Memory Manager Header * PROGRAMMERS: ReactOS Portable Systems Group */ + +#ifdef _M_AMD64
#define MI_MIN_PAGES_FOR_NONPAGED_POOL_TUNING ((255*1024*1024) >> PAGE_SHIFT) #define MI_MIN_PAGES_FOR_SYSPTE_TUNING ((19*1024*1024) >> PAGE_SHIFT) @@ -26,8 +28,8 @@
#define MI_SYSTEM_VIEW_SIZE (16 * 1024 * 1024)
-#define MI_PAGED_POOL_START (PVOID)0xE1000000 -#define MI_NONPAGED_POOL_END (PVOID)0xFFBE0000 +#define MI_PAGED_POOL_START (PVOID)0xFFFFFA8000000000ULL +#define MI_NONPAGED_POOL_END (PVOID)0xFFFFFAE000000000ULL
#define MM_HIGHEST_VAD_ADDRESS \ (PVOID)((ULONG_PTR)MM_HIGHEST_USER_ADDRESS - (16 * PAGE_SIZE)) @@ -39,6 +41,44 @@ #define POOL_LISTS_PER_PAGE (PAGE_SIZE / sizeof(LIST_ENTRY)) #define BASE_POOL_TYPE_MASK 1 #define POOL_MAX_ALLOC (PAGE_SIZE - (sizeof(POOL_HEADER) + sizeof(LIST_ENTRY))) + +#else + +#define MI_MIN_PAGES_FOR_NONPAGED_POOL_TUNING ((255*1024*1024) >> PAGE_SHIFT) +#define MI_MIN_PAGES_FOR_SYSPTE_TUNING ((19*1024*1024) >> PAGE_SHIFT) +#define MI_MIN_PAGES_FOR_SYSPTE_BOOST ((32*1024*1024) >> PAGE_SHIFT) +#define MI_MAX_INIT_NONPAGED_POOL_SIZE (128 * 1024 * 1024) +#define MI_MAX_NONPAGED_POOL_SIZE (128 * 1024 * 1024) +#define MI_MAX_FREE_PAGE_LISTS 4 + +#define MI_MIN_INIT_PAGED_POOLSIZE (32 * 1024 * 1024) + +#define MI_SESSION_VIEW_SIZE (20 * 1024 * 1024) +#define MI_SESSION_POOL_SIZE (16 * 1024 * 1024) +#define MI_SESSION_IMAGE_SIZE (8 * 1024 * 1024) +#define MI_SESSION_WORKING_SET_SIZE (4 * 1024 * 1024) +#define MI_SESSION_SIZE (MI_SESSION_VIEW_SIZE + \ + MI_SESSION_POOL_SIZE + \ + MI_SESSION_IMAGE_SIZE + \ + MI_SESSION_WORKING_SET_SIZE) + +#define MI_SYSTEM_VIEW_SIZE (16 * 1024 * 1024) + +#define MI_PAGED_POOL_START (PVOID)0xE1000000 +#define MI_NONPAGED_POOL_END (PVOID)0xFFBE0000 + +#define MM_HIGHEST_VAD_ADDRESS \ + (PVOID)((ULONG_PTR)MM_HIGHEST_USER_ADDRESS - (16 * PAGE_SIZE)) + + +// +// FIXFIX: These should go in ex.h after the pool merge +// +#define POOL_LISTS_PER_PAGE (PAGE_SIZE / sizeof(LIST_ENTRY)) +#define BASE_POOL_TYPE_MASK 1 +#define POOL_MAX_ALLOC (PAGE_SIZE - (sizeof(POOL_HEADER) + sizeof(LIST_ENTRY))) + +#endif
typedef struct _POOL_DESCRIPTOR { @@ -123,27 +163,27 @@
extern MMPTE HyperTemplatePte;
-extern ULONG MmSizeOfNonPagedPoolInBytes; -extern ULONG MmMaximumNonPagedPoolInBytes; +extern ULONG_PTR MmSizeOfNonPagedPoolInBytes; +extern ULONG_PTR MmMaximumNonPagedPoolInBytes; extern PVOID MmNonPagedSystemStart; extern PVOID MmNonPagedPoolStart; extern PVOID MmNonPagedPoolExpansionStart; extern PVOID MmNonPagedPoolEnd; -extern ULONG MmSizeOfPagedPoolInBytes; +extern ULONG_PTR MmSizeOfPagedPoolInBytes; extern PVOID MmPagedPoolStart; extern PVOID MmPagedPoolEnd; extern PVOID MmSessionBase; -extern ULONG MmSessionSize; +extern ULONG_PTR MmSessionSize; extern PMMPTE MmFirstReservedMappingPte, MmLastReservedMappingPte; extern PMMPTE MiFirstReservedZeroingPte; extern MI_PFN_CACHE_ATTRIBUTE MiPlatformCacheAttributes[2][MmMaximumCacheType]; extern PPHYSICAL_MEMORY_DESCRIPTOR MmPhysicalMemoryBlock; -extern ULONG MmBootImageSize; +extern ULONG_PTR MmBootImageSize; extern PMMPTE MmSystemPtesStart[MaximumPtePoolTypes]; extern PMMPTE MmSystemPtesEnd[MaximumPtePoolTypes]; extern PMEMORY_ALLOCATION_DESCRIPTOR MxFreeDescriptor; extern MEMORY_ALLOCATION_DESCRIPTOR MxOldFreeDescriptor; -extern ULONG MxPfnAllocation; +extern ULONG_PTR MxPfnAllocation; extern MM_PAGED_POOL_INFO MmPagedPoolInfo; extern RTL_BITMAP MiPfnBitMap; extern KGUARDED_MUTEX MmPagedPoolMutex; @@ -151,10 +191,10 @@ extern PVOID MmPagedPoolEnd; extern PVOID MmNonPagedSystemStart; extern PVOID MiSystemViewStart; -extern ULONG MmSystemViewSize; +extern ULONG_PTR MmSystemViewSize; extern PVOID MmSessionBase; extern PVOID MiSessionSpaceEnd; -extern ULONG MmSizeOfPagedPoolInBytes; +extern ULONG_PTR MmSizeOfPagedPoolInBytes; extern PMMPTE MmSystemPagePtes;
NTSTATUS
Modified: branches/ros-amd64-bringup/reactos/ntoskrnl/mm/amd64/init.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/reactos/ntoskr... ============================================================================== --- branches/ros-amd64-bringup/reactos/ntoskrnl/mm/amd64/init.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/reactos/ntoskrnl/mm/amd64/init.c [iso-8859-1] Mon Nov 9 07:46:31 2009 @@ -15,54 +15,464 @@
#include "../ARM3/miarm.h"
+#define MI_SESSION_SPACE_END (PVOID)0xFFFFF98000000000ULL +#define MI_SESSION_VIEW_END 0xFFFFF97FFF000000ULL +#define MI_NON_PAGED_SYSTEM_START_MIN 0x0FFFFFAA000000000ULL
/* GLOBALS *****************************************************************/
-ULONG MmMaximumNonPagedPoolPercent; -ULONG MmSizeOfNonPagedPoolInBytes; -ULONG MmMaximumNonPagedPoolInBytes; - -PVOID MiSessionSpaceEnd; // 0xC0000000 - -ULONG64 MmUserProbeAddress; -PVOID MmHighestUserAddress; -PVOID MmSystemRangeStart; - -ULONG MmNumberOfPhysicalPages, MmHighestPhysicalPage, MmLowestPhysicalPage = -1; - -ULONG MmBootImageSize; - -PPHYSICAL_MEMORY_DESCRIPTOR MmPhysicalMemoryBlock; - -RTL_BITMAP MiPfnBitMap; - +ULONG64 MmUserProbeAddress = 0x7FFFFFF0000ULL; +PVOID MmHighestUserAddress = (PVOID)0x7FFFFFEFFFFULL; +PVOID MmSystemRangeStart = (PVOID)KSEG0_BASE; // FFFF080000000000 + +/* Size of session view, pool, and image */ +ULONG64 MmSessionSize = MI_SESSION_SIZE; +ULONG64 MmSessionViewSize = MI_SESSION_VIEW_SIZE; +ULONG64 MmSessionPoolSize = MI_SESSION_POOL_SIZE; +ULONG64 MmSessionImageSize = MI_SESSION_IMAGE_SIZE; + +/* Session space addresses */ +PVOID MiSessionSpaceEnd = MI_SESSION_SPACE_END; // FFFFF98000000000 +PVOID MiSessionImageEnd; // FFFFF98000000000 = MiSessionSpaceEnd +PVOID MiSessionImageStart; // ?FFFFF97FFF000000 = MiSessionImageEnd - MmSessionImageSize +PVOID MiSessionViewEnd; // FFFFF97FFF000000 +PVOID MiSessionViewStart; // = MiSessionViewEnd - MmSessionViewSize +PVOID MiSessionPoolEnd; // = MiSessionViewStart +PVOID MiSessionPoolStart; // FFFFF90000000000 = MiSessionPoolEnd - MmSessionPoolSize +PVOID MmSessionBase; // FFFFF90000000000 = MiSessionPoolStart + +/* System view */ +ULONG64 MmSystemViewSize = MI_SYSTEM_VIEW_SIZE; +PVOID MiSystemViewStart; + +ULONG64 MmMinimumNonPagedPoolSize = 256 * 1024; +ULONG64 MmSizeOfNonPagedPoolInBytes; +ULONG64 MmMaximumNonPagedPoolInBytes; +ULONG64 MmMaximumNonPagedPoolPercent; +ULONG64 MmMinAdditionNonPagedPoolPerMb = 32 * 1024; +ULONG64 MmMaxAdditionNonPagedPoolPerMb = 400 * 1024; +ULONG64 MmDefaultMaximumNonPagedPool = 1024 * 1024; PVOID MmNonPagedSystemStart; PVOID MmNonPagedPoolStart; PVOID MmNonPagedPoolExpansionStart; PVOID MmNonPagedPoolEnd = MI_NONPAGED_POOL_END;
+ULONG64 MmSizeOfPagedPoolInBytes = MI_MIN_INIT_PAGED_POOLSIZE; PVOID MmPagedPoolStart = MI_PAGED_POOL_START; PVOID MmPagedPoolEnd;
-ULONG MmSizeOfPagedPoolInBytes = MI_MIN_INIT_PAGED_POOLSIZE; - -PVOID MmSessionBase; -ULONG MmSessionSize; + +ULONG64 MmBootImageSize; +PPHYSICAL_MEMORY_DESCRIPTOR MmPhysicalMemoryBlock; +RTL_BITMAP MiPfnBitMap; +ULONG MmNumberOfPhysicalPages, MmHighestPhysicalPage, MmLowestPhysicalPage = -1; +ULONG64 MmNumberOfSystemPtes; +PMMPTE MmSystemPagePtes; +ULONG64 MxPfnAllocation; + +///////////////////////////////////////////////
PMEMORY_ALLOCATION_DESCRIPTOR MxFreeDescriptor; MEMORY_ALLOCATION_DESCRIPTOR MxOldFreeDescriptor;
-PMMPTE MmSystemPagePtes; -ULONG MxPfnAllocation; -PVOID MiSystemViewStart; -ULONG MmSystemViewSize; +PFN_NUMBER MxFreePageBase; +ULONG64 MxFreePageCount = 0; + +VOID +NTAPI +MxSetupFreePageList(IN PLOADER_PARAMETER_BLOCK LoaderBlock) +{ + PMEMORY_ALLOCATION_DESCRIPTOR MdBlock; + PLIST_ENTRY ListEntry; + + /* Loop the memory descriptors */ + for (ListEntry = LoaderBlock->MemoryDescriptorListHead.Flink; + ListEntry != &LoaderBlock->MemoryDescriptorListHead; + ListEntry = ListEntry->Flink) + { + /* Get the memory block */ + MdBlock = CONTAINING_RECORD(ListEntry, + MEMORY_ALLOCATION_DESCRIPTOR, + ListEntry); + + /* Check if this is free memory */ + if ((MdBlock->MemoryType == LoaderFree) || + (MdBlock->MemoryType == LoaderLoadedProgram) || + (MdBlock->MemoryType == LoaderFirmwareTemporary) || + (MdBlock->MemoryType == LoaderOsloaderStack)) + { + /* Check if this is the largest memory descriptor */ + if (MdBlock->PageCount > MxFreePageCount) + { + /* For now, it is */ + MxFreeDescriptor = MdBlock; + MxFreePageBase = MdBlock->BasePage; + MxFreePageCount = MdBlock->PageCount; + } + } + } +} + +PFN_NUMBER +NTAPI +MxGetNextPage(IN PFN_NUMBER PageCount) +{ + PFN_NUMBER Pfn; + + /* Make sure we have enough pages */ + if (PageCount > MxFreePageCount) + { + /* Crash the system */ + KeBugCheckEx(INSTALL_MORE_MEMORY, + MmNumberOfPhysicalPages, + MxFreeDescriptor->PageCount, + MxOldFreeDescriptor.PageCount, + PageCount); + } + + /* Use our lowest usable free pages */ + Pfn = MxFreePageBase; + MxFreePageBase += PageCount; + MxFreePageCount -= PageCount; + return Pfn; +} + +VOID +MxMapPage(PVOID Address) +{ + PMMPTE Pte; + MMPTE TmpPte; + + TmpPte.u.Long = 0; + TmpPte.u.Hard.Valid = 1; + + /* Get a pointer to the PXE */ + Pte = MiAddressToPxe(Address); + if (!Pte->u.Hard.Valid) + { + /* It's not valid, map it! */ + TmpPte.u.Hard.PageFrameNumber = MxGetNextPage(1); + *Pte = TmpPte; + } + + /* Get a pointer to the PPE */ + Pte = MiAddressToPpe(Address); + if (!Pte->u.Hard.Valid) + { + /* It's not valid, map it! */ + TmpPte.u.Hard.PageFrameNumber = MxGetNextPage(1); + *Pte = TmpPte; + } + + /* Get a pointer to the PDE */ + Pte = MiAddressToPde(Address); + if (!Pte->u.Hard.Valid) + { + /* It's not valid, map it! */ + TmpPte.u.Hard.PageFrameNumber = MxGetNextPage(1); + *Pte = TmpPte; + } + + /* Get a pointer to the PTE */ + Pte = MiAddressToPte(Address); + if (!Pte->u.Hard.Valid) + { + /* It's not valid, map it! */ + TmpPte.u.Hard.PageFrameNumber = MxGetNextPage(1); + *Pte = TmpPte; + } +} + +VOID +MxMapPageRange(PVOID Address, ULONG64 PageCount) +{ + ULONG64 i; + + for (i = 0; i < PageCount; i++) + { + MxMapPage(Address); + Address = (PVOID)((ULONG64)Address + PAGE_SIZE); + } +} + + +VOID +NTAPI +MiArmIninializeMemoryLayout(IN PLOADER_PARAMETER_BLOCK LoaderBlock) +{ + /* Get the size of the boot loader's image allocations */ + MmBootImageSize = KeLoaderBlock->Extension->LoaderPagesSpanned; + MmBootImageSize *= PAGE_SIZE; + MmBootImageSize = (MmBootImageSize + (4 * 1024 * 1024) - 1) & ~((4 * 1024 * 1024) - 1); + ASSERT((MmBootImageSize % (4 * 1024 * 1024)) == 0); + + MiSessionSpaceEnd = (PVOID)MI_SESSION_SPACE_END; + + /* This is where we will load Win32k.sys and the video driver */ + MiSessionImageEnd = MiSessionSpaceEnd; + MiSessionImageStart = (PVOID)((ULONG_PTR)MiSessionImageEnd - + MmSessionImageSize); + + /* The view starts right below the session working set (itself below + * the image area) */ + MiSessionViewEnd = (PVOID)MI_SESSION_VIEW_END; + MiSessionViewStart = (PVOID)((ULONG_PTR)MiSessionViewStart - + MmSessionViewSize); + + /* Session pool follows */ + MiSessionPoolEnd = MiSessionViewStart; + MiSessionPoolStart = (PVOID)((ULONG_PTR)MiSessionPoolEnd - + MmSessionPoolSize); + + /* And it all begins here */ + MmSessionBase = MiSessionPoolStart; + + // Sanity check that our math is correct + //ASSERT((ULONG_PTR)MmSessionBase + MmSessionSize == PTE_BASE); + + /* System view space ends at session space, so now that we know where + * this is, we can compute the base address of system view space itself. */ + MiSystemViewStart = (PVOID)((ULONG_PTR)MmSessionBase - + MmSystemViewSize); + + /* Use the default */ + MmNumberOfSystemPtes = 22000; + +} + +VOID +MiArmInitializePageTable() +{ + ULONG64 PageFrameOffset; + PMMPTE StartPte, EndPte; + + /* Set CR3 for the system process */ + PageFrameOffset = ((PMMPTE)PXE_BASE)->u.Hard.PageFrameNumber << PAGE_SHIFT; + PsGetCurrentProcess()->Pcb.DirectoryTableBase[0] = PageFrameOffset; + + /* Clear user mode mappings in PML4 */ + StartPte = MiAddressToPxe(0); + EndPte = MiAddressToPxe(MmSystemRangeStart); + RtlZeroMemory(StartPte, (EndPte - StartPte) * sizeof(MMPTE)); +} + + +VOID +NTAPI +MiArmEvaluateMemoryDescriptors(IN PLOADER_PARAMETER_BLOCK LoaderBlock) +{ + PMEMORY_ALLOCATION_DESCRIPTOR MdBlock; + PLIST_ENTRY ListEntry; + PFN_NUMBER BasePage, LastPage, PageCount; + + /* Loop the memory descriptors */ + for (ListEntry = LoaderBlock->MemoryDescriptorListHead.Flink; + ListEntry != &LoaderBlock->MemoryDescriptorListHead; + ListEntry = ListEntry->Flink) + { + /* Get the descriptor */ + MdBlock = CONTAINING_RECORD(ListEntry, + MEMORY_ALLOCATION_DESCRIPTOR, + ListEntry); + + /* Skip pages that are not part of the PFN database */ + if ((MdBlock->MemoryType == LoaderFirmwarePermanent) || + (MdBlock->MemoryType == LoaderBBTMemory) || + (MdBlock->MemoryType == LoaderHALCachedMemory) || // ??? + (MdBlock->MemoryType == LoaderSpecialMemory)) + { + continue; + } + + /* Check if BURNMEM was used */ + if (MdBlock->MemoryType != LoaderBad) + { + /* Count this in the total of pages */ + MmNumberOfPhysicalPages += MdBlock->PageCount; + } + + BasePage = MdBlock->BasePage; + LastPage = MdBlock->BasePage + MdBlock->PageCount - 1; + + /* Check if this is the new lowest page */ + if (BasePage < MmLowestPhysicalPage) + { + /* Update the lowest page */ + MmLowestPhysicalPage = BasePage; + } + + /* Check if this is the new highest page */ + if (LastPage > MmHighestPhysicalPage) + { + /* Update the highest page */ + MmHighestPhysicalPage = LastPage; + } + + /* Map pages for the PFN database */ + PageCount = (MdBlock->PageCount * sizeof(MMPFN)) / PAGE_SIZE; + MxMapPageRange(&MmPfnDatabase[BasePage], PageCount); + + /* Zero out the pages */ + RtlZeroMemory(&MmPfnDatabase[BasePage], PageCount * PAGE_SIZE); + } + + /* Calculate the number of bytes, and then convert to pages */ + MxPfnAllocation = (MmHighestPhysicalPage + 1) * sizeof(MMPFN); + MxPfnAllocation >>= PAGE_SHIFT; + MxPfnAllocation++; + +} + +VOID +NTAPI +MiArmPrepareNonPagedPool() +{ + PFN_NUMBER PageCount; + + /* Check if this is a machine with less than 256MB of RAM, and no overide */ + if ((MmNumberOfPhysicalPages <= MI_MIN_PAGES_FOR_NONPAGED_POOL_TUNING) && + !(MmSizeOfNonPagedPoolInBytes)) + { + /* Force the non paged pool to be 2MB so we can reduce RAM usage */ + MmSizeOfNonPagedPoolInBytes = 2 * 1024 * 1024; + } + + /* Check if the user gave a ridicuously large nonpaged pool RAM size */ + if ((MmSizeOfNonPagedPoolInBytes >> PAGE_SHIFT) > + (MmNumberOfPhysicalPages * 7 / 8)) + { + /* More than 7/8ths of RAM was dedicated to nonpaged pool, ignore! */ + MmSizeOfNonPagedPoolInBytes = 0; + } + + /* Check if no registry setting was set, or if the setting was too low */ + if (MmSizeOfNonPagedPoolInBytes < MmMinimumNonPagedPoolSize) + { + /* Start with the minimum (256 KB) and add 32 KB for each MB above 4 */ + MmSizeOfNonPagedPoolInBytes = MmMinimumNonPagedPoolSize; + MmSizeOfNonPagedPoolInBytes += (MmNumberOfPhysicalPages - 1024) / + 256 * MmMinAdditionNonPagedPoolPerMb; + } + + /* Check if the registy setting or our dynamic calculation was too high */ + if (MmSizeOfNonPagedPoolInBytes > MI_MAX_INIT_NONPAGED_POOL_SIZE) + { + // Set it to the maximum */ + MmSizeOfNonPagedPoolInBytes = MI_MAX_INIT_NONPAGED_POOL_SIZE; + } + + /* Check if a percentage cap was set through the registry */ + if (MmMaximumNonPagedPoolPercent) + { + /* Don't feel like supporting this right now */ + UNIMPLEMENTED; + } + + /* Page-align the nonpaged pool size */ + MmSizeOfNonPagedPoolInBytes &= ~(PAGE_SIZE - 1); + + /* Now, check if there was a registry size for the maximum size */ + if (!MmMaximumNonPagedPoolInBytes) + { + /* Start with the default (1MB) and add 400 KB for each MB above 4 */ + MmMaximumNonPagedPoolInBytes = MmDefaultMaximumNonPagedPool; + MmMaximumNonPagedPoolInBytes += (MmNumberOfPhysicalPages - 1024) / + 256 * MmMaxAdditionNonPagedPoolPerMb; + } + + /* Don't let the maximum go too high */ + if (MmMaximumNonPagedPoolInBytes > MI_MAX_NONPAGED_POOL_SIZE) + { + /* Set it to the upper limit */ + MmMaximumNonPagedPoolInBytes = MI_MAX_NONPAGED_POOL_SIZE; + } + + /* Calculate the nonpaged pool expansion start region */ + MmNonPagedPoolExpansionStart = (PVOID)((ULONG_PTR)MmNonPagedPoolEnd - + MmMaximumNonPagedPoolInBytes + + MmSizeOfNonPagedPoolInBytes); + MmNonPagedPoolExpansionStart = (PVOID)PAGE_ALIGN(MmNonPagedPoolExpansionStart); + + DPRINT("NP Pool has been tuned to: %d bytes and %d bytes\n", + MmSizeOfNonPagedPoolInBytes, MmMaximumNonPagedPoolInBytes); + + /* Now calculate the nonpaged system VA region, which includes the + * nonpaged pool expansion (above) and the system PTEs. Note that it is + * then aligned to a PDE boundary (4MB). */ + MmNonPagedSystemStart = (PVOID)((ULONG_PTR)MmNonPagedPoolExpansionStart - + (MmNumberOfSystemPtes + 1) * PAGE_SIZE); + MmNonPagedSystemStart = (PVOID)((ULONG_PTR)MmNonPagedSystemStart & + ~((4 * 1024 * 1024) - 1)); + + /* Don't let it go below the minimum */ + if (MmNonPagedSystemStart < (PVOID)MI_NON_PAGED_SYSTEM_START_MIN) + { + /* This is a hard-coded limit in the Windows NT address space */ + MmNonPagedSystemStart = (PVOID)MI_NON_PAGED_SYSTEM_START_MIN; + + /* Reduce the amount of system PTEs to reach this point */ + MmNumberOfSystemPtes = ((ULONG_PTR)MmNonPagedPoolExpansionStart - + (ULONG_PTR)MmNonPagedSystemStart) >> + PAGE_SHIFT; + MmNumberOfSystemPtes--; + ASSERT(MmNumberOfSystemPtes > 1000); + } + + /* Non paged pool comes after the PFN database */ + MmNonPagedPoolStart = (PVOID)((ULONG_PTR)MmPfnDatabase + + (MxPfnAllocation << PAGE_SHIFT)); + + /* Map the nonpaged pool */ + PageCount = (MmSizeOfNonPagedPoolInBytes + PAGE_SIZE - 1) / PAGE_SIZE; + MxMapPageRange(MmNonPagedPoolStart, PageCount); + + /* Sanity check: make sure we have properly defined the system PTE space */ + ASSERT(MiAddressToPte(MmNonPagedSystemStart) < + MiAddressToPte(MmNonPagedPoolExpansionStart)); + +}
NTSTATUS NTAPI MmArmInitSystem(IN ULONG Phase, IN PLOADER_PARAMETER_BLOCK LoaderBlock) { - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; -} - + if (Phase == 0) + { + /* Get a continuous range of physical pages */ + MxSetupFreePageList(LoaderBlock); + + /* Initialize the memory layout */ + MiArmIninializeMemoryLayout(LoaderBlock); + DPRINT1("MmArmInitSystem 3\n"); + + /* Loop descriptors and prepare PFN database */ + MiArmEvaluateMemoryDescriptors(LoaderBlock); + DPRINT1("MmArmInitSystem 4\n"); + + MiArmInitializePageTable(); + DPRINT1("MmArmInitSystem 5\n"); + + /* Configure size of the non paged pool */ + MiArmPrepareNonPagedPool(); + + /* Initialize the ARM3 nonpaged pool */ + MiInitializeArmPool(); + + /* Update the memory descriptor, to make sure the pages we used + won't get inserted into the PFN database */ + MxOldFreeDescriptor = *MxFreeDescriptor; + MxFreeDescriptor->BasePage = MxFreePageBase; + MxFreeDescriptor->PageCount = MxFreePageCount; + } + else if (Phase == 1) + { + /* The PFN database was created, restore the free descriptor */ + *MxFreeDescriptor = MxOldFreeDescriptor; + + + } + + return STATUS_SUCCESS; +} +
-
tkreuzer＠svn.reactos.org