Changeset 111b9b9 in mainline for kernel/generic/include

Timestamp:

2023-02-11T19:13:44Z (3 years ago)

Author:

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

Branches:

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

Children:

4777e02

Parents:

76e17d7c

git-author:

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

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2023-02-11 19:13:44)

Message:

Reimplement waitq using thread_wait/wakeup

This adds a few functions to the thread API which can be
summarized as "stop running until woken up by others".
The ordering and context-switching concerns are thus yeeted
to this abstraction and waitq only deals with maintaining
the queues. Overall, this makes the control flow in waitq
much easier to navigate.

Location:

kernel/generic/include

Files:

• proc/scheduler.h (modified) (1 diff)
• proc/thread.h (modified) (4 diffs)
• synch/waitq.h (modified) (3 diffs)
• time/timeout.h (modified) (2 diffs)

kernel/generic/include/proc/scheduler.h

@@ -57 +57 @@
 extern void scheduler_fpu_lazy_request(void);
 extern void scheduler(void);
+extern void scheduler_locked(ipl_t);
 extern void kcpulb(void *arg);
 

kernel/generic/include/proc/thread.h

@@ -79 +79 @@
         odlink_t lthreads;
 
+        /** Tracking variable for thread_wait/thread_wakeup */
+        atomic_int sleep_state;
+
         /**
          * If true, the thread is terminating.
@@ -85 +88 @@
          */
         volatile bool interrupted;
+
+        /** Wait queue in which this thread sleeps. Used for debug printouts. */
+        _Atomic(waitq_t *) sleep_queue;
 
         /** Waitq for thread_join_timeout(). */
@@ -108 +114 @@
         context_t saved_context;
         ipl_t saved_ipl;
-
-        /**
-         * From here, the stored timeout context
-         * is restored when sleep times out.
-         */
-        context_t sleep_timeout_context;
-
-        /**
-         * From here, the stored interruption context
-         * is restored when sleep is interrupted.
-         */
-        context_t sleep_interruption_context;
-
-        /** 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;
 
         /**
@@ -216 +197 @@
 extern void thread_ready(thread_t *);
 extern void thread_exit(void) __attribute__((noreturn));
-extern void thread_interrupt(thread_t *, bool);
+extern void thread_interrupt(thread_t *);
+
+typedef enum {
+        THREAD_OK,
+        THREAD_TERMINATING,
+} thread_termination_state_t;
+
+typedef enum {
+        THREAD_WAIT_SUCCESS,
+        THREAD_WAIT_TIMEOUT,
+} thread_wait_result_t;
+
+extern thread_termination_state_t thread_wait_start(void);
+extern thread_wait_result_t thread_wait_finish(deadline_t);
+extern void thread_wakeup(thread_t *);
 
 static inline thread_t *thread_ref(thread_t *thread)

kernel/generic/include/synch/waitq.h

@@ -41 +41 @@
 #include <adt/list.h>
 
-typedef enum {
-        WAKEUP_FIRST = 0,
-        WAKEUP_ALL,
-        WAKEUP_CLOSE,
-} wakeup_mode_t;
-
 /** Wait queue structure.
  *
@@ -58 +52 @@
 
         /**
-         * Number of waitq_wakeup() calls that didn't find a thread to wake up.
-         *
+         * If negative, number of wakeups that are to be ignored (necessary for futex operation).
+         * If positive, number of wakeups that weren't able to wake a thread.
          */
-        int missed_wakeups;
-
-        /** Number of wakeups that need to be ignored due to futex timeout. */
-        int ignore_wakeups;
+        int wakeup_balance;
 
         /** List of sleeping threads for which there was no missed_wakeup. */
         list_t sleepers;
+
+        bool closed;
 } waitq_t;
+
+typedef struct wait_guard {
+        ipl_t ipl;
+} wait_guard_t;
 
 struct thread;
@@ -75 +72 @@
 extern void waitq_initialize_with_count(waitq_t *, int);
 extern errno_t waitq_sleep(waitq_t *);
-extern errno_t waitq_sleep_timeout(waitq_t *, uint32_t, unsigned int, bool *);
-extern ipl_t waitq_sleep_prepare(waitq_t *);
-extern errno_t waitq_sleep_unsafe(waitq_t *, bool *);
-extern errno_t waitq_sleep_timeout_unsafe(waitq_t *, uint32_t, unsigned int, bool *);
-extern void waitq_sleep_finish(waitq_t *, bool, ipl_t);
-extern void waitq_wakeup(waitq_t *, wakeup_mode_t);
-extern void _waitq_wakeup_unsafe(waitq_t *, wakeup_mode_t);
-extern void waitq_interrupt_sleep(struct thread *);
+extern errno_t _waitq_sleep_timeout(waitq_t *, uint32_t, unsigned int);
+extern errno_t waitq_sleep_timeout(waitq_t *, uint32_t);
+extern wait_guard_t waitq_sleep_prepare(waitq_t *);
+extern errno_t waitq_sleep_unsafe(waitq_t *, wait_guard_t);
+extern errno_t waitq_sleep_timeout_unsafe(waitq_t *, uint32_t, unsigned int, wait_guard_t);
+
+extern void waitq_wake_one(waitq_t *);
+extern void waitq_wake_all(waitq_t *);
+extern void waitq_signal(waitq_t *);
+extern void waitq_close(waitq_t *);
 
 #endif

kernel/generic/include/time/timeout.h

@@ -42 +42 @@
 typedef void (*timeout_handler_t)(void *arg);
 
+typedef uint64_t deadline_t;
+#define DEADLINE_NEVER ((deadline_t) UINT64_MAX)
+
 typedef struct {
         /** Link to the list of active timeouts on timeout->cpu */
         link_t link;
         /** Timeout will be activated when current clock tick reaches this value. */
-        uint64_t deadline;
+        deadline_t deadline;
         /** Function that will be called on timeout activation. */
         timeout_handler_t handler;
@@ -59 +62 @@
 #define us2ticks(us)  ((uint64_t) (((uint32_t) (us) / (1000000 / HZ))))
 
+extern deadline_t timeout_deadline_in_usec(uint32_t us);
+
 extern void timeout_init(void);
 extern void timeout_initialize(timeout_t *);
 extern void timeout_register(timeout_t *, uint64_t, timeout_handler_t, void *);
+extern void timeout_register_deadline(timeout_t *, deadline_t, timeout_handler_t, void *);
 extern bool timeout_unregister(timeout_t *);