Changes in kernel/generic/src/synch/mutex.c [9f2f5ee:e88eb48] in mainline

File:

• kernel/generic/src/synch/mutex.c (modified) (5 diffs)

kernel/generic/src/synch/mutex.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2001-2004 Jakub Jermar
- * Copyright (c) 2025 Jiří Zárevúcky
  * All rights reserved.
  *
@@ -39 +38 @@
 #include <assert.h>
 #include <errno.h>
-#include <proc/thread.h>
-#include <stdatomic.h>
 #include <synch/mutex.h>
 #include <synch/semaphore.h>
+#include <arch.h>
+#include <stacktrace.h>
+#include <cpu.h>
+#include <proc/thread.h>
 
 /** Initialize mutex.
@@ -51 +52 @@
 void mutex_initialize(mutex_t *mtx, mutex_type_t type)
 {
-        *mtx = MUTEX_INITIALIZER(*mtx, type);
-}
-
-/** A race in mtx->owner access is unavoidable, so we have to make
- * access to it formally atomic. These are convenience functions to
- * read/write the variable without memory barriers, since we don't need
- * them and C11 atomics default to the strongest possible memory ordering
- * by default, which is utterly ridiculous.
- */
-static inline thread_t *_get_owner(mutex_t *mtx)
-{
-        return atomic_load_explicit(&mtx->owner, memory_order_relaxed);
-}
-
-/** Counterpart to _get_owner(). */
-static inline void _set_owner(mutex_t *mtx, thread_t *owner)
-{
-        atomic_store_explicit(&mtx->owner, owner, memory_order_relaxed);
+        mtx->type = type;
+        mtx->owner = NULL;
+        mtx->nesting = 0;
+        semaphore_initialize(&mtx->sem, 1);
 }
 
@@ -79 +66 @@
 bool mutex_locked(mutex_t *mtx)
 {
-        if (!THREAD)
-                return mtx->nesting > 0;
+        return semaphore_count_get(&mtx->sem) <= 0;
+}
 
-        return _get_owner(mtx) == THREAD;
-}
+#define MUTEX_DEADLOCK_THRESHOLD        100000000
 
 /** Acquire mutex.
  *
- * This operation is uninterruptible and cannot fail.
- */
-void mutex_lock(mutex_t *mtx)
-{
-        if (!THREAD) {
-                assert(mtx->type == MUTEX_RECURSIVE || mtx->nesting == 0);
-                mtx->nesting++;
-                return;
-        }
-
-        if (_get_owner(mtx) == THREAD) {
-                /* This will also detect nested locks on a non-recursive mutex. */
-                assert(mtx->type == MUTEX_RECURSIVE);
-                assert(mtx->nesting > 0);
-                mtx->nesting++;
-                return;
-        }
-
-        semaphore_down(&mtx->sem);
-
-        _set_owner(mtx, THREAD);
-        assert(mtx->nesting == 0);
-        mtx->nesting = 1;
-}
-
-/** Acquire mutex with timeout.
+ * Timeout mode and non-blocking mode can be requested.
  *
  * @param mtx    Mutex.
  * @param usec   Timeout in microseconds.
+ * @param flags  Specify mode of operation.
  *
- * @return EOK if lock was successfully acquired, something else otherwise.
+ * 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 mutex_lock_timeout(mutex_t *mtx, uint32_t usec)
+errno_t _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, unsigned int flags)
 {
-        if (!THREAD) {
-                assert(mtx->type == MUTEX_RECURSIVE || mtx->nesting == 0);
-                mtx->nesting++;
-                return EOK;
+        errno_t rc;
+
+        if (mtx->type == MUTEX_PASSIVE && THREAD) {
+                rc = _semaphore_down_timeout(&mtx->sem, usec, flags);
+        } else if (mtx->type == MUTEX_RECURSIVE) {
+                assert(THREAD);
+
+                if (mtx->owner == THREAD) {
+                        mtx->nesting++;
+                        return EOK;
+                } else {
+                        rc = _semaphore_down_timeout(&mtx->sem, usec, flags);
+                        if (rc == EOK) {
+                                mtx->owner = THREAD;
+                                mtx->nesting = 1;
+                        }
+                }
+        } else {
+                assert((mtx->type == MUTEX_ACTIVE) || !THREAD);
+                assert(usec == SYNCH_NO_TIMEOUT);
+                assert(!(flags & SYNCH_FLAGS_INTERRUPTIBLE));
+
+                unsigned int cnt = 0;
+                bool deadlock_reported = false;
+                do {
+                        if (cnt++ > MUTEX_DEADLOCK_THRESHOLD) {
+                                printf("cpu%u: looping on active mutex %p\n",
+                                    CPU->id, mtx);
+                                stack_trace();
+                                cnt = 0;
+                                deadlock_reported = true;
+                        }
+                        rc = semaphore_trydown(&mtx->sem);
+                } while (rc != EOK && !(flags & SYNCH_FLAGS_NON_BLOCKING));
+                if (deadlock_reported)
+                        printf("cpu%u: not deadlocked\n", CPU->id);
         }
 
-        if (_get_owner(mtx) == THREAD) {
-                assert(mtx->type == MUTEX_RECURSIVE);
-                assert(mtx->nesting > 0);
-                mtx->nesting++;
-                return EOK;
-        }
-
-        errno_t rc = semaphore_down_timeout(&mtx->sem, usec);
-        if (rc != EOK)
-                return rc;
-
-        _set_owner(mtx, THREAD);
-        assert(mtx->nesting == 0);
-        mtx->nesting = 1;
-        return EOK;
-}
-
-/** Attempt to acquire mutex without blocking.
- *
- * @return EOK if lock was successfully acquired, something else otherwise.
- */
-errno_t mutex_trylock(mutex_t *mtx)
-{
-        return mutex_lock_timeout(mtx, 0);
+        return rc;
 }
 
@@ -159 +134 @@
 void mutex_unlock(mutex_t *mtx)
 {
-        if (--mtx->nesting > 0) {
-                assert(mtx->type == MUTEX_RECURSIVE);
-                return;
+        if (mtx->type == MUTEX_RECURSIVE) {
+                assert(mtx->owner == THREAD);
+                if (--mtx->nesting > 0)
+                        return;
+                mtx->owner = NULL;
         }
-
-        assert(mtx->nesting == 0);
-
-        if (!THREAD)
-                return;
-
-        assert(_get_owner(mtx) == THREAD);
-        _set_owner(mtx, NULL);
-
         semaphore_up(&mtx->sem);
 }