X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Farch%2Fx86%2Fmm_phys.c;h=cc6857d150c559e6e3389e8ba6e7190be4c07c6c;hb=0be4add5a8c5f142878c942ff1def5038fb42058;hp=648449e9c468f594b56ba801835d854bcb589b48;hpb=b7cb1e892d25645359de4c4e5f6a598137dfdfd0;p=tpg%2Facess2.git diff --git a/Kernel/arch/x86/mm_phys.c b/Kernel/arch/x86/mm_phys.c index 648449e9..cc6857d1 100644 --- a/Kernel/arch/x86/mm_phys.c +++ b/Kernel/arch/x86/mm_phys.c @@ -1,24 +1,34 @@ /* - AcessOS Microkernel Version - mm_phys.c -*/ -#include + * Acess2 + * - Physical memory manager + */ +#define DEBUG 0 +#include #include #include +//#define USE_STACK 1 +#define TRACE_ALLOCS 0 // Print trace messages on AllocPhys/DerefPhys + #define REFERENCE_BASE 0xE0400000 // === IMPORTS === extern void gKernelEnd; // === PROTOTYPES === -Uint32 MM_AllocPhys(); -void MM_RefPhys(Uint32 Addr); -void MM_DerefPhys(Uint32 Addr); +void MM_Install(tMBoot_Info *MBoot); +//tPAddr MM_AllocPhys(void); +//tPAddr MM_AllocPhysRange(int Pages, int MaxBits); +//void MM_RefPhys(tPAddr PAddr); +//void MM_DerefPhys(tPAddr PAddr); +// int MM_GetRefCount(tPAddr PAddr); // === GLOBALS === - int giPhysAlloc = 0; -Uint giPageCount = 0; +tMutex glPhysAlloc; +Uint64 giPhysAlloc = 0; // Number of allocated pages +Uint64 giPageCount = 0; // Total number of pages +Uint64 giLastPossibleFree = 0; // Last possible free page (before all pages are used) + Uint32 gaSuperBitmap[1024]; // Blocks of 1024 Pages Uint32 gaPageBitmap[1024*1024/32]; // Individual pages Uint32 *gaPageReferences; @@ -28,26 +38,57 @@ void MM_Install(tMBoot_Info *MBoot) { Uint kernelPages, num; Uint i; + Uint64 maxAddr = 0; tMBoot_Module *mods; + tMBoot_MMapEnt *ent; + + // --- Find largest address + MBoot->MMapAddr |= KERNEL_BASE; + ent = (void *)( MBoot->MMapAddr ); + while( (Uint)ent < MBoot->MMapAddr + MBoot->MMapLength ) + { + // Adjust for size + ent->Size += 4; + + // If entry is RAM and is above `maxAddr`, change `maxAddr` + if(ent->Type == 1 && ent->Base + ent->Length > maxAddr) + maxAddr = ent->Base + ent->Length; + // Go to next entry + ent = (tMBoot_MMapEnt *)( (Uint)ent + ent->Size ); + } + + if(maxAddr == 0) { + giPageCount = (MBoot->HighMem >> 2) + 256; // HighMem is a kByte value + } + else { + giPageCount = maxAddr >> 12; + } + giLastPossibleFree = giPageCount - 1; - // Initialise globals - giPageCount = (MBoot->HighMem >> 2) + 256; // HighMem is a kByte value - Log("giPageCount = %i", giPageCount); + memsetd(gaPageBitmap, 0xFFFFFFFF, giPageCount/32); - // Get used page count - kernelPages = (Uint)&gKernelEnd - KERNEL_BASE; + // Set up allocateable space + ent = (void *)( MBoot->MMapAddr ); + while( (Uint)ent < MBoot->MMapAddr + MBoot->MMapLength ) + { + memsetd( &gaPageBitmap[ent->Base/(4096*32)], 0, ent->Length/(4096*32) ); + ent = (tMBoot_MMapEnt *)( (Uint)ent + ent->Size ); + } + + // Get used page count (Kernel) + kernelPages = (Uint)&gKernelEnd - KERNEL_BASE - 0x100000; kernelPages += 0xFFF; // Page Align kernelPages >>= 12; // Fill page bitmap num = kernelPages/32; - memsetd(gaPageBitmap, -1, num); - gaPageBitmap[ num ] = (1 << (kernelPages & 31)) - 1; + memsetd( &gaPageBitmap[0x100000/(4096*32)], -1, num ); + gaPageBitmap[ 0x100000/(4096*32) + num ] = (1 << (kernelPages & 31)) - 1; // Fill Superpage bitmap num = kernelPages/(32*32); - memsetd(gaSuperBitmap, -1, num); - gaSuperBitmap[ num ] = (1 << ((kernelPages / 32) & 31)) - 1; + memsetd( &gaSuperBitmap[0x100000/(4096*32*32)], -1, num ); + gaSuperBitmap[ 0x100000/(4096*32*32) + num ] = (1 << ((kernelPages / 32) & 31)) - 1; // Mark Multiboot's pages as taken // - Structure @@ -65,12 +106,17 @@ void MM_Install(tMBoot_Info *MBoot) } // Allocate References - Log("Reference Pages %i", (giPageCount*4+0xFFF)>>12); + //LOG("Reference Pages %i", (giPageCount*4+0xFFF)>>12); for(num = 0; num < (giPageCount*4+0xFFF)>>12; num++) { - MM_Allocate( REFERENCE_BASE + (num<<12) ); + if( !MM_Allocate( REFERENCE_BASE + (num<<12) ) ) + { + Panic("Oh, ****, no space for the reference pages, that's bad"); + for(;;); + } } + //LOG("Filling"); // Fill references gaPageReferences = (void*)REFERENCE_BASE; memsetd(gaPageReferences, 1, kernelPages); @@ -81,121 +127,377 @@ void MM_Install(tMBoot_Info *MBoot) } /** - * \fn tPAddr MM_AllocPhys() - * \brief Allocates a physical page + * \fn tPAddr MM_AllocPhys(void) + * \brief Allocates a physical page from the general pool */ -tPAddr MM_AllocPhys() +tPAddr MM_AllocPhys(void) { - int num = giPageCount / 32 / 32; - int a, b, c; - Uint32 ret; + // int a, b, c; + int indx = -1; + tPAddr ret; - LOCK( &giPhysAlloc ); + ENTER(""); + Mutex_Acquire( &glPhysAlloc ); + + // Classful scan + #if 1 + { + const int addrClasses[] = {0,16,20,24,32,64}; + const int numAddrClasses = sizeof(addrClasses)/sizeof(addrClasses[0]); + int i; + int first, last; + for( i = numAddrClasses; i -- > 1; ) + { +// Log("Scanning %i (%i bits)", i, addrClasses[i]); + first = 1 << (addrClasses[i-1] - 12); + last = (1 << (addrClasses[i] - 12)) - 1; + // Range is above the last free page + if( first > giLastPossibleFree ) + continue; + // Last possible free page is in the range + if( last > giLastPossibleFree ) + last = giLastPossibleFree; + +// Log(" first=%i,max=%i", first, last); + // Scan the range + for( indx = first; indx < last; ) + { +// Log("indx = %i (< %i?)", indx, last); + if( gaSuperBitmap[indx>>10] == -1 ) { + indx += 1024; + continue; + } + + if( gaPageBitmap[indx>>5] == -1 ) { + indx += 32; + continue; + } + + if( gaPageBitmap[indx>>5] & (1 << (indx&31)) ) { + indx ++; + continue; + } + break; + } + if( indx < last ) break; + + giLastPossibleFree = first; // Well, we couldn't find any in this range + } + // Out of memory? + if( i <= 1 ) indx = -1; +// Log("indx = %i", indx); + } + #elif 0 // Find free page - for(a=0;gaSuperBitmap[a]==-1&&a= 0; ) + { + if( gaSuperBitmap[indx>>10] == -1 ) { + indx -= 1024; + continue; + } + + if( gaPageBitmap[indx>>5] == -1 ) { + indx -= 32; + continue; + } + + if( gaPageBitmap[indx>>5] & (1 << (indx&31)) ) { + indx --; + continue; + } + break; + } + if( indx >= 0 ) + giLastPossibleFree = indx; + LOG("indx = %i", indx); + #else + c = giLastPossibleFree % 32; + b = (giLastPossibleFree / 32) % 32; + a = giLastPossibleFree / 1024; + + LOG("a=%i,b=%i,c=%i", a, b, c); + for( ; gaSuperBitmap[a] == -1 && a >= 0; a-- ); + if(a < 0) { + Mutex_Release( &glPhysAlloc ); + Warning("MM_AllocPhys - OUT OF MEMORY (Called by %p) - %lli/%lli used", + __builtin_return_address(0), giPhysAlloc, giPageCount); + LEAVE('i', 0); + return 0; + } + for( ; gaSuperBitmap[a] & (1<= 0 ) + giLastPossibleFree = indx; + #endif + + if( indx < 0 ) { + Mutex_Release( &glPhysAlloc ); + Warning("MM_AllocPhys - OUT OF MEMORY (Called by %p) - %lli/%lli used (indx = %x)", + __builtin_return_address(0), giPhysAlloc, giPageCount, indx); + Log_Debug("PMem", "giLastPossibleFree = %lli", giLastPossibleFree); + LEAVE('i', 0); + return 0; + } + + if( indx > 0xFFFFF ) { + Panic("The fuck? Too many pages! (indx = 0x%x)", indx); + } + + if( indx >= giPageCount ) { + Mutex_Release( &glPhysAlloc ); + Log_Error("PMem", "MM_AllocPhys - indx(%i) > giPageCount(%i)", indx, giPageCount); + LEAVE('i', 0); return 0; } - for(b=0;gaSuperBitmap[a]&(1<0;c++); // Mark page used if(gaPageReferences) - gaPageReferences[a*32*32+b*32+c] = 1; - gaPageBitmap[ a*32+b ] |= 1 << c; + gaPageReferences[ indx ] = 1; + gaPageBitmap[ indx>>5 ] |= 1 << (indx&31); + + giPhysAlloc ++; + + // Get address + ret = indx << 12; + + // Mark used block + if(gaPageBitmap[ indx>>5 ] == -1) { + gaSuperBitmap[indx>>10] |= 1 << ((indx>>5)&31); + } + + // Release Spinlock + Mutex_Release( &glPhysAlloc ); + + LEAVE('X', ret); + #if TRACE_ALLOCS + Log_Debug("PMem", "MM_AllocPhys: RETURN 0x%llx (%i free)", ret, giPageCount-giPhysAlloc); + #endif + return ret; +} + +/** + * \fn tPAddr MM_AllocPhysRange(int Pages, int MaxBits) + * \brief Allocate a range of physical pages + * \param Pages Number of pages to allocate + * \param MaxBits Maximum number of address bits to use + */ +tPAddr MM_AllocPhysRange(int Pages, int MaxBits) +{ + int a, b; + int i, idx, sidx; + tPAddr ret; + + ENTER("iPages iMaxBits", Pages, MaxBits); + + // Sanity Checks + if(MaxBits < 0) { + LEAVE('i', 0); + return 0; + } + if(MaxBits > PHYS_BITS) MaxBits = PHYS_BITS; + + // Lock + Mutex_Acquire( &glPhysAlloc ); + + // Set up search state + if( giLastPossibleFree > ((tPAddr)1 << (MaxBits-12)) ) { + sidx = (tPAddr)1 << (MaxBits-12); + } + else { + sidx = giLastPossibleFree; + } + idx = sidx / 32; + sidx %= 32; + b = idx % 32; + a = idx / 32; + + #if 0 + LOG("a=%i, b=%i, idx=%i, sidx=%i", a, b, idx, sidx); + + // Find free page + for( ; gaSuperBitmap[a] == -1 && a --; ) b = 31; + if(a < 0) { + Mutex_Release( &glPhysAlloc ); + Warning("MM_AllocPhysRange - OUT OF MEMORY (Called by %p)", __builtin_return_address(0)); + LEAVE('i', 0); + return 0; + } + LOG("a = %i", a); + for( ; gaSuperBitmap[a] & (1 << b); b-- ) sidx = 31; + LOG("b = %i", b); + idx = a * 32 + b; + for( ; gaPageBitmap[idx] & (1 << sidx); sidx-- ) + LOG("gaPageBitmap[%i] = 0x%08x", idx, gaPageBitmap[idx]); + + LOG("idx = %i, sidx = %i", idx, sidx); + #else + + #endif + + // Check if the gap is large enough + while( idx >= 0 ) + { + // Find a free page + for( ; ; ) + { + // Bulk Skip + if( gaPageBitmap[idx] == -1 ) { + idx --; + sidx = 31; + continue; + } + + if( gaPageBitmap[idx] & (1 << sidx) ) { + sidx --; + if(sidx < 0) { sidx = 31; idx --; } + if(idx < 0) break; + continue; + } + break; + } + if( idx < 0 ) break; + + // Check if it is a free range + for( i = 0; i < Pages; i++ ) + { + // Used page? break + if( gaPageBitmap[idx] & (1 << sidx) ) + break; + + sidx --; + if(sidx < 0) { sidx = 31; idx --; } + if(idx < 0) break; + } + + if( i == Pages ) + break; + } + + // Check if an address was found + if( idx < 0 ) { + Mutex_Release( &glPhysAlloc ); + Warning("MM_AllocPhysRange - OUT OF MEMORY (Called by %p)", __builtin_return_address(0)); + LEAVE('i', 0); + return 0; + } + + // Mark pages used + for( i = 0; i < Pages; i++ ) + { + if(gaPageReferences) + gaPageReferences[idx*32+sidx] = 1; + gaPageBitmap[ idx ] |= 1 << sidx; + sidx ++; + giPhysAlloc ++; + if(sidx == 32) { sidx = 0; idx ++; } + } // Get address - ret = (a << 22) + (b << 17) + (c << 12); + ret = (idx << 17) | (sidx << 12); // Mark used block - if(gaPageBitmap[ a*32+b ] == -1) gaSuperBitmap[a] |= 1 << b; + if(gaPageBitmap[ idx ] == -1) gaSuperBitmap[idx/32] |= 1 << (idx%32); // Release Spinlock - RELEASE( &giPhysAlloc ); - LOG("Allocated 0x%x\n", ret); - //LOG("ret = %x", ret); + Mutex_Release( &glPhysAlloc ); + + LEAVE('X', ret); + #if TRACE_ALLOCS + Log_Debug("PMem", "MM_AllocPhysRange: RETURN 0x%llx-0x%llx (%i free)", + ret, ret + (1<>= 12; + PAddr >>= 12; // We don't care about non-ram pages - if(Addr >= giPageCount) return; + if(PAddr >= giPageCount) return; // Lock Structures - LOCK( &giPhysAlloc ); + Mutex_Acquire( &glPhysAlloc ); // Reference the page if(gaPageReferences) - gaPageReferences[ Addr ] ++; + gaPageReferences[ PAddr ] ++; // Mark as used - gaPageBitmap[ Addr / 32 ] |= 1 << (Addr&31); + gaPageBitmap[ PAddr / 32 ] |= 1 << (PAddr&31); // Mark used block - if(gaPageBitmap[ Addr / 32 ] == -1) gaSuperBitmap[Addr/1024] |= 1 << ((Addr/32)&31); + if(gaPageBitmap[ PAddr / 32 ] == -1) + gaSuperBitmap[PAddr/1024] |= 1 << ((PAddr/32)&31); // Release Spinlock - RELEASE( &giPhysAlloc ); + Mutex_Release( &glPhysAlloc ); } /** - * \fn void MM_DerefPhys(Uint32 Addr) + * \fn void MM_DerefPhys(tPAddr PAddr) + * \brief Dereferences a physical page */ -void MM_DerefPhys(tPAddr Addr) +void MM_DerefPhys(tPAddr PAddr) { // Get page number - Addr >>= 12; + PAddr >>= 12; // We don't care about non-ram pages - if(Addr >= giPageCount) return; + if(PAddr >= giPageCount) return; // Check if it is freed - if(gaPageReferences[ Addr ] == 0) { + if(gaPageReferences[ PAddr ] == 0) { Warning("MM_DerefPhys - Non-referenced memory dereferenced"); return; } // Lock Structures - LOCK( &giPhysAlloc ); + Mutex_Acquire( &glPhysAlloc ); + if( giLastPossibleFree < PAddr ) + giLastPossibleFree = PAddr; + // Dereference - gaPageReferences[ Addr ] --; + gaPageReferences[ PAddr ] --; // Mark as free in bitmaps - if( gaPageReferences[ Addr ] == 0 ) + if( gaPageReferences[ PAddr ] == 0 ) { - LOG("Freed 0x%x\n", Addr); - gaPageBitmap[ Addr / 32 ] &= ~(1 << (Addr&31)); - if(gaPageReferences[ Addr ] == 0) - gaSuperBitmap[ Addr >> 10 ] &= ~(1 << ((Addr >> 5)&31)); + #if TRACE_ALLOCS + Log_Debug("PMem", "MM_DerefPhys: Free'd 0x%x (%i free)", PAddr, giPageCount-giPhysAlloc); + #endif + //LOG("Freed 0x%x by %p\n", PAddr<<12, __builtin_return_address(0)); + giPhysAlloc --; + gaPageBitmap[ PAddr / 32 ] &= ~(1 << (PAddr&31)); + if(gaPageReferences[ PAddr ] == 0) + gaSuperBitmap[ PAddr >> 10 ] &= ~(1 << ((PAddr >> 5)&31)); } // Release spinlock - RELEASE( &giPhysAlloc ); + Mutex_Release( &glPhysAlloc ); } /** * \fn int MM_GetRefCount(tPAddr Addr) */ -int MM_GetRefCount(tPAddr Addr) +int MM_GetRefCount(tPAddr PAddr) { // Get page number - Addr >>= 12; + PAddr >>= 12; // We don't care about non-ram pages - if(Addr >= giPageCount) return -1; + if(PAddr >= giPageCount) return -1; // Check if it is freed - return gaPageReferences[ Addr ]; + return gaPageReferences[ PAddr ]; }