Changes in kernel/generic/src/synch/futex.c [a49a1a1:4774a32] in mainline

File:

• kernel/generic/src/synch/futex.c (modified) (13 diffs)

kernel/generic/src/synch/futex.c

@@ -37 +37 @@
 
 #include <synch/futex.h>
-#include <synch/mutex.h>
+#include <synch/rwlock.h>
 #include <synch/spinlock.h>
 #include <synch/synch.h>
@@ -65 +65 @@
 
 /**
- * Mutex protecting global futex hash table.
+ * Read-write lock protecting global futex hash table.
  * It is also used to serialize access to all futex_t structures.
  * Must be acquired before the task futex B+tree lock.
  */
-static mutex_t futex_ht_lock;
+static rwlock_t futex_ht_lock;
 
 /** Futex hash table. */
@@ -84 +84 @@
 void futex_init(void)
 {
-        mutex_initialize(&futex_ht_lock, MUTEX_PASSIVE);
+        rwlock_initialize(&futex_ht_lock);
         hash_table_create(&futex_ht, FUTEX_HT_SIZE, 1, &futex_ht_ops);
 }
@@ -113 +113 @@
         uintptr_t paddr;
         pte_t *t;
+        ipl_t ipl;
         int rc;
         
+        ipl = interrupts_disable();
+
         /*
          * Find physical address of futex counter.
@@ -122 +125 @@
         if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
                 page_table_unlock(AS, true);
+                interrupts_restore(ipl);
                 return (unative_t) ENOENT;
         }
@@ -127 +131 @@
         page_table_unlock(AS, true);
         
+        interrupts_restore(ipl);        
+
         futex = futex_find(paddr);
 
@@ -150 +156 @@
         uintptr_t paddr;
         pte_t *t;
+        ipl_t ipl;
+        
+        ipl = interrupts_disable();
         
         /*
@@ -158 +167 @@
         if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
                 page_table_unlock(AS, true);
+                interrupts_restore(ipl);
                 return (unative_t) ENOENT;
         }
@@ -163 +173 @@
         page_table_unlock(AS, true);
         
+        interrupts_restore(ipl);
+
         futex = futex_find(paddr);
                 
@@ -188 +200 @@
          * or allocate new one if it does not exist already.
          */
-        mutex_lock(&futex_ht_lock);
+        rwlock_read_lock(&futex_ht_lock);
         item = hash_table_find(&futex_ht, &paddr);
         if (item) {
@@ -200 +212 @@
                         /*
                          * The futex is new to the current task.
-                         * Upgrade its reference count and put it to the
-                         * current task's B+tree of known futexes.
+                         * However, we only have read access.
+                         * Gain write access and try again.
                          */
-                        futex->refcount++;
-                        btree_insert(&TASK->futexes, paddr, futex, leaf);
+                        mutex_unlock(&TASK->futexes_lock);
+                        goto gain_write_access;
                 }
                 mutex_unlock(&TASK->futexes_lock);
+
+                rwlock_read_unlock(&futex_ht_lock);
         } else {
-                futex = (futex_t *) malloc(sizeof(futex_t), 0);
-                futex_initialize(futex);
-                futex->paddr = paddr;
-                hash_table_insert(&futex_ht, &paddr, &futex->ht_link);
+gain_write_access:
+                /*
+                 * Upgrade to writer is not currently supported,
+                 * therefore, it is necessary to release the read lock
+                 * and reacquire it as a writer.
+                 */
+                rwlock_read_unlock(&futex_ht_lock);
+
+                rwlock_write_lock(&futex_ht_lock);
+                /*
+                 * Avoid possible race condition by searching
+                 * the hash table once again with write access.
+                 */
+                item = hash_table_find(&futex_ht, &paddr);
+                if (item) {
+                        futex = hash_table_get_instance(item, futex_t, ht_link);
                         
-                /*
-                 * This is the first task referencing the futex.
-                 * It can be directly inserted into its
-                 * B+tree of known futexes.
-                 */
-                mutex_lock(&TASK->futexes_lock);
-                btree_insert(&TASK->futexes, paddr, futex, NULL);
-                mutex_unlock(&TASK->futexes_lock);
-                
+                        /*
+                         * See if this futex is known to the current task.
+                         */
+                        mutex_lock(&TASK->futexes_lock);
+                        if (!btree_search(&TASK->futexes, paddr, &leaf)) {
+                                /*
+                                 * The futex is new to the current task.
+                                 * Upgrade its reference count and put it to the
+                                 * current task's B+tree of known futexes.
+                                 */
+                                futex->refcount++;
+                                btree_insert(&TASK->futexes, paddr, futex,
+                                    leaf);
+                        }
+                        mutex_unlock(&TASK->futexes_lock);
+        
+                        rwlock_write_unlock(&futex_ht_lock);
+                } else {
+                        futex = (futex_t *) malloc(sizeof(futex_t), 0);
+                        futex_initialize(futex);
+                        futex->paddr = paddr;
+                        hash_table_insert(&futex_ht, &paddr, &futex->ht_link);
+                        
+                        /*
+                         * This is the first task referencing the futex.
+                         * It can be directly inserted into its
+                         * B+tree of known futexes.
+                         */
+                        mutex_lock(&TASK->futexes_lock);
+                        btree_insert(&TASK->futexes, paddr, futex, NULL);
+                        mutex_unlock(&TASK->futexes_lock);
+                        
+                        rwlock_write_unlock(&futex_ht_lock);
+                }
         }
-        mutex_unlock(&futex_ht_lock);
         
         return futex;
@@ -274 +324 @@
         link_t *cur;
         
-        mutex_lock(&futex_ht_lock);
+        rwlock_write_lock(&futex_ht_lock);
         mutex_lock(&TASK->futexes_lock);
 
@@ -294 +344 @@
         
         mutex_unlock(&TASK->futexes_lock);
-        mutex_unlock(&futex_ht_lock);
+        rwlock_write_unlock(&futex_ht_lock);
 }