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         Log("MM_Allocate: (VAddr=%x)", VAddr);
 285         Log("MM_Allocate: MM_AllocPhys()");
 286         ret = MM_AllocPhys();
 287         Log("MM_Allocate: ret = %x", ret);
 288         if(!ret)        return 0;
 289
 290         if( !MM_Map(VAddr, ret) )
 291         {
 292                 Warning("MM_Allocate: Unable to map", ret);
 293                 MM_DerefPhys(ret);
 294                 return 0;
 295         }
 296
 297         return ret;
 298 }
 299
 300 void MM_Deallocate(tVAddr VAddr)
 301 {
 302         tPAddr  phys;
 303
 304         phys = MM_GetPhysAddr(VAddr);
 305         if(!phys)       return ;
 306
 307         MM_Unmap(VAddr);
 308
 309         MM_DerefPhys(phys);
 310 }
 311
 312 /**
 313  * \brief Get the physical address of a virtual location
 314  */
 315 tPAddr MM_GetPhysAddr(tVAddr Addr)
 316 {
 317         Log("MM_GetPhysAddr: (Addr=0x%x)", Addr);
 318         if( !(PAGEMAPLVL4(Addr >> 39) & 1) )
 319                 return 0;
 320         Log(" MM_GetPhysAddr: PDP Valid");
 321         if( !(PAGEDIRPTR(Addr >> 30) & 1) )
 322                 return 0;
 323         Log(" MM_GetPhysAddr: PD Valid");
 324         if( !(PAGEDIR(Addr >> 21) & 1) )
 325                 return 0;
 326         Log(" MM_GetPhysAddr: PT Valid");
 327         if( !(PAGETABLE(Addr >> PTAB_SHIFT) & 1) )
 328                 return 0;
 329         Log(" MM_GetPhysAddr: Page Valid");
 330
 331         return (PAGETABLE(Addr >> PTAB_SHIFT) & ~0xFFF) | (Addr & 0xFFF);
 332 }
 333
 334 /**
 335  * \brief Sets the flags on a page
 336  */
 337 void MM_SetFlags(tVAddr VAddr, Uint Flags, Uint Mask)
 338 {
 339         tPAddr  *ent;
 340
 341         // Validity Check
 342         if( !(PAGEMAPLVL4(VAddr >> 39) & 1) )
 343                 return ;
 344         if( !(PAGEDIRPTR(VAddr >> 30) & 1) )
 345                 return ;
 346         if( !(PAGEDIR(VAddr >> 21) & 1) )
 347                 return ;
 348         if( !(PAGETABLE(VAddr >> 12) & 1) )
 349                 return ;
 350
 351         // Set Flags
 352         ent = &PAGETABLE(VAddr >> 12);
 353
 354         // Read-Only
 355         if( Mask & MM_PFLAG_RO )
 356         {
 357                 if( Flags & MM_PFLAG_RO ) {
 358                         *ent &= ~PF_WRITE;
 359                 }
 360                 else {
 361                         *ent |= PF_WRITE;
 362                 }
 363         }
 364
 365         // Kernel
 366         if( Mask & MM_PFLAG_KERNEL )
 367         {
 368                 if( Flags & MM_PFLAG_KERNEL ) {
 369                         *ent &= ~PF_USER;
 370                 }
 371                 else {
 372                         *ent |= PF_USER;
 373                 }
 374         }
 375
 376         // Copy-On-Write
 377         if( Mask & MM_PFLAG_COW )
 378         {
 379                 if( Flags & MM_PFLAG_COW ) {
 380                         *ent &= ~PF_WRITE;
 381                         *ent |= PF_COW;
 382                 }
 383                 else {
 384                         *ent &= ~PF_COW;
 385                         *ent |= PF_WRITE;
 386                 }
 387         }
 388
 389         // Execute
 390         if( Mask & MM_PFLAG_EXEC )
 391         {
 392                 if( Flags & MM_PFLAG_EXEC ) {
 393                         *ent &= ~PF_NX;
 394                 }
 395                 else {
 396                         *ent |= PF_NX;
 397                 }
 398         }
 399 }
 400
 401 /**
 402  * \brief Get the flags applied to a page
 403  */
 404 Uint MM_GetFlags(tVAddr VAddr)
 405 {
 406         tPAddr  *ent;
 407         Uint    ret = 0;
 408
 409         // Validity Check
 410         if( !(PAGEMAPLVL4(VAddr >> 39) & 1) )
 411                 return 0;
 412         if( !(PAGEDIRPTR(VAddr >> 30) & 1) )
 413                 return 0;
 414         if( !(PAGEDIR(VAddr >> 21) & 1) )
 415                 return 0;
 416         if( !(PAGETABLE(VAddr >> 12) & 1) )
 417                 return 0;
 418
 419         // Set Flags
 420         ent = &PAGETABLE(VAddr >> 12);
 421
 422         // Read-Only
 423         if( !(*ent & PF_WRITE) )        ret |= MM_PFLAG_RO;
 424         // Kernel
 425         if( !(*ent & PF_USER) ) ret |= MM_PFLAG_KERNEL;
 426         // Copy-On-Write
 427         if( *ent & PF_COW )     ret |= MM_PFLAG_COW;
 428         // Execute
 429         if( !(*ent & PF_NX) )   ret |= MM_PFLAG_EXEC;
 430
 431         return ret;
 432 }
 433
 434 // --- Hardware Mappings ---
 435 /**
 436  * \brief Map a range of hardware pages
 437  */
 438 tVAddr MM_MapHWPages(tPAddr PAddr, Uint Number)
 439 {
 440         Log_KernelPanic("MM", "TODO: Implement MM_MapHWPages");
 441         return 0;
 442 }
 443
 444 /**
 445  * \brief Free a range of hardware pages
 446  */
 447 void MM_UnmapHWPages(tVAddr VAddr, Uint Number)
 448 {
 449         Log_KernelPanic("MM", "TODO: Implement MM_UnmapHWPages");
 450 }
 451
 452 // --- Tempory Mappings ---
 453 tVAddr MM_MapTemp(tPAddr PAddr)
 454 {
 455         Log_KernelPanic("MM", "TODO: Implement MM_MapTemp");
 456         return 0;
 457 }
 458
 459 void MM_FreeTemp(tVAddr VAddr)
 460 {
 461         Log_KernelPanic("MM", "TODO: Implement MM_FreeTemp");
 462         return ;
 463 }
 464
 465
 466 // --- Address Space Clone --
 467 tPAddr MM_Clone(void)
 468 {
 469         tPAddr  ret;
 470
 471         // #1 Create a copy of the PML4
 472         ret = MM_AllocPhys();
 473         if(!ret)        return 0;
 474
 475         // #2 Alter the fractal pointer
 476         // #3 Set Copy-On-Write to all user pages
 477         // #4 Return
 478         return 0;
 479 }
 480
 481 void MM_ClearUser(void)
 482 {
 483         tVAddr  addr = 0;
 484         // #1 Traverse the structure < 2^47, Deref'ing all pages
 485         // #2 Free tables/dirs/pdps once they have been cleared
 486
 487         for( addr = 0; addr < 0x800000000000; )
 488         {
 489                 if( PAGEMAPLVL4(addr >> PML4_SHIFT) & 1 )
 490                 {
 491                         if( PAGEDIRPTR(addr >> PDP_SHIFT) & 1 )
 492                         {
 493                                 if( PAGEDIR(addr >> PDIR_SHIFT) & 1 )
 494                                 {
 495                                         // Page
 496                                         if( PAGETABLE(addr >> PTAB_SHIFT) & 1 ) {
 497                                                 MM_DerefPhys( PAGETABLE(addr >> PTAB_SHIFT) & PADDR_MASK );
 498                                                 PAGETABLE(addr >> PTAB_SHIFT) = 0;
 499                                         }
 500                                         addr += 1 << PTAB_SHIFT;
 501                                         // Dereference the PDIR Entry
 502                                         if( (addr + (1 << PTAB_SHIFT)) >> PDIR_SHIFT != (addr >> PDIR_SHIFT) ) {
 503                                                 MM_DerefPhys( PAGEMAPLVL4(addr >> PDIR_SHIFT) & PADDR_MASK );
 504                                                 PAGEDIR(addr >> PDIR_SHIFT) = 0;
 505                                         }
 506                                 }
 507                                 else {
 508                                         addr += 1 << PDIR_SHIFT;
 509                                         continue;
 510                                 }
 511                                 // Dereference the PDP Entry
 512                                 if( (addr + (1 << PDIR_SHIFT)) >> PDP_SHIFT != (addr >> PDP_SHIFT) ) {
 513                                         MM_DerefPhys( PAGEMAPLVL4(addr >> PDP_SHIFT) & PADDR_MASK );
 514                                         PAGEDIRPTR(addr >> PDP_SHIFT) = 0;
 515                                 }
 516                         }
 517                         else {
 518                                 addr += 1 << PDP_SHIFT;
 519                                 continue;
 520                         }
 521                         // Dereference the PML4 Entry
 522                         if( (addr + (1 << PDP_SHIFT)) >> PML4_SHIFT != (addr >> PML4_SHIFT) ) {
 523                                 MM_DerefPhys( PAGEMAPLVL4(addr >> PML4_SHIFT) & PADDR_MASK );
 524                                 PAGEMAPLVL4(addr >> PML4_SHIFT) = 0;
 525                         }
 526                 }
 527                 else {
 528                         addr += (tVAddr)1 << PML4_SHIFT;
 529                         continue;
 530                 }
 531         }
 532 }
 533
 534 tVAddr MM_NewWorkerStack(void)
 535 {
 536         return 0;
 537 }
 538
 539 tVAddr MM_NewKStack(void)
 540 {
 541         return 0;
 542 }