Changeset 38a1a84 in mainline for arch/mips32/src/mm/tlb.c

Timestamp:

2005-10-05T21:29:16Z (20 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

bca1b47

Parents:

49c1f93

Message:

MIPS32 memory management work.
Fix some bugs introduced yesterday (PTL3 index is indeed calculated by >> 14).
Introduce two new bits in pte_t (i.e. 'a' and 'w').
Implement TLB Invalid Exception and TLB Modified Exception. (Needs review and testing)

File:

• arch/mips32/src/mm/tlb.c (modified) (6 diffs)

arch/mips32/src/mm/tlb.c

@@ -43 +43 @@
 static void tlb_modified_fail(struct exception_regdump *pstate);
 
+static pte_t *find_mapping_and_check(__address badvaddr);
+static void prepare_entry_lo(struct entry_lo *lo, bool g, bool v, bool d, bool c, __address pfn);
+
 /** Initialize TLB
  *
@@ -80 +83 @@
 void tlb_refill(struct exception_regdump *pstate)
 {
-        struct entry_hi hi;
+        struct entry_lo lo;
         __address badvaddr;
         pte_t *pte;
         
-        *((__u32 *) &hi) = cp0_entry_hi_read();
         badvaddr = cp0_badvaddr_read();
         
-        spinlock_lock(&VM->lock);
-
-        /*
-         * Refill cannot succeed if the ASIDs don't match.
-         */
-        if (hi.asid != VM->asid)
-                goto fail;
-
-        /*
-         * Refill cannot succeed if badvaddr is not
-         * associated with any mapping.
-         */
-        pte = find_mapping(badvaddr, 0);
+        spinlock_lock(&VM->lock);               
+        pte = find_mapping_and_check(badvaddr);
         if (!pte)
                 goto fail;
-                
-        /*
-         * Refill cannot succeed if the mapping is marked as invalid.
-         */
-        if (!pte->v)
-                goto fail;
+
+        /*
+         * Record access to PTE.
+         */
+        pte->a = 1;
+
+        prepare_entry_lo(&lo, pte->g, pte->v, pte->d, pte->c, pte->pfn);
 
         /*
          * New entry is to be inserted into TLB
          */
-        cp0_pagemask_write(TLB_PAGE_MASK_16K);
         if ((badvaddr/PAGE_SIZE) % 2 == 0) {
-                cp0_entry_lo0_write(*((__u32 *) pte));
+                cp0_entry_lo0_write(*((__u32 *) &lo));
                 cp0_entry_lo1_write(0);
         }
         else {
                 cp0_entry_lo0_write(0);
-                cp0_entry_lo1_write(*((__u32 *) pte));
+                cp0_entry_lo1_write(*((__u32 *) &lo));
         }
         tlbwr();
@@ -131 +122 @@
 }
 
+/** Process TLB Invalid Exception
+ *
+ * Process TLB Invalid Exception.
+ *
+ * @param pstate Interrupted register context.
+ */
 void tlb_invalid(struct exception_regdump *pstate)
 {
+        struct index index;
+        __address badvaddr;
+        struct entry_lo lo;
+        pte_t *pte;
+
+        badvaddr = cp0_badvaddr_read();
+
+        /*
+         * Locate the faulting entry in TLB.
+         */
+        tlbp();
+        *((__u32 *) &index) = cp0_index_read();
+        
+        spinlock_lock(&VM->lock);       
+        
+        /*
+         * Fail if the entry is not in TLB.
+         */
+        if (index.p)
+                goto fail;
+
+        pte = find_mapping_and_check(badvaddr);
+        if (!pte)
+                goto fail;
+
+        /*
+         * Read the faulting TLB entry.
+         */
+        tlbr();
+
+        /*
+         * Record access to PTE.
+         */
+        pte->a = 1;
+
+        prepare_entry_lo(&lo, pte->g, pte->v, pte->d, pte->c, pte->pfn);
+
+        /*
+         * The entry is to be updated in TLB.
+         */
+        if ((badvaddr/PAGE_SIZE) % 2 == 0)
+                cp0_entry_lo0_write(*((__u32 *) &lo));
+        else
+                cp0_entry_lo1_write(*((__u32 *) &lo));
+        tlbwi();
+
+        spinlock_unlock(&VM->lock);     
+        return;
+        
+fail:
+        spinlock_unlock(&VM->lock);
         tlb_invalid_fail(pstate);
 }
 
