Changeset 83789ea2 in mainline

Timestamp:

2023-02-09T16:12:24Z (22 months ago)

Author:

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

Branches:

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

Children:

c0b54c9

Parents:

ba25c4b

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2022-08-16 17:52:15)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2023-02-09 16:12:24)

Message:

Simplify timeout handling

Since timeout_unregister() now waits for the handler to complete,
we can get rid of some of the bookkeeping in waitq and thread code.
We can also turn timeout_t into a local variable instead of
keeping it around in thread_t.

Location:

kernel/generic

Files:

• include/proc/thread.h (modified) (1 diff)
• src/proc/thread.c (modified) (2 diffs)
• src/synch/waitq.c (modified) (8 diffs)
• src/time/timeout.c (modified) (1 diff)

kernel/generic/include/proc/thread.h

@@ -121 +121 @@
         /** Wait queue in which this thread sleeps. */
         waitq_t *sleep_queue;
-        /** Timeout used for timeoutable sleeping.  */
-        timeout_t sleep_timeout;
-        /** Flag signalling sleep timeout in progress. */
-        volatile bool timeout_pending;
 
         /**

kernel/generic/src/proc/thread.c

@@ -360 +360 @@
         thread->state = Entering;
 
-        timeout_initialize(&thread->sleep_timeout);
         thread->sleep_interruptible = false;
         thread->sleep_composable = false;
         thread->sleep_queue = NULL;
-        thread->timeout_pending = false;
 
         thread->in_copy_from_uspace = false;
@@ -500 +498 @@
         }
 
-restart:
         irq_spinlock_lock(&THREAD->lock, true);
-        if (THREAD->timeout_pending) {
-                /* Busy waiting for timeouts in progress */
-                irq_spinlock_unlock(&THREAD->lock, true);
-                goto restart;
-        }
-
         THREAD->state = Exiting;
         irq_spinlock_unlock(&THREAD->lock, true);

kernel/generic/src/synch/waitq.c

@@ -121 +121 @@
         }
 
-        thread->timeout_pending = false;
         irq_spinlock_unlock(&thread->lock, false);
 
@@ -172 +171 @@
                         goto grab_locks;
                 }
-
-                if ((thread->timeout_pending) &&
-                    (timeout_unregister(&thread->sleep_timeout)))
-                        thread->timeout_pending = false;
 
                 list_remove(&thread->wq_link);
@@ -270 +265 @@
 ipl_t waitq_sleep_prepare(waitq_t *wq)
 {
-        ipl_t ipl;
-
-restart:
-        ipl = interrupts_disable();
-
-        if (THREAD) {  /* Needed during system initiailzation */
-                /*
-                 * Busy waiting for a delayed timeout.
-                 * This is an important fix for the race condition between
-                 * a delayed timeout and a next call to waitq_sleep_timeout().
-                 * Simply, the thread is not allowed to go to sleep if
-                 * there are timeouts in progress.
-                 *
-                 */
-                irq_spinlock_lock(&THREAD->lock, false);
-
-                if (THREAD->timeout_pending) {
-                        irq_spinlock_unlock(&THREAD->lock, false);
-                        interrupts_restore(ipl);
-                        goto restart;
-                }
-
-                irq_spinlock_unlock(&THREAD->lock, false);
-        }
-
+        ipl_t ipl = interrupts_disable();
         irq_spinlock_lock(&wq->lock, false);
         return ipl;
@@ -374 +345 @@
         irq_spinlock_lock(&THREAD->lock, false);
 
+        timeout_t timeout;
+        timeout_initialize(&timeout);
+
         THREAD->sleep_composable = (flags & SYNCH_FLAGS_FUTEX);
 
@@ -395 +369 @@
                         THREAD->last_cycle = get_cycle();
                         irq_spinlock_unlock(&THREAD->lock, false);
+                        if (usec) {
+                                timeout_unregister(&timeout);
+                        }
                         return EINTR;
                 }
@@ -409 +386 @@
                 }
 
-                THREAD->timeout_pending = true;
-                timeout_register(&THREAD->sleep_timeout, (uint64_t) usec,
-                    waitq_sleep_timed_out, THREAD);
+                timeout_register(&timeout, (uint64_t) usec, waitq_sleep_timed_out, THREAD);
         }
 
@@ -433 +408 @@
         /* wq->lock is released in scheduler_separated_stack() */
         scheduler();
+
+        if (usec) {
+                timeout_unregister(&timeout);
+        }
 
         return EOK;
@@ -560 +539 @@
         list_remove(&thread->wq_link);
 
-        if ((thread->timeout_pending) &&
-            (timeout_unregister(&thread->sleep_timeout)))
-                thread->timeout_pending = false;
-
         thread->sleep_queue = NULL;
         irq_spinlock_unlock(&thread->lock, false);

kernel/generic/src/time/timeout.c

@@ -128 +128 @@
 bool timeout_unregister(timeout_t *timeout)
 {
+        if (atomic_load_explicit(&timeout->finished, memory_order_acquire))
+                /* The timeout fired and finished already, no need to check the list. */
+                return false;
+
         assert(timeout->cpu);