Kernel/arch/armv7/mm_virt.c

   1 /*
   2  * Acess2
   3  *
   4  * ARM7 Virtual Memory Manager
   5  * - arch/arm7/mm_virt.c
   6  */
   7 #define DEBUG   0
   8 #include <acess.h>
   9 #include <mm_virt.h>
  10 #include <hal_proc.h>
  11
  12 #define TRACE_MAPS      0
  13
  14 #define AP_KRW_ONLY     1       // Kernel page
  15 #define AP_KRO_ONLY     5       // Kernel RO page
  16 #define AP_RW_BOTH      3       // Standard RW
  17 #define AP_RO_BOTH      6       // COW Page
  18 #define AP_RO_USER      2       // User RO Page
  19 #define PADDR_MASK_LVL1 0xFFFFFC00
  20
  21 // === IMPORTS ===
  22 extern Uint32   kernel_table0[];
  23
  24 // === TYPES ===
  25 typedef struct
  26 {
  27         tPAddr  PhysAddr;
  28         Uint8   Size;
  29         Uint8   Domain;
  30         BOOL    bExecutable;
  31         BOOL    bGlobal;
  32         BOOL    bShared;
  33          int    AP;
  34 } tMM_PageInfo;
  35
  36 //#define FRACTAL(table1, addr) ((table1)[ (0xFF8/4*1024) + ((addr)>>20)])
  37 #define FRACTAL(table1, addr)   ((table1)[ (0xFF8/4*1024) + ((addr)>>22)])
  38 #define USRFRACTAL(addr)        (*((Uint32*)(0x7FDFF000) + ((addr)>>22)))
  39 #define TLBIALL()       __asm__ __volatile__ ("mcr p15, 0, %0, c8, c7, 0" : : "r" (0))
  40 #define TLBIMVA(addr)   __asm__ __volatile__ ("mcr p15, 0, %0, c8, c7, 1" : : "r" (addr))
  41
  42 // === PROTOTYPES ===
  43 void    MM_int_GetTables(tVAddr VAddr, Uint32 **Table0, Uint32 **Table1);
  44  int    MM_int_AllocateCoarse(tVAddr VAddr, int Domain);
  45  int    MM_int_SetPageInfo(tVAddr VAddr, tMM_PageInfo *pi);
  46  int    MM_int_GetPageInfo(tVAddr VAddr, tMM_PageInfo *pi);
  47 tVAddr  MM_NewUserStack(void);
  48 tPAddr  MM_AllocateZero(tVAddr VAddr);
  49 tPAddr  MM_AllocateRootTable(void);
  50 void    MM_int_CloneTable(Uint32 *DestEnt, int Table);
  51 tPAddr  MM_Clone(void);
  52 tVAddr  MM_NewKStack(int bGlobal);
  53 void    MM_int_DumpTableEnt(tVAddr Start, size_t Len, tMM_PageInfo *Info);
  54 //void  MM_DumpTables(tVAddr Start, tVAddr End);
  55
  56 // === GLOBALS ===
  57 tPAddr  giMM_ZeroPage;
  58
  59 // === CODE ===
  60 int MM_InitialiseVirtual(void)
  61 {
  62         return 0;
  63 }
  64
  65 void MM_int_GetTables(tVAddr VAddr, Uint32 **Table0, Uint32 **Table1)
  66 {
  67         if(VAddr & 0x80000000) {
  68                 *Table0 = (void*)&kernel_table0;        // Level 0
  69                 *Table1 = (void*)MM_TABLE1KERN; // Level 1
  70         }
  71         else {
  72                 *Table0 = (void*)MM_TABLE0USER;
  73                 *Table1 = (void*)MM_TABLE1USER;
  74         }
  75 }
  76
  77 int MM_int_AllocateCoarse(tVAddr VAddr, int Domain)
  78 {
  79         Uint32  *table0, *table1;
  80         Uint32  *desc;
  81         tPAddr  paddr;
  82
  83         ENTER("xVAddr iDomain", VAddr, Domain);
  84
  85         MM_int_GetTables(VAddr, &table0, &table1);
  86
  87         VAddr &= ~(0x400000-1); // 4MiB per "block", 1 Page
  88
  89         desc = &table0[ VAddr>>20];
  90         LOG("desc = %p", desc);
  91
  92         // table0: 4 bytes = 1 MiB
  93
  94         LOG("desc[0] = %x", desc[0]);
  95         LOG("desc[1] = %x", desc[1]);
  96         LOG("desc[2] = %x", desc[2]);
  97         LOG("desc[3] = %x", desc[3]);
  98
  99         if( (desc[0] & 3) != 0 || (desc[1] & 3) != 0
 100          || (desc[2] & 3) != 0 || (desc[3] & 3) != 0 )
 101         {
 102                 // Error?
 103                 LEAVE('i', 1);
 104                 return 1;
 105         }
 106
 107         paddr = MM_AllocPhys();
 108         if( !paddr )
 109         {
 110                 // Error
 111                 LEAVE('i', 2);
 112                 return 2;
 113         }
 114
 115         *desc = paddr | (Domain << 5) | 1;
 116         desc[1] = desc[0] + 0x400;
 117         desc[2] = desc[0] + 0x800;
 118         desc[3] = desc[0] + 0xC00;
 119
 120         if( VAddr < 0x80000000 ) {
 121 //              Log("USRFRACTAL(%p) = %p", VAddr, &USRFRACTAL(VAddr));
 122                 USRFRACTAL(VAddr) = paddr | 3;
 123         }
 124         else {
 125 //              Log("FRACTAL(%p) = %p", VAddr, &FRACTAL(table1, VAddr));
 126                 FRACTAL(table1, VAddr) = paddr | 3;
 127         }
 128
 129         // TLBIALL
 130         TLBIALL();
 131
 132         LEAVE('i', 0);
 133         return 0;
 134 }
 135
 136 int MM_int_SetPageInfo(tVAddr VAddr, tMM_PageInfo *pi)
 137 {
 138         Uint32  *table0, *table1;
 139         Uint32  *desc;
 140
 141         ENTER("pVAddr ppi", VAddr, pi);
 142
 143         MM_int_GetTables(VAddr, &table0, &table1);
 144
 145         desc = &table0[ VAddr >> 20 ];
 146         LOG("desc = %p", desc);
 147
 148         switch(pi->Size)
 149         {
 150         case 12:        // Small Page
 151         case 16:        // Large Page
 152                 LOG("Page");
 153                 if( (*desc & 3) == 0 ) {
 154                         MM_int_AllocateCoarse( VAddr, pi->Domain );
 155                 }
 156                 desc = &table1[ VAddr >> 12 ];
 157                 LOG("desc (2) = %p", desc);
 158                 if( pi->Size == 12 )
 159                 {
 160                         // Small page
 161                         // - Error if overwriting a large page
 162                         if( (*desc & 3) == 1 )  LEAVE_RET('i', 1);
 163                         if( pi->PhysAddr == 0 ) {
 164                                 *desc = 0;
 165                                 LEAVE('i', 0);
 166                                 return 0;
 167                         }
 168
 169                         *desc = (pi->PhysAddr & 0xFFFFF000) | 2;
 170                         if(!pi->bExecutable)    *desc |= 1;     // XN
 171                         if(!pi->bGlobal)        *desc |= 1 << 11;       // NG
 172                         if( pi->bShared)        *desc |= 1 << 10;       // S
 173                         *desc |= (pi->AP & 3) << 4;     // AP
 174                         *desc |= ((pi->AP >> 2) & 1) << 9;      // APX
 175                         TLBIMVA(VAddr & 0xFFFFF000);
 176                         LEAVE('i', 0);
 177                         return 0;
 178                 }
 179                 else
 180                 {
 181                         // Large page
 182                         // TODO:
 183                         Log_Warning("MMVirt", "TODO: Implement large pages in MM_int_SetPageInfo");
 184                 }
 185                 break;
 186         case 20:        // Section or unmapped
 187                 Warning("TODO: Implement sections");
 188                 break;
 189         case 24:        // Supersection
 190                 // Error if not aligned
 191                 if( VAddr & 0xFFFFFF ) {
 192                         LEAVE('i', 1);
 193                         return 1;
 194                 }
 195                 if( (*desc & 3) == 0 || ((*desc & 3) == 2 && (*desc & (1 << 18)))  )
 196                 {
 197                         if( pi->PhysAddr == 0 ) {
 198                                 *desc = 0;
 199                                 // TODO: Apply to all entries
 200                                 LEAVE('i', 0);
 201                                 return 0;
 202                         }
 203                         // Apply
 204                         *desc = pi->PhysAddr & 0xFF000000;
 205 //                      *desc |= ((pi->PhysAddr >> 32) & 0xF) << 20;
 206 //                      *desc |= ((pi->PhysAddr >> 36) & 0x7) << 5;
 207                         *desc |= 2 | (1 << 18);
 208                         // TODO: Apply to all entries
 209                         LEAVE('i', 0);
 210                         return 0;
 211                 }
 212                 // TODO: What here?
 213                 LEAVE('i', 1);
 214                 return 1;
 215         }
 216
 217         LEAVE('i', 1);
 218         return 1;
 219 }
 220
 221 int MM_int_GetPageInfo(tVAddr VAddr, tMM_PageInfo *pi)
 222 {
 223         Uint32  *table0, *table1;
 224         Uint32  desc;
 225
 226 //      LogF("MM_int_GetPageInfo: VAddr=%p, pi=%p\n", VAddr, pi);
 227
 228         MM_int_GetTables(VAddr, &table0, &table1);
 229
 230         desc = table0[ VAddr >> 20 ];
 231
 232 //      if( VAddr > 0x90000000)
 233 //              LOG("table0 desc(%p) = %x", &table0[ VAddr >> 20 ], desc);
 234
 235         pi->bExecutable = 1;
 236         pi->bGlobal = 0;
 237         pi->bShared = 0;
 238         pi->AP = 0;
 239
 240         switch( (desc & 3) )
 241         {
 242         // 0: Unmapped
 243         case 0:
 244                 pi->PhysAddr = 0;
 245                 pi->Size = 20;
 246                 pi->Domain = 0;
 247                 return 1;
 248
 249         // 1: Coarse page table
 250         case 1:
 251                 // Domain from top level table
 252                 pi->Domain = (desc >> 5) & 7;
 253                 // Get next level
 254                 desc = table1[ VAddr >> 12 ];
 255 //              LOG("table1 desc(%p) = %x", &table1[ VAddr >> 12 ], desc);
 256                 switch( desc & 3 )
 257                 {
 258                 // 0: Unmapped
 259                 case 0:
 260                         pi->Size = 12;
 261                         return 1;
 262                 // 1: Large Page (64KiB)
 263                 case 1:
 264                         pi->Size = 16;
 265                         pi->PhysAddr = desc & 0xFFFF0000;
 266                         pi->AP = ((desc >> 4) & 3) | (((desc >> 9) & 1) << 2);
 267                         pi->bExecutable = !(desc & 0x8000);
 268                         pi->bShared = (desc >> 10) & 1;
 269                         return 0;
 270                 // 2/3: Small page
 271                 case 2:
 272                 case 3:
 273                         pi->Size = 12;
 274                         pi->PhysAddr = desc & 0xFFFFF000;
 275                         pi->bExecutable = !(desc & 1);
 276                         pi->bGlobal = !(desc >> 11);
 277                         pi->bShared = (desc >> 10) & 1;
 278                         pi->AP = ((desc >> 4) & 3) | (((desc >> 9) & 1) << 2);
 279                         return 0;
 280                 }
 281                 return 1;
 282
 283         // 2: Section (or Supersection)
 284         case 2:
 285                 if( desc & (1 << 18) ) {
 286                         // Supersection
 287                         pi->PhysAddr = desc & 0xFF000000;
 288                         pi->PhysAddr |= (Uint64)((desc >> 20) & 0xF) << 32;
 289                         pi->PhysAddr |= (Uint64)((desc >> 5) & 0x7) << 36;
 290                         pi->Size = 24;
 291                         pi->Domain = 0; // Supersections default to zero
 292                         pi->AP = ((desc >> 10) & 3) | (((desc >> 15) & 1) << 2);
 293                         return 0;
 294                 }
 295
 296                 // Section
 297                 pi->PhysAddr = desc & 0xFFF80000;
 298                 pi->Size = 20;
 299                 pi->Domain = (desc >> 5) & 7;
 300                 pi->AP = ((desc >> 10) & 3) | (((desc >> 15) & 1) << 2);
 301                 return 0;
 302
 303         // 3: Reserved (invalid)
 304         case 3:
 305                 pi->PhysAddr = 0;
 306                 pi->Size = 20;
 307                 pi->Domain = 0;
 308                 return 2;
 309         }
 310         return 2;
 311 }
 312
 313 // --- Exports ---
 314 tPAddr MM_GetPhysAddr(tVAddr VAddr)
 315 {
 316         tMM_PageInfo    pi;
 317         if( MM_int_GetPageInfo(VAddr, &pi) )
 318                 return 0;
 319         return pi.PhysAddr | (VAddr & ((1 << pi.Size)-1));
 320 }
 321
 322 Uint MM_GetFlags(tVAddr VAddr)
 323 {
 324         tMM_PageInfo    pi;
 325          int    ret;
 326
 327         if( MM_int_GetPageInfo(VAddr, &pi) )
 328                 return 0;
 329
 330         ret = 0;
 331
 332         switch(pi.AP)
 333         {
 334         case 0:
 335                 break;
 336         case AP_KRW_ONLY:
 337                 ret |= MM_PFLAG_KERNEL;
 338                 break;
 339         case AP_KRO_ONLY:
 340                 ret |= MM_PFLAG_KERNEL|MM_PFLAG_RO;
 341                 break;
 342         case AP_RW_BOTH:
 343                 break;
 344         case AP_RO_BOTH:
 345                 ret |= MM_PFLAG_COW;
 346                 break;
 347         case AP_RO_USER:
 348                 ret |= MM_PFLAG_RO;
 349                 break;
 350         }
 351
 352         if( pi.bExecutable )    ret |= MM_PFLAG_EXEC;
 353         return ret;
 354 }
 355
 356 void MM_SetFlags(tVAddr VAddr, Uint Flags, Uint Mask)
 357 {
 358         tMM_PageInfo    pi;
 359         Uint    curFlags;
 360
 361         if( MM_int_GetPageInfo(VAddr, &pi) )
 362                 return ;
 363
 364         curFlags = MM_GetPhysAddr(VAddr);
 365         if( (curFlags & Mask) == Flags )
 366                 return ;
 367         curFlags &= ~Mask;
 368         curFlags |= Flags;
 369
 370         if( curFlags & MM_PFLAG_COW )
 371                 pi.AP = AP_RO_BOTH;
 372         else
 373         {
 374                 switch(curFlags & (MM_PFLAG_KERNEL|MM_PFLAG_RO) )
 375                 {
 376                 case 0:
 377                         pi.AP = AP_RW_BOTH;     break;
 378                 case MM_PFLAG_KERNEL:
 379                         pi.AP = AP_KRW_ONLY;    break;
 380                 case MM_PFLAG_RO:
 381                         pi.AP = AP_RO_USER;     break;
 382                 case MM_PFLAG_KERNEL|MM_PFLAG_RO:
 383                         pi.AP = AP_KRO_ONLY;    break;
 384                 }
 385         }
 386
 387         pi.bExecutable = !!(curFlags & MM_PFLAG_EXEC);
 388
 389         MM_int_SetPageInfo(VAddr, &pi);
 390 }
 391
 392 int MM_Map(tVAddr VAddr, tPAddr PAddr)
 393 {
 394         tMM_PageInfo    pi = {0};
 395         #if TRACE_MAPS
 396         Log("MM_Map %P=>%p", PAddr, VAddr);
 397         #endif
 398
 399         pi.PhysAddr = PAddr;
 400         pi.Size = 12;
 401         if(VAddr < USER_STACK_TOP)
 402                 pi.AP = AP_RW_BOTH;
 403         else
 404                 pi.AP = AP_KRW_ONLY;    // Kernel Read/Write
 405         pi.bExecutable = 1;
 406         if( MM_int_SetPageInfo(VAddr, &pi) ) {
 407                 MM_DerefPhys(pi.PhysAddr);
 408                 return 0;
 409         }
 410         return pi.PhysAddr;
 411 }
 412
 413 tPAddr MM_Allocate(tVAddr VAddr)
 414 {
 415         tMM_PageInfo    pi = {0};
 416
 417         ENTER("pVAddr", VAddr);
 418
 419         pi.PhysAddr = MM_AllocPhys();
 420         if( pi.PhysAddr == 0 )  LEAVE_RET('i', 0);
 421         pi.Size = 12;
 422         if(VAddr < USER_STACK_TOP)
 423                 pi.AP = AP_RW_BOTH;
 424         else
 425                 pi.AP = AP_KRW_ONLY;
 426         pi.bExecutable = 1;
 427         if( MM_int_SetPageInfo(VAddr, &pi) ) {
 428                 MM_DerefPhys(pi.PhysAddr);
 429                 LEAVE('i', 0);
 430                 return 0;
 431         }
 432         LEAVE('x', pi.PhysAddr);
 433         return pi.PhysAddr;
 434 }
 435
 436 tPAddr MM_AllocateZero(tVAddr VAddr)
 437 {
 438         if( !giMM_ZeroPage ) {
 439                 giMM_ZeroPage = MM_Allocate(VAddr);
 440                 MM_RefPhys(giMM_ZeroPage);
 441                 memset((void*)VAddr, 0, PAGE_SIZE);
 442         }
 443         else {
 444                 MM_RefPhys(giMM_ZeroPage);
 445                 MM_Map(VAddr, giMM_ZeroPage);
 446         }
 447         MM_SetFlags(VAddr, MM_PFLAG_COW, MM_PFLAG_COW);
 448         return giMM_ZeroPage;
 449 }
 450
 451 void MM_Deallocate(tVAddr VAddr)
 452 {
 453         tMM_PageInfo    pi;
 454
 455         if( MM_int_GetPageInfo(VAddr, &pi) )    return ;
 456
 457         if( pi.PhysAddr == 0 )  return;
 458         MM_DerefPhys(pi.PhysAddr);
 459
 460         pi.PhysAddr = 0;
 461         pi.AP = 0;
 462         pi.bExecutable = 0;
 463         MM_int_SetPageInfo(VAddr, &pi);
 464 }
 465
 466 tPAddr MM_AllocateRootTable(void)
 467 {
 468         tPAddr  ret;
 469
 470         ret = MM_AllocPhysRange(2, -1);
 471         if( ret & 0x1000 ) {
 472                 MM_DerefPhys(ret);
 473                 MM_DerefPhys(ret+0x1000);
 474                 ret = MM_AllocPhysRange(3, -1);
 475                 if( ret & 0x1000 ) {
 476                         MM_DerefPhys(ret);
 477                         ret += 0x1000;
 478 //                      Log("MM_AllocateRootTable: Second try not aligned, %P", ret);
 479                 }
 480                 else {
 481                         MM_DerefPhys(ret + 0x2000);
 482 //                      Log("MM_AllocateRootTable: Second try aligned, %P", ret);
 483                 }
 484         }
 485 //      else
 486 //              Log("MM_AllocateRootTable: Got it in one, %P", ret);
 487         return ret;
 488 }
 489
 490 void MM_int_CloneTable(Uint32 *DestEnt, int Table)
 491 {
 492         tPAddr  table;
 493         Uint32  *tmp_map;
 494         Uint32  *cur = (void*)MM_TABLE0USER;
 495 //      Uint32  *cur = &FRACTAL(MM_TABLE1USER,0);
 496          int    i;
 497
 498         table = MM_AllocPhys();
 499         if(!table)      return ;
 500
 501         tmp_map = (void*)MM_MapTemp(table);
 502
 503         for( i = 0; i < 1024; i ++ )
 504         {
 505                 switch(cur[i] & 3)
 506                 {
 507                 case 0: tmp_map[i] = 0; break;
 508                 case 1:
 509                         tmp_map[i] = 0;
 510                         Log_Error("MMVirt", "TODO: Support large pages in MM_int_CloneTable");
 511                         // Large page?
 512                         break;
 513                 case 2:
 514                 case 3:
 515                         // Small page
 516                         // - If full RW
 517                         if( (cur[Table*256] & 0x230) == 0x030 )
 518                                 cur[Table*256+i] |= 0x200;      // Set to full RO (Full RO=COW, User RO = RO)
 519                         tmp_map[i] = cur[Table*256+i];
 520                         break;
 521                 }
 522         }
 523
 524         DestEnt[0] = table + 0*0x400 + 1;
 525         DestEnt[1] = table + 1*0x400 + 1;
 526         DestEnt[2] = table + 2*0x400 + 1;
 527         DestEnt[3] = table + 3*0x400 + 1;
 528 }
 529
 530 tPAddr MM_Clone(void)
 531 {
 532         tPAddr  ret;
 533         Uint32  *new_lvl1_1, *new_lvl1_2, *cur;
 534         Uint32  *tmp_map;
 535          int    i;
 536
 537         ret = MM_AllocateRootTable();
 538
 539         cur = (void*)MM_TABLE0USER;
 540         new_lvl1_1 = (void*)MM_MapTemp(ret);
 541         new_lvl1_2 = (void*)MM_MapTemp(ret+0x1000);
 542         tmp_map = new_lvl1_1;
 543         for( i = 0; i < 0x800-4; i ++ )
 544         {
 545 //              Log("i = %i", i);
 546                 if( i == 0x400 )
 547                         tmp_map = &new_lvl1_2[-0x400];
 548                 switch( cur[i] & 3 )
 549                 {
 550                 case 0: tmp_map[i] = 0; break;
 551                 case 1:
 552                         MM_int_CloneTable(&tmp_map[i], i);
 553                         i += 3; // Tables are alocated in blocks of 4
 554                         break;
 555                 case 2:
 556                 case 3:
 557                         Log_Error("MMVirt", "TODO: Support Sections/Supersections in MM_Clone (i=%i)", i);
 558                         tmp_map[i] = 0;
 559                         break;
 560                 }
 561         }
 562
 563         // Allocate Fractal table
 564         {
 565                  int    j, num;
 566                 tPAddr  tmp = MM_AllocPhys();
 567                 Uint32  *table = (void*)MM_MapTemp(tmp);
 568                 Uint32  sp;
 569                 register Uint32 __SP asm("sp");
 570
 571                 // Map table to last 4MiB of user space
 572                 new_lvl1_2[0x3FC] = tmp + 0*0x400 + 1;
 573                 new_lvl1_2[0x3FD] = tmp + 1*0x400 + 1;
 574                 new_lvl1_2[0x3FE] = tmp + 2*0x400 + 1;
 575                 new_lvl1_2[0x3FF] = tmp + 3*0x400 + 1;
 576
 577                 tmp_map = new_lvl1_1;
 578                 for( j = 0; j < 512; j ++ )
 579                 {
 580                         if( j == 256 )
 581                                 tmp_map = &new_lvl1_2[-0x400];
 582                         if( (tmp_map[j*4] & 3) == 1 )
 583                         {
 584                                 table[j] = tmp_map[j*4] & PADDR_MASK_LVL1;// 0xFFFFFC00;
 585                                 table[j] |= 0x813;      // nG, Kernel Only, Small page, XN
 586                         }
 587                         else
 588                                 table[j] = 0;
 589                 }
 590                 // Fractal
 591                 table[j++] = (ret + 0x0000) | 0x813;
 592                 table[j++] = (ret + 0x1000) | 0x813;
 593                 // Nuke the rest
 594                 for(      ; j < 1024; j ++ )
 595                         table[j] = 0;
 596
 597                 // Get kernel stack bottom
 598                 sp = __SP & ~(MM_KSTACK_SIZE-1);
 599                 j = (sp / 0x1000) % 1024;
 600                 num = MM_KSTACK_SIZE/0x1000;
 601
 602                 // Copy stack pages
 603                 for(; num--; j ++, sp += 0x1000)
 604                 {
 605                         tVAddr  page;
 606                         void    *tmp_page;
 607
 608                         page = MM_AllocPhys();
 609                         table[j] = page | 0x813;
 610
 611                         tmp_page = (void*)MM_MapTemp(page);
 612                         memcpy(tmp_page, (void*)sp, 0x1000);
 613                         MM_FreeTemp( (tVAddr) tmp_page );
 614                 }
 615
 616                 MM_FreeTemp( (tVAddr)table );
 617         }
 618
 619         MM_FreeTemp( (tVAddr)new_lvl1_1 );
 620         MM_FreeTemp( (tVAddr)new_lvl1_2 );
 621
 622         return ret;
 623 }
 624
 625 tPAddr MM_ClearUser(void)
 626 {
 627         // TODO: Implement ClearUser
 628         return 0;
 629 }
 630
 631 tVAddr MM_MapTemp(tPAddr PAddr)
 632 {
 633         tVAddr  ret;
 634         tMM_PageInfo    pi;
 635
 636         for( ret = MM_TMPMAP_BASE; ret < MM_TMPMAP_END - PAGE_SIZE; ret += PAGE_SIZE )
 637         {
 638                 if( MM_int_GetPageInfo(ret, &pi) == 0 )
 639                         continue;
 640
 641 //              Log("MapTemp %P at %p", PAddr, ret);
 642                 MM_RefPhys(PAddr);      // Counter the MM_Deallocate in FreeTemp
 643                 MM_Map(ret, PAddr);
 644
 645                 return ret;
 646         }
 647         Log_Warning("MMVirt", "MM_MapTemp: All slots taken");
 648         return 0;
 649 }
 650
 651 void MM_FreeTemp(tVAddr VAddr)
 652 {
 653         // TODO: Implement FreeTemp
 654         if( VAddr < MM_TMPMAP_BASE || VAddr >= MM_TMPMAP_END ) {
 655                 Log_Warning("MMVirt", "MM_FreeTemp: Passed an addr not from MM_MapTemp (%p)", VAddr);
 656                 return ;
 657         }
 658
 659         MM_Deallocate(VAddr);
 660 }
 661
 662 tVAddr MM_MapHWPages(tPAddr PAddr, Uint NPages)
 663 {
 664         tVAddr  ret;
 665          int    i;
 666         tMM_PageInfo    pi;
 667
 668         ENTER("xPAddr iNPages", PAddr, NPages);
 669
 670         // Scan for a location
 671         for( ret = MM_HWMAP_BASE; ret < MM_HWMAP_END - NPages * PAGE_SIZE; ret += PAGE_SIZE )
 672         {
 673 //              LOG("checking %p", ret);
 674                 // Check if there is `NPages` free pages
 675                 for( i = 0; i < NPages; i ++ )
 676                 {
 677                         if( MM_int_GetPageInfo(ret + i*PAGE_SIZE, &pi) == 0 )
 678                                 break;
 679                 }
 680                 // Nope, jump to after the used page found and try again
 681 //              LOG("i = %i, ==? %i", i, NPages);
 682                 if( i != NPages ) {
 683                         ret += i * PAGE_SIZE;
 684                         continue ;
 685                 }
 686
 687                 // Map the pages
 688                 for( i = 0; i < NPages; i ++ )
 689                         MM_Map(ret+i*PAGE_SIZE, PAddr+i*PAGE_SIZE);
 690                 // and return
 691                 LEAVE('p', ret);
 692                 return ret;
 693         }
 694         Log_Warning("MMVirt", "MM_MapHWPages: No space for a %i page block", NPages);
 695         LEAVE('p', 0);
 696         return 0;
 697 }
 698
 699 tVAddr MM_AllocDMA(int Pages, int MaxBits, tPAddr *PAddr)
 700 {
 701         tPAddr  phys;
 702         tVAddr  ret;
 703
 704         phys = MM_AllocPhysRange(Pages, MaxBits);
 705         if(!phys) {
 706                 Log_Warning("MMVirt", "No space left for a %i page block (MM_AllocDMA)", Pages);
 707                 return 0;
 708         }
 709
 710         ret = MM_MapHWPages(phys, Pages);
 711         *PAddr = phys;
 712
 713         return ret;
 714 }
 715
 716 void MM_UnmapHWPages(tVAddr Vaddr, Uint Number)
 717 {
 718         Log_Error("MMVirt", "TODO: Implement MM_UnmapHWPages");
 719 }
 720
 721 tVAddr MM_NewKStack(int bShared)
 722 {
 723         tVAddr  min_addr, max_addr;
 724         tVAddr  addr, ofs;
 725
 726         if( bShared ) {
 727                 min_addr = MM_GLOBALSTACKS;
 728                 max_addr = MM_GLOBALSTACKS_END;
 729         }
 730         else {
 731                 min_addr = MM_KSTACK_BASE;
 732                 max_addr = MM_KSTACK_END;
 733         }
 734
 735         // Locate a free slot
 736         for( addr = min_addr; addr < max_addr; addr += MM_KSTACK_SIZE )
 737         {
 738                 tMM_PageInfo    pi;
 739                 if( MM_int_GetPageInfo(addr+MM_KSTACK_SIZE-PAGE_SIZE, &pi) )    break;
 740         }
 741
 742         // Check for an error
 743         if(addr >= max_addr) {
 744                 return 0;
 745         }
 746
 747         // 1 guard page
 748         for( ofs = PAGE_SIZE; ofs < MM_KSTACK_SIZE; ofs += PAGE_SIZE )
 749         {
 750                 if( MM_Allocate(addr + ofs) == 0 )
 751                 {
 752                         while(ofs)
 753                         {
 754                                 ofs -= PAGE_SIZE;
 755                                 MM_Deallocate(addr + ofs);
 756                         }
 757                         Log_Warning("MMVirt", "MM_NewKStack: Unable to allocate");
 758                         return 0;
 759                 }
 760         }
 761         return addr + ofs;
 762 }
 763
 764 tVAddr MM_NewUserStack(void)
 765 {
 766         tVAddr  addr, ofs;
 767
 768         addr = USER_STACK_TOP - USER_STACK_SIZE;
 769         if( MM_GetPhysAddr(addr + PAGE_SIZE) ) {
 770                 Log_Error("MMVirt", "Unable to create initial user stack, addr %p taken",
 771                         addr + PAGE_SIZE
 772                         );
 773                 return 0;
 774         }
 775
 776         // 1 guard page
 777         for( ofs = PAGE_SIZE; ofs < USER_STACK_SIZE; ofs += PAGE_SIZE )
 778         {
 779                 tPAddr  rv;
 780                 if(ofs >= USER_STACK_SIZE - USER_STACK_COMM)
 781                         rv = MM_Allocate(addr + ofs);
 782                 else
 783                         rv = MM_AllocateZero(addr + ofs);
 784                 if(rv == 0)
 785                 {
 786                         while(ofs)
 787                         {
 788                                 ofs -= PAGE_SIZE;
 789                                 MM_Deallocate(addr + ofs);
 790                         }
 791                         Log_Warning("MMVirt", "MM_NewUserStack: Unable to allocate");
 792                         return 0;
 793                 }
 794                 MM_SetFlags(addr+ofs, 0, MM_PFLAG_KERNEL);
 795         }
 796         Log("Return %p", addr + ofs);
 797         MM_DumpTables(0, 0x80000000);
 798         return addr + ofs;
 799 }
 800
 801 void MM_int_DumpTableEnt(tVAddr Start, size_t Len, tMM_PageInfo *Info)
 802 {
 803         if( giMM_ZeroPage && Info->PhysAddr == giMM_ZeroPage )
 804         {
 805                 Log("%p => %8s - 0x%7x %i %x",
 806                         Start, "ZERO", Len,
 807                         Info->Domain, Info->AP
 808                         );
 809         }
 810         else
 811         {
 812                 Log("%p => %8x - 0x%7x %i %x",
 813                         Start, Info->PhysAddr-Len, Len,
 814                         Info->Domain, Info->AP
 815                         );
 816         }
 817 }
 818
 819 void MM_DumpTables(tVAddr Start, tVAddr End)
 820 {
 821         tVAddr  range_start = 0, addr;
 822         tMM_PageInfo    pi, pi_old;
 823          int    i = 0, inRange=0;
 824
 825         pi_old.Size = 0;
 826
 827         Log("Page Table Dump:");
 828         range_start = Start;
 829         for( addr = Start; i == 0 || (addr && addr < End); i = 1 )
 830         {
 831 //              Log("addr = %p", addr);
 832                 int rv = MM_int_GetPageInfo(addr, &pi);
 833                 if( rv
 834                  || pi.Size != pi_old.Size
 835                  || pi.Domain != pi_old.Domain
 836                  || pi.AP != pi_old.AP
 837                  || pi_old.PhysAddr != pi.PhysAddr )
 838                 {
 839                         if(inRange) {
 840                                 MM_int_DumpTableEnt(range_start, addr - range_start, &pi_old);
 841                         }
 842                         addr &= ~((1 << pi.Size)-1);
 843                         range_start = addr;
 844                 }
 845
 846                 pi_old = pi;
 847                 // Handle the zero page
 848                 if( !giMM_ZeroPage || pi_old.Size != 12 || pi_old.PhysAddr != giMM_ZeroPage )
 849                         pi_old.PhysAddr += 1 << pi_old.Size;
 850                 addr += 1 << pi_old.Size;
 851                 inRange = (rv == 0);
 852         }
 853         if(inRange)
 854                 MM_int_DumpTableEnt(range_start, addr - range_start, &pi);
 855         Log("Done");
 856 }
 857