feat: use standard mutexes (#1015)

CMakeLists.txt

@@ -167,11 +167,6 @@ if (Threads_FOUND)
   set (CMAKE_REQUIRED_LIBRARIES Threads::Threads)
 endif (Threads_FOUND)
 
-check_cxx_symbol_exists (pthread_rwlock_destroy pthread.h HAVE_RWLOCK_DESTROY)
-check_cxx_symbol_exists (pthread_rwlock_init pthread.h HAVE_RWLOCK_INIT)
-check_cxx_symbol_exists (pthread_rwlock_rdlock pthread.h HAVE_RWLOCK_RDLOCK)
-check_cxx_symbol_exists (pthread_rwlock_unlock pthread.h HAVE_RWLOCK_UNLOCK)
-check_cxx_symbol_exists (pthread_rwlock_wrlock pthread.h HAVE_RWLOCK_WRLOCK)
 check_cxx_symbol_exists (pthread_threadid_np pthread.h HAVE_PTHREAD_THREADID_NP)
 
 cmake_pop_check_state ()
@@ -391,7 +386,6 @@ set (GLOG_SRCS
   ${GLOG_PUBLIC_H}
   src/base/commandlineflags.h
   src/base/googleinit.h
-  src/base/mutex.h
   src/demangle.cc
   src/demangle.h
   src/logging.cc
@@ -440,6 +434,13 @@ set (glog_libraries_options_for_static_linking)
 # CMake always uses the generated export header
 target_compile_definitions (glog PUBLIC GLOG_USE_GLOG_EXPORT)
 
+if (WIN32)
+  # Do not define min and max as macros
+  target_compile_definitions (glog PRIVATE NOMINMAX)
+  # Exclude unnecessary funcitonality
+  target_compile_definitions (glog PRIVATE WIN32_LEAN_AND_MEAN)
+endif (WIN32)
+
 if (HAVE_LIB_GFLAGS)
   target_compile_definitions (glog PUBLIC GLOG_USE_GFLAGS)
 endif (HAVE_LIB_GFLAGS)

bazel/glog.bzl

@@ -59,7 +59,7 @@ def glog_library(with_gflags = 1, **kwargs):
         "-Wno-unused-function",
         "-Wno-unused-local-typedefs",
         "-Wno-unused-variable",
-        # Allows src/base/mutex.h to include pthread.h.
+        # Allows to include pthread.h.
         "-DHAVE_PTHREAD",
         # Allows src/logging.cc to determine the host name.
         "-DHAVE_SYS_UTSNAME_H",
@@ -154,7 +154,6 @@ def glog_library(with_gflags = 1, **kwargs):
         name = "shared_headers",
         srcs = [
             "src/base/commandlineflags.h",
-            "src/base/mutex.h",
             "src/stacktrace.h",
             "src/utilities.h",
         ]

src/base/mutex.h

@@ -1,352 +0,0 @@
-// Copyright (c) 2007, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---
-// Author: Craig Silverstein.
-//
-// A simple mutex wrapper, supporting locks and read-write locks.
-// You should assume the locks are *not* re-entrant.
-//
-// To use: you should define the following macros in your configure.ac:
-//   ACX_PTHREAD
-//   AC_RWLOCK
-// The latter is defined in ../autoconf.
-//
-// This class is meant to be internal-only and should be wrapped by an
-// internal namespace.  Before you use this module, please give the
-// name of your internal namespace for this module.  Or, if you want
-// to expose it, you'll want to move it to the Google namespace.  We
-// cannot put this class in global namespace because there can be some
-// problems when we have multiple versions of Mutex in each shared object.
-//
-// NOTE: by default, we have #ifdef'ed out the TryLock() method.
-//       This is for two reasons:
-// 1) TryLock() under Windows is a bit annoying (it requires a
-//    #define to be defined very early).
-// 2) TryLock() is broken for NO_THREADS mode, at least in NDEBUG
-//    mode.
-// If you need TryLock(), and either these two caveats are not a
-// problem for you, or you're willing to work around them, then
-// feel free to #define GMUTEX_TRYLOCK, or to remove the #ifdefs
-// in the code below.
-//
-// CYGWIN NOTE: Cygwin support for rwlock seems to be buggy:
-//    http://www.cygwin.com/ml/cygwin/2008-12/msg00017.html
-// Because of that, we might as well use windows locks for
-// cygwin.  They seem to be more reliable than the cygwin pthreads layer.
-//
-// TRICKY IMPLEMENTATION NOTE:
-// This class is designed to be safe to use during
-// dynamic-initialization -- that is, by global constructors that are
-// run before main() starts.  The issue in this case is that
-// dynamic-initialization happens in an unpredictable order, and it
-// could be that someone else's dynamic initializer could call a
-// function that tries to acquire this mutex -- but that all happens
-// before this mutex's constructor has run.  (This can happen even if
-// the mutex and the function that uses the mutex are in the same .cc
-// file.)  Basically, because Mutex does non-trivial work in its
-// constructor, it's not, in the naive implementation, safe to use
-// before dynamic initialization has run on it.
-//
-// The solution used here is to pair the actual mutex primitive with a
-// bool that is set to true when the mutex is dynamically initialized.
-// (Before that it's false.)  Then we modify all mutex routines to
-// look at the bool, and not try to lock/unlock until the bool makes
-// it to true (which happens after the Mutex constructor has run.)
-//
-// This works because before main() starts -- particularly, during
-// dynamic initialization -- there are no threads, so a) it's ok that
-// the mutex operations are a no-op, since we don't need locking then
-// anyway; and b) we can be quite confident our bool won't change
-// state between a call to Lock() and a call to Unlock() (that would
-// require a global constructor in one translation unit to call Lock()
-// and another global constructor in another translation unit to call
-// Unlock() later, which is pretty perverse).
-//
-// That said, it's tricky, and can conceivably fail; it's safest to
-// avoid trying to acquire a mutex in a global constructor, if you
-// can.  One way it can fail is that a really smart compiler might
-// initialize the bool to true at static-initialization time (too
-// early) rather than at dynamic-initialization time.  To discourage
-// that, we set is_safe_ to true in code (not the constructor
-// colon-initializer) and set it to true via a function that always
-// evaluates to true, but that the compiler can't know always
-// evaluates to true.  This should be good enough.
-
-#ifndef GOOGLE_MUTEX_H_
-#define GOOGLE_MUTEX_H_
-
-#include "config.h"  // to figure out pthreads support
-
-#if defined(NO_THREADS)
-typedef int MutexType;  // to keep a lock-count
-#elif defined(_WIN32) || defined(__CYGWIN__)
-#  ifndef WIN32_LEAN_AND_MEAN
-#    define WIN32_LEAN_AND_MEAN  // We only need minimal includes
-#  endif
-#  ifdef GMUTEX_TRYLOCK
-// We need Windows NT or later for TryEnterCriticalSection().  If you
-// don't need that functionality, you can remove these _WIN32_WINNT
-// lines, and change TryLock() to assert(0) or something.
-#    ifndef _WIN32_WINNT
-#      define _WIN32_WINNT 0x0400
-#    endif
-#  endif
-// To avoid macro definition of ERROR.
-#  ifndef NOGDI
-#    define NOGDI
-#  endif
-// To avoid macro definition of min/max.
-#  ifndef NOMINMAX
-#    define NOMINMAX
-#  endif
-#  include <windows.h>
-typedef CRITICAL_SECTION MutexType;
-#elif defined(HAVE_PTHREAD) && defined(HAVE_RWLOCK)
-// Needed for pthread_rwlock_*.  If it causes problems, you could take it
-// out, but then you'd have to unset HAVE_RWLOCK (at least on linux -- it
-// *does* cause problems for FreeBSD, or MacOSX, but isn't needed
-// for locking there.)
-#  ifdef __linux__
-#    ifndef _XOPEN_SOURCE  // Some other header might have already set it for
-                           // us.
-#      define _XOPEN_SOURCE 500  // may be needed to get the rwlock calls
-#    endif
-#  endif
-#  include <pthread.h>
-using MutexType = pthread_rwlock_t;
-#elif defined(HAVE_PTHREAD)
-#  include <pthread.h>
-typedef pthread_mutex_t MutexType;
-#else
-#  error Need to implement mutex.h for your architecture, or #define NO_THREADS
-#endif
-
-// We need to include these header files after defining _XOPEN_SOURCE
-// as they may define the _XOPEN_SOURCE macro.
-#include <cassert>
-#include <cstdlib>  // for abort()
-
-#define MUTEX_NAMESPACE glog_internal_namespace_
-
-namespace MUTEX_NAMESPACE {
-
-class Mutex {
- public:
-  // Create a Mutex that is not held by anybody.  This constructor is
-  // typically used for Mutexes allocated on the heap or the stack.
-  // See below for a recommendation for constructing global Mutex
-  // objects.
-  inline Mutex();
-
-  // Destructor
-  inline ~Mutex();
-
-  inline void Lock();    // Block if needed until free then acquire exclusively
-  inline void Unlock();  // Release a lock acquired via Lock()
-#ifdef GMUTEX_TRYLOCK
-  inline bool TryLock();  // If free, Lock() and return true, else return false
-#endif
-  // Note that on systems that don't support read-write locks, these may
-  // be implemented as synonyms to Lock() and Unlock().  So you can use
-  // these for efficiency, but don't use them anyplace where being able
-  // to do shared reads is necessary to avoid deadlock.
-  inline void ReaderLock();  // Block until free or shared then acquire a share
-  inline void ReaderUnlock();           // Release a read share of this Mutex
-  inline void WriterLock() { Lock(); }  // Acquire an exclusive lock
-  inline void WriterUnlock() { Unlock(); }  // Release a lock from WriterLock()
-
-  // TODO(hamaji): Do nothing, implement correctly.
-  inline void AssertHeld() {}
-
- private:
-  MutexType mutex_;
-  // We want to make sure that the compiler sets is_safe_ to true only
-  // when we tell it to, and never makes assumptions is_safe_ is
-  // always true.  volatile is the most reliable way to do that.
-  volatile bool is_safe_;
-
-  inline void SetIsSafe() { is_safe_ = true; }
-
-  // Catch the error of writing Mutex when intending MutexLock.
-  explicit Mutex(Mutex* /*ignored*/) {}
-  // Disallow "evil" constructors
-  Mutex(const Mutex&) = delete;
-  void operator=(const Mutex&) = delete;
-};
-
-// Now the implementation of Mutex for various systems
-#if defined(NO_THREADS)
-
-// When we don't have threads, we can be either reading or writing,
-// but not both.  We can have lots of readers at once (in no-threads
-// mode, that's most likely to happen in recursive function calls),
-// but only one writer.  We represent this by having mutex_ be -1 when
-// writing and a number > 0 when reading (and 0 when no lock is held).
-//
-// In debug mode, we assert these invariants, while in non-debug mode
-// we do nothing, for efficiency.  That's why everything is in an
-// assert.
-
-Mutex::Mutex() : mutex_(0) {}
-Mutex::~Mutex() { assert(mutex_ == 0); }
-void Mutex::Lock() { assert(--mutex_ == -1); }
-void Mutex::Unlock() { assert(mutex_++ == -1); }
-#  ifdef GMUTEX_TRYLOCK
-bool Mutex::TryLock() {
-  if (mutex_) return false;
-  Lock();
-  return true;
-}
-#  endif
-void Mutex::ReaderLock() { assert(++mutex_ > 0); }
-void Mutex::ReaderUnlock() { assert(mutex_-- > 0); }
-
-#elif defined(_WIN32) || defined(__CYGWIN__)
-
-Mutex::Mutex() {
-  InitializeCriticalSection(&mutex_);
-  SetIsSafe();
-}
-Mutex::~Mutex() { DeleteCriticalSection(&mutex_); }
-void Mutex::Lock() {
-  if (is_safe_) EnterCriticalSection(&mutex_);
-}
-void Mutex::Unlock() {
-  if (is_safe_) LeaveCriticalSection(&mutex_);
-}
-#  ifdef GMUTEX_TRYLOCK
-bool Mutex::TryLock() {
-  return is_safe_ ? TryEnterCriticalSection(&mutex_) != 0 : true;
-}
-#  endif
-void Mutex::ReaderLock() { Lock(); }  // we don't have read-write locks
-void Mutex::ReaderUnlock() { Unlock(); }
-
-#elif defined(HAVE_PTHREAD) && defined(HAVE_RWLOCK)
-
-#  define SAFE_PTHREAD(fncall)                       \
-    do { /* run fncall if is_safe_ is true */        \
-      if (is_safe_ && fncall(&mutex_) != 0) abort(); \
-    } while (0)
-
-Mutex::Mutex() {
-  SetIsSafe();
-  if (is_safe_ && pthread_rwlock_init(&mutex_, nullptr) != 0) abort();
-}
-Mutex::~Mutex() { SAFE_PTHREAD(pthread_rwlock_destroy); }
-void Mutex::Lock() { SAFE_PTHREAD(pthread_rwlock_wrlock); }
-void Mutex::Unlock() { SAFE_PTHREAD(pthread_rwlock_unlock); }
-#  ifdef GMUTEX_TRYLOCK
-bool Mutex::TryLock() {
-  return is_safe_ ? pthread_rwlock_trywrlock(&mutex_) == 0 : true;
-}
-#  endif
-void Mutex::ReaderLock() { SAFE_PTHREAD(pthread_rwlock_rdlock); }
-void Mutex::ReaderUnlock() { SAFE_PTHREAD(pthread_rwlock_unlock); }
-#  undef SAFE_PTHREAD
-
-#elif defined(HAVE_PTHREAD)
-
-#  define SAFE_PTHREAD(fncall)                       \
-    do { /* run fncall if is_safe_ is true */        \
-      if (is_safe_ && fncall(&mutex_) != 0) abort(); \
-    } while (0)
-
-Mutex::Mutex() {
-  SetIsSafe();
-  if (is_safe_ && pthread_mutex_init(&mutex_, nullptr) != 0) abort();
-}
-Mutex::~Mutex() { SAFE_PTHREAD(pthread_mutex_destroy); }
-void Mutex::Lock() { SAFE_PTHREAD(pthread_mutex_lock); }
-void Mutex::Unlock() { SAFE_PTHREAD(pthread_mutex_unlock); }
-#  ifdef GMUTEX_TRYLOCK
-bool Mutex::TryLock() {
-  return is_safe_ ? pthread_mutex_trylock(&mutex_) == 0 : true;
-}
-#  endif
-void Mutex::ReaderLock() { Lock(); }
-void Mutex::ReaderUnlock() { Unlock(); }
-#  undef SAFE_PTHREAD
-
-#endif
-
-// --------------------------------------------------------------------------
-// Some helper classes
-
-// MutexLock(mu) acquires mu when constructed and releases it when destroyed.
-class MutexLock {
- public:
-  explicit MutexLock(Mutex* mu) : mu_(mu) { mu_->Lock(); }
-  ~MutexLock() { mu_->Unlock(); }
-
- private:
-  Mutex* const mu_;
-  // Disallow "evil" constructors
-  MutexLock(const MutexLock&) = delete;
-  void operator=(const MutexLock&) = delete;
-};
-
-// ReaderMutexLock and WriterMutexLock do the same, for rwlocks
-class ReaderMutexLock {
- public:
-  explicit ReaderMutexLock(Mutex* mu) : mu_(mu) { mu_->ReaderLock(); }
-  ~ReaderMutexLock() { mu_->ReaderUnlock(); }
-
- private:
-  Mutex* const mu_;
-  // Disallow "evil" constructors
-  ReaderMutexLock(const ReaderMutexLock&) = delete;
-  void operator=(const ReaderMutexLock&) = delete;
-};
-
-class WriterMutexLock {
- public:
-  explicit WriterMutexLock(Mutex* mu) : mu_(mu) { mu_->WriterLock(); }
-  ~WriterMutexLock() { mu_->WriterUnlock(); }
-
- private:
-  Mutex* const mu_;
-  // Disallow "evil" constructors
-  WriterMutexLock(const WriterMutexLock&) = delete;
-  void operator=(const WriterMutexLock&) = delete;
-};
-
-// Catch bug where variable name is omitted, e.g. MutexLock (&mu);
-#define MutexLock(x) COMPILE_ASSERT(0, mutex_lock_decl_missing_var_name)
-#define ReaderMutexLock(x) COMPILE_ASSERT(0, rmutex_lock_decl_missing_var_name)
-#define WriterMutexLock(x) COMPILE_ASSERT(0, wmutex_lock_decl_missing_var_name)
-
-}  // namespace MUTEX_NAMESPACE
-
-using namespace MUTEX_NAMESPACE;
-
-#undef MUTEX_NAMESPACE
-
-#endif /* #define GOOGLE_MUTEX_H__ */

src/config.h.cmake.in

@@ -46,9 +46,6 @@
 /* Define if you have the 'pwrite' function */
 #cmakedefine HAVE_PWRITE
 
-/* define if the compiler implements pthread_rwlock_* */
-#cmakedefine HAVE_RWLOCK
-
 /* Define if you have the 'sigaction' function */
 #cmakedefine HAVE_SIGACTION
 

src/logging.cc

@@ -36,6 +36,8 @@
 #include <cstddef>
 #include <iomanip>
 #include <iterator>
+#include <mutex>
+#include <shared_mutex>
 #include <string>
 
 #include "base/commandlineflags.h"  // to get the program name
@@ -404,7 +406,7 @@ struct LogMessage::LogMessageData {
 // changing the destination file for log messages of a given severity) also
 // lock this mutex.  Please be sure that anybody who might possibly need to
 // lock it does so.
-static Mutex log_mutex;
+static std::mutex log_mutex;
 
 // Number of messages sent at each severity.  Under log_mutex.
 int64 LogMessage::num_messages_[NUM_SEVERITIES] = {0, 0, 0, 0};
@@ -457,7 +459,7 @@ class LogFileObject : public base::Logger {
   // It is the actual file length for the system loggers,
   // i.e., INFO, ERROR, etc.
   uint32 LogSize() override {
-    MutexLock l(&lock_);
+    std::lock_guard<std::mutex> l{mutex_};
     return file_length_;
   }
 
@@ -469,7 +471,7 @@ class LogFileObject : public base::Logger {
  private:
   static const uint32 kRolloverAttemptFrequency = 0x20;
 
-  Mutex lock_;
+  std::mutex mutex_;
   bool base_filename_selected_;
   string base_filename_;
   string symlink_basename_;
@@ -560,6 +562,17 @@ class LogDestination {
   static void DeleteLogDestinations();
 
  private:
+#if defined(__cpp_lib_shared_mutex) && (__cpp_lib_shared_mutex >= 201505L)
+  // Use untimed shared mutex
+  using SinkMutex = std::shared_mutex;
+  using SinkLock = std::lock_guard<SinkMutex>;
+#else  // !(defined(__cpp_lib_shared_mutex) && (__cpp_lib_shared_mutex >=
+       // 201505L)) Fallback to timed shared mutex
+  using SinkMutex = std::shared_timed_mutex;
+  using SinkLock = std::unique_lock<SinkMutex>;
+#endif  // defined(__cpp_lib_shared_mutex) && (__cpp_lib_shared_mutex >=
+        // 201505L)
+
   LogDestination(LogSeverity severity, const char* base_filename);
   ~LogDestination();
 
@@ -612,7 +625,7 @@ class LogDestination {
 
   // Protects the vector sinks_,
   // but not the LogSink objects its elements reference.
-  static Mutex sink_mutex_;
+  static SinkMutex sink_mutex_;
 
   // Disallow
   LogDestination(const LogDestination&) = delete;
@@ -626,7 +639,7 @@ string LogDestination::addresses_;
 string LogDestination::hostname_;
 
 vector<LogSink*>* LogDestination::sinks_ = nullptr;
-Mutex LogDestination::sink_mutex_;
+LogDestination::SinkMutex LogDestination::sink_mutex_;
 bool LogDestination::terminal_supports_color_ = TerminalSupportsColor();
 
 /* static */
@@ -674,7 +687,7 @@ inline void LogDestination::FlushLogFilesUnsafe(int min_severity) {
 inline void LogDestination::FlushLogFiles(int min_severity) {
   // Prevent any subtle race conditions by wrapping a mutex lock around
   // all this stuff.
-  MutexLock l(&log_mutex);
+  std::lock_guard<std::mutex> l{log_mutex};
   for (int i = min_severity; i < NUM_SEVERITIES; i++) {
     LogDestination* log = log_destination(i);
     if (log != nullptr) {
@@ -688,7 +701,7 @@ inline void LogDestination::SetLogDestination(LogSeverity severity,
   assert(severity >= 0 && severity < NUM_SEVERITIES);
   // Prevent any subtle race conditions by wrapping a mutex lock around
   // all this stuff.
-  MutexLock l(&log_mutex);
+  std::lock_guard<std::mutex> l{log_mutex};
   log_destination(severity)->fileobject_.SetBasename(base_filename);
 }
 
@@ -696,14 +709,14 @@ inline void LogDestination::SetLogSymlink(LogSeverity severity,
                                           const char* symlink_basename) {
   CHECK_GE(severity, 0);
   CHECK_LT(severity, NUM_SEVERITIES);
-  MutexLock l(&log_mutex);
+  std::lock_guard<std::mutex> l{log_mutex};
   log_destination(severity)->fileobject_.SetSymlinkBasename(symlink_basename);
 }
 
 inline void LogDestination::AddLogSink(LogSink* destination) {
   // Prevent any subtle race conditions by wrapping a mutex lock around
   // all this stuff.
-  MutexLock l(&sink_mutex_);
+  SinkLock l{sink_mutex_};
   if (!sinks_) sinks_ = new vector<LogSink*>;
   sinks_->push_back(destination);
 }
@@ -711,7 +724,7 @@ inline void LogDestination::AddLogSink(LogSink* destination) {
 inline void LogDestination::RemoveLogSink(LogSink* destination) {
   // Prevent any subtle race conditions by wrapping a mutex lock around
   // all this stuff.
-  MutexLock l(&sink_mutex_);
+  SinkLock l{sink_mutex_};
   // This doesn't keep the sinks in order, but who cares?
   if (sinks_) {
     sinks_->erase(std::remove(sinks_->begin(), sinks_->end(), destination),
@@ -722,7 +735,7 @@ inline void LogDestination::RemoveLogSink(LogSink* destination) {
 inline void LogDestination::SetLogFilenameExtension(const char* ext) {
   // Prevent any subtle race conditions by wrapping a mutex lock around
   // all this stuff.
-  MutexLock l(&log_mutex);
+  std::lock_guard<std::mutex> l{log_mutex};
   for (int severity = 0; severity < NUM_SEVERITIES; ++severity) {
     log_destination(severity)->fileobject_.SetExtension(ext);
   }
@@ -732,7 +745,7 @@ inline void LogDestination::SetStderrLogging(LogSeverity min_severity) {
   assert(min_severity >= 0 && min_severity < NUM_SEVERITIES);
   // Prevent any subtle race conditions by wrapping a mutex lock around
   // all this stuff.
-  MutexLock l(&log_mutex);
+  std::lock_guard<std::mutex> l{log_mutex};
   FLAGS_stderrthreshold = min_severity;
 }
 
@@ -750,7 +763,7 @@ inline void LogDestination::SetEmailLogging(LogSeverity min_severity,
   assert(min_severity >= 0 && min_severity < NUM_SEVERITIES);
   // Prevent any subtle race conditions by wrapping a mutex lock around
   // all this stuff.
-  MutexLock l(&log_mutex);
+  std::lock_guard<std::mutex> l{log_mutex};
   LogDestination::email_logging_severity_ = min_severity;
   LogDestination::addresses_ = addresses;
 }
@@ -898,7 +911,7 @@ inline void LogDestination::LogToSinks(LogSeverity severity,
                                        const LogMessageTime& logmsgtime,
                                        const char* message,
                                        size_t message_len) {
-  ReaderMutexLock l(&sink_mutex_);
+  std::shared_lock<SinkMutex> l{sink_mutex_};
   if (sinks_) {
     for (size_t i = sinks_->size(); i-- > 0;) {
       (*sinks_)[i]->send(severity, full_filename, base_filename, line,
@@ -908,7 +921,7 @@ inline void LogDestination::LogToSinks(LogSeverity severity,
 }
 
 inline void LogDestination::WaitForSinks(LogMessage::LogMessageData* data) {
-  ReaderMutexLock l(&sink_mutex_);
+  std::shared_lock<SinkMutex> l{sink_mutex_};
   if (sinks_) {
     for (size_t i = sinks_->size(); i-- > 0;) {
       (*sinks_)[i]->WaitTillSent();
@@ -937,7 +950,7 @@ void LogDestination::DeleteLogDestinations() {
     delete log_destination;
     log_destination = nullptr;
   }
-  MutexLock l(&sink_mutex_);
+  SinkLock l{sink_mutex_};
   delete sinks_;
   sinks_ = nullptr;
 }
@@ -988,7 +1001,7 @@ LogFileObject::LogFileObject(LogSeverity severity, const char* base_filename)
 }
 
 LogFileObject::~LogFileObject() {
-  MutexLock l(&lock_);
+  std::lock_guard<std::mutex> l{mutex_};
   if (file_ != nullptr) {
     fclose(file_);
     file_ = nullptr;
@@ -996,7 +1009,7 @@ LogFileObject::~LogFileObject() {
 }
 
 void LogFileObject::SetBasename(const char* basename) {
-  MutexLock l(&lock_);
+  std::lock_guard<std::mutex> l{mutex_};
   base_filename_selected_ = true;
   if (base_filename_ != basename) {
     // Get rid of old log file since we are changing names
@@ -1010,7 +1023,7 @@ void LogFileObject::SetBasename(const char* basename) {
 }
 
 void LogFileObject::SetExtension(const char* ext) {
-  MutexLock l(&lock_);
+  std::lock_guard<std::mutex> l{mutex_};
   if (filename_extension_ != ext) {
     // Get rid of old log file since we are changing names
     if (file_ != nullptr) {
@@ -1023,12 +1036,12 @@ void LogFileObject::SetExtension(const char* ext) {
 }
 
 void LogFileObject::SetSymlinkBasename(const char* symlink_basename) {
-  MutexLock l(&lock_);
+  std::lock_guard<std::mutex> l{mutex_};
   symlink_basename_ = symlink_basename;
 }
 
 void LogFileObject::Flush() {
-  MutexLock l(&lock_);
+  std::lock_guard<std::mutex> l{mutex_};
   FlushUnlocked();
 }
 
@@ -1150,7 +1163,7 @@ bool LogFileObject::CreateLogfile(const string& time_pid_string) {
 
 void LogFileObject::Write(bool force_flush, time_t timestamp,
                           const char* message, size_t message_len) {
-  MutexLock l(&lock_);
+  std::lock_guard<std::mutex> l{mutex_};
 
   // We don't log if the base_name_ is "" (which means "don't write")
   if (base_filename_selected_ && base_filename_.empty()) {
@@ -1536,7 +1549,7 @@ bool LogCleaner::IsLogLastModifiedOver(const string& filepath,
 // the data from the first call, we allocate two sets of space.  One
 // for exclusive use by the first thread, and one for shared use by
 // all other threads.
-static Mutex fatal_msg_lock;
+static std::mutex fatal_msg_lock;
 static CrashReason crash_reason;
 static bool fatal_msg_exclusive = true;
 static LogMessage::LogMessageData fatal_msg_data_exclusive;
@@ -1626,7 +1639,7 @@ void LogMessage::Init(const char* file, int line, LogSeverity severity,
 #endif  // defined(GLOG_THREAD_LOCAL_STORAGE)
     data_->first_fatal_ = false;
   } else {
-    MutexLock l(&fatal_msg_lock);
+    std::lock_guard<std::mutex> l{fatal_msg_lock};
     if (fatal_msg_exclusive) {
       fatal_msg_exclusive = false;
       data_ = &fatal_msg_data_exclusive;
@@ -1750,7 +1763,7 @@ void LogMessage::Flush() {
   // Prevent any subtle race conditions by wrapping a mutex lock around
   // the actual logging action per se.
   {
-    MutexLock l(&log_mutex);
+    std::lock_guard<std::mutex> l{log_mutex};
     (this->*(data_->send_method_))();
     ++num_messages_[static_cast<int>(data_->severity_)];
   }
@@ -1797,7 +1810,6 @@ void ReprintFatalMessage() {
 void LogMessage::SendToLog() EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
   static bool already_warned_before_initgoogle = false;
 
-  log_mutex.AssertHeld();
 
   RAW_DCHECK(data_->num_chars_to_log_ > 0 &&
                  data_->message_text_[data_->num_chars_to_log_ - 1] == '\n',
@@ -1879,7 +1891,7 @@ void LogMessage::SendToLog() EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
     // can use the logging facility. Alternately, we could add
     // an entire unsafe logging interface to bypass locking
     // for signal handlers but this seems simpler.
-    log_mutex.Unlock();
+    log_mutex.unlock();
     LogDestination::WaitForSinks(data_);
 
     const char* message = "*** Check failure stack trace: ***\n";
@@ -2001,18 +2013,18 @@ void LogMessage::SendToSyslogAndLog() {
 }
 
 base::Logger* base::GetLogger(LogSeverity severity) {
-  MutexLock l(&log_mutex);
+  std::lock_guard<std::mutex> l{log_mutex};
   return LogDestination::log_destination(severity)->GetLoggerImpl();
 }
 
 void base::SetLogger(LogSeverity severity, base::Logger* logger) {
-  MutexLock l(&log_mutex);
+  std::lock_guard<std::mutex> l{log_mutex};
   LogDestination::log_destination(severity)->SetLoggerImpl(logger);
 }
 
 // L < log_mutex.  Acquires and releases mutex_.
 int64 LogMessage::num_messages(int severity) {
-  MutexLock l(&log_mutex);
+  std::lock_guard<std::mutex> l{log_mutex};
   return num_messages_[severity];
 }
 
@@ -2145,7 +2157,7 @@ namespace internal {
 
 bool GetExitOnDFatal();
 bool GetExitOnDFatal() {
-  MutexLock l(&log_mutex);
+  std::lock_guard<std::mutex> l{log_mutex};
   return exit_on_dfatal;
 }
 
@@ -2161,7 +2173,7 @@ bool GetExitOnDFatal() {
 // these differences are acceptable.
 void SetExitOnDFatal(bool value);
 void SetExitOnDFatal(bool value) {
-  MutexLock l(&log_mutex);
+  std::lock_guard<std::mutex> l{log_mutex};
   exit_on_dfatal = value;
 }
 

src/logging_unittest.cc

@@ -50,6 +50,7 @@
 #include <iomanip>
 #include <iostream>
 #include <memory>
+#include <mutex>
 #include <queue>
 #include <sstream>
 #include <string>
@@ -1196,29 +1197,29 @@ class TestLogSinkWriter : public Thread {
 
   // Just buffer it (can't use LOG() here).
   void Buffer(const string& message) {
-    mutex_.Lock();
+    mutex_.lock();
     RAW_LOG(INFO, "Buffering");
     messages_.push(message);
-    mutex_.Unlock();
+    mutex_.unlock();
     RAW_LOG(INFO, "Buffered");
   }
 
   // Wait for the buffer to clear (can't use LOG() here).
   void Wait() {
     RAW_LOG(INFO, "Waiting");
-    mutex_.Lock();
+    mutex_.lock();
     while (!NoWork()) {
-      mutex_.Unlock();
+      mutex_.unlock();
       SleepForMilliseconds(1);
-      mutex_.Lock();
+      mutex_.lock();
     }
     RAW_LOG(INFO, "Waited");
-    mutex_.Unlock();
+    mutex_.unlock();
   }
 
   // Trigger thread exit.
   void Stop() {
-    MutexLock l(&mutex_);
+    std::lock_guard<std::mutex> l(mutex_);
     should_exit_ = true;
   }
 
@@ -1232,14 +1233,14 @@ class TestLogSinkWriter : public Thread {
   // Thread body; CAN use LOG() here!
   void Run() override {
     while (true) {
-      mutex_.Lock();
+      mutex_.lock();
       while (!HaveWork()) {
-        mutex_.Unlock();
+        mutex_.unlock();
         SleepForMilliseconds(1);
-        mutex_.Lock();
+        mutex_.lock();
       }
       if (should_exit_ && messages_.empty()) {
-        mutex_.Unlock();
+        mutex_.unlock();
         break;
       }
       // Give the main thread time to log its message,
@@ -1253,7 +1254,7 @@ class TestLogSinkWriter : public Thread {
       // where LOG() usage can't be eliminated,
       // e.g. pushing the message over with an RPC:
       size_t messages_left = messages_.size();
-      mutex_.Unlock();
+      mutex_.unlock();
       SleepForMilliseconds(20);
       // May not use LOG while holding mutex_, because Buffer()
       // acquires mutex_, and Buffer is called from LOG(),
@@ -1267,7 +1268,7 @@ class TestLogSinkWriter : public Thread {
 
   // data ---------------
 
-  Mutex mutex_;
+  std::mutex mutex_;
   bool should_exit_{false};
   queue<string> messages_;  // messages to be logged
 };

src/utilities.h

@@ -54,7 +54,6 @@
 
 #include <string>
 
-#include "base/mutex.h"  // This must go first so we get _XOPEN_SOURCE
 #include "glog/logging.h"
 
 #if defined(GLOG_OS_WINDOWS)

src/vlog_is_on.cc

@@ -36,6 +36,7 @@
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
+#include <mutex>
 #include <string>
 
 #include "base/commandlineflags.h"
@@ -121,7 +122,7 @@ struct VModuleInfo {
 };
 
 // This protects the following global variables.
-static Mutex vmodule_lock;
+static std::mutex vmodule_mutex;
 // Pointer to head of the VModuleInfo list.
 // It's a map from module pattern to logging level for those module(s).
 static VModuleInfo* vmodule_list = nullptr;
@@ -130,9 +131,8 @@ static SiteFlag* cached_site_list = nullptr;
 // Boolean initialization flag.
 static bool inited_vmodule = false;
 
-// L >= vmodule_lock.
+// L >= vmodule_mutex.
 static void VLOG2Initializer() {
-  vmodule_lock.AssertHeld();
   // Can now parse --vmodule flag and initialize mapping of module-specific
   // logging levels.
   inited_vmodule = false;
@@ -172,7 +172,8 @@ int SetVLOGLevel(const char* module_pattern, int log_level) {
   size_t const pattern_len = strlen(module_pattern);
   bool found = false;
   {
-    MutexLock l(&vmodule_lock);  // protect whole read-modify-write
+    std::lock_guard<std::mutex> l(
+        vmodule_mutex);  // protect whole read-modify-write
     for (const VModuleInfo* info = vmodule_list; info != nullptr;
          info = info->next) {
       if (info->module_pattern == module_pattern) {
@@ -221,7 +222,7 @@ int SetVLOGLevel(const char* module_pattern, int log_level) {
 // NOTE: This function must not allocate memory or require any locks.
 bool InitVLOG3__(SiteFlag* site_flag, int32* level_default, const char* fname,
                  int32 verbose_level) {
-  MutexLock l(&vmodule_lock);
+  std::lock_guard<std::mutex> l(vmodule_mutex);
   bool read_vmodule_flag = inited_vmodule;
   if (!read_vmodule_flag) {
     VLOG2Initializer();