Changeset 2a003d5b in mainline

Timestamp:

2006-01-26T14:13:50Z (19 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

c2b95d3

Parents:

4a2f4bb

Message:

Page hash table modifications.

Files:

• arch/ia64/include/asm.h (modified) (1 diff)
• arch/ia64/include/mm/page.h (modified) (1 diff)
• arch/ia64/include/register.h (modified) (1 diff)
• arch/ia64/src/mm/page.c (modified) (2 diffs)
• arch/sparc64/include/mm/page.h (modified) (1 diff)
• genarch/include/mm/page_ht.h (modified) (4 diffs)
• genarch/src/mm/page_ht.c (modified) (5 diffs)

arch/ia64/include/asm.h

@@ -240 +240 @@
 }
 
+/** Disable protection key checking. */
+static inline void pk_disable(void)
+{
+        __asm__ volatile ("rsm %0\n" : : "i" (PSR_PK_MASK));
+}
+
 extern void cpu_halt(void);
 extern void cpu_sleep(void);

arch/ia64/include/mm/page.h

@@ -43 +43 @@
 
 /** Implementation of page hash table interface. */
+#define HT_ENTRIES_ARCH                 0
 #define HT_HASH_ARCH(page, asid)        0
 #define HT_COMPARE_ARCH(page, asid, t)  0
 #define HT_SLOT_EMPTY_ARCH(t)           1
+#define HT_INVALIDATE_SLOT_ARCH(t)
 #define HT_GET_NEXT_ARCH(t)             0
 #define HT_SET_NEXT_ARCH(t, s)

arch/ia64/include/register.h

@@ -35 +35 @@
 
 #define CR_IVR_MASK     0xf
+#define PSR_IC_MASK     0x2000
 #define PSR_I_MASK      0x4000
-#define PSR_IC_MASK     0x2000
+#define PSR_PK_MASK     0x8000
 
 /** Application registers. */

arch/ia64/src/mm/page.c

@@ -34 +34 @@
 #include <config.h>
 #include <panic.h>
+#include <arch/asm.h>
 
 __u64 thash(__u64 va);
@@ -141 +142 @@
 {
         page_operations = &page_ht_operations;
+        pk_disable();
         set_VHPT_environment();
 }

arch/sparc64/include/mm/page.h

@@ -43 +43 @@
 
 /** Implementation of page hash table interface. */
+#define HT_ENTRIES_ARCH                 0
 #define HT_HASH_ARCH(page, asid)        0
 #define HT_COMPARE_ARCH(page, asid, t)  0
 #define HT_SLOT_EMPTY_ARCH(t)           1
+#define HT_INVALIDATE_SLOT_ARCH(t)
 #define HT_GET_NEXT_ARCH(t)             0
 #define HT_SET_NEXT_ARCH(t, s)

genarch/include/mm/page_ht.h

@@ -37 +37 @@
 
 #include <mm/page.h>
+#include <typedefs.h>
+
+/** Number of slots in page hash table. */
+#define HT_ENTRIES                      HT_ENTRIES_ARCH
 
 /** Hash function.
@@ -57 +61 @@
 #define HT_COMPARE(page, asid, t)       HT_COMPARE_ARCH(page, asid, t)
 
-/** Identify empty hash table slots.
+/** Identify empty page hash table slots.
  *
  * @param t Pointer ro hash table typed pte_t *.
@@ -64 +68 @@
  */
 #define HT_SLOT_EMPTY(t)                HT_SLOT_EMPTY_ARCH(t)
+
+/** Invalidate/empty page hash table slot.
+ *
+ * @param t Address of the slot to be invalidated.
+ */
+#define HT_INVALIDATE_SLOT(t)           HT_INVALIDATE_SLOT_ARCH(t)
 
 /** Return next record in collision chain.
@@ -90 +100 @@
 #define HT_SET_RECORD(t, page, asid, frame, flags)      HT_SET_RECORD_ARCH(t, page, asid, frame, flags)
 
+
 extern page_operations_t page_ht_operations;
+extern spinlock_t page_ht_lock;
+
+extern pte_t *page_ht;
+
+extern void ht_invalidate_all(void);
 
 #endif

genarch/src/mm/page_ht.c

@@ -35 +35 @@
 #include <typedefs.h>
 #include <arch/asm.h>
+#include <synch/spinlock.h>
+#include <arch.h>
 #include <debug.h>
+
+/**
+ * This lock protects the page hash table. Note that software must
+ * be still careful about ordering of writes to ensure consistent
+ * view of the page hash table for hardware helpers such as VHPT
+ * walker on ia64.
+ */
+SPINLOCK_INITIALIZE(page_ht_lock);
+
+/**
+ * Page hash table pointer.
+ * The page hash table may be accessed only when page_ht_lock is held.
+ */
+pte_t *page_ht = NULL;
 
 static void ht_mapping_insert(__address page, asid_t asid, __address frame, int flags, __address root);
