Changeset 2a2fbc8 in mainline for kernel/genarch/src

Timestamp:

2016-09-01T17:05:13Z (9 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

42d08592

Parents:

f126c87 (diff), fb63c06 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge from lp:~jakub/helenos/pt

Location:

kernel/genarch/src/mm

Files:

• as_ht.c (modified) (5 diffs)
• page_ht.c (modified) (9 diffs)
• page_pt.c (modified) (4 diffs)

kernel/genarch/src/mm/as_ht.c

@@ -77 +77 @@
         if (flags & FLAG_AS_KERNEL) {
                 hash_table_create(&page_ht, PAGE_HT_ENTRIES, 2, &ht_operations);
-                mutex_initialize(&page_ht_lock, MUTEX_PASSIVE);
                 pte_cache = slab_cache_create("pte_t", sizeof(pte_t), 0,
                     NULL, NULL, SLAB_CACHE_MAGDEFERRED);
@@ -99 +98 @@
 /** Lock page table.
  *
- * Lock address space and page hash table.
+ * Lock address space.
  * Interrupts must be disabled.
  *
@@ -110 +109 @@
         if (lock)
                 mutex_lock(&as->lock);
-        
-        mutex_lock(&page_ht_lock);
 }
 
 /** Unlock page table.
  *
- * Unlock address space and page hash table.
+ * Unlock address space.
  * Interrupts must be disabled.
  *
@@ -125 +122 @@
 void ht_unlock(as_t *as, bool unlock)
 {
-        mutex_unlock(&page_ht_lock);
-        
         if (unlock)
                 mutex_unlock(&as->lock);
@@ -140 +135 @@
 bool ht_locked(as_t *as)
 {
-        return (mutex_locked(&page_ht_lock) && mutex_locked(&as->lock));
+        return mutex_locked(&as->lock);
 }
 

kernel/genarch/src/mm/page_ht.c

@@ -59 +59 @@
 static void ht_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
 static void ht_mapping_remove(as_t *, uintptr_t);
-static pte_t *ht_mapping_find(as_t *, uintptr_t, bool);
+static bool ht_mapping_find(as_t *, uintptr_t, bool, pte_t *);
+static void ht_mapping_update(as_t *, uintptr_t, bool, pte_t *);
 static void ht_mapping_make_global(uintptr_t, size_t);
 
@@ -70 +71 @@
  *
  */
-mutex_t page_ht_lock;
+IRQ_SPINLOCK_STATIC_INITIALIZE(page_ht_lock);
 
 /** Page hash table.
@@ -91 +92 @@
         .mapping_remove = ht_mapping_remove,
         .mapping_find = ht_mapping_find,
+        .mapping_update = ht_mapping_update,
         .mapping_make_global = ht_mapping_make_global
 };
@@ -191 +193 @@
 
         ASSERT(page_table_locked(as));
+
+        irq_spinlock_lock(&page_ht_lock, true);
         
         if (!hash_table_find(&page_ht, key)) {
@@ -217 +221 @@
                 hash_table_insert(&page_ht, key, &pte->link);
         }
+
+        irq_spinlock_unlock(&page_ht_lock, true);
 }
 
@@ -238 +244 @@
         ASSERT(page_table_locked(as));
         
+        irq_spinlock_lock(&page_ht_lock, true);
+
         /*
          * Note that removed PTE's will be freed
@@ -243 +251 @@
          */
         hash_table_remove(&page_ht, key, 2);
-}
-
-
-/** Find mapping for virtual page in page hash table.
- *
- * @param as     Address space to which page belongs.
- * @param page   Virtual page.
- * @param nolock True if the page tables need not be locked.
- *
- * @return NULL if there is no such mapping; requested mapping otherwise.
- *
- */
-pte_t *ht_mapping_find(as_t *as, uintptr_t page, bool nolock)
+
+        irq_spinlock_unlock(&page_ht_lock, true);
+}
+
+static pte_t *ht_mapping_find_internal(as_t *as, uintptr_t page, bool nolock)
 {
         sysarg_t key[2] = {
@@ -263 +263 @@
 
         ASSERT(nolock || page_table_locked(as));
-        
+
         link_t *cur = hash_table_find(&page_ht, key);
         if (cur)
@@ -271 +271 @@
 }
 
+/** Find mapping for virtual page in page hash table.
+ *
+ * @param as       Address space to which page belongs.
+ * @param page     Virtual page.
+ * @param nolock   True if the page tables need not be locked.
+ * @param[out] pte Structure that will receive a copy of the found PTE.
+ *
+ * @return True if the mapping was found, false otherwise.
+ */
+bool ht_mapping_find(as_t *as, uintptr_t page, bool nolock, pte_t *pte)
+{
+        irq_spinlock_lock(&page_ht_lock, true);
+
+        pte_t *t = ht_mapping_find_internal(as, page, nolock);
+        if (t)
+                *pte = *t;
+
+        irq_spinlock_unlock(&page_ht_lock, true);
+        
+        return t != NULL;
+}
+
+/** Update mapping for virtual page in page hash table.
+ *
+ * @param as       Address space to which page belongs.
+ * @param page     Virtual page.
+ * @param nolock   True if the page tables need not be locked.
+ * @param pte      New PTE.
+ */
+void ht_mapping_update(as_t *as, uintptr_t page, bool nolock, pte_t *pte)
+{
+        irq_spinlock_lock(&page_ht_lock, true);
+
+        pte_t *t = ht_mapping_find_internal(as, page, nolock);
+        if (!t)
+                panic("Updating non-existent PTE");
+        
+        ASSERT(pte->as == t->as);
+        ASSERT(pte->page == t->page);
+        ASSERT(pte->frame == t->frame);
+        ASSERT(pte->g == t->g);
+        ASSERT(pte->x == t->x);
+        ASSERT(pte->w == t->w);
+        ASSERT(pte->k == t->k);
+        ASSERT(pte->c == t->c);
+        ASSERT(pte->p == t->p);
+
+        t->a = pte->a;
+        t->d = pte->d;
+
+        irq_spinlock_unlock(&page_ht_lock, true);
+}
+
 void ht_mapping_make_global(uintptr_t base, size_t size)
 {

kernel/genarch/src/mm/page_pt.c

@@ -53 +53 @@
 static void pt_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
 static void pt_mapping_remove(as_t *, uintptr_t);
-static pte_t *pt_mapping_find(as_t *, uintptr_t, bool);
+static bool pt_mapping_find(as_t *, uintptr_t, bool, pte_t *pte);
+static void pt_mapping_update(as_t *, uintptr_t, bool, pte_t *pte);
 static void pt_mapping_make_global(uintptr_t, size_t);
 
@@ -60 +61 @@
         .mapping_remove = pt_mapping_remove,
         .mapping_find = pt_mapping_find,
+        .mapping_update = pt_mapping_update,
         .mapping_make_global = pt_mapping_make_global
 };
@@ -289 +291 @@
 }
 
