WebSVN – HelenOS – Diff – /branches/fs/kernel/generic/src/mm/as.c

 #include <arch/mm/page.h>
 #include <genarch/mm/page_pt.h>
 #include <genarch/mm/page_ht.h>
 #include <mm/asid.h>
 #include <arch/mm/asid.h>
+#include <preemption.h>
 #include <synch/spinlock.h>
 #include <synch/mutex.h>
 #include <adt/list.h>
 #include <adt/btree.h>
 #include <proc/task.h>
  */
 static slab_cache_t *as_slab;
 #endif
 /**
+ * This lock serializes access to the ASID subsystem.
+ * It protects:
- * This lock protects inactive_as_with_asid_head list. It must be acquired
+ * - inactive_as_with_asid_head list
+ * - as->asid for each as of the as_t type
- * before as_t mutex.
+ * - asids_allocated counter
  */
-SPINLOCK_INITIALIZE(inactive_as_with_asid_lock);
+SPINLOCK_INITIALIZE(asidlock);
 /**
  * This list contains address spaces that are not active on any
  * processor and that have valid ASID.
  */
     if (flags & FLAG_AS_KERNEL)
         as->asid = ASID_KERNEL;
     else
         as->asid = ASID_INVALID;
-    as->refcount = 0;
+    atomic_set(&as->refcount, 0);
     as->cpu_refcount = 0;
 #ifdef AS_PAGE_TABLE
     as->genarch.page_table = page_table_create(flags);
 #else
     page_table_create(flags);
 /** Destroy adress space.
+ *
  * When there are no tasks referencing this address space (i.e. its refcount is
  * zero), the address space can be destroyed.
+ *
+ * We know that we don't hold any spinlock.
  */
 void as_destroy(as_t *as)
+{
     ipl_t ipl;
     bool cond;
+    DEADLOCK_PROBE_INIT(p_asidlock);
-    ASSERT(as->refcount == 0);
+    ASSERT(atomic_get(&as->refcount) == 0);
     /*
      * Since there is no reference to this area,
      * it is safe not to lock its mutex.
      */
+    /*
+     * We need to avoid deadlock between TLB shootdown and asidlock.
+     * We therefore try to take asid conditionally and if we don't succeed,
+     * we enable interrupts and try again. This is done while preemption is
+     * disabled to prevent nested context switches. We also depend on the
+     * fact that so far no spinlocks are held.
+     */
+    preemption_disable();
-    ipl = interrupts_disable();
+    ipl = interrupts_read();
+retry:
+    interrupts_disable();
-    spinlock_lock(&inactive_as_with_asid_lock);
+    if (!spinlock_trylock(&asidlock)) {
+        interrupts_enable();
+        DEADLOCK_PROBE(p_asidlock, DEADLOCK_THRESHOLD);
+        goto retry;
+    }
+    preemption_enable();    /* Interrupts disabled, enable preemption */
     if (as->asid != ASID_INVALID && as != AS_KERNEL) {
         if (as != AS && as->cpu_refcount == 0)
             list_remove(&as->inactive_as_with_asid_link);
         asid_put(as->asid);
+    }
-    spinlock_unlock(&inactive_as_with_asid_lock);
+    spinlock_unlock(&asidlock);
     /*
      * Destroy address space areas of the address space.
      * The B+tree must be walked carefully because it is
      * also being destroyed.
                 count_t c =
                     (count_t) node->value[node->keys - 1];
                 int i = 0;
                 if (overlaps(b, c * PAGE_SIZE, area->base,
-                    pages*PAGE_SIZE)) {
+                    pages * PAGE_SIZE)) {
                     if (b + c * PAGE_SIZE <= start_free) {
                         /*
                          * The whole interval fits
                          * completely in the resized
+        }
         /*
          * Finish TLB shootdown sequence.
          */
         tlb_invalidate_pages(as->asid, area->base + pages * PAGE_SIZE,
             area->pages - pages);
-        tlb_shootdown_finalize();
         /*
          * Invalidate software translation caches (e.g. TSB on sparc64).
          */
         as_invalidate_translation_cache(as, area->base +
             pages * PAGE_SIZE, area->pages - pages);
+        tlb_shootdown_finalize();
     } else {
         /*
          * Growing the area.
          * Check for overlaps with other address space areas.
          */
                 ASSERT(pte && PTE_VALID(pte) &&
                     PTE_PRESENT(pte));
                 if (area->backend &&
                     area->backend->frame_free) {
                     area->backend->frame_free(area, b +
-                    j * PAGE_SIZE, PTE_GET_FRAME(pte));
+                        j * PAGE_SIZE, PTE_GET_FRAME(pte));
+                }
                 page_mapping_remove(as, b + j * PAGE_SIZE);
                 page_table_unlock(as, false);
+            }
+        }
+    }
     /*
      * Finish TLB shootdown sequence.
      */
     tlb_invalidate_pages(as->asid, area->base, area->pages);
-    tlb_shootdown_finalize();
     /*
      * Invalidate potential software translation caches (e.g. TSB on
      * sparc64).
      */
     as_invalidate_translation_cache(as, area->base, area->pages);
