[libc-commits] [libc] a5ee818 - [libc][NFC] Add a platform independent thread support library.

Siva Chandra Reddy via libc-commits libc-commits at lists.llvm.org
Fri Mar 4 10:33:55 PST 2022


Author: Siva Chandra Reddy
Date: 2022-03-04T18:33:46Z
New Revision: a5ee8183c049d377539c2b6452c8817589dd2df4

URL: https://github.com/llvm/llvm-project/commit/a5ee8183c049d377539c2b6452c8817589dd2df4
DIFF: https://github.com/llvm/llvm-project/commit/a5ee8183c049d377539c2b6452c8817589dd2df4.diff

LOG: [libc][NFC] Add a platform independent thread support library.

The idea is that, other parts of the libc which require thread/lock
support will be able to use this platform independent setup.

With this change, only the linux implementation of a mutex type has been
moved to the new library. Because of this, there is some duplication
between the new library and src/threads/linux. A follow up change will
move all of src/threads/linux to the new library. The duplication should
be eliminated with that move.

Reviewed By: lntue

Differential Revision: https://reviews.llvm.org/D120795

Added: 
    libc/include/llvm-libc-types/__mutex_type.h
    libc/src/__support/threads/CMakeLists.txt
    libc/src/__support/threads/linux/CMakeLists.txt
    libc/src/__support/threads/linux/mutex.h
    libc/src/__support/threads/mutex.h
    libc/src/threads/mtx_destroy.cpp
    libc/src/threads/mtx_init.cpp
    libc/src/threads/mtx_lock.cpp
    libc/src/threads/mtx_unlock.cpp

Modified: 
    libc/include/llvm-libc-types/CMakeLists.txt
    libc/include/llvm-libc-types/mtx_t.h
    libc/src/__support/CMakeLists.txt
    libc/src/threads/CMakeLists.txt
    libc/src/threads/linux/CMakeLists.txt
    libc/src/threads/linux/CndVar.h
    libc/src/threads/linux/cnd_wait.cpp

Removed: 
    libc/src/threads/linux/Mutex.h
    libc/src/threads/linux/mtx_destroy.cpp
    libc/src/threads/linux/mtx_init.cpp
    libc/src/threads/linux/mtx_lock.cpp
    libc/src/threads/linux/mtx_unlock.cpp


################################################################################
diff  --git a/libc/include/llvm-libc-types/CMakeLists.txt b/libc/include/llvm-libc-types/CMakeLists.txt
index 08d7f8c911d7f..8fb859d94156e 100644
--- a/libc/include/llvm-libc-types/CMakeLists.txt
+++ b/libc/include/llvm-libc-types/CMakeLists.txt
@@ -1,6 +1,7 @@
 add_header(__bsearchcompare_t HDR __bsearchcompare_t.h)
 add_header(__call_once_func_t HDR __call_once_func_t.h)
 add_header(__futex_word HDR __futex_word.h)
+add_header(__mutex_type HDR __mutex_type.h)
 add_header(__qsortcompare_t HDR __qsortcompare_t.h)
 add_header(__sighandler_t HDR __sighandler_t.h)
 add_header(cnd_t HDR cnd_t.h)
@@ -14,7 +15,7 @@ add_header(fexcept_t HDR fexcept_t.h)
 add_header(float_t HDR float_t.h)
 add_header(imaxdiv_t HDR imaxdiv_t.h)
 add_header(mode_t HDR mode_t.h)
-add_header(mtx_t HDR mtx_t.h DEPENDS .__futex_word)
+add_header(mtx_t HDR mtx_t.h DEPENDS .__futex_word .__mutex_type)
 add_header(off_t HDR off_t.h)
 add_header(once_flag HDR once_flag.h DEPENDS .__futex_word)
 add_header(size_t HDR size_t.h)

diff  --git a/libc/include/llvm-libc-types/__mutex_type.h b/libc/include/llvm-libc-types/__mutex_type.h
new file mode 100644
index 0000000000000..37cb856fd58b8
--- /dev/null
+++ b/libc/include/llvm-libc-types/__mutex_type.h
@@ -0,0 +1,24 @@
+//===-- Definition of a common mutex type ---------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <llvm-libc-types/__futex_word.h>
+
+typedef struct {
+  unsigned char __timed;
+  unsigned char __recursive;
+  unsigned char __robust;
+
+  void *__owner;
+  unsigned long long __lock_count;
+
+#ifdef __unix__
+  __futex_word __ftxw;
+#else
+#error "Mutex type not defined for the target platform."
+#endif
+} __mutex_type;

