Changes in kernel/generic/src/synch/mutex.c [e88eb48:9f2f5ee] 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.
  *
@@ -38 +39 @@
 #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.
@@ -52 +51 @@
 void mutex_initialize(mutex_t *mtx, mutex_type_t type)
 {
-        mtx->type = type;
-        mtx->owner = NULL;
-        mtx->nesting = 0;
-        semaphore_initialize(&mtx->sem, 1);
+        *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);
 }
 
@@ -66 +79 @@
 bool mutex_locked(mutex_t *mtx)
 {
-        return semaphore_count_get(&mtx->sem) <= 0;
+        if (!THREAD)
+                return mtx->nesting > 0;
+
+        return _get_owner(mtx) == THREAD;
 }
-
-#define MUTEX_DEADLOCK_THRESHOLD        100000000
 
 /** Acquire mutex.
  *
- * Timeout mode and non-blocking mode can be requested.
+ * 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.
  *
  * @param mtx    Mutex.
  * @param usec   Timeout in microseconds.
- * @param flags  Specify 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().
- *
+ * @return EOK if lock was successfully acquired, something else otherwise.
  */
-errno_t _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, unsigned int flags)
+errno_t mutex_lock_timeout(mutex_t *mtx, uint32_t usec)
 {
-        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 (!THREAD) {
+                assert(mtx->type == MUTEX_RECURSIVE || mtx->nesting == 0);
+                mtx->nesting++;
+                return EOK;
         }
 
-        return rc;
+        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);
 }
 
@@ -134 +159 @@
 void mutex_unlock(mutex_t *mtx)
 {
-        if (mtx->type == MUTEX_RECURSIVE) {
-                assert(mtx->owner == THREAD);
-                if (--mtx->nesting > 0)
-                        return;
-                mtx->owner = NULL;
+        if (--mtx->nesting > 0) {
+                assert(mtx->type == MUTEX_RECURSIVE);
+                return;
         }
+
+        assert(mtx->nesting == 0);
+
+        if (!THREAD)
+                return;
+
+        assert(_get_owner(mtx) == THREAD);
+        _set_owner(mtx, NULL);
+
         semaphore_up(&mtx->sem);
 }