4 * include/tpl_mm_phys_bitmap.h
5 * Physical Memory Manager Template
10 * Uses 4.125+PtrSize bytes per page
13 #define MM_PAGE_REFCOUNTS MM_PMM_BASE
14 #define MM_PAGE_NODES (MM_PMM_BASE+(MM_MAXPHYSPAGE*sizeof(Uint32)))
15 #define MM_PAGE_BITMAP (MM_PAGE_NODES+(MM_MAXPHYSPAGE*sizeof(void*)))
17 #define PAGE_BITMAP_FREE(__pg) (gaPageBitmaps[(__pg)/32] & (1LL << ((__pg)&31)))
18 #define PAGE_BITMAP_SETFREE(__pg) do{gaPageBitmaps[(__pg)/32] |= (1LL << ((__pg)&31));}while(0)
19 #define PAGE_BITMAP_SETUSED(__pg) do{gaPageBitmaps[(__pg)/32] &= ~(1LL << ((__pg)&31));}while(0)
22 //void MM_InitPhys_Multiboot(tMBoot_Info *MBoot);
23 //tPAddr MM_AllocPhysRange(int Num, int Bits);
24 //tPAddr MM_AllocPhys(void);
25 //void MM_RefPhys(tPAddr PAddr);
26 //void MM_DerefPhys(tPAddr PAddr);
27 int MM_int_GetRangeID( tPAddr Addr );
28 int MM_int_GetMapEntry( void *Data, int Index, tPAddr *Start, tPAddr *Length );
29 void MM_Tpl_InitPhys(int MaxRAMPage, void *MemoryMap);
32 tMutex glPhysicalPages;
33 void **gapPageNodes = (void*)MM_PAGE_NODES; //!< Associated VFS Node for each page
34 Uint32 *gaiPageReferences = (void*)MM_PAGE_REFCOUNTS; // Reference Counts
35 Uint32 *gaPageBitmaps = (void*)MM_PAGE_BITMAP; // Used bitmap (1 == avail)
36 Uint64 giMaxPhysPage = 0; // Maximum Physical page
44 * \brief Initialise the physical memory manager with a passed memory map
46 void MM_Tpl_InitPhys(int MaxRAMPage, void *MemoryMap)
49 tPAddr rangeStart, rangeLen;
51 if( MM_PAGE_BITMAP + (MM_MAXPHYSPAGE/8) > MM_PMM_END ) {
52 Log_KernelPanic("PMM", "Config Error, PMM cannot fit data in allocated range");
55 giMaxPhysPage = MaxRAMPage;
57 // for( i = 0; i < MM_RANGE_MAX; i ++ )
58 // gaiPhysRangeFirstFree[i] = -1;
61 while( MM_int_GetMapEntry(MemoryMap, mapIndex++, &rangeStart, &rangeLen) )
65 LOG("Range %i, %P to %P", mapIndex-1, rangeStart, rangeLen);
66 rangeStart /= PAGE_SIZE;
67 rangeLen /= PAGE_SIZE;
69 giPhysNumFree += rangeLen;
71 LOG("rangeStart = 0x%x, rangeLen = 0x%x", rangeStart, rangeLen);
73 if( giPhysFirstFree == -1 || giPhysFirstFree > rangeStart )
74 giPhysFirstFree = rangeStart;
76 if( giPhysLastFree < rangeStart + rangeLen )
77 giPhysLastFree = rangeStart + rangeLen;
79 LOG("giPhysFirstFree = 0x%x, giPhysLastFree = 0x%x", giPhysFirstFree, giPhysLastFree);
81 bitmap_page = (tVAddr)&gaPageBitmaps[rangeStart/32];
82 bitmap_page &= ~(PAGE_SIZE-1);
84 // Only need to allocate bitmaps
85 if( !MM_GetPhysAddr( bitmap_page ) ) {
86 if( !MM_Allocate( bitmap_page ) ) {
87 Log_KernelPanic("PMM", "Out of memory during init, this is bad");
90 // memset( (void*)bitmap_page, 0, (rangeStart/8) & ~(PAGE_SIZE-1) );
91 memset( (void*)bitmap_page, 0, PAGE_SIZE );
95 for( ; (rangeStart & 31) && rangeLen > 0; rangeStart++, rangeLen-- ) {
96 gaPageBitmaps[rangeStart / 32] |= 1 << (rangeStart&31);
97 LOG("gaPageBitmaps[%i] = 0x%x", rangeStart/32, gaPageBitmaps[rangeStart/32]);
99 // Mark blocks of 32 as avail
100 for( ; rangeLen > 31; rangeStart += 32, rangeLen -= 32 ) {
101 gaPageBitmaps[rangeStart / 32] = -1;
104 for( ; rangeLen > 0; rangeStart ++, rangeLen -- ) {
105 gaPageBitmaps[rangeStart / 32] |= 1 << (rangeStart&31);
111 LOG("giPhysFirstFree = 0x%x, giPhysLastFree = 0x%x", giPhysFirstFree, giPhysLastFree);
116 * \brief Allocate a contiguous range of physical pages with a maximum
117 * bit size of \a MaxBits
118 * \param Pages Number of pages to allocate
119 * \param MaxBits Maximum size of the physical address
120 * \note If \a MaxBits is <= 0, any sized address is used (with preference
121 * to higher addresses)
123 tPAddr MM_AllocPhysRange(int Pages, int MaxBits)
128 ENTER("iPages iBits", Pages, MaxBits);
130 Mutex_Acquire(&glPhysicalPages);
132 // Check if there is enough in the range
133 if(giPhysNumFree >= Pages)
135 LOG("{0x%x -> 0x%x}", giPhysFirstFree, giPhysLastFree);
136 // Do a cheap scan, scanning upwards from the first free page in
139 addr = giPhysFirstFree;
140 while( addr <= giPhysLastFree )
143 // Check the super bitmap
144 if( gaSuperBitmap[addr / (32*32)] == 0 )
146 LOG("nFree = %i = 0 (super) (0x%x)", nFree, addr);
149 addr &= ~(32*32-1); // (1LL << 6+6) - 1
153 LOG("gaPageBitmaps[%i] = 0x%x", addr/32, gaPageBitmaps[addr/32]);
154 // Check page block (32 pages)
155 if( gaPageBitmaps[addr / 32] == 0) {
156 LOG("nFree = %i = 0 (block) (0x%x)", nFree, addr);
162 // Check individual page
163 if( !(gaPageBitmaps[addr / 32] & (1LL << (addr & 31))) )
165 LOG("nFree = %i = 0 (page) (0x%x)", nFree, addr);
172 LOG("nFree(%i) == %i (1x%x)", nFree, Pages, addr);
176 LOG("nFree = %i", nFree);
177 // If we don't find a contiguous block, nFree will not be equal
178 // to Num, so we set it to zero and do the expensive lookup.
179 if(nFree != Pages) nFree = 0;
185 // Oops. ok, let's do an expensive check (scan down the list
186 // until a free range is found)
188 addr = gaiPhysRangeLastFree[ rangeID ];
191 Mutex_Release(&glPhysicalPages);
194 Warning(" MM_AllocPhysRange: Out of memory (unable to fulfil request for %i pages)", Pages);
196 "Out of memory (unable to fulfil request for %i pages)",
202 LOG("nFree = %i, addr = 0x%08x", nFree, (addr-Pages) << 12);
204 // Mark pages as allocated
206 for( i = 0; i < Pages; i++, addr++ )
209 PAGE_BITMAP_SETUSED(addr);
210 // Maintain first possible free
212 if(addr == giPhysFirstFree)
213 giPhysFirstFree += 1;
215 LOG("if( MM_GetPhysAddr( %p ) )", &gaiPageReferences[addr]);
216 // Mark as referenced if the reference count page is valid
217 if( MM_GetPhysAddr( (tVAddr)&gaiPageReferences[addr] ) ) {
218 gaiPageReferences[addr] = 1;
221 ret = addr - Pages; // Save the return address
222 LOG("ret = %x", ret);
225 LogF("MM_AllocPhysRange: %P (%i pages)\n", ret, Pages);
229 // Update super bitmap
230 Pages += addr & (32-1);
232 Pages = (Pages + (32-1)) & ~(32-1);
233 for( i = 0; i < Pages/32; i++ )
235 if( gaPageBitmaps[ addr / 32 ] + 1 == 0 )
236 gaSuperBitmap[addr / (32*32)] |= 1LL << ((addr / 32) & 31);
240 Mutex_Release(&glPhysicalPages);
241 LEAVE('x', ret << 12);
246 * \brief Allocate a single physical page, with no preference as to address size.
248 tPAddr MM_AllocPhys(void)
254 // Hack to allow allocation during setup
255 for(i = 0; i < NUM_STATIC_ALLOC; i++) {
256 if( gaiStaticAllocPages[i] ) {
257 tPAddr ret = gaiStaticAllocPages[i];
258 gaiStaticAllocPages[i] = 0;
259 Log("MM_AllocPhys: Return %x, static alloc %i", ret, i);
265 for( ret = 0; ret < giMaxPhysPage; ret ++ )
267 if( !MM_GetPhysAddr( (tVAddr)&gaPageBitmaps[ret/32] ) ) {
271 if( gaPageBitmaps[ret/32] == 0 ) {
275 if( gaPageBitmaps[ret/32] & (1 << (ret&31)) ) {
276 gaPageBitmaps[ret/32] &= ~(1 << (ret&31));
277 return ret * PAGE_SIZE;
280 Log_Error("PMM", "MM_AllocPhys failed duing init");
284 Log("AllocPhys by %p", __builtin_return_address(0));
287 return MM_AllocPhysRange(1, -1);
291 * \brief Reference a physical page
293 void MM_RefPhys(tPAddr PAddr)
295 tPAddr page = PAddr / PAGE_SIZE;
296 tVAddr refpage = (tVAddr)&gaiPageReferences[page] & ~(PAGE_SIZE-1);
298 if( page >= giMaxPhysPage ) return ;
300 if( PAGE_BITMAP_FREE(page) )
303 PAGE_BITMAP_SETUSED(page);
305 if( gaPageBitmaps[page / 32] == 0 )
306 gaSuperBitmap[page / (32*32)] &= ~(1LL << ((page / 32) & 31));
308 if( MM_GetPhysAddr( refpage ) )
309 gaiPageReferences[page] = 1;
314 if( !MM_GetPhysAddr( refpage ) )
316 int pages_per_page, basepage, i;
317 if( MM_Allocate(refpage) == 0 ) {
318 // Out of memory, can this be resolved?
319 // TODO: Reclaim memory
320 Log_Error("PMM", "Out of memory (MM_RefPhys)");
323 pages_per_page = PAGE_SIZE/sizeof(*gaiPageReferences);
324 basepage = page & ~(pages_per_page-1);
325 for( i = 0; i < pages_per_page; i ++ ) {
326 if( PAGE_BITMAP_FREE(basepage+i) )
327 gaiPageReferences[basepage+i] = 0;
329 gaiPageReferences[basepage+i] = 1;
331 gaiPageReferences[page] = 2;
334 gaiPageReferences[ page ] ++;
338 int MM_GetRefCount(tPAddr PAddr)
341 if( MM_GetPhysAddr( (tVAddr)&gaiPageReferences[PAddr] ) ) {
342 return gaiPageReferences[PAddr];
345 if( gaPageBitmaps[ PAddr / 32 ] & (1LL << (PAddr&31)) ) {
353 * \brief Dereference a physical page
355 void MM_DerefPhys(tPAddr PAddr)
357 Uint64 page = PAddr >> 12;
359 if( PAddr >> 12 > giMaxPhysPage ) return ;
361 ENTER("PPAddr", PAddr);
363 if( MM_GetPhysAddr( (tVAddr)&gaiPageReferences[page] ) )
365 if( gaiPageReferences[page] > 0 )
366 gaiPageReferences[ page ] --;
367 if( gaiPageReferences[ page ] == 0 ) {
368 gaPageBitmaps[ page / 32 ] |= 1 << (page&31);
369 // TODO: Catch when all pages in this range have been dereferenced
373 gaPageBitmaps[ page / 32 ] |= 1 << (page&31);
374 // Clear node if needed
375 if( MM_GetPhysAddr( (tVAddr)&gapPageNodes[page] ) ) {
376 gapPageNodes[page] = NULL;
377 // TODO: Catch when all pages in this range are not using nodes
380 // Update the free counts if the page was freed
381 if( gaPageBitmaps[ page / 32 ] & (1LL << (page&31)) )
384 if( giPhysFirstFree == -1 || giPhysFirstFree > page )
385 giPhysFirstFree = page;
386 if( giPhysLastFree < page )
387 giPhysLastFree = page;
391 // If the bitmap entry is not zero, set the bit free in the super bitmap
392 if(gaPageBitmaps[ page / 32 ] != 0 ) {
393 gaSuperBitmap[page / (32*32)] |= 1LL << ((page / 32) & 31);
399 int MM_SetPageNode(tPAddr PAddr, void *Node)
401 tPAddr page = PAddr >> 12;
402 tVAddr node_page = ((tVAddr)&gapPageNodes[page]) & ~(PAGE_SIZE-1);
404 if( !MM_GetRefCount(PAddr) ) return 1;
406 if( !MM_GetPhysAddr(node_page) ) {
407 if( !MM_Allocate(node_page) )
409 memset( (void*)node_page, 0, PAGE_SIZE );
412 gapPageNodes[page] = Node;
416 int MM_GetPageNode(tPAddr PAddr, void **Node)
418 if( !MM_GetRefCount(PAddr) ) return 1;
421 if( !MM_GetPhysAddr( (tVAddr)&gapPageNodes[PAddr] ) ) {
426 *Node = gapPageNodes[PAddr];