+    tlb_shootdown_finalize();
     btree_destroy(&area->used_space);
     area->attributes |= AS_AREA_ATTR_PARTIAL;
+ *
  * @return Zero on success or ENOENT if there is no such task or if there is no
  * such address space area, EPERM if there was a problem in accepting the area
  * or ENOMEM if there was a problem in allocating destination address space
  * area. ENOTSUP is returned if the address space area backend does not support
- * sharing or if the kernel detects an attempt to create an illegal address
- * alias.
+ * sharing.
  */
 int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size,
           as_t *dst_as, uintptr_t dst_base, int dst_flags_mask)
+{
     ipl_t ipl;
         mutex_unlock(&src_as->lock);
         interrupts_restore(ipl);
         return EPERM;
+    }
-#ifdef CONFIG_VIRT_IDX_DCACHE
-    if (!(dst_flags_mask & AS_AREA_EXEC)) {
-        if (PAGE_COLOR(src_area->base) != PAGE_COLOR(dst_base)) {
-            /*
-             * Refuse to create an illegal address alias.
-             */
-            mutex_unlock(&src_area->lock);
-            mutex_unlock(&src_as->lock);
-            interrupts_restore(ipl);
-            return ENOTSUP;
-        }
-    }
-#endif /* CONFIG_VIRT_IDX_DCACHE */
     /*
      * Now we are committed to sharing the area.
      * First, prepare the area for sharing.
      * Then it will be safe to unlock it.
      */
+}
 /** Switch address spaces.
+ *
  * Note that this function cannot sleep as it is essentially a part of
- * scheduling. Sleeping here would lead to deadlock on wakeup.
+ * scheduling. Sleeping here would lead to deadlock on wakeup. Another
+ * thing which is forbidden in this context is locking the address space.
+ *
+ * When this function is enetered, no spinlocks may be held.
+ *
  * @param old Old address space or NULL.
  * @param new New address space.
  */
 void as_switch(as_t *old_as, as_t *new_as)
+{
+    DEADLOCK_PROBE_INIT(p_asidlock);
-    ipl_t ipl;
+    preemption_disable();
+retry:
-    bool needs_asid = false;
+    (void) interrupts_disable();
+    if (!spinlock_trylock(&asidlock)) {
+        /*
+         * Avoid deadlock with TLB shootdown.
+         * We can enable interrupts here because
+         * preemption is disabled. We should not be
+         * holding any other lock.
+         */
-    ipl = interrupts_disable();
+        (void) interrupts_enable();
-    spinlock_lock(&inactive_as_with_asid_lock);
+        DEADLOCK_PROBE(p_asidlock, DEADLOCK_THRESHOLD);
+        goto retry;
+    }
+    preemption_enable();
     /*
      * First, take care of the old address space.
      */
     if (old_as) {
-        mutex_lock_active(&old_as->lock);
         ASSERT(old_as->cpu_refcount);
         if((--old_as->cpu_refcount == 0) && (old_as != AS_KERNEL)) {
             /*
              * The old address space is no longer active on
              * any processor. It can be appended to the
              * list of inactive address spaces with assigned
              * ASID.
              */
-             ASSERT(old_as->asid != ASID_INVALID);
+            ASSERT(old_as->asid != ASID_INVALID);
-             list_append(&old_as->inactive_as_with_asid_link,
+            list_append(&old_as->inactive_as_with_asid_link,
-                 &inactive_as_with_asid_head);
+                &inactive_as_with_asid_head);
+        }
-        mutex_unlock(&old_as->lock);
         /*
          * Perform architecture-specific tasks when the address space
          * is being removed from the CPU.
          */
+    }
     /*
      * Second, prepare the new address space.
      */
-    mutex_lock_active(&new_as->lock);
     if ((new_as->cpu_refcount++ == 0) && (new_as != AS_KERNEL)) {
-        if (new_as->asid != ASID_INVALID) {
+        if (new_as->asid != ASID_INVALID)
             list_remove(&new_as->inactive_as_with_asid_link);
-        } else {
+        else
-            /*
-             * Defer call to asid_get() until new_as->lock is released.
-             */
-            needs_asid = true;
+            new_as->asid = asid_get();
-        }
+    }
 #ifdef AS_PAGE_TABLE
     SET_PTL0_ADDRESS(new_as->genarch.page_table);
 #endif
-    mutex_unlock(&new_as->lock);
-    if (needs_asid) {
-        /*
-         * Allocation of new ASID was deferred
-         * until now in order to avoid deadlock.
-         */
-        asid_t asid;
-        asid = asid_get();
-        mutex_lock_active(&new_as->lock);
-        new_as->asid = asid;
-        mutex_unlock(&new_as->lock);
-    }
-    spinlock_unlock(&inactive_as_with_asid_lock);
-    interrupts_restore(ipl);
     /*
      * Perform architecture-specific steps.
      * (e.g. write ASID to hardware register etc.)
      */
     as_install_arch(new_as);
+    spinlock_unlock(&asidlock);
     AS = new_as;
+}
 /** Convert address space area flags to page flags.

Subversion Repositories HelenOS

(root)/branches/fs/kernel/generic/src/mm/as.c – Rev 2131 → 2422