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_TABLE1USER;
 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 //              Log_Debug("MMVirt", "cur[%i] (%p) = %x", Table*256+i, &cur[Table*256+i], cur[Table*256+i]);
 506                 switch(cur[Table*256+i] & 3)
 507                 {
 508                 case 0: tmp_map[i] = 0; break;
 509                 case 1:
 510                         tmp_map[i] = 0;
 511                         Log_Error("MMVirt", "TODO: Support large pages in MM_int_CloneTable (%p)", (Table*256+i)*0x1000);
 512                         // Large page?
 513                         break;
 514                 case 2:
 515                 case 3:
 516                         // Small page
 517                         // - If full RW
 518                         if( (cur[Table*256] & 0x230) == 0x030 )
 519                                 cur[Table*256+i] |= 0x200;      // Set to full RO (Full RO=COW, User RO = RO)
 520                         tmp_map[i] = cur[Table*256+i];
 521                         break;
 522                 }
 523         }
 524
 525         DestEnt[0] = table + 0*0x400 + 1;
 526         DestEnt[1] = table + 1*0x400 + 1;
 527         DestEnt[2] = table + 2*0x400 + 1;
 528         DestEnt[3] = table + 3*0x400 + 1;
 529 }
 530
 531 tPAddr MM_Clone(void)
 532 {
 533         tPAddr  ret;
 534         Uint32  *new_lvl1_1, *new_lvl1_2, *cur;
 535         Uint32  *tmp_map;
 536          int    i;
 537
 538 //      MM_DumpTables(0, KERNEL_BASE);
 539
 540         ret = MM_AllocateRootTable();
 541
 542         cur = (void*)MM_TABLE0USER;
 543         new_lvl1_1 = (void*)MM_MapTemp(ret);
 544         new_lvl1_2 = (void*)MM_MapTemp(ret+0x1000);
 545         tmp_map = new_lvl1_1;
 546         for( i = 0; i < 0x800-4; i ++ )
 547         {
 548 //              Log("i = %i", i);
 549                 if( i == 0x400 )
 550                         tmp_map = &new_lvl1_2[-0x400];
 551                 switch( cur[i] & 3 )
 552                 {
 553                 case 0: tmp_map[i] = 0; break;
 554                 case 1:
 555                         MM_int_CloneTable(&tmp_map[i], i);
 556                         i += 3; // Tables are alocated in blocks of 4
 557                         break;
 558                 case 2:
 559                 case 3:
 560                         Log_Error("MMVirt", "TODO: Support Sections/Supersections in MM_Clone (i=%i)", i);
 561                         tmp_map[i] = 0;
 562                         break;
 563                 }
 564         }
 565
 566         // Allocate Fractal table
 567         {
 568                  int    j, num;
 569                 tPAddr  tmp = MM_AllocPhys();
 570                 Uint32  *table = (void*)MM_MapTemp(tmp);
 571                 Uint32  sp;
 572                 register Uint32 __SP asm("sp");
 573
 574                 // Map table to last 4MiB of user space
 575                 new_lvl1_2[0x3FC] = tmp + 0*0x400 + 1;
 576                 new_lvl1_2[0x3FD] = tmp + 1*0x400 + 1;
 577                 new_lvl1_2[0x3FE] = tmp + 2*0x400 + 1;
 578                 new_lvl1_2[0x3FF] = tmp + 3*0x400 + 1;
 579
 580                 tmp_map = new_lvl1_1;
 581                 for( j = 0; j < 512; j ++ )
 582                 {
 583                         if( j == 256 )
 584                                 tmp_map = &new_lvl1_2[-0x400];
 585                         if( (tmp_map[j*4] & 3) == 1 )
 586                         {
 587                                 table[j] = tmp_map[j*4] & PADDR_MASK_LVL1;// 0xFFFFFC00;
 588                                 table[j] |= 0x813;      // nG, Kernel Only, Small page, XN
 589                         }
 590                         else
 591                                 table[j] = 0;
 592                 }
 593                 // Fractal
 594                 table[j++] = (ret + 0x0000) | 0x813;
 595                 table[j++] = (ret + 0x1000) | 0x813;
 596                 // Nuke the rest
 597                 for(      ; j < 1024; j ++ )
 598                         table[j] = 0;
 599
 600                 // Get kernel stack bottom
 601                 sp = __SP & ~(MM_KSTACK_SIZE-1);
 602                 j = (sp / 0x1000) % 1024;
 603                 num = MM_KSTACK_SIZE/0x1000;
 604
 605                 // Copy stack pages
 606                 for(; num--; j ++, sp += 0x1000)
 607                 {
 608                         tVAddr  page;
 609                         void    *tmp_page;
 610
 611                         page = MM_AllocPhys();
 612                         table[j] = page | 0x813;
 613
 614                         tmp_page = (void*)MM_MapTemp(page);
 615                         memcpy(tmp_page, (void*)sp, 0x1000);
 616                         MM_FreeTemp( (tVAddr) tmp_page );
 617                 }
 618
 619                 MM_FreeTemp( (tVAddr)table );
 620         }
 621
 622         MM_FreeTemp( (tVAddr)new_lvl1_1 );
 623         MM_FreeTemp( (tVAddr)new_lvl1_2 );
 624
 625         return ret;
 626 }
 627
 628 tPAddr MM_ClearUser(void)
 629 {
 630         // TODO: Implement ClearUser
 631         return 0;
 632 }
 633
 634 tVAddr MM_MapTemp(tPAddr PAddr)
 635 {
 636         tVAddr  ret;
 637         tMM_PageInfo    pi;
 638
 639         for( ret = MM_TMPMAP_BASE; ret < MM_TMPMAP_END - PAGE_SIZE; ret += PAGE_SIZE )
 640         {
 641                 if( MM_int_GetPageInfo(ret, &pi) == 0 )
 642                         continue;
 643
 644 //              Log("MapTemp %P at %p", PAddr, ret);
 645                 MM_RefPhys(PAddr);      // Counter the MM_Deallocate in FreeTemp
 646                 MM_Map(ret, PAddr);
 647
 648                 return ret;
 649         }
 650         Log_Warning("MMVirt", "MM_MapTemp: All slots taken");
 651         return 0;
 652 }
 653
 654 void MM_FreeTemp(tVAddr VAddr)
 655 {
 656         // TODO: Implement FreeTemp
 657         if( VAddr < MM_TMPMAP_BASE || VAddr >= MM_TMPMAP_END ) {
 658                 Log_Warning("MMVirt", "MM_FreeTemp: Passed an addr not from MM_MapTemp (%p)", VAddr);
 659                 return ;
 660         }
 661
 662         MM_Deallocate(VAddr);
 663 }
 664
 665 tVAddr MM_MapHWPages(tPAddr PAddr, Uint NPages)
 666 {
 667         tVAddr  ret;
 668          int    i;
 669         tMM_PageInfo    pi;
 670
 671         ENTER("xPAddr iNPages", PAddr, NPages);
 672
 673         // Scan for a location
 674         for( ret = MM_HWMAP_BASE; ret < MM_HWMAP_END - NPages * PAGE_SIZE; ret += PAGE_SIZE )
 675         {
 676 //              LOG("checking %p", ret);
 677                 // Check if there is `NPages` free pages
 678                 for( i = 0; i < NPages; i ++ )
 679                 {
 680                         if( MM_int_GetPageInfo(ret + i*PAGE_SIZE, &pi) == 0 )
 681                                 break;
 682                 }
 683                 // Nope, jump to after the used page found and try again
 684 //              LOG("i = %i, ==? %i", i, NPages);
 685                 if( i != NPages ) {
 686                         ret += i * PAGE_SIZE;
 687                         continue ;
 688                 }
 689
 690                 // Map the pages
 691                 for( i = 0; i < NPages; i ++ )
 692                         MM_Map(ret+i*PAGE_SIZE, PAddr+i*PAGE_SIZE);
 693                 // and return
 694                 LEAVE('p', ret);
 695                 return ret;
 696         }
 697         Log_Warning("MMVirt", "MM_MapHWPages: No space for a %i page block", NPages);
 698         LEAVE('p', 0);
 699         return 0;
 700 }
 701
 702 tVAddr MM_AllocDMA(int Pages, int MaxBits, tPAddr *PAddr)
 703 {
 704         tPAddr  phys;
 705         tVAddr  ret;
 706
 707         phys = MM_AllocPhysRange(Pages, MaxBits);
 708         if(!phys) {
 709                 Log_Warning("MMVirt", "No space left for a %i page block (MM_AllocDMA)", Pages);
 710                 return 0;
 711         }
 712
 713         ret = MM_MapHWPages(phys, Pages);
 714         *PAddr = phys;
 715
 716         return ret;
 717 }
 718
 719 void MM_UnmapHWPages(tVAddr Vaddr, Uint Number)
 720 {
 721         Log_Error("MMVirt", "TODO: Implement MM_UnmapHWPages");
 722 }
 723
 724 tVAddr MM_NewKStack(int bShared)
 725 {
 726         tVAddr  min_addr, max_addr;
 727         tVAddr  addr, ofs;
 728
 729         if( bShared ) {
 730                 min_addr = MM_GLOBALSTACKS;
 731                 max_addr = MM_GLOBALSTACKS_END;
 732         }
 733         else {
 734                 min_addr = MM_KSTACK_BASE;
 735                 max_addr = MM_KSTACK_END;
 736         }
 737
 738         // Locate a free slot
 739         for( addr = min_addr; addr < max_addr; addr += MM_KSTACK_SIZE )
 740         {
 741                 tMM_PageInfo    pi;
 742                 if( MM_int_GetPageInfo(addr+MM_KSTACK_SIZE-PAGE_SIZE, &pi) )    break;
 743         }
 744
 745         // Check for an error
 746         if(addr >= max_addr) {
 747                 return 0;
 748         }
 749
 750         // 1 guard page
 751         for( ofs = PAGE_SIZE; ofs < MM_KSTACK_SIZE; ofs += PAGE_SIZE )
 752         {
 753                 if( MM_Allocate(addr + ofs) == 0 )
 754                 {
 755                         while(ofs)
 756                         {
 757                                 ofs -= PAGE_SIZE;
 758                                 MM_Deallocate(addr + ofs);
 759                         }
 760                         Log_Warning("MMVirt", "MM_NewKStack: Unable to allocate");
 761                         return 0;
 762                 }
 763         }
 764         return addr + ofs;
 765 }
 766
 767 tVAddr MM_NewUserStack(void)
 768 {
 769         tVAddr  addr, ofs;
 770
 771         addr = USER_STACK_TOP - USER_STACK_SIZE;
 772         if( MM_GetPhysAddr(addr + PAGE_SIZE) ) {
 773                 Log_Error("MMVirt", "Unable to create initial user stack, addr %p taken",
 774                         addr + PAGE_SIZE
 775                         );
 776                 return 0;
 777         }
 778
 779         // 1 guard page
 780         for( ofs = PAGE_SIZE; ofs < USER_STACK_SIZE; ofs += PAGE_SIZE )
 781         {
 782                 tPAddr  rv;
 783                 if(ofs >= USER_STACK_SIZE - USER_STACK_COMM)
 784                         rv = MM_Allocate(addr + ofs);
 785                 else
 786                         rv = MM_AllocateZero(addr + ofs);
 787                 if(rv == 0)
 788                 {
 789                         while(ofs)
 790                         {
 791                                 ofs -= PAGE_SIZE;
 792                                 MM_Deallocate(addr + ofs);
 793                         }
 794                         Log_Warning("MMVirt", "MM_NewUserStack: Unable to allocate");
 795                         return 0;
 796                 }
 797                 MM_SetFlags(addr+ofs, 0, MM_PFLAG_KERNEL);
 798         }
 799         Log("Return %p", addr + ofs);
 800         MM_DumpTables(0, 0x80000000);
 801         return addr + ofs;
 802 }
 803
 804 void MM_int_DumpTableEnt(tVAddr Start, size_t Len, tMM_PageInfo *Info)
 805 {
 806         if( giMM_ZeroPage && Info->PhysAddr == giMM_ZeroPage )
 807         {
 808                 Log("%p => %8s - 0x%7x %i %x",
 809                         Start, "ZERO", Len,
 810                         Info->Domain, Info->AP
 811                         );
 812         }
 813         else
 814         {
 815                 Log("%p => %8x - 0x%7x %i %x",
 816                         Start, Info->PhysAddr-Len, Len,
 817                         Info->Domain, Info->AP
 818                         );
 819         }
 820 }
 821
 822 void MM_DumpTables(tVAddr Start, tVAddr End)
 823 {
 824         tVAddr  range_start = 0, addr;
 825         tMM_PageInfo    pi, pi_old;
 826          int    i = 0, inRange=0;
 827
 828         pi_old.Size = 0;
 829
 830         Log("Page Table Dump:");
 831         range_start = Start;
 832         for( addr = Start; i == 0 || (addr && addr < End); i = 1 )
 833         {
 834 //              Log("addr = %p", addr);
 835                 int rv = MM_int_GetPageInfo(addr, &pi);
 836                 if( rv
 837                  || pi.Size != pi_old.Size
 838                  || pi.Domain != pi_old.Domain
 839                  || pi.AP != pi_old.AP
 840                  || pi_old.PhysAddr != pi.PhysAddr )
 841                 {
 842                         if(inRange) {
 843                                 MM_int_DumpTableEnt(range_start, addr - range_start, &pi_old);
 844                         }
 845                         addr &= ~((1 << pi.Size)-1);
 846                         range_start = addr;
 847                 }
 848
 849                 pi_old = pi;
 850                 // Handle the zero page
 851                 if( !giMM_ZeroPage || pi_old.Size != 12 || pi_old.PhysAddr != giMM_ZeroPage )
 852                         pi_old.PhysAddr += 1 << pi_old.Size;
 853                 addr += 1 << pi_old.Size;
 854                 inRange = (rv == 0);
 855         }
 856         if(inRange)
 857                 MM_int_DumpTableEnt(range_start, addr - range_start, &pi);
 858         Log("Done");
 859 }
 860