riscv/mmu.cc

   1 // See LICENSE for license details.
   2
   3 #include "mmu.h"
   4 #include "sim.h"
   5 #include "processor.h"
   6
   7 mmu_t::mmu_t(char* _mem, size_t _memsz)
   8  : mem(_mem), memsz(_memsz), proc(NULL)
   9 {
  10   flush_tlb();
  11 }
  12
  13 mmu_t::~mmu_t()
  14 {
  15 }
  16
  17 void mmu_t::flush_icache()
  18 {
  19   for (size_t i = 0; i < ICACHE_SIZE; i++)
  20     icache[i].tag = -1;
  21 }
  22
  23 void mmu_t::flush_tlb()
  24 {
  25   memset(tlb_insn_tag, -1, sizeof(tlb_insn_tag));
  26   memset(tlb_load_tag, -1, sizeof(tlb_load_tag));
  27   memset(tlb_store_tag, -1, sizeof(tlb_store_tag));
  28
  29   flush_icache();
  30 }
  31
  32 void* mmu_t::refill_tlb(reg_t addr, reg_t bytes, bool store, bool fetch)
  33 {
  34   reg_t idx = (addr >> PGSHIFT) % TLB_ENTRIES;
  35   reg_t expected_tag = addr >> PGSHIFT;
  36
  37   reg_t pte = walk(addr);
  38
  39   reg_t pte_perm = pte & PTE_PERM;
  40   if (proc == NULL || (proc->state.sr & SR_S))
  41     pte_perm = (pte_perm/(PTE_SX/PTE_UX)) & PTE_PERM;
  42   pte_perm |= pte & PTE_V;
  43
  44   reg_t perm = (fetch ? PTE_UX : store ? PTE_UW : PTE_UR) | PTE_V;
  45   if(unlikely((pte_perm & perm) != perm))
  46   {
  47     if (fetch)
  48       throw trap_instruction_access_fault(addr);
  49     if (store)
  50       throw trap_store_access_fault(addr);
  51     throw trap_load_access_fault(addr);
  52   }
  53
  54   reg_t pgoff = addr & (PGSIZE-1);
  55   reg_t pgbase = pte >> PGSHIFT << PGSHIFT;
  56   reg_t paddr = pgbase + pgoff;
  57
  58   if (unlikely(tracer.interested_in_range(pgbase, pgbase + PGSIZE, store, fetch)))
  59     tracer.trace(paddr, bytes, store, fetch);
  60   else
  61   {
  62     tlb_load_tag[idx] = (pte_perm & PTE_UR) ? expected_tag : -1;
  63     tlb_store_tag[idx] = (pte_perm & PTE_UW) ? expected_tag : -1;
  64     tlb_insn_tag[idx] = (pte_perm & PTE_UX) ? expected_tag : -1;
  65     tlb_data[idx] = mem + pgbase - (addr & ~(PGSIZE-1));
  66   }
  67
  68   return mem + paddr;
  69 }
  70
  71 pte_t mmu_t::walk(reg_t addr)
  72 {
  73   pte_t pte = 0;
  74
  75   // the address must be a canonical sign-extended VA_BITS-bit number
  76   int shift = 8*sizeof(reg_t) - VA_BITS;
  77   if (((sreg_t)addr << shift >> shift) != (sreg_t)addr)
  78     ;
  79   else if (proc == NULL || !(proc->state.sr & SR_VM))
  80   {
  81     if(addr < memsz)
  82       pte = PTE_V | PTE_PERM | ((addr >> PGSHIFT) << PGSHIFT);
  83   }
  84   else
  85   {
  86     reg_t base = proc->get_state()->ptbr;
  87     reg_t ptd;
  88
  89     int ptshift = (LEVELS-1)*PTIDXBITS;
  90     for(reg_t i = 0; i < LEVELS; i++, ptshift -= PTIDXBITS)
  91     {
  92       reg_t idx = (addr >> (PGSHIFT+ptshift)) & ((1<<PTIDXBITS)-1);
  93
  94       reg_t pte_addr = base + idx*sizeof(pte_t);
  95       if(pte_addr >= memsz)
  96         break;
  97
  98       ptd = *(pte_t*)(mem+pte_addr);
  99
 100       if (!(ptd & PTE_V)) // invalid mapping
 101         break;
 102       else if (ptd & PTE_T) // next level of page table
 103         base = (ptd >> PGSHIFT) << PGSHIFT;
 104       else // the actual PTE
 105       {
 106         // if this PTE is from a larger PT, fake a leaf
 107         // PTE so the TLB will work right
 108         reg_t vpn = addr >> PGSHIFT;
 109         ptd |= (vpn & ((1<<(ptshift))-1)) << PGSHIFT;
 110
 111         // fault if physical addr is out of range
 112         if (((ptd >> PGSHIFT) << PGSHIFT) < memsz)
 113           pte = ptd;
 114         break;
 115       }
 116     }
 117   }
 118
 119   return pte;
 120 }
 121
 122 void mmu_t::register_memtracer(memtracer_t* t)
 123 {
 124   flush_tlb();
 125   tracer.hook(t);
 126 }