core/rmutex: use atomic utils

Replace use of C11 atomics with atomic utils. This fixes > error: address argument to atomic operation must be a pointer to a > trivially-copyable type ('_Atomic(int) *' invalid) error when compiling on AVR with LLVM.
RIOT-OS · Jan 4, 2022 · 97b66d9 · 97b66d9
1 parent aaf502a
commit 97b66d9
Show file tree

Hide file tree

Showing 5 changed files with 15 additions and 21 deletions.
diff --git a/core/include/rmutex.h b/core/include/rmutex.h
@@ -24,11 +24,6 @@
 #define RMUTEX_H
 
 #include <stdint.h>
-#ifdef __cplusplus
-#include "c11_atomics_compat.hpp"
-#else
-#include <stdatomic.h>
-#endif
 
 #include "mutex.h"
 #include "sched.h"
@@ -62,14 +57,14 @@ typedef struct rmutex_t {
      *          atomic_int_least16_t is used. Note @ref kernel_pid_t is an int16
      * @internal
      */
-    atomic_int_least16_t owner;
+    kernel_pid_t owner;
 } rmutex_t;
 
 /**
  * @brief Static initializer for rmutex_t.
  * @details This initializer is preferable to rmutex_init().
  */
-#define RMUTEX_INIT { MUTEX_INIT, 0, ATOMIC_VAR_INIT(KERNEL_PID_UNDEF) }
+#define RMUTEX_INIT { MUTEX_INIT, 0, KERNEL_PID_UNDEF }
 
 /**
  * @brief Initializes a recursive mutex object.

diff --git a/core/rmutex.c b/core/rmutex.c
@@ -24,9 +24,10 @@
 #include <stdio.h>
 #include <inttypes.h>
 
+#include "assert.h"
+#include "atomic_utils.h"
 #include "rmutex.h"
 #include "thread.h"
-#include "assert.h"
 
 #define ENABLE_DEBUG 0
 #include "debug.h"
@@ -78,7 +79,7 @@ static int _lock(rmutex_t *rmutex, int trylock)
          */
 
         /* ensure that owner is read atomically, since I need a consistent value */
-        owner = atomic_load_explicit(&rmutex->owner, memory_order_relaxed);
+        owner = atomic_load_kernel_pid(&rmutex->owner);
         DEBUG("rmutex %" PRIi16 " : mutex held by %" PRIi16 " \n",
               thread_getpid(), owner);
 
@@ -104,8 +105,7 @@ static int _lock(rmutex_t *rmutex, int trylock)
     DEBUG("rmutex %" PRIi16 " : setting the owner\n", thread_getpid());
 
     /* ensure that owner is written atomically, since others need a consistent value */
-    atomic_store_explicit(&rmutex->owner, thread_getpid(),
-                          memory_order_relaxed);
+    atomic_store_kernel_pid(&rmutex->owner, thread_getpid());
 
     DEBUG("rmutex %" PRIi16 " : increasing refs\n", thread_getpid());
 
@@ -127,8 +127,8 @@ int rmutex_trylock(rmutex_t *rmutex)
 
 void rmutex_unlock(rmutex_t *rmutex)
 {
-    assert(atomic_load_explicit(&rmutex->owner,
-                                memory_order_relaxed) == thread_getpid());
+    /* ensure that owner is read atomically, since I need a consistent value */
+    assert(atomic_load_kernel_pid(&rmutex->owner) == thread_getpid());
     assert(rmutex->refcount > 0);
 
     DEBUG("rmutex %" PRIi16 " : decrementing refs refs\n", thread_getpid());
@@ -143,8 +143,7 @@ void rmutex_unlock(rmutex_t *rmutex)
         DEBUG("rmutex %" PRIi16 " : resetting owner\n", thread_getpid());
 
         /* ensure that owner is written only once */
-        atomic_store_explicit(&rmutex->owner, KERNEL_PID_UNDEF,
-                              memory_order_relaxed);
+        atomic_store_kernel_pid(&rmutex->owner, KERNEL_PID_UNDEF);
 
         DEBUG("rmutex %" PRIi16 " : releasing mutex\n", thread_getpid());
 

diff --git a/sys/xtimer/xtimer.c b/sys/xtimer/xtimer.c
@@ -23,6 +23,7 @@
 #include <string.h>
 
 #include "xtimer.h"
+#include "atomic_utils.h"
 #include "msg.h"
 #include "mutex.h"
 #include "rmutex.h"
@@ -224,8 +225,7 @@ int xtimer_rmutex_lock_timeout(rmutex_t *rmutex, uint64_t timeout)
         return 0;
     }
     if (xtimer_mutex_lock_timeout(&rmutex->mutex, timeout) == 0) {
-        atomic_store_explicit(&rmutex->owner,
-                              thread_getpid(), memory_order_relaxed);
+        atomic_store_kernel_pid(&rmutex->owner, thread_getpid());
         rmutex->refcount++;
         return 0;
     }

diff --git a/sys/ztimer/util.c b/sys/ztimer/util.c
@@ -23,6 +23,7 @@
 #include <assert.h>
 #include <errno.h>
 
+#include "atomic_utils.h"
 #include "irq.h"
 #include "mutex.h"
 #include "rmutex.h"
@@ -190,8 +191,7 @@ int ztimer_rmutex_lock_timeout(ztimer_clock_t *clock, rmutex_t *rmutex,
         return 0;
     }
     if (ztimer_mutex_lock_timeout(clock, &rmutex->mutex, timeout) == 0) {
-        atomic_store_explicit(&rmutex->owner,
-                              thread_getpid(), memory_order_relaxed);
+        atomic_store_kernel_pid(&rmutex->owner, thread_getpid());
         rmutex->refcount++;
         return 0;
     }

diff --git a/sys/ztimer64/util.c b/sys/ztimer64/util.c
@@ -23,6 +23,7 @@
 #include <assert.h>
 #include <errno.h>
 
+#include "atomic_utils.h"
 #include "irq.h"
 #include "mutex.h"
 #include "rmutex.h"
@@ -183,8 +184,7 @@ int ztimer64_rmutex_lock_until(ztimer64_clock_t *clock, rmutex_t *rmutex,
         return 0;
     }
     if (ztimer64_mutex_lock_until(clock, &rmutex->mutex, target) == 0) {
-        atomic_store_explicit(&rmutex->owner,
-                              thread_getpid(), memory_order_relaxed);
+        atomic_store_kernel_pid(&rmutex->owner, thread_getpid());
         rmutex->refcount++;
         return 0;
     }