diff  --git a/libc/include/llvm-libc-types/mtx_t.h b/libc/include/llvm-libc-types/mtx_t.h
index d0b5491ee9e9e..ac6453eeabf03 100644
--- a/libc/include/llvm-libc-types/mtx_t.h
+++ b/libc/include/llvm-libc-types/mtx_t.h
@@ -9,15 +9,8 @@
 #ifndef __LLVM_LIBC_TYPES_MTX_T_H__
 #define __LLVM_LIBC_TYPES_MTX_T_H__
 
-#include <llvm-libc-types/__futex_word.h>
+#include <llvm-libc-types/__mutex_type.h>
 
-typedef struct {
-#ifdef __unix__
-  __futex_word __ftxw;
-#else
-#error "mtx_t type not defined for the target platform."
-#endif
-  int __mtx_type;
-} mtx_t;
+typedef __mutex_type mtx_t;
 
 #endif // __LLVM_LIBC_TYPES_MTX_T_H__

diff  --git a/libc/src/__support/CMakeLists.txt b/libc/src/__support/CMakeLists.txt
index 56d1b07ad0847..892011035127a 100644
--- a/libc/src/__support/CMakeLists.txt
+++ b/libc/src/__support/CMakeLists.txt
@@ -57,3 +57,4 @@ add_header_library(
 add_subdirectory(File)
 add_subdirectory(FPUtil)
 add_subdirectory(OSUtil)
+add_subdirectory(threads)

diff  --git a/libc/src/__support/threads/CMakeLists.txt b/libc/src/__support/threads/CMakeLists.txt
new file mode 100644
index 0000000000000..52b57cb05ef4c
--- /dev/null
+++ b/libc/src/__support/threads/CMakeLists.txt
@@ -0,0 +1,11 @@
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
+  add_subdirectory(${LIBC_TARGET_OS})
+endif()
+
+add_header_library(
+  thread
+  HDRS
+    mutex.h
+  DEPS
+    .${LIBC_TARGET_OS}.thread
+)

diff  --git a/libc/src/__support/threads/linux/CMakeLists.txt b/libc/src/__support/threads/linux/CMakeLists.txt
new file mode 100644
index 0000000000000..53a150a05d2d7
--- /dev/null
+++ b/libc/src/__support/threads/linux/CMakeLists.txt
@@ -0,0 +1,9 @@
+add_header_library(
+  thread
+  HDRS
+    mutex.h
+  DEPENDS
+    libc.include.sys_syscall
+    libc.src.__support.CPP.atomic
+    libc.src.__support.OSUtil.osutil
+)

diff  --git a/libc/src/__support/threads/linux/mutex.h b/libc/src/__support/threads/linux/mutex.h
new file mode 100644
index 0000000000000..feb5c0f30b7ef
--- /dev/null
+++ b/libc/src/__support/threads/linux/mutex.h
@@ -0,0 +1,137 @@
+#ifndef LLVM_LIBC_SRC_SUPPORT_THREAD_LINUX_MUTEX_H
+#define LLVM_LIBC_SRC_SUPPORT_THREAD_LINUX_MUTEX_H
+
+#include "include/sys/syscall.h" // For syscall numbers.
+#include "src/__support/CPP/atomic.h"
+#include "src/__support/OSUtil/syscall.h" // For syscall functions.
+#include "src/__support/threads/mutex.h"
+
+#include <linux/futex.h>
+#include <stdint.h>
+#include <threads.h>
+
+namespace __llvm_libc {
+
+struct Mutex {
+  unsigned char timed;
+  unsigned char recursive;
+  unsigned char robust;
+
+  void *owner;
+  unsigned long long lock_count;
+
+  using FutexWordType = unsigned int;
+
+  cpp::Atomic<FutexWordType> futex_word;
+
+  enum class LockState : FutexWordType {
+    Free,
+    Locked,
+    Waiting,
+  };
+
+public:
+  constexpr Mutex(bool istimed, bool isrecursive, bool isrobust)
+      : timed(istimed), recursive(isrecursive), robust(isrobust),
+        owner(nullptr), lock_count(0),
+        futex_word(FutexWordType(LockState::Free)) {}
+
+  static MutexError init(Mutex *mutex, bool istimed, bool isrecur,
+                         bool isrobust) {
+    mutex->timed = istimed;
+    mutex->recursive = isrecur;
+    mutex->robust = isrobust;
+    mutex->owner = nullptr;
+    mutex->lock_count = 0;
+    mutex->futex_word.set(FutexWordType(LockState::Free));
+    return MutexError::NONE;
+  }
+
+  static MutexError init(mtx_t *m, bool istimed, bool isrecur, bool isrobust) {
+    auto *mutex = reinterpret_cast<Mutex *>(m);
+    return init(mutex, istimed, isrecur, isrobust);
+  }
+
+  static MutexError destroy(mtx_t *) { return MutexError::NONE; }
+
+  MutexError reset();
+
+  MutexError lock() {
+    bool was_waiting = false;
+    while (true) {
+      FutexWordType mutex_status = FutexWordType(LockState::Free);
+      FutexWordType locked_status = FutexWordType(LockState::Locked);
+
+      if (futex_word.compare_exchange_strong(
+              mutex_status, FutexWordType(LockState::Locked))) {
+        if (was_waiting)
+          futex_word = FutexWordType(LockState::Waiting);
+        return MutexError::NONE;
+      }
+
+      switch (LockState(mutex_status)) {
+      case LockState::Waiting:
+        // If other threads are waiting already, then join them. Note that the
+        // futex syscall will block if the futex data is still
+        // `LockState::Waiting` (the 4th argument to the syscall function
+        // below.)
+        __llvm_libc::syscall(SYS_futex, &futex_word.val, FUTEX_WAIT_PRIVATE,
+                             FutexWordType(LockState::Waiting), 0, 0, 0);
+        was_waiting = true;
+        // Once woken up/unblocked, try everything all over.
+        continue;
+      case LockState::Locked:
+        // Mutex has been locked by another thread so set the status to
+        // LockState::Waiting.
+        if (futex_word.compare_exchange_strong(
+                locked_status, FutexWordType(LockState::Waiting))) {
+          // If we are able to set the futex data to `LockState::Waiting`, then
+          // we will wait for the futex to be woken up. Note again that the
+          // following syscall will block only if the futex data is still
+          // `LockState::Waiting`.
+          __llvm_libc::syscall(SYS_futex, &futex_word, FUTEX_WAIT_PRIVATE,
+                               FutexWordType(LockState::Waiting), 0, 0, 0);
+          was_waiting = true;
+        }
+        continue;
+      case LockState::Free:
+        // If it was LockState::Free, we shouldn't be here at all.
+        [[clang::fallthrough]];
+      default:
+        // Mutex status cannot be anything else. So control should not reach
+        // here at all.
+        return MutexError::BAD_LOCK_STATE;
+      }
+    }
+  }
+
+  MutexError unlock() {
+    while (true) {
+      FutexWordType mutex_status = FutexWordType(LockState::Waiting);
+      if (futex_word.compare_exchange_strong(mutex_status,
+                                             FutexWordType(LockState::Free))) {
+        // If any thread is waiting to be woken up, then do it.
+        __llvm_libc::syscall(SYS_futex, &futex_word, FUTEX_WAKE_PRIVATE, 1, 0,
+                             0, 0);
+        return MutexError::NONE;
+      }
+
+      if (mutex_status == FutexWordType(LockState::Locked)) {
+        // If nobody was waiting at this point, just free it.
+        if (futex_word.compare_exchange_strong(mutex_status,
+                                               FutexWordType(LockState::Free)))
+          return MutexError::NONE;
+      } else {
+        // This can happen, for example if some thread tries to unlock an
+        // already free mutex.
+        return MutexError::UNLOCK_WITHOUT_LOCK;
+      }
+    }
+  }
+
+  MutexError trylock();
+};
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_SUPPORT_THREAD_LINUX_MUTEX_H

diff  --git a/libc/src/__support/threads/mutex.h b/libc/src/__support/threads/mutex.h
new file mode 100644
index 0000000000000..4ae2fc45552ad
--- /dev/null
+++ b/libc/src/__support/threads/mutex.h
@@ -0,0 +1,64 @@
+#ifndef LLVM_LIBC_SRC_SUPPORT_THREAD_MUTEX_H
+#define LLVM_LIBC_SRC_SUPPORT_THREAD_MUTEX_H
+
+namespace __llvm_libc {
+
+enum class MutexError : int {
+  NONE,
+  BUSY,
+  TIMEOUT,
+  UNLOCK_WITHOUT_LOCK,
+  BAD_LOCK_STATE,
+};
+
+} // namespace __llvm_libc
+
+// Platform independent code will include this header file which pulls
+// the platfrom specific specializations using platform macros.
+//
+// The platform specific specializations should define a class by name
+// Mutex with non-static methods having the following signature:
+//
+// MutexError lock();
+// MutexError trylock();
+// MutexError timedlock(...);
+// MutexError unlock();
+// MutexError reset(); // Used to reset inconsistent robust mutexes.
+//
+// Apart from the above non-static methods, the specializations should
+// also provide few static methods with the following signature:
+//
+// static MutexError init(mtx_t *);
+// static MutexError destroy(mtx_t *);
+//
+// All of the static and non-static methods should ideally be implemented
+// as inline functions so that implementations of public functions can
+// call them without a function call overhead.
+//
+// Another point to keep in mind that is that the libc internally needs a
+// few global locks. So, to avoid static initialization order fiasco, we
+// want the constructors of the Mutex classes to be constexprs.
+
+#ifdef __unix__
+#include "linux/mutex.h"
+#endif // __unix__
+
+namespace __llvm_libc {
+
+static_assert(sizeof(Mutex) <= sizeof(mtx_t),
+              "The public mtx_t type cannot accommodate the internal mutex "
+              "type.");
+
+// An RAII class for easy locking and unlocking of mutexes.
+class MutexLock {
+  Mutex *mutex;
+
+public:
+  explicit MutexLock(Mutex *m) : mutex(m) { mutex->lock(); }
+
+  ~MutexLock() { mutex->unlock(); }
+};
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_SUPPORT_THREAD_MUTEX_H

diff  --git a/libc/src/threads/CMakeLists.txt b/libc/src/threads/CMakeLists.txt
index de72701bef759..2a4f04debce55 100644
--- a/libc/src/threads/CMakeLists.txt
+++ b/libc/src/threads/CMakeLists.txt
@@ -25,30 +25,46 @@ add_entrypoint_object(
 
 add_entrypoint_object(
   mtx_init
-  ALIAS
+  SRCS
+    mtx_init.cpp
+  HDRS
+    mtx_init.h
   DEPENDS
-    .${LIBC_TARGET_OS}.mtx_init
+    libc.include.threads
+    libc.src.__support.threads.thread
 )
 
 add_entrypoint_object(
   mtx_destroy
-  ALIAS
+  SRCS
+    mtx_destroy.cpp
+  HDRS
+    mtx_destroy.h
   DEPENDS
-    .${LIBC_TARGET_OS}.mtx_destroy
+    libc.include.threads
+    libc.src.__support.threads.thread
 )
 
 add_entrypoint_object(
   mtx_lock
-  ALIAS
+  SRCS
+    mtx_lock.cpp
+  HDRS
+    mtx_lock.h
   DEPENDS
-    .${LIBC_TARGET_OS}.mtx_lock
+    libc.include.threads
+    libc.src.__support.threads.thread
 )
 
 add_entrypoint_object(
   mtx_unlock
-  ALIAS
+  SRCS
+    mtx_unlock.cpp
+  HDRS
+    mtx_unlock.h
   DEPENDS
-    .${LIBC_TARGET_OS}.mtx_unlock
+    libc.include.threads
+    libc.src.__support.threads.thread
 )
 
 add_entrypoint_object(

diff  --git a/libc/src/threads/linux/CMakeLists.txt b/libc/src/threads/linux/CMakeLists.txt
index f5ac139889e8e..5ca715b3c6a55 100644
--- a/libc/src/threads/linux/CMakeLists.txt
+++ b/libc/src/threads/linux/CMakeLists.txt
@@ -27,7 +27,6 @@ add_header_library(
   HDRS
     CndVar.h
     Futex.h
-    Mutex.h
     Thread.h
   DEPENDS
     .thread_start_args_h
@@ -35,6 +34,7 @@ add_header_library(
     libc.include.threads
     libc.src.__support.CPP.atomic
     libc.src.__support.OSUtil.osutil
+    libc.src.__support.threads.thread
 )
 
 add_entrypoint_object(
@@ -74,50 +74,6 @@ add_entrypoint_object(
     libc.src.sys.mman.munmap
 )
 
-add_entrypoint_object(
-  mtx_init
-  SRCS
-    mtx_init.cpp
-  HDRS
-    ../mtx_init.h
-  DEPENDS
-    .threads_utils
-    libc.include.threads
-)
-
-add_entrypoint_object(
-  mtx_destroy
-  SRCS
-    mtx_destroy.cpp
-  HDRS
-    ../mtx_destroy.h
-  DEPENDS
-    .threads_utils
-    libc.include.threads
-)
-
-add_entrypoint_object(
-  mtx_lock
-  SRCS
-    mtx_lock.cpp
-  HDRS
-    ../mtx_lock.h
-  DEPENDS
-    .threads_utils
-    libc.include.threads
-)
-
-add_entrypoint_object(
-  mtx_unlock
-  SRCS
-    mtx_unlock.cpp
-  HDRS
-    ../mtx_unlock.h
-  DEPENDS
-    .threads_utils
-    libc.include.threads
-)
-
 add_entrypoint_object(
   cnd_init
   SRCS
@@ -149,6 +105,7 @@ add_entrypoint_object(
   DEPENDS
     .threads_utils
     libc.include.threads
+    libc.src.__support.threads.thread
 )
 
 add_entrypoint_object(

diff  --git a/libc/src/threads/linux/CndVar.h b/libc/src/threads/linux/CndVar.h
index 11136005db54b..2b914d480c764 100644
--- a/libc/src/threads/linux/CndVar.h
+++ b/libc/src/threads/linux/CndVar.h
@@ -9,12 +9,11 @@
 #ifndef LLVM_LIBC_SRC_THREADS_LINUX_CNDVAR_H
 #define LLVM_LIBC_SRC_THREADS_LINUX_CNDVAR_H
 
-#include "Mutex.h"
-
 #include "include/sys/syscall.h" // For syscall numbers.
 #include "include/threads.h"     // For values like thrd_success etc.
 #include "src/__support/CPP/atomic.h"
 #include "src/__support/OSUtil/syscall.h" // For syscall functions.
+#include "src/__support/threads/mutex.h"
 
 #include <linux/futex.h> // For futex operations.
 #include <stdint.h>
@@ -38,7 +37,8 @@ struct CndVar {
 
   static int init(CndVar *cv) {
     cv->waitq_front = cv->waitq_back = nullptr;
-    return Mutex::init(&cv->qmtx, mtx_plain);
+    auto err = Mutex::init(&cv->qmtx, false, false, false);
+    return err == MutexError::NONE ? thrd_success : thrd_error;
   }
 
   static void destroy(CndVar *cv) {
@@ -67,7 +67,7 @@ struct CndVar {
         waitq_back = &waiter;
       }
 
-      if (m->unlock() != thrd_success) {
+      if (m->unlock() != MutexError::NONE) {
         // If we do not remove the queued up waiter before returning,
         // then another thread can potentially signal a non-existing
         // waiter. Note also that we do this with |qmtx| locked. This
@@ -88,7 +88,8 @@ struct CndVar {
 
     // At this point, if locking |m| fails, we can simply return as the
     // queued up waiter would have been removed from the queue.
-    return m->lock();
+    auto err = m->lock();
+    return err == MutexError::NONE ? thrd_success : thrd_error;
   }
 
   int notify_one() {
@@ -105,7 +106,7 @@ struct CndVar {
     if (waitq_front == nullptr)
       waitq_back = nullptr;
 
-    qmtx.futex_word = Mutex::MS_Free;
+    qmtx.futex_word = Mutex::FutexWordType(Mutex::LockState::Free);
 
     __llvm_libc::syscall(
         SYS_futex, &qmtx.futex_word.val, FUTEX_WAKE_OP, 1, 1,

diff  --git a/libc/src/threads/linux/Mutex.h b/libc/src/threads/linux/Mutex.h
deleted file mode 100644
index a8fe8537d064b..0000000000000
--- a/libc/src/threads/linux/Mutex.h
+++ /dev/null
@@ -1,122 +0,0 @@
-//===-- Utility mutex classes -----------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_LIBC_SRC_THREADS_LINUX_MUTEX_H
-#define LLVM_LIBC_SRC_THREADS_LINUX_MUTEX_H
-
-#include "Futex.h"
-
-#include "include/sys/syscall.h"          // For syscall numbers.
-#include "include/threads.h"              // For values like thrd_success etc.
-#include "src/__support/CPP/atomic.h"     // For atomics support
-#include "src/__support/OSUtil/syscall.h" // For syscall functions.
-
-#include <linux/futex.h> // For futex operations.
-
-namespace __llvm_libc {
-
-struct Mutex {
-  enum Status : FutexWordType {
-    MS_Free,
-    MS_Locked,
-    MS_Waiting,
-  };
-
-  cpp::Atomic<FutexWordType> futex_word;
-  int type;
-
-  static int init(Mutex *mutex, int type) {
-    mutex->futex_word = MS_Free;
-    mutex->type = type;
-    return thrd_success;
-  }
-
-  int lock() {
-    bool was_waiting = false;
-    while (true) {
-      FutexWordType mutex_status = MS_Free;
-      FutexWordType locked_status = MS_Locked;
-
-      if (futex_word.compare_exchange_strong(mutex_status, MS_Locked)) {
-        if (was_waiting)
-          futex_word = MS_Waiting;
-        return thrd_success;
-      }
-
-      switch (mutex_status) {
-      case MS_Waiting:
-        // If other threads are waiting already, then join them. Note that the
-        // futex syscall will block if the futex data is still `MS_Waiting` (the
-        // 4th argument to the syscall function below.)
-        __llvm_libc::syscall(SYS_futex, &futex_word.val, FUTEX_WAIT_PRIVATE,
-                             MS_Waiting, 0, 0, 0);
-        was_waiting = true;
-        // Once woken up/unblocked, try everything all over.
-        continue;
-      case MS_Locked:
-        // Mutex has been locked by another thread so set the status to
-        // MS_Waiting.
-        if (futex_word.compare_exchange_strong(locked_status, MS_Waiting)) {
-          // If we are able to set the futex data to `MS_Waiting`, then we will
-          // wait for the futex to be woken up. Note again that the following
-          // syscall will block only if the futex data is still `MS_Waiting`.
-          __llvm_libc::syscall(SYS_futex, &futex_word.val, FUTEX_WAIT_PRIVATE,
-                               MS_Waiting, 0, 0, 0);
-          was_waiting = true;
-        }
-        continue;
-      case MS_Free:
-        // If it was MS_Free, we shouldn't be here at all.
-        [[clang::fallthrough]];
-      default:
-        // Mutex status cannot be anything else. So control should not reach
-        // here at all.
-        return thrd_error;
-      }
-    }
-  }
-
-  int unlock() {
-    while (true) {
-      FutexWordType mutex_status = MS_Waiting;
-      if (futex_word.compare_exchange_strong(mutex_status, MS_Free)) {
-        // If any thread is waiting to be woken up, then do it.
-        __llvm_libc::syscall(SYS_futex, &futex_word.val, FUTEX_WAKE_PRIVATE, 1,
-                             0, 0, 0);
-        return thrd_success;
-      }
-
-      if (mutex_status == MS_Locked) {
-        // If nobody was waiting at this point, just free it.
-        if (futex_word.compare_exchange_strong(mutex_status, MS_Free))
-          return thrd_success;
-      } else {
-        // This can happen, for example if some thread tries to unlock an
-        // already free mutex.
-        return thrd_error;
-      }
-    }
-  }
-};
-
-static_assert(sizeof(Mutex) == sizeof(mtx_t),
-              "Sizes of internal representation of mutex and the public mtx_t "
-              "do not match.");
-
-class MutexLock {
-  Mutex *mutex;
-
-public:
-  explicit MutexLock(Mutex *m) : mutex(m) { mutex->lock(); }
-
-  ~MutexLock() { mutex->unlock(); }
-};
-
-} // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_THREADS_LINUX_MUTEX_H

diff  --git a/libc/src/threads/linux/cnd_wait.cpp b/libc/src/threads/linux/cnd_wait.cpp
index b75a69957d9d0..5c0aed7be76da 100644
--- a/libc/src/threads/linux/cnd_wait.cpp
+++ b/libc/src/threads/linux/cnd_wait.cpp
@@ -7,10 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "CndVar.h"
-#include "Mutex.h"
 
-#include "src/threads/cnd_wait.h"
 #include "src/__support/common.h"
+#include "src/__support/threads/mutex.h"
+#include "src/threads/cnd_wait.h"
 
 namespace __llvm_libc {
 

diff  --git a/libc/src/threads/linux/mtx_destroy.cpp b/libc/src/threads/mtx_destroy.cpp
similarity index 93%
rename from libc/src/threads/linux/mtx_destroy.cpp
rename to libc/src/threads/mtx_destroy.cpp
index a64cfde4835bc..773db20759c31 100644
--- a/libc/src/threads/linux/mtx_destroy.cpp
+++ b/libc/src/threads/mtx_destroy.cpp
@@ -9,7 +9,7 @@
 #include "src/threads/mtx_destroy.h"
 #include "include/threads.h" // For mtx_t definition.
 #include "src/__support/common.h"
-#include "src/threads/linux/Mutex.h"
+#include "src/__support/threads/mutex.h"
 
 namespace __llvm_libc {
 

diff  --git a/libc/src/threads/linux/mtx_init.cpp b/libc/src/threads/mtx_init.cpp
similarity index 70%
rename from libc/src/threads/linux/mtx_init.cpp
rename to libc/src/threads/mtx_init.cpp
index 7ff606d7d2212..367e91dc7ceea 100644
--- a/libc/src/threads/linux/mtx_init.cpp
+++ b/libc/src/threads/mtx_init.cpp
@@ -9,13 +9,13 @@
 #include "src/threads/mtx_init.h"
 #include "include/threads.h" // For mtx_t definition.
 #include "src/__support/common.h"
-#include "src/threads/linux/Mutex.h"
+#include "src/__support/threads/mutex.h"
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(int, mtx_init, (mtx_t * mutex, int type)) {
-  auto *m = reinterpret_cast<Mutex *>(mutex);
-  return Mutex::init(m, type);
+LLVM_LIBC_FUNCTION(int, mtx_init, (mtx_t * m, int type)) {
+  auto err = Mutex::init(m, type | mtx_timed, type | mtx_recursive, 0);
+  return err == MutexError::NONE ? thrd_success : thrd_error;
 }
 
 } // namespace __llvm_libc

diff  --git a/libc/src/threads/linux/mtx_lock.cpp b/libc/src/threads/mtx_lock.cpp
similarity index 78%
rename from libc/src/threads/linux/mtx_lock.cpp
rename to libc/src/threads/mtx_lock.cpp
index f520601a69732..9200fedb2a37f 100644
--- a/libc/src/threads/linux/mtx_lock.cpp
+++ b/libc/src/threads/mtx_lock.cpp
@@ -7,16 +7,17 @@
 //===----------------------------------------------------------------------===//
 
 #include "src/threads/mtx_lock.h"
-#include "include/threads.h"      // For mtx_t definition.
+#include "include/threads.h" // For mtx_t definition.
 #include "src/__support/common.h"
-#include "src/threads/linux/Mutex.h"
+#include "src/__support/threads/mutex.h"
 
 namespace __llvm_libc {
 
 // The implementation currently handles only plain mutexes.
 LLVM_LIBC_FUNCTION(int, mtx_lock, (mtx_t * mutex)) {
   auto *m = reinterpret_cast<Mutex *>(mutex);
-  return m->lock();
+  auto err = m->lock();
+  return err == MutexError::NONE ? thrd_success : thrd_error;
 }
 
 } // namespace __llvm_libc

diff  --git a/libc/src/threads/linux/mtx_unlock.cpp b/libc/src/threads/mtx_unlock.cpp
similarity index 78%
rename from libc/src/threads/linux/mtx_unlock.cpp
rename to libc/src/threads/mtx_unlock.cpp
index 07d13d5cb2acc..1b971215129cc 100644
--- a/libc/src/threads/linux/mtx_unlock.cpp
+++ b/libc/src/threads/mtx_unlock.cpp
@@ -7,16 +7,17 @@
 //===----------------------------------------------------------------------===//
 
 #include "src/threads/mtx_unlock.h"
-#include "include/threads.h"      // For mtx_t definition.
+#include "include/threads.h" // For mtx_t definition.
 #include "src/__support/common.h"
-#include "src/threads/linux/Mutex.h"
+#include "src/__support/threads/mutex.h"
 
 namespace __llvm_libc {
 
 // The implementation currently handles only plain mutexes.
 LLVM_LIBC_FUNCTION(int, mtx_unlock, (mtx_t * mutex)) {
   auto *m = reinterpret_cast<Mutex *>(mutex);
-  return m->unlock();
+  auto err = m->unlock();
+  return err == MutexError::NONE ? thrd_success : thrd_error;
 }
 
 } // namespace __llvm_libc


        


More information about the libc-commits mailing list