Changeset 8119363 in mainline for kernel

Timestamp:

2018-06-26T17:35:40Z (7 years ago)

Author:

Jiří Zárevúcky <jiri.zarevucky@…>

Branches:

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

Children:

6e569bf

Parents:

fbfe59d (diff), e768aea (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 some preliminary async/fibril framework changes.

Location:

kernel/generic

Files:

• include/proc/thread.h (modified) (1 diff)
• include/synch/futex.h (modified) (1 diff)
• include/synch/waitq.h (modified) (1 diff)
• src/proc/thread.c (modified) (1 diff)
• src/synch/futex.c (modified) (3 diffs)
• src/synch/waitq.c (modified) (6 diffs)

kernel/generic/include/proc/thread.h

@@ -112 +112 @@
         /** If true, the thread can be interrupted from sleep. */
         bool sleep_interruptible;
+
+        /**
+         * If true, and this thread's sleep returns without a wakeup
+         * (timed out or interrupted), waitq ignores the next wakeup.
+         * This is necessary for futex to be able to handle those conditions.
+         */
+        bool sleep_composable;
+
         /** Wait queue in which this thread sleeps. */
         waitq_t *sleep_queue;

kernel/generic/include/synch/futex.h

@@ -53 +53 @@
 
 extern void futex_init(void);
-extern sys_errno_t sys_futex_sleep(uintptr_t);
+extern sys_errno_t sys_futex_sleep(uintptr_t, uintptr_t);
 extern sys_errno_t sys_futex_wakeup(uintptr_t);
 

kernel/generic/include/synch/waitq.h

@@ -62 +62 @@
         int missed_wakeups;
 
+        /** Number of wakeups that need to be ignored due to futex timeout. */
+        int ignore_wakeups;
+
         /** List of sleeping threads for which there was no missed_wakeup. */
         list_t sleepers;

kernel/generic/src/proc/thread.c

@@ -383 +383 @@
         timeout_initialize(&thread->sleep_timeout);
         thread->sleep_interruptible = false;
+        thread->sleep_composable = false;
         thread->sleep_queue = NULL;
         thread->timeout_pending = false;

kernel/generic/src/synch/futex.c

@@ -398 +398 @@
 }
 
-/** Sleep in futex wait queue.
- *
- * @param uaddr         Userspace address of the futex counter.
+/** Sleep in futex wait queue with a timeout.
+ *  If the sleep times out or is interrupted, the next wakeup is ignored.
+ *  The userspace portion of the call must handle this condition.
+ *
+ * @param uaddr         Userspace address of the futex counter.
+ * @param timeout       Maximum number of useconds to sleep. 0 means no limit.
  *
  * @return              If there is no physical mapping for uaddr ENOENT is
@@ -406 +409 @@
  *                      waitq_sleep_timeout().
  */
-sys_errno_t sys_futex_sleep(uintptr_t uaddr)
+sys_errno_t sys_futex_sleep(uintptr_t uaddr, uintptr_t timeout)
 {
         futex_t *futex = get_futex(uaddr);
@@ -417 +420 @@
 #endif
 
-        errno_t rc = waitq_sleep_timeout(
-            &futex->wq, 0, SYNCH_FLAGS_INTERRUPTIBLE, NULL);
+        errno_t rc = waitq_sleep_timeout(&futex->wq, timeout,
+            SYNCH_FLAGS_INTERRUPTIBLE | SYNCH_FLAGS_FUTEX, NULL);
 
 #ifdef CONFIG_UDEBUG

kernel/generic/src/synch/waitq.c

@@ -57 +57 @@
 #include <adt/list.h>
 #include <arch/cycle.h>
+#include <mem.h>
 
 static void waitq_sleep_timed_out(void *);
@@ -71 +72 @@
 void waitq_initialize(waitq_t *wq)
 {
+        memsetb(wq, sizeof(*wq), 0);
         irq_spinlock_initialize(&wq->lock, "wq.lock");
         list_initialize(&wq->sleepers);
-        wq->missed_wakeups = 0;
 }
 
@@ -114 +115 @@
                 thread->saved_context = thread->sleep_timeout_context;
                 do_wakeup = true;
+                if (thread->sleep_composable)
+                        wq->ignore_wakeups++;
                 thread->sleep_queue = NULL;
                 irq_spinlock_unlock(&wq->lock, false);
@@ -176 +179 @@
                 list_remove(&thread->wq_link);
                 thread->saved_context = thread->sleep_interruption_context;
+                if (thread->sleep_composable)
+                        wq->ignore_wakeups++;
                 do_wakeup = true;
                 thread->sleep_queue = NULL;
@@ -393 +398 @@
          */
         irq_spinlock_lock(&THREAD->lock, false);
+
+        THREAD->sleep_composable = (flags & SYNCH_FLAGS_FUTEX);
 
         if (flags & SYNCH_FLAGS_INTERRUPTIBLE) {
@@ -538 +545 @@
         assert(irq_spinlock_locked(&wq->lock));
 
+        if (wq->ignore_wakeups > 0) {
+                if (mode == WAKEUP_FIRST) {
+                        wq->ignore_wakeups--;
+                        return;
+                }
+                wq->ignore_wakeups = 0;
+        }
+
 loop:
         if (list_empty(&wq->sleepers)) {