Changeset 5110d0a in mainline for kernel/generic/src

Timestamp:

2023-02-07T16:02:50Z (2 years ago)

Author:

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

Branches:

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

Children:

7c5320c

Parents:

8a55346

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2023-02-06 16:44:26)

git-committer:

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

Message:

Turn a bunch of macros into regular functions

Location:

kernel/generic/src

Files:

• proc/thread.c (modified) (1 diff)
• synch/condvar.c (modified) (2 diffs)
• synch/mutex.c (modified) (2 diffs)
• synch/semaphore.c (modified) (1 diff)
• synch/waitq.c (modified) (2 diffs)

kernel/generic/src/proc/thread.c

@@ -629 +629 @@
 }
 
+errno_t thread_join(thread_t *thread)
+{
+        return thread_join_timeout(thread, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
+}
+
 /** Wait for another thread to exit.
  *

kernel/generic/src/synch/condvar.c

@@ -76 +76 @@
  * @param mtx           Mutex.
  * @param usec          Timeout value in microseconds.
- * @param flags         Select mode of operation.
- *
- * For exact description of meaning of possible combinations of usec and flags,
- * see comment for waitq_sleep_timeout().  Note that when
- * SYNCH_FLAGS_NON_BLOCKING is specified here, EAGAIN is always
- * returned.
  *
  * @return              See comment for waitq_sleep_timeout().
  */
-errno_t _condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, uint32_t usec, int flags)
+errno_t condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, uint32_t usec)
 {
         errno_t rc;
@@ -96 +90 @@
 
         cv->wq.missed_wakeups = 0;      /* Enforce blocking. */
-        rc = waitq_sleep_timeout_unsafe(&cv->wq, usec, flags, &blocked);
+        rc = waitq_sleep_timeout_unsafe(&cv->wq, usec, SYNCH_FLAGS_NON_BLOCKING, &blocked);
+        assert(blocked || rc != EOK);
+
+        waitq_sleep_finish(&cv->wq, blocked, ipl);
+        /* Lock only after releasing the waitq to avoid a possible deadlock. */
+        mutex_lock(mtx);
+
+        return rc;
+}
+
+errno_t condvar_wait(condvar_t *cv, mutex_t *mtx)
+{
+        errno_t rc;
+        ipl_t ipl;
+        bool blocked;
+
+        ipl = waitq_sleep_prepare(&cv->wq);
+        /* Unlock only after the waitq is locked so we don't miss a wakeup. */
+        mutex_unlock(mtx);
+
+        cv->wq.missed_wakeups = 0;      /* Enforce blocking. */
+        rc = waitq_sleep_unsafe(&cv->wq, &blocked);
         assert(blocked || rc != EOK);
 

kernel/generic/src/synch/mutex.c

@@ -85 +85 @@
  *
  */
-errno_t _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, unsigned int flags)
+static errno_t _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, unsigned int flags)
 {
         errno_t rc;
@@ -128 +128 @@
 }
 
+errno_t mutex_trylock(mutex_t *mtx)
+{
+        return _mutex_lock_timeout(mtx, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING);
+}
+
+errno_t mutex_lock(mutex_t *mtx)
+{
+        return _mutex_lock_timeout(mtx, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
+}
+
+errno_t mutex_lock_timeout(mutex_t *mtx, uint32_t usec)
+{
+        return _mutex_lock_timeout(mtx, usec, SYNCH_FLAGS_NON_BLOCKING);
+}
+
 /** Release mutex.
  *

kernel/generic/src/synch/semaphore.c

@@ -53 +53 @@
 {
         waitq_initialize(&sem->wq);
-        waitq_count_set(&sem->wq, val);
+        if (val != 0)
+                waitq_count_set(&sem->wq, val);
 }
 
-/** Semaphore down
- *
- * Semaphore down.
- * Conditional mode and mode with timeout can be requested.
+errno_t _semaphore_down_timeout(semaphore_t *sem, uint32_t usec, unsigned flags)
+{
+        errno_t rc = waitq_sleep_timeout(&sem->wq, usec, flags, NULL);
+        assert(rc == EOK || rc == ETIMEOUT || rc == EAGAIN);
+        return rc;
+}
+
+errno_t semaphore_trydown(semaphore_t *sem)
+{
+        return _semaphore_down_timeout(sem, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING);
+}
+
+/** Semaphore down with timeout
  *
  * @param sem   Semaphore.
  * @param usec  Timeout in microseconds.
- * @param flags Select mode of operation.
- *
- * For exact description of possible combinations of
- * usec and flags, see comment for waitq_sleep_timeout().
  *
  * @return See comment for waitq_sleep_timeout().
  *
  */
-errno_t _semaphore_down_timeout(semaphore_t *sem, uint32_t usec, unsigned int flags)
+errno_t semaphore_down_timeout(semaphore_t *sem, uint32_t usec)
 {
-        return waitq_sleep_timeout(&sem->wq, usec, flags, NULL);
+        return _semaphore_down_timeout(sem, usec, SYNCH_FLAGS_NON_BLOCKING);
+}
+
+void semaphore_down(semaphore_t *sem)
+{
+        errno_t rc = waitq_sleep(&sem->wq);
+        assert(rc == EOK);
 }
 

kernel/generic/src/synch/waitq.c

@@ -194 +194 @@
 #define PARAM_NON_BLOCKING(flags, usec) \
         (((flags) & SYNCH_FLAGS_NON_BLOCKING) && ((usec) == 0))
+
+errno_t waitq_sleep(waitq_t *wq)
+{
+        return waitq_sleep_timeout(wq, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE, NULL);
+}
 
 /** Sleep until either wakeup, timeout or interruption occurs
@@ -326 +331 @@
 
         interrupts_restore(ipl);
+}
+
+errno_t waitq_sleep_unsafe(waitq_t *wq, bool *blocked)
+{
+        return waitq_sleep_timeout_unsafe(wq, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE, blocked);
 }