address CR

Author: SchrodingerZhu

libc/src/__support/threads/linux/mutex.h

@@ -49,29 +49,27 @@ class Mutex final : private internal::RawMutex {
 
   LIBC_INLINE static MutexError destroy(Mutex *) { return MutexError::NONE; }
 
+  // TODO: record owner and lock count.
   LIBC_INLINE MutexError lock() {
     this->internal::RawMutex::lock(
-        /* timeout */ cpp::nullopt,
-        /* is_pshared */ this->pshared,
-        /* spin_count */ LIBC_COPT_RAW_MUTEX_DEFAULT_SPIN_COUNT);
-    // TODO: record owner and lock count.
+        /* timeout */ cpp::nullopt, this->pshared);
     return MutexError::NONE;
   }
 
+  // TODO: record owner and lock count.
   LIBC_INLINE MutexError timed_lock(internal::AbsTimeout abs_time) {
-    if (this->internal::RawMutex::lock(
-            abs_time, /* is_shared */ this->pshared,
-            /* spin_count */ LIBC_COPT_RAW_MUTEX_DEFAULT_SPIN_COUNT))
+    if (this->internal::RawMutex::lock(abs_time, this->pshared))
       return MutexError::NONE;
     return MutexError::TIMEOUT;
   }
 
   LIBC_INLINE MutexError unlock() {
-    if (this->internal::RawMutex::unlock(/* is_shared */ this->pshared))
+    if (this->internal::RawMutex::unlock(this->pshared))
       return MutexError::NONE;
     return MutexError::UNLOCK_WITHOUT_LOCK;
   }
 
+  // TODO: record owner and lock count.
   LIBC_INLINE MutexError try_lock() {
     if (this->internal::RawMutex::try_lock())
       return MutexError::NONE;

libc/src/__support/threads/linux/raw_mutex.h

@@ -75,7 +75,7 @@ class RawMutex {
           futex.exchange(IN_CONTENTION, cpp::MemoryOrder::ACQUIRE) == UNLOCKED)
         return true;
       // Contention persists. Park the thread and wait for further notification.
-      if (-ETIMEDOUT == futex.wait(IN_CONTENTION, timeout, is_pshared))
+      if (ETIMEDOUT == -futex.wait(IN_CONTENTION, timeout, is_pshared))
         return false;
       // Continue to spin after waking up.
       state = spin(spin_count);
@@ -100,7 +100,9 @@ class RawMutex {
        bool is_shared = false,
        uint_fast32_t spin_count = LIBC_COPT_RAW_MUTEX_DEFAULT_SPIN_COUNT) {
     // Timeout will not be checked if immediate lock is possible.
-    return try_lock() || lock_slow(timeout, is_shared, spin_count);
+    if (try_lock())
+      return true;
+    return lock_slow(timeout, is_shared, spin_count);
   }
   LIBC_INLINE bool unlock(bool is_pshared = false) {
     FutexWordType prev = futex.exchange(UNLOCKED, cpp::MemoryOrder::RELEASE);

libc/test/src/__support/threads/linux/raw_mutex_test.cpp

@@ -1,3 +1,11 @@
+//===-- Unittests for Linux's RawMutex ------------------------------------===//
+//
+// 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 "include/llvm-libc-macros/linux/time-macros.h"
 #include "src/__support/CPP/atomic.h"
 #include "src/__support/OSUtil/syscall.h"