+/** Process TLB Modified Exception
+ *
+ * Process TLB Modified Exception.
+ *
+ * @param pstate Interrupted register context.
+ */
+
 void tlb_modified(struct exception_regdump *pstate)
 {
+        struct index index;
+        __address badvaddr;
+        struct entry_lo lo;
+        pte_t *pte;
+
+        badvaddr = cp0_badvaddr_read();
+
+        /*
+         * Locate the faulting entry in TLB.
+         */
+        tlbp();
+        *((__u32 *) &index) = cp0_index_read();
+        
+        spinlock_lock(&VM->lock);       
+        
+        /*
+         * Fail if the entry is not in TLB.
+         */
+        if (index.p)
+                goto fail;
+
+        pte = find_mapping_and_check(badvaddr);
+        if (!pte)
+                goto fail;
+
+        /*
+         * Fail if the page is not writable.
+         */
+        if (!pte->w)
+                goto fail;
+
+        /*
+         * Read the faulting TLB entry.
+         */
+        tlbr();
+
+        /*
+         * Record access and write to PTE.
+         */
+        pte->a = 1;
+        pte->d = 1;
+
+        prepare_entry_lo(&lo, pte->g, pte->v, pte->w, pte->c, pte->pfn);
+
+        /*
+         * The entry is to be updated in TLB.
+         */
+        if ((badvaddr/PAGE_SIZE) % 2 == 0)
+                cp0_entry_lo0_write(*((__u32 *) &lo));
+        else
+                cp0_entry_lo1_write(*((__u32 *) &lo));
+        tlbwi();
+
+        spinlock_unlock(&VM->lock);     
+        return;
+        
+fail:
+        spinlock_unlock(&VM->lock);
         tlb_modified_fail(pstate);
 }
@@ -163 +276 @@
         if (s)
                 symbol = s;
-        panic("%X: TLB Invalid Exception at %X(%s)\n", cp0_badvaddr_read(),
-              pstate->epc, symbol);
+        panic("%X: TLB Invalid Exception at %X(%s)\n", cp0_badvaddr_read(), pstate->epc, symbol);
 }
 
@@ -174 +286 @@
         if (s)
                 symbol = s;
-        panic("%X: TLB Modified Exception at %X(%s)\n", cp0_badvaddr_read(),
-              pstate->epc, symbol);
+        panic("%X: TLB Modified Exception at %X(%s)\n", cp0_badvaddr_read(), pstate->epc, symbol);
 }
 
@@ -189 +300 @@
         cpu_priority_restore(pri);
 }
+
+/** Try to find PTE for faulting address
+ *
+ * Try to find PTE for faulting address.
+ * The VM->lock must be held on entry to this function.
+ *
+ * @param badvaddr Faulting virtual address.
+ *
+ * @return PTE on success, NULL otherwise.
+ */
+pte_t *find_mapping_and_check(__address badvaddr)
+{
+        struct entry_hi hi;
+        pte_t *pte;
+
+        *((__u32 *) &hi) = cp0_entry_hi_read();
+
+        /*
+         * Handler cannot succeed if the ASIDs don't match.
+         */
+        if (hi.asid != VM->asid)
+                return NULL;
+        
+        /*
+         * Handler cannot succeed if badvaddr has no mapping.
+         */
+        pte = find_mapping(badvaddr, 0);
+        if (!pte)
+                return NULL;
+
+        /*
+         * Handler cannot succeed if the mapping is marked as invalid.
+         */
+        if (!pte->v)
+                return NULL;
+
+        return pte;
+}
+
+void prepare_entry_lo(struct entry_lo *lo, bool g, bool v, bool d, bool c, __address pfn)
+{
+        lo->g = g;
+        lo->v = v;
+        lo->d = d;
+        lo->c = c;
+        lo->pfn = pfn;
+        lo->zero = 0;
+}