Changeset 2299914 in mainline for generic/src/mm/as.c

Timestamp:

2006-03-16T12:57:31Z (19 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

e898a8d7

Parents:

b7dcabb

Message:

Page table locking.

File:

• generic/src/mm/as.c (modified) (7 diffs)

generic/src/mm/as.c

@@ -174 +174 @@
         
         ipl = interrupts_disable();
-        spinlock_lock(&as->lock);
+        page_table_lock(as, true);
         
         area = find_area_and_lock(as, page);
@@ -184 +184 @@
         
         spinlock_unlock(&area->lock);
-        spinlock_unlock(&as->lock);
+        page_table_unlock(as, true);
         interrupts_restore(ipl);
 }
@@ -199 +199 @@
 int as_page_fault(__address page)
 {
+        pte_t *pte;
         as_area_t *area;
         __address frame;
         
         ASSERT(AS);
+
         spinlock_lock(&AS->lock);
-        
         area = find_area_and_lock(AS, page);    
         if (!area) {
@@ -213 +214 @@
                 spinlock_unlock(&AS->lock);
                 return 0;
+        }
+
+        page_table_lock(AS, false);
+        
+        /*
+         * To avoid race condition between two page faults
+         * on the same address, we need to make sure
+         * the mapping has not been already inserted.
+         */
+        if ((pte = page_mapping_find(AS, page))) {
+                if (PTE_PRESENT(pte)) {
+                        page_table_unlock(AS, false);
+                        spinlock_unlock(&area->lock);
+                        spinlock_unlock(&AS->lock);
+                        return 1;
+                }
         }
 
@@ -238 +255 @@
          */
         page_mapping_insert(AS, page, frame, get_area_flags(area));
+        page_table_unlock(AS, false);
         
         spinlock_unlock(&area->lock);
         spinlock_unlock(&AS->lock);
-
         return 1;
 }
@@ -358 +375 @@
 }
 
+/** Lock page table.
+ *
+ * This function should be called before any page_mapping_insert(),
+ * page_mapping_remove() and page_mapping_find().
+ * 
+ * Locking order is such that address space areas must be locked
+ * prior to this call. Address space can be locked prior to this
+ * call in which case the lock argument is false.
+ *
+ * @param as Address space.
+ * @param as_locked If false, do not attempt to lock as->lock.
+ */
+void page_table_lock(as_t *as, bool lock)
+{
+        ASSERT(as_operations);
+        ASSERT(as_operations->page_table_lock);
+
+        as_operations->page_table_lock(as, lock);
+}
+
+/** Unlock page table.
+ *
+ * @param as Address space.
+ * @param as_locked If false, do not attempt to unlock as->lock.
+ */
+void page_table_unlock(as_t *as, bool unlock)
+{
+        ASSERT(as_operations);
+        ASSERT(as_operations->page_table_unlock);
+
+        as_operations->page_table_unlock(as, unlock);
+}
+
 /** Find address space area and change it.
  *
@@ -398 +448 @@
                          * Releasing physical memory.
                          * This depends on the fact that the memory was allocated using frame_alloc().
-                         */ 
+                         */
+                        page_table_lock(as, false);
                         pte = page_mapping_find(as, area->base + i*PAGE_SIZE);
                         if (pte && PTE_VALID(pte)) {
+                                __address frame;
+
                                 ASSERT(PTE_PRESENT(pte));
-                                frame_free(ADDR2PFN(PTE_GET_FRAME(pte)));
+                                frame = PTE_GET_FRAME(pte);
                                 page_mapping_remove(as, area->base + i*PAGE_SIZE);
+                                page_table_unlock(as, false);
+
+                                frame_free(ADDR2PFN(frame));
+                        } else {
+                                page_table_unlock(as, false);
                         }
                 }