Kernel/arch/x86_64/mm_virt.c

   1 /*
   2  * Acess2 x86_64 Port
   3  *
   4  * Virtual Memory Manager
   5  */
   6 #include <acess.h>
   7 #include <mm_virt.h>
   8 #include <proc.h>
   9
  10 // === CONSTANTS ===
  11 #define PML4_SHIFT      39
  12 #define PDP_SHIFT       30
  13 #define PDIR_SHIFT      21
  14 #define PTAB_SHIFT      12
  15
  16 #define PADDR_MASK      0x7FFFFFFF##FFFFF000
  17 #define PAGE_MASK       (((Uint)1 << 36)-1)
  18 #define TABLE_MASK      (((Uint)1 << 27)-1)
  19 #define PDP_MASK        (((Uint)1 << 18)-1)
  20 #define PML4_MASK       (((Uint)1 << 9)-1)
  21
  22 #define PF_PRESENT      0x1
  23 #define PF_WRITE        0x2
  24 #define PF_USER         0x4
  25 #define PF_COW          0x200
  26 #define PF_PAGED        0x400
  27 #define PF_NX           0x80000000##00000000
  28
  29 // === MACROS ===
  30 #define PAGETABLE(idx)  (*((tPAddr*)MM_FRACTAL_BASE+((idx)&PAGE_MASK)))
  31 #define PAGEDIR(idx)    PAGETABLE((MM_FRACTAL_BASE>>12)+((idx)&TABLE_MASK))
  32 #define PAGEDIRPTR(idx) PAGEDIR((MM_FRACTAL_BASE>>21)+((idx)&PDP_MASK))
  33 #define PAGEMAPLVL4(idx)        PAGEDIRPTR((MM_FRACTAL_BASE>>30)+((idx)&PML4_MASK))
  34
  35 #define INVLPG(__addr)  __asm__ __volatile__ ("invlpg (%0)"::"r"(__addr));
  36
  37 // === PROTOTYPES ===
  38 void    MM_InitVirt(void);
  39 void    MM_FinishVirtualInit(void);
  40 void    MM_PageFault(tVAddr Addr, Uint ErrorCode, tRegs *Regs);
  41 void    MM_DumpTables(tVAddr Start, tVAddr End);
  42  int    MM_Map(tVAddr VAddr, tPAddr PAddr);
  43
  44 // === GLOBALS ===
  45
  46 // === CODE ===
  47 void MM_InitVirt(void)
  48 {
  49 }
  50
  51 void MM_FinishVirtualInit(void)
  52 {
  53 }
  54
  55 /**
  56  * \brief Called on a page fault
  57  */
  58 void MM_PageFault(tVAddr Addr, Uint ErrorCode, tRegs *Regs)
  59 {
  60         // TODO: Copy on Write
  61         #if 0
  62         if( gaPageDir  [Addr>>22] & PF_PRESENT
  63          && gaPageTable[Addr>>12] & PF_PRESENT
  64          && gaPageTable[Addr>>12] & PF_COW )
  65         {
  66                 tPAddr  paddr;
  67                 if(MM_GetRefCount( gaPageTable[Addr>>12] & ~0xFFF ) == 1)
  68                 {
  69                         gaPageTable[Addr>>12] &= ~PF_COW;
  70                         gaPageTable[Addr>>12] |= PF_PRESENT|PF_WRITE;
  71                 }
  72                 else
  73                 {
  74                         //Log("MM_PageFault: COW - MM_DuplicatePage(0x%x)", Addr);
  75                         paddr = MM_DuplicatePage( Addr );
  76                         MM_DerefPhys( gaPageTable[Addr>>12] & ~0xFFF );
  77                         gaPageTable[Addr>>12] &= PF_USER;
  78                         gaPageTable[Addr>>12] |= paddr|PF_PRESENT|PF_WRITE;
  79                 }
  80
  81                 INVLPG( Addr & ~0xFFF );
  82                 return;
  83         }
  84         #endif
  85
  86         // If it was a user, tell the thread handler
  87         if(ErrorCode & 4) {
  88                 Warning("%s %s %s memory%s",
  89                         (ErrorCode&4?"User":"Kernel"),
  90                         (ErrorCode&2?"write to":"read from"),
  91                         (ErrorCode&1?"bad/locked":"non-present"),
  92                         (ErrorCode&16?" (Instruction Fetch)":"")
  93                         );
  94                 Warning("User Pagefault: Instruction at %04x:%08x accessed %p",
  95                         Regs->CS, Regs->RIP, Addr);
  96                 __asm__ __volatile__ ("sti");   // Restart IRQs
  97 //              Threads_SegFault(Addr);
  98                 return ;
  99         }
 100
 101         // Kernel #PF
 102         Debug_KernelPanic();
 103         // -- Check Error Code --
 104         if(ErrorCode & 8)
 105                 Warning("Reserved Bits Trashed!");
 106         else
 107         {
 108                 Warning("%s %s %s memory%s",
 109                         (ErrorCode&4?"User":"Kernel"),
 110                         (ErrorCode&2?"write to":"read from"),
 111                         (ErrorCode&1?"bad/locked":"non-present"),
 112                         (ErrorCode&16?" (Instruction Fetch)":"")
 113                         );
 114         }
 115
 116         Log("Code at %p accessed %p", Regs->RIP, Addr);
 117         // Print Stack Backtrace
 118 //      Error_Backtrace(Regs->RIP, Regs->RBP);
 119
 120         MM_DumpTables(0, -1);
 121 }
 122
 123 /**
 124  * \brief Dumps the layout of the page tables
 125  */
 126 void MM_DumpTables(tVAddr Start, tVAddr End)
 127 {
 128         const tPAddr    CHANGEABLE_BITS = 0xFF8;
 129         const tPAddr    MASK = ~CHANGEABLE_BITS;        // Physical address and access bits
 130         tVAddr  rangeStart = 0;
 131         tPAddr  expected = CHANGEABLE_BITS;     // MASK is used because it's not a vaild value
 132         tVAddr  curPos;
 133         Uint    page;
 134
 135         End &= (1L << 48) - 1;
 136
 137         Start >>= 12;   End >>= 12;
 138
 139         Log("Table Entries:");
 140         for(page = Start, curPos = Start<<12;
 141                 page < End;
 142                 curPos += 0x1000, page++)
 143         {
 144                 if( curPos == 0x800000000000L )
 145                         curPos = 0xFFFF800000000000L;
 146
 147                 // End of a range
 148                 if(
 149                         !(PAGEMAPLVL4(page>>27) & PF_PRESENT)
 150                 ||      !(PAGEDIRPTR(page>>18) & PF_PRESENT)
 151                 ||      !(PAGEDIR(page>>9) & PF_PRESENT)
 152                 ||  !(PAGETABLE(page) & PF_PRESENT)
 153                 ||  (PAGETABLE(page) & MASK) != expected)
 154                 {
 155                         if(expected != CHANGEABLE_BITS) {
 156                                 Log("%016x-0x%016x => %013x-%013x (%c%c%c%c)",
 157                                         rangeStart, curPos - 1,
 158                                         PAGETABLE(rangeStart>>12) & ~0xFFF,
 159                                         (expected & ~0xFFF) - 1,
 160                                         (expected & PF_PAGED ? 'p' : '-'),
 161                                         (expected & PF_COW ? 'C' : '-'),
 162                                         (expected & PF_USER ? 'U' : '-'),
 163                                         (expected & PF_WRITE ? 'W' : '-')
 164                                         );
 165                                 expected = CHANGEABLE_BITS;
 166                         }
 167                         if( !(PAGEMAPLVL4(page>>27) & PF_PRESENT) ) {
 168                                 page += (1 << 27) - 1;
 169                                 curPos += (1L << 39) - 0x1000;
 170                                 continue;
 171                         }
 172                         if( !(PAGEDIRPTR(page>>18) & PF_PRESENT) ) {
 173                                 page += (1 << 18) - 1;
 174                                 curPos += (1L << 30) - 0x1000;
 175                                 continue;
 176                         }
 177                         if( !(PAGEDIR(page>>9) & PF_PRESENT) ) {
 178                                 page += (1 << 9) - 1;
 179                                 curPos += (1L << 21) - 0x1000;
 180                                 continue;
 181                         }
 182                         if( !(PAGETABLE(page) & PF_PRESENT) )   continue;
 183
 184                         expected = (PAGETABLE(page) & MASK);
 185                         rangeStart = curPos;
 186                 }
 187                 if(expected != CHANGEABLE_BITS)
 188                         expected += 0x1000;
 189         }
 190
 191         if(expected != CHANGEABLE_BITS) {
 192                 Log("%016x-%016x => %013x-%013x (%s%s%s%s)",
 193                         rangeStart, curPos - 1,
 194                         PAGETABLE(rangeStart>>12) & ~0xFFF,
 195                         (expected & ~0xFFF) - 1,
 196                         (expected & PF_PAGED ? "p" : "-"),
 197                         (expected & PF_COW ? "C" : "-"),
 198                         (expected & PF_USER ? "U" : "-"),
 199                         (expected & PF_WRITE ? "W" : "-")
 200                         );
 201                 expected = 0;
 202         }
 203 }
 204
 205 /**
 206  * \brief Map a physical page to a virtual one
 207  */
 208 int MM_Map(tVAddr VAddr, tPAddr PAddr)
 209 {
 210         tPAddr  tmp;
 211
 212         Log("MM_Map: (VAddr=0x%x, PAddr=0x%x)", VAddr, PAddr);
 213
 214         // Check PML4
 215         //Log(" MM_Map: &PAGEMAPLVL4(%x) = %x", VAddr >> 39, &PAGEMAPLVL4(VAddr >> 39));
 216         //Log(" MM_Map: &PAGEDIRPTR(%x) = %x", VAddr >> 30, &PAGEDIRPTR(VAddr >> 30));
 217         //Log(" MM_Map: &PAGEDIR(%x) = %x", VAddr >> 21, &PAGEDIR(VAddr >> 21));
 218         //Log(" MM_Map: &PAGETABLE(%x) = %x", VAddr >> 12, &PAGETABLE(VAddr >> 12));
 219         //Log(" MM_Map: &PAGETABLE(0) = %x", &PAGETABLE(0));
 220         if( !(PAGEMAPLVL4(VAddr >> 39) & 1) )
 221         {
 222                 tmp = MM_AllocPhys();
 223                 if(!tmp)        return 0;
 224                 PAGEMAPLVL4(VAddr >> 39) = tmp | 3;
 225                 INVLPG( &PAGEDIRPTR( (VAddr>>39)<<9 ) );
 226                 memset( &PAGEDIRPTR( (VAddr>>39)<<9 ), 0, 4096 );
 227         }
 228
 229         // Check PDP
 230         if( !(PAGEDIRPTR(VAddr >> 30) & 1) )
 231         {
 232                 tmp = MM_AllocPhys();
 233                 if(!tmp)        return 0;
 234                 PAGEDIRPTR(VAddr >> 30) = tmp | 3;
 235                 INVLPG( &PAGEDIR( (VAddr>>30)<<9 ) );
 236                 memset( &PAGEDIR( (VAddr>>30)<<9 ), 0, 0x1000 );
 237         }
 238
 239         // Check Page Dir
 240         if( !(PAGEDIR(VAddr >> 21) & 1) )
 241         {
 242                 tmp = MM_AllocPhys();
 243                 if(!tmp)        return 0;
 244                 PAGEDIR(VAddr >> 21) = tmp | 3;
 245                 INVLPG( &PAGETABLE( (VAddr>>21)<<9 ) );
 246                 memset( &PAGETABLE( (VAddr>>21)<<9 ), 0, 4096 );
 247         }
 248
 249         // Check if this virtual address is already mapped
 250         if( PAGETABLE(VAddr >> PTAB_SHIFT) & 1 )
 251                 return 0;
 252
 253         PAGETABLE(VAddr >> PTAB_SHIFT) = PAddr | 3;
 254
 255         INVLPG( VAddr );
 256         Log("MM_Map: RETURN 1");
 257
 258         return 1;
 259 }
 260
 261 /**
 262  * \brief Removed a mapped page
 263  */
 264 void MM_Unmap(tVAddr VAddr)
 265 {
 266         // Check PML4
 267         if( !(PAGEMAPLVL4(VAddr >> 39) & 1) )   return ;
 268         // Check PDP
 269         if( !(PAGEDIRPTR(VAddr >> 30) & 1) )    return ;
 270         // Check Page Dir
 271         if( !(PAGEDIR(VAddr >> 21) & 1) )       return ;
 272
 273         PAGETABLE(VAddr >> PTAB_SHIFT) = 0;
 274         INVLPG( VAddr );
 275 }
 276
 277 /**
 278  * \brief Allocate a block of memory at the specified virtual address
 279  */
 280 tPAddr MM_Allocate(tVAddr VAddr)
 281 {
 282         tPAddr  ret;
 283
 284         ENTER("xVAddr", VAddr);
 285
 286         if( !MM_Map(VAddr, 0) ) // Make sure things are allocated
 287         {
 288                 Warning("MM_Allocate: Unable to map, tables did not initialise");
 289                 LEAVE('i', 0);
 290                 return 0;
 291         }
 292
 293         ret = MM_AllocPhys();
 294         LOG("ret = %x", ret);
 295         if(!ret) {
 296                 LEAVE('i', 0);
 297                 return 0;
 298         }
 299
 300         if( !MM_Map(VAddr, ret) )
 301         {
 302                 Warning("MM_Allocate: Unable to map. Strange, we should have errored earlier");
 303                 MM_DerefPhys(ret);
 304                 LEAVE('i');
 305                 return 0;
 306         }
 307
 308         LEAVE('x', ret);
 309         return ret;
 310 }
 311
 312 void MM_Deallocate(tVAddr VAddr)
 313 {
 314         tPAddr  phys;
 315
 316         phys = MM_GetPhysAddr(VAddr);
 317         if(!phys)       return ;
 318
 319         MM_Unmap(VAddr);
 320
 321         MM_DerefPhys(phys);
 322 }
 323
 324 /**
 325  * \brief Get the physical address of a virtual location
 326  */
 327 tPAddr MM_GetPhysAddr(tVAddr Addr)
 328 {
 329         Log("MM_GetPhysAddr: (Addr=0x%x)", Addr);
 330         if( !(PAGEMAPLVL4(Addr >> 39) & 1) )
 331                 return 0;
 332         Log(" MM_GetPhysAddr: PDP Valid");
 333         if( !(PAGEDIRPTR(Addr >> 30) & 1) )
 334                 return 0;
 335         Log(" MM_GetPhysAddr: PD Valid");
 336         if( !(PAGEDIR(Addr >> 21) & 1) )
 337                 return 0;
 338         Log(" MM_GetPhysAddr: PT Valid");
 339         if( !(PAGETABLE(Addr >> PTAB_SHIFT) & 1) )
 340                 return 0;
 341         Log(" MM_GetPhysAddr: Page Valid");
 342
 343         return (PAGETABLE(Addr >> PTAB_SHIFT) & ~0xFFF) | (Addr & 0xFFF);
 344 }
 345
 346 /**
 347  * \brief Sets the flags on a page
 348  */
 349 void MM_SetFlags(tVAddr VAddr, Uint Flags, Uint Mask)
 350 {
 351         tPAddr  *ent;
 352
 353         // Validity Check
 354         if( !(PAGEMAPLVL4(VAddr >> 39) & 1) )
 355                 return ;
 356         if( !(PAGEDIRPTR(VAddr >> 30) & 1) )
 357                 return ;
 358         if( !(PAGEDIR(VAddr >> 21) & 1) )
 359                 return ;
 360         if( !(PAGETABLE(VAddr >> 12) & 1) )
 361                 return ;
 362
 363         // Set Flags
 364         ent = &PAGETABLE(VAddr >> 12);
 365
 366         // Read-Only
 367         if( Mask & MM_PFLAG_RO )
 368         {
 369                 if( Flags & MM_PFLAG_RO ) {
 370                         *ent &= ~PF_WRITE;
 371                 }
 372                 else {
 373                         *ent |= PF_WRITE;
 374                 }
 375         }
 376
 377         // Kernel
 378         if( Mask & MM_PFLAG_KERNEL )
 379         {
 380                 if( Flags & MM_PFLAG_KERNEL ) {
 381                         *ent &= ~PF_USER;
 382                 }
 383                 else {
 384                         *ent |= PF_USER;
 385                 }
 386         }
 387
 388         // Copy-On-Write
 389         if( Mask & MM_PFLAG_COW )
 390         {
 391                 if( Flags & MM_PFLAG_COW ) {
 392                         *ent &= ~PF_WRITE;
 393                         *ent |= PF_COW;
 394                 }
 395                 else {
 396                         *ent &= ~PF_COW;
 397                         *ent |= PF_WRITE;
 398                 }
 399         }
 400
 401         // Execute
 402         if( Mask & MM_PFLAG_EXEC )
 403         {
 404                 if( Flags & MM_PFLAG_EXEC ) {
 405                         *ent &= ~PF_NX;
 406                 }
 407                 else {
 408                         *ent |= PF_NX;
 409                 }
 410         }
 411 }
 412
 413 /**
 414  * \brief Get the flags applied to a page
 415  */
 416 Uint MM_GetFlags(tVAddr VAddr)
 417 {
 418         tPAddr  *ent;
 419         Uint    ret = 0;
 420
 421         // Validity Check
 422         if( !(PAGEMAPLVL4(VAddr >> 39) & 1) )
 423                 return 0;
 424         if( !(PAGEDIRPTR(VAddr >> 30) & 1) )
 425                 return 0;
 426         if( !(PAGEDIR(VAddr >> 21) & 1) )
 427                 return 0;
 428         if( !(PAGETABLE(VAddr >> 12) & 1) )
 429                 return 0;
 430
 431         // Set Flags
 432         ent = &PAGETABLE(VAddr >> 12);
 433
 434         // Read-Only
 435         if( !(*ent & PF_WRITE) )        ret |= MM_PFLAG_RO;
 436         // Kernel
 437         if( !(*ent & PF_USER) ) ret |= MM_PFLAG_KERNEL;
 438         // Copy-On-Write
 439         if( *ent & PF_COW )     ret |= MM_PFLAG_COW;
 440         // Execute
 441         if( !(*ent & PF_NX) )   ret |= MM_PFLAG_EXEC;
 442
 443         return ret;
 444 }
 445
 446 // --- Hardware Mappings ---
 447 /**
 448  * \brief Map a range of hardware pages
 449  */
 450 tVAddr MM_MapHWPages(tPAddr PAddr, Uint Number)
 451 {
 452         Log_KernelPanic("MM", "TODO: Implement MM_MapHWPages");
 453         return 0;
 454 }
 455
 456 /**
 457  * \brief Free a range of hardware pages
 458  */
 459 void MM_UnmapHWPages(tVAddr VAddr, Uint Number)
 460 {
 461         Log_KernelPanic("MM", "TODO: Implement MM_UnmapHWPages");
 462 }
 463
 464 // --- Tempory Mappings ---
 465 tVAddr MM_MapTemp(tPAddr PAddr)
 466 {
 467         Log_KernelPanic("MM", "TODO: Implement MM_MapTemp");
 468         return 0;
 469 }
 470
 471 void MM_FreeTemp(tVAddr VAddr)
 472 {
 473         Log_KernelPanic("MM", "TODO: Implement MM_FreeTemp");
 474         return ;
 475 }
 476
 477
 478 // --- Address Space Clone --
 479 tPAddr MM_Clone(void)
 480 {
 481         tPAddr  ret;
 482
 483         // #1 Create a copy of the PML4
 484         ret = MM_AllocPhys();
 485         if(!ret)        return 0;
 486
 487         // #2 Alter the fractal pointer
 488         // #3 Set Copy-On-Write to all user pages
 489         // #4 Return
 490         return 0;
 491 }
 492
 493 void MM_ClearUser(void)
 494 {
 495         tVAddr  addr = 0;
 496         // #1 Traverse the structure < 2^47, Deref'ing all pages
 497         // #2 Free tables/dirs/pdps once they have been cleared
 498
 499         for( addr = 0; addr < 0x800000000000; )
 500         {
 501                 if( PAGEMAPLVL4(addr >> PML4_SHIFT) & 1 )
 502                 {
 503                         if( PAGEDIRPTR(addr >> PDP_SHIFT) & 1 )
 504                         {
 505                                 if( PAGEDIR(addr >> PDIR_SHIFT) & 1 )
 506                                 {
 507                                         // Page
 508                                         if( PAGETABLE(addr >> PTAB_SHIFT) & 1 ) {
 509                                                 MM_DerefPhys( PAGETABLE(addr >> PTAB_SHIFT) & PADDR_MASK );
 510                                                 PAGETABLE(addr >> PTAB_SHIFT) = 0;
 511                                         }
 512                                         addr += 1 << PTAB_SHIFT;
 513                                         // Dereference the PDIR Entry
 514                                         if( (addr + (1 << PTAB_SHIFT)) >> PDIR_SHIFT != (addr >> PDIR_SHIFT) ) {
 515                                                 MM_DerefPhys( PAGEMAPLVL4(addr >> PDIR_SHIFT) & PADDR_MASK );
 516                                                 PAGEDIR(addr >> PDIR_SHIFT) = 0;
 517                                         }
 518                                 }
 519                                 else {
 520                                         addr += 1 << PDIR_SHIFT;
 521                                         continue;
 522                                 }
 523                                 // Dereference the PDP Entry
 524                                 if( (addr + (1 << PDIR_SHIFT)) >> PDP_SHIFT != (addr >> PDP_SHIFT) ) {
 525                                         MM_DerefPhys( PAGEMAPLVL4(addr >> PDP_SHIFT) & PADDR_MASK );
 526                                         PAGEDIRPTR(addr >> PDP_SHIFT) = 0;
 527                                 }
 528                         }
 529                         else {
 530                                 addr += 1 << PDP_SHIFT;
 531                                 continue;
 532                         }
 533                         // Dereference the PML4 Entry
 534                         if( (addr + (1 << PDP_SHIFT)) >> PML4_SHIFT != (addr >> PML4_SHIFT) ) {
 535                                 MM_DerefPhys( PAGEMAPLVL4(addr >> PML4_SHIFT) & PADDR_MASK );
 536                                 PAGEMAPLVL4(addr >> PML4_SHIFT) = 0;
 537                         }
 538                 }
 539                 else {
 540                         addr += (tVAddr)1 << PML4_SHIFT;
 541                         continue;
 542                 }
 543         }
 544 }
 545
 546 tVAddr MM_NewWorkerStack(void)
 547 {
 548         return 0;
 549 }
 550
 551 tVAddr MM_NewKStack(void)
 552 {
 553         return 0;
 554 }