KernelLand/Kernel/include/tpl_mm_phys_stack.h

   1 /*
   2  * Acess2 Core
   3  *
   4  * include/tpl_mm_phys.h
   5  * Physical Memory Manager Template
   6  */
   7 #define DEBUG   0
   8
   9 /**
  10  * \file tpl_mm_phys_stack.h
  11  * \brief Template physical memory manager
  12  *
  13  * An extensible physical memory manager
  14  *
  15  * Usage: Requires NUM_MM_PHYS_RANGES to be set to the number of address
  16  * "classes" wanted.
  17  * MAX_PHYS_PAGES - Used to calculate structure sizes
  18  * PADDR_TYPE
  19  */
  20
  21 // === PROTOTYPES ===
  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_IsPhysUnavail( tPageNum Page );
  29
  30 // === GLOBALS ===
  31 tMutex  glPhysicalPages;
  32 //Uint64        *gaPageStacks[NUM_MM_PHYS_RANGES];      // Page stacks
  33  int    giPageStackSizes[NUM_MM_PHYS_RANGES];   // Points to the first unused slot
  34 Uint32  *gaiPageReferences = (void*)MM_PAGE_COUNTS;     // Reference Counts
  35 Uint64  giMaxPhysPage = 0;      // Maximum Physical page
  36
  37 // === CODE ===
  38 /**
  39  * \brief Initialise the physical memory map using a Multiboot 1 map
  40  */
  41 void MM_Tpl_InitPhys(int MaxRAMPage)
  42 {
  43         const int       PAGE_SIZE = 0x1000;
  44         const int       pagesPerPageOnStack = PAGE_SIZE / sizeof(gaPageStack[0]);
  45          int    i;
  46         tPageNum        page;
  47
  48 //      ENTER("pMBoot=%p", MBoot);
  49
  50         giMaxPhysPage = MaxRAMPage;
  51
  52         tPAddr  page = 0;
  53         for( i = 0; i < NUM_MM_PHYS_RANGES; i ++ )
  54         {
  55                 for( ; page < giPageRangeMax[i] && page < giMaxPhysPage; page ++ )
  56                 {
  57                          int    rangeSize;
  58
  59                         rangeSize = MM_int_IsPhysUnavail(page);
  60                         if( rangeSize > 0 ) {
  61                                 page += rangeSize;
  62                                 continue;
  63                         }
  64                         // Page is avaliable for use
  65
  66                         // Check if the page stack is allocated
  67                         tVAddr  stack_page = &gaPageStacks[i][giPageStackSizes[i]&~pagesPerPageOnStack];
  68                         if( !MM_GetPhysAddr( stack_page ) ) {
  69                                 MM_Map( stack_page, page*PAGE_SIZE );
  70                         }
  71                         else {
  72                                 gaPageStacks[i][ giPageStackSizes[i] ] = page;
  73                                 giPageStackSizes[i] ++;
  74                         }
  75                 }
  76         }
  77
  78         LEAVE('-');
  79 }
  80
  81 void MM_DumpStatistics(void)
  82 {
  83         // TODO: PM Statistics for tpl_mm_phys_bitmap
  84 }
  85
  86 /**
  87  * \brief Allocate a contiguous range of physical pages with a maximum
  88  *        bit size of \a MaxBits
  89  * \param Pages Number of pages to allocate
  90  * \param MaxBits       Maximum size of the physical address
  91  * \note If \a MaxBits is <= 0, any sized address is used (with preference
  92  *       to higher addresses)
  93  */
  94 tPAddr MM_AllocPhysRange(int Pages, int MaxBits)
  95 {
  96         tPAddr  addr, ret;
  97          int    rangeID;
  98          int    nFree = 0, i;
  99
 100         ENTER("iPages iBits", Pages, MaxBits);
 101
 102         if( MaxBits <= 0 || MaxBits >= 64 )     // Speedup for the common case
 103                 rangeID = MM_PHYS_MAX;
 104         else
 105                 rangeID = MM_int_GetRangeID( (1LL << MaxBits) - 1 );
 106
 107         LOG("rangeID = %i", rangeID);
 108
 109         Mutex_Acquire(&glPhysicalPages);
 110
 111         // Check if the range actually has any free pages
 112         while(giPageStackSizes[rangeID] == 0 && rangeID)
 113                 rangeID --;
 114
 115         LOG("rangeID = %i", rangeID);
 116
 117         // What the? Oh, man. No free pages
 118         if(giPageStackSizes[rangeID] == 0) {
 119                 Mutex_Release(&glPhysicalPages);
 120                 // TODO: Page out / attack the cache
 121                 // ATM. Just Warning
 122                 Warning(" MM_AllocPhysRange: Out of free pages");
 123                 Log_Warning("Arch",
 124                         "Out of memory (unable to fulfil request for %i pages), zero remaining",
 125                         Pages
 126                         );
 127                 LEAVE('i', 0);
 128                 return 0;
 129         }
 130
 131         // Check if there is enough in the range
 132         if(giPhysRangeFree[rangeID] >= Pages)
 133         {
 134                 LOG("{%i,0x%x -> 0x%x}",
 135                         giPhysRangeFree[rangeID],
 136                         giPhysRangeFirst[rangeID], giPhysRangeLast[rangeID]
 137                         );
 138                 // Do a cheap scan, scanning upwards from the first free page in
 139                 // the range
 140                 nFree = 0;
 141                 addr = giPhysRangeFirst[ rangeID ];
 142                 while( addr <= giPhysRangeLast[ rangeID ] )
 143                 {
 144                         //Log(" MM_AllocPhysRange: addr = 0x%x", addr);
 145                         // Check the super bitmap
 146                         if( gaSuperBitmap[addr >> (6+6)] + 1 == 0 ) {
 147                                 LOG("nFree = %i = 0 (super) (0x%x)", nFree, addr);
 148                                 nFree = 0;
 149                                 addr += 1LL << (6+6);
 150                                 addr &= ~0xFFF; // (1LL << 6+6) - 1
 151                                 continue;
 152                         }
 153                         // Check page block (64 pages)
 154                         if( gaMainBitmap[addr >> 6] + 1 == 0) {
 155                                 LOG("nFree = %i = 0 (main) (0x%x)", nFree, addr);
 156                                 nFree = 0;
 157                                 addr += 1LL << (6);
 158                                 addr &= ~0x3F;
 159                                 continue;
 160                         }
 161                         // Check individual page
 162                         if( gaMainBitmap[addr >> 6] & (1LL << (addr & 63)) ) {
 163                                 LOG("nFree = %i = 0 (page) (0x%x)", nFree, addr);
 164                                 nFree = 0;
 165                                 addr ++;
 166                                 continue;
 167                         }
 168                         nFree ++;
 169                         addr ++;
 170                         LOG("nFree(%i) == %i (0x%x)", nFree, Pages, addr);
 171                         if(nFree == Pages)
 172                                 break;
 173                 }
 174                 LOG("nFree = %i", nFree);
 175                 // If we don't find a contiguous block, nFree will not be equal
 176                 // to Num, so we set it to zero and do the expensive lookup.
 177                 if(nFree != Pages)      nFree = 0;
 178         }
 179
 180         if( !nFree )
 181         {
 182                 // Oops. ok, let's do an expensive check (scan down the list
 183                 // until a free range is found)
 184                 nFree = 1;
 185                 addr = giPhysRangeLast[ rangeID ];
 186                 // TODO
 187                 Mutex_Release(&glPhysicalPages);
 188                 // TODO: Page out
 189                 // ATM. Just Warning
 190                 Warning(" MM_AllocPhysRange: Out of memory (unable to fulfil request for %i pages)", Pages);
 191                 Log_Warning("Arch",
 192                         "Out of memory (unable to fulfil request for %i pages)",
 193                         Pages
 194                         );
 195                 LEAVE('i', 0);
 196                 return 0;
 197         }
 198         LOG("nFree = %i, addr = 0x%08x", nFree, addr);
 199
 200         // Mark pages as allocated
 201         addr -= Pages;
 202         for( i = 0; i < Pages; i++, addr++ )
 203         {
 204                 gaMainBitmap[addr >> 6] |= 1LL << (addr & 63);
 205                 rangeID = MM_int_GetRangeID(addr << 12);
 206                 giPhysRangeFree[ rangeID ] --;
 207                 LOG("%x == %x", addr, giPhysRangeFirst[ rangeID ]);
 208                 if(addr == giPhysRangeFirst[ rangeID ])
 209                         giPhysRangeFirst[ rangeID ] += 1;
 210         }
 211         ret = addr;     // Save the return address
 212
 213         // Update super bitmap
 214         Pages += addr & (64-1);
 215         addr &= ~(64-1);
 216         Pages = (Pages + (64-1)) & ~(64-1);
 217         for( i = 0; i < Pages/64; i++ )
 218         {
 219                 if( gaMainBitmap[ addr >> 6 ] + 1 == 0 )
 220                         gaSuperBitmap[addr>>12] |= 1LL << ((addr >> 6) & 63);
 221         }
 222
 223         Mutex_Release(&glPhysicalPages);
 224         LEAVE('x', ret << 12);
 225         return ret << 12;
 226 }
 227
 228 /**
 229  * \brief Allocate a single physical page, with no preference as to address
 230  *        size.
 231  */
 232 tPAddr MM_AllocPhys(void)
 233 {
 234          int    i;
 235
 236         // Hack to allow allocation during setup
 237         for(i = 0; i < NUM_STATIC_ALLOC; i++) {
 238                 if( gaiStaticAllocPages[i] ) {
 239                         tPAddr  ret = gaiStaticAllocPages[i];
 240                         gaiStaticAllocPages[i] = 0;
 241                         Log("MM_AllocPhys: Return %x, static alloc %i", ret, i);
 242                         return ret;
 243                 }
 244         }
 245
 246         return MM_AllocPhysRange(1, -1);
 247 }
 248
 249 /**
 250  * \brief Reference a physical page
 251  */
 252 void MM_RefPhys(tPAddr PAddr)
 253 {
 254         Uint64  page = PAddr >> 12;
 255
 256         if( PAddr >> 12 > giMaxPhysPage )       return ;
 257
 258         if( gaMainBitmap[ page >> 6 ] & (1LL << (page&63)) )
 259         {
 260                 // Reference again
 261                 gaMultiBitmap[ page >> 6 ] |= 1LL << (page&63);
 262                 gaiPageReferences[ page ] ++;
 263         }
 264         else
 265         {
 266                 // Allocate
 267                 gaMainBitmap[page >> 6] |= 1LL << (page&63);
 268                 if( gaMainBitmap[page >> 6 ] + 1 == 0 )
 269                         gaSuperBitmap[page>> 12] |= 1LL << ((page >> 6) & 63);
 270         }
 271 }
 272
 273 /**
 274  * \brief Dereference a physical page
 275  */
 276 void MM_DerefPhys(tPAddr PAddr)
 277 {
 278         Uint64  page = PAddr >> 12;
 279
 280         if( PAddr >> 12 > giMaxPhysPage )       return ;
 281
 282         if( gaMultiBitmap[ page >> 6 ] & (1LL << (page&63)) ) {
 283                 gaiPageReferences[ page ] --;
 284                 if( gaiPageReferences[ page ] == 1 )
 285                         gaMultiBitmap[ page >> 6 ] &= ~(1LL << (page&63));
 286                 if( gaiPageReferences[ page ] == 0 )
 287                         gaMainBitmap[ page >> 6 ] &= ~(1LL << (page&63));
 288         }
 289         else
 290                 gaMainBitmap[ page >> 6 ] &= ~(1LL << (page&63));
 291
 292         // Update the free counts if the page was freed
 293         if( !(gaMainBitmap[ page >> 6 ] & (1LL << (page&63))) )
 294         {
 295                  int    rangeID;
 296                 rangeID = MM_int_GetRangeID( PAddr );
 297                 giPhysRangeFree[ rangeID ] ++;
 298                 if( giPhysRangeFirst[rangeID] > page )
 299                         giPhysRangeFirst[rangeID] = page;
 300                 if( giPhysRangeLast[rangeID] < page )
 301                         giPhysRangeLast[rangeID] = page;
 302         }
 303
 304         // If the bitmap entry is not -1, unset the bit in the super bitmap
 305         if(gaMainBitmap[ page >> 6 ] + 1 != 0 ) {
 306                 gaSuperBitmap[page >> 12] &= ~(1LL << ((page >> 6) & 63));
 307         }
 308 }
 309
 310 /**
 311  * \brief Takes a physical address and returns the ID of its range
 312  * \param Addr  Physical address of page
 313  * \return Range ID from eMMPhys_Ranges
 314  */
 315 int MM_int_GetRangeID( tPAddr Addr )
 316 {
 317         if(Addr >> 32)
 318                 return MM_PHYS_MAX;
 319         else if(Addr >> 24)
 320                 return MM_PHYS_32BIT;
 321         else if(Addr >> 20)
 322                 return MM_PHYS_24BIT;
 323         else if(Addr >> 16)
 324                 return MM_PHYS_20BIT;
 325         else
 326                 return MM_PHYS_16BIT;
 327 }