-/** Find mapping for virtual page in hierarchical page tables.
- *
- * @param as     Address space to which page belongs.
- * @param page   Virtual page.
- * @param nolock True if the page tables need not be locked.
- *
- * @return NULL if there is no such mapping; entry from PTL3 describing
- *         the mapping otherwise.
- *
- */
-pte_t *pt_mapping_find(as_t *as, uintptr_t page, bool nolock)
+static pte_t *pt_mapping_find_internal(as_t *as, uintptr_t page, bool nolock)
 {
         ASSERT(nolock || page_table_locked(as));
@@ -334 +326 @@
         
         return &ptl3[PTL3_INDEX(page)];
+}
+
+/** Find mapping for virtual page in hierarchical page tables.
+ *
+ * @param as       Address space to which page belongs.
+ * @param page     Virtual page.
+ * @param nolock   True if the page tables need not be locked.
+ * @param[out] pte Structure that will receive a copy of the found PTE.
+ *
+ * @return True if the mapping was found, false otherwise.
+ */
+bool pt_mapping_find(as_t *as, uintptr_t page, bool nolock, pte_t *pte)
+{
+        pte_t *t = pt_mapping_find_internal(as, page, nolock);
+        if (t)
+                *pte = *t;
+        return t != NULL;
+}
+
+/** Update mapping for virtual page in hierarchical page tables.
+ *
+ * @param as       Address space to which page belongs.
+ * @param page     Virtual page.
+ * @param nolock   True if the page tables need not be locked.
+ * @param[in] pte  New PTE.
+ */
+void pt_mapping_update(as_t *as, uintptr_t page, bool nolock, pte_t *pte)
+{
+        pte_t *t = pt_mapping_find_internal(as, page, nolock);
+        if (!t)
+                panic("Updating non-existent PTE");     
+
+        ASSERT(PTE_VALID(t) == PTE_VALID(pte));
+        ASSERT(PTE_PRESENT(t) == PTE_PRESENT(pte));
+        ASSERT(PTE_GET_FRAME(t) == PTE_GET_FRAME(pte));
+        ASSERT(PTE_WRITABLE(t) == PTE_WRITABLE(pte));
+        ASSERT(PTE_EXECUTABLE(t) == PTE_EXECUTABLE(pte));
+
+        *t = *pte;
 }