@@ -48 +64 @@
  *
  * Map virtual address 'page' to physical address 'frame'
- * using 'flags'.
+ * using 'flags'. In order not to disturb hardware searching,
+ * new mappings are appended to the end of the collision
+ * chain.
  *
  * @param page Virtual address of the page to be mapped.
@@ -58 +76 @@
 void ht_mapping_insert(__address page, asid_t asid, __address frame, int flags, __address root)
 {
-        pte_t *t, *u = NULL;
+        pte_t *t, *u;
+        ipl_t ipl;
+        
+        ipl = interrupts_disable();
+        spinlock_lock(&page_ht_lock);
         
         t = HT_HASH(page, asid);
         if (!HT_SLOT_EMPTY(t)) {
-                u = (pte_t *) malloc(sizeof(pte_t));    /* FIXME: use slab allocator for this */
-                if (!u)
-                        panic("could not allocate memory for hash table\n");
-                *u = *t;
+        
+                /*
+                 * The slot is occupied.
+                 * Walk through the collision chain and append the mapping to its end.
+                 */
+                 
+                do {
+                        u = t;
+                        if (HT_COMPARE(page, asid, t)) {
+                                /*
+                                 * Nothing to do,
+                                 * the record is already there.
+                                 */
+                                spinlock_unlock(&page_ht_lock);
+                                interrupts_restore(ipl);
+                                return;
+                        }
+                } while ((t = HT_GET_NEXT(t)));
+        
+                t = (pte_t *) malloc(sizeof(pte_t));    /* FIXME: use slab allocator for this */
+                if (!t)
+                        panic("could not allocate memory\n");
+
+                HT_SET_NEXT(u, t);
         }
-        HT_SET_NEXT(t, u);
+        
         HT_SET_RECORD(t, page, asid, frame, flags);
+        HT_SET_NEXT(t, NULL);
+        
+        spinlock_unlock(&page_ht_lock);
+        interrupts_restore(ipl);
 }
 
@@ -74 +120 @@
  *
  * Find mapping for virtual page.
+ *
+ * Interrupts must be disabled.
  *
  * @param page Virtual page.
@@ -85 +133 @@
         pte_t *t;
         
+        spinlock_lock(&page_ht_lock);
         t = HT_HASH(page, asid);
-        while (!HT_COMPARE(page, asid, t) && HT_GET_NEXT(t))
-                t = HT_GET_NEXT(t);
+        if (!HT_SLOT_EMPTY(t)) {
+                while (!HT_COMPARE(page, asid, t) && HT_GET_NEXT(t))
+                        t = HT_GET_NEXT(t);
+                t = HT_COMPARE(page, asid, t) ? t : NULL;
+        } else {
+                t = NULL;
+        }
+        spinlock_unlock(&page_ht_lock);
+        return t;
+}
+
+/** Invalidate page hash table.
+ *
+ * Interrupts must be disabled.
+ */
+void ht_invalidate_all(void)
+{
+        pte_t *t, *u;
+        int i;
         
-        return HT_COMPARE(page, asid, t) ? t : NULL;
+        spinlock_lock(&page_ht_lock);
+        for (i = 0; i < HT_ENTRIES; i++) {
+                if (!HT_SLOT_EMPTY(&page_ht[i])) {
+                        t = HT_GET_NEXT(&page_ht[i]);
+                        while (t) {
+                                u = t;
+                                t = HT_GET_NEXT(t);
+                                free(u);                /* FIXME: use slab allocator for this */
+                        }
+                        HT_INVALIDATE_SLOT(&page_ht[i]);
+                }
+        }
+        spinlock_unlock(&page_ht_lock);
 }