MDEV-24167 fixup: Always derive srw_lock from rw_lock

dr-m · dr-m · commit 1fdc161d8fae · 2020-11-30T11:47:09.000+02:00
Let us always base srw_lock on our own std::atomic&lt;uint32_t&gt;
based rw_lock. In this way, we can extend the locks in a portable
way across all platforms.

We will use futex system calls where available:
Linux, OpenBSD, and Microsoft Windows.

Elsewhere, we will emulate futex with a mutex and a condition variable.

Thanks to Daniel Black for testing this on OpenBSD.
diff --git a/storage/innobase/CMakeLists.txt b/storage/innobase/CMakeLists.txt
@@ -327,6 +327,7 @@ SET(INNOBASE_SOURCES
 	srv/srv0mon.cc
 	srv/srv0srv.cc
 	srv/srv0start.cc
+	sync/srw_lock.cc
 	sync/sync0arr.cc
 	sync/sync0rw.cc
 	sync/sync0debug.cc
@@ -349,12 +350,6 @@ SET(INNOBASE_SOURCES
 	ut/ut0vec.cc
 	ut/ut0wqueue.cc)
 
-IF (UNIX)
-  IF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    SET(INNOBASE_SOURCES ${INNOBASE_SOURCES} "sync/srw_lock_futex.cc")
-  ENDIF()
-ENDIF()
-
 MYSQL_ADD_PLUGIN(innobase ${INNOBASE_SOURCES} STORAGE_ENGINE
   MODULE_OUTPUT_NAME ha_innodb
   DEFAULT RECOMPILE_FOR_EMBEDDED
diff --git a/storage/innobase/include/rw_lock.h b/storage/innobase/include/rw_lock.h
@@ -76,6 +76,8 @@ class rw_lock
       write_lock_wait_start();
     return false;
   }
+  /** @return the lock word value */
+  uint32_t value() const { return lock.load(std::memory_order_acquire); }
 
 public:
   /** Default constructor */
diff --git a/storage/innobase/include/srw_lock.h b/storage/innobase/include/srw_lock.h
@@ -19,133 +19,127 @@ this program; if not, write to the Free Software Foundation, Inc.,
 #pragma once
 #include "univ.i"
 
-#if 0 // defined SAFE_MUTEX
-# define SRW_LOCK_DUMMY /* Use mysql_rwlock_t for debugging purposes */
+#if !(defined __linux__ || defined _WIN32 || defined __OpenBSD__)
+# define SRW_LOCK_DUMMY
+#elif 0 // defined SAFE_MUTEX
+# define SRW_LOCK_DUMMY /* Use dummy implementation for debugging purposes */
 #endif
 
-#if defined SRW_LOCK_DUMMY || (!defined _WIN32 && !defined __linux__)
-#else
-# ifdef _WIN32
-#  include <windows.h>
-# else
-#  include "rw_lock.h"
-# endif
-#endif
+#include "rw_lock.h"
 
+/** Slim reader-writer lock with no recursion */
+class srw_lock_low final : private rw_lock
+{
 #ifdef UNIV_PFS_RWLOCK
-# define SRW_LOCK_INIT(key) init(key)
-#else
-# define SRW_LOCK_INIT(key) init()
+  friend class srw_lock;
 #endif
-
-class srw_lock final
-#if defined __linux__ && !defined SRW_LOCK_DUMMY
-  : protected rw_lock
+#ifdef SRW_LOCK_DUMMY
+  pthread_mutex_t mutex;
+  pthread_cond_t cond;
 #endif
-{
-#if defined SRW_LOCK_DUMMY || (!defined _WIN32 && !defined __linux__)
-  mysql_rwlock_t lock;
-public:
-  void SRW_LOCK_INIT(mysql_pfs_key_t key) { mysql_rwlock_init(key, &lock); }
-  void destroy() { mysql_rwlock_destroy(&lock); }
-  void rd_lock() { mysql_rwlock_rdlock(&lock); }
-  void rd_unlock() { mysql_rwlock_unlock(&lock); }
-  void wr_lock() { mysql_rwlock_wrlock(&lock); }
-  void wr_unlock() { mysql_rwlock_unlock(&lock); }
-#else
-# ifdef UNIV_PFS_RWLOCK
-  PSI_rwlock *pfs_psi;
-# endif
-# ifdef _WIN32
-  SRWLOCK lock;
-  bool read_trylock() { return TryAcquireSRWLockShared(&lock); }
-  bool write_trylock() { return TryAcquireSRWLockExclusive(&lock); }
-  void read_lock() { AcquireSRWLockShared(&lock); }
-  void write_lock() { AcquireSRWLockExclusive(&lock); }
-# else
   /** @return pointer to the lock word */
   rw_lock *word() { return static_cast<rw_lock*>(this); }
   /** Wait for a read lock.
   @param l lock word from a failed read_trylock() */
   void read_lock(uint32_t l);
   /** Wait for a write lock after a failed write_trylock() */
   void write_lock();
-# endif
+  /** Wait for signal
+  @param l lock word from a failed acquisition */
+  inline void wait(uint32_t l);
+  /** Send signal to one waiter */
+  inline void wake_one();
+  /** Send signal to all waiters */
+  inline void wake_all();
+public:
+#ifdef SRW_LOCK_DUMMY
+  void init();
+  void destroy();
+#else
+  void init() { DBUG_ASSERT(!is_locked_or_waiting()); }
+  void destroy() { DBUG_ASSERT(!is_locked_or_waiting()); }
+#endif
+  bool rd_lock_try() { uint32_t l; return read_trylock(l); }
+  bool wr_lock_try() { return write_trylock(); }
+  void rd_lock() { uint32_t l; if (!read_trylock(l)) read_lock(l); }
+  void wr_lock() { if (!write_trylock()) write_lock(); }
+  void rd_unlock();
+  void wr_unlock();
+};
+
+#ifndef UNIV_PFS_RWLOCK
+# define SRW_LOCK_INIT(key) init()
+typedef srw_lock_low srw_lock;
+#else
+# define SRW_LOCK_INIT(key) init(key)
+
+/** Slim reader-writer lock with PERFORMANCE_SCHEMA instrumentation */
+class srw_lock
+{
+  srw_lock_low lock;
+  PSI_rwlock *pfs_psi;
 
 public:
-  void SRW_LOCK_INIT(mysql_pfs_key_t key)
+  void init(mysql_pfs_key_t key)
   {
-# ifdef UNIV_PFS_RWLOCK
+    lock.init();
     pfs_psi= PSI_RWLOCK_CALL(init_rwlock)(key, this);
-# endif
-    IF_WIN(lock= SRWLOCK_INIT, static_assert(4 == sizeof(rw_lock), "ABI"));
   }
   void destroy()
   {
-# ifdef UNIV_PFS_RWLOCK
     if (pfs_psi)
     {
       PSI_RWLOCK_CALL(destroy_rwlock)(pfs_psi);
       pfs_psi= nullptr;
     }
-# endif
-    IF_WIN(, DBUG_ASSERT(!is_locked_or_waiting()));
+    lock.destroy();
   }
   void rd_lock()
   {
-    IF_WIN(, uint32_t l);
-# ifdef UNIV_PFS_RWLOCK
-    if (read_trylock(IF_WIN(, l)))
+    uint32_t l;
+    if (lock.read_trylock(l))
       return;
     if (pfs_psi)
     {
       PSI_rwlock_locker_state state;
       PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_rdwait)
         (&state, pfs_psi, PSI_RWLOCK_READLOCK, __FILE__, __LINE__);
-      read_lock(IF_WIN(, l));
+      lock.read_lock(l);
       if (locker)
         PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, 0);
       return;
     }
-# endif /* UNIV_PFS_RWLOCK */
-    IF_WIN(read_lock(), if (!read_trylock(l)) read_lock(l));
+    lock.read_lock(l);
+  }
+  void rd_unlock()
+  {
+    if (pfs_psi)
+      PSI_RWLOCK_CALL(unlock_rwlock)(pfs_psi);
+    lock.rd_unlock();
   }
   void wr_lock()
   {
-# ifdef UNIV_PFS_RWLOCK
-    if (write_trylock())
+    if (lock.write_trylock())
       return;
     if (pfs_psi)
     {
       PSI_rwlock_locker_state state;
       PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_wrwait)
         (&state, pfs_psi, PSI_RWLOCK_WRITELOCK, __FILE__, __LINE__);
-      write_lock();
+      lock.write_lock();
       if (locker)
         PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, 0);
       return;
     }
-# endif /* UNIV_PFS_RWLOCK */
-    IF_WIN(, if (!write_trylock())) write_lock();
-  }
-#ifdef _WIN32
-  void rd_unlock()
-  {
-#ifdef UNIV_PFS_RWLOCK
-    if (pfs_psi) PSI_RWLOCK_CALL(unlock_rwlock)(pfs_psi);
-#endif
-    ReleaseSRWLockShared(&lock);
+    lock.write_lock();
   }
   void wr_unlock()
   {
-#ifdef UNIV_PFS_RWLOCK
-    if (pfs_psi) PSI_RWLOCK_CALL(unlock_rwlock)(pfs_psi);
-#endif
-    ReleaseSRWLockExclusive(&lock);
+    if (pfs_psi)
+      PSI_RWLOCK_CALL(unlock_rwlock)(pfs_psi);
+    lock.wr_unlock();
   }
-#else
-  void rd_unlock();
-  void wr_unlock();
-#endif
-#endif
+  bool rd_lock_try() { return lock.rd_lock_try(); }
+  bool wr_lock_try() { return lock.wr_lock_try(); }
 };
+#endif
diff --git a/storage/innobase/sync/srw_lock.cc b/storage/innobase/sync/srw_lock.cc
@@ -0,0 +1,162 @@
+/*****************************************************************************
+
+Copyright (c) 2020, MariaDB Corporation.
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
+
+*****************************************************************************/
+
+#include "srw_lock.h"
+#include "srv0srv.h"
+
+#ifdef SRW_LOCK_DUMMY
+void srw_lock_low::init()
+{
+  DBUG_ASSERT(!is_locked_or_waiting());
+  pthread_mutex_init(&mutex, nullptr);
+  pthread_cond_init(&cond, nullptr);
+}
+
+void srw_lock_low::destroy()
+{
+  DBUG_ASSERT(!is_locked_or_waiting());
+  pthread_mutex_destroy(&mutex);
+  pthread_cond_destroy(&cond);
+}
+
+inline void srw_lock_low::wait(uint32_t l)
+{
+  pthread_mutex_lock(&mutex);
+  if (value() == l)
+    pthread_cond_wait(&cond, &mutex);
+  pthread_mutex_unlock(&mutex);
+}
+
+inline void srw_lock_low::wake_one()
+{
+  pthread_mutex_lock(&mutex);
+  pthread_cond_signal(&cond);
+  pthread_mutex_unlock(&mutex);
+}
+
+inline void srw_lock_low::wake_all()
+{
+  pthread_mutex_lock(&mutex);
+  pthread_cond_broadcast(&cond);
+  pthread_mutex_unlock(&mutex);
+}
+#else
+static_assert(4 == sizeof(rw_lock), "ABI");
+# ifdef _WIN32
+#  include <synchapi.h>
+
+inline void srw_lock_low::wait(uint32_t l)
+{
+  WaitOnAddress(word(), &l, 4, INFINITE);
+}
+inline void srw_lock_low::wake_one() { WakeByAddressSingle(word()); }
+inline void srw_lock_low::wake_all() { WakeByAddressAll(word()); }
+# else
+#  ifdef __linux__
+#   include <linux/futex.h>
+#   include <sys/syscall.h>
+#   define SRW_FUTEX(a,op,n) \
+    syscall(SYS_futex, a, FUTEX_ ## op ## _PRIVATE, n, nullptr, nullptr, 0)
+#  elif defined __OpenBSD__
+#  include <sys/time.h>
+#  include <sys/futex.h>
+#   define SRW_FUTEX(a,op,n) \
+    futex((volatile uint32_t*) a, FUTEX_ ## op, n, nullptr, nullptr)
+#  else
+#   error "no futex support"
+#  endif
+
+inline void srw_lock_low::wait(uint32_t l) { SRW_FUTEX(word(), WAIT, l); }
+inline void srw_lock_low::wake_one() { SRW_FUTEX(word(), WAKE, 1); }
+inline void srw_lock_low::wake_all() { SRW_FUTEX(word(), WAKE, INT_MAX); }
+# endif
+#endif
+
+/** Wait for a read lock.
+@param lock word value from a failed read_trylock() */
+void srw_lock_low::read_lock(uint32_t l)
+{
+  do
+  {
+    if (l == WRITER_WAITING)
+    {
+    wake_writer:
+#ifdef SRW_LOCK_DUMMY
+      pthread_mutex_lock(&mutex);
+      {
+        pthread_cond_signal(&cond);
+        pthread_cond_wait(&cond, &mutex);
+        l= value();
+      }
+      while (l == WRITER_WAITING);
+      pthread_mutex_unlock(&mutex);
+      continue;
+#else
+      wake_one();
+#endif
+    }
+    else
+      for (auto spin= srv_n_spin_wait_rounds; spin; spin--)
+      {
+        ut_delay(srv_spin_wait_delay);
+        if (read_trylock(l))
+          return;
+        else if (l == WRITER_WAITING)
+          goto wake_writer;
+      }
+
+    wait(l);
+  }
+  while (!read_trylock(l));
+}
+
+/** Wait for a write lock after a failed write_trylock() */
+void srw_lock_low::write_lock()
+{
+  for (;;)
+  {
+    uint32_t l= write_lock_wait_start();
+    /* We are the first writer to be granted the lock. Spin for a while. */
+    for (auto spin= srv_n_spin_wait_rounds; spin; spin--)
+    {
+      if (write_lock_wait_try(l))
+        return;
+      if (!(l & WRITER_WAITING))
+        l= write_lock_wait_start();
+      ut_delay(srv_spin_wait_delay);
+    }
+
+    if (write_lock_wait_try(l))
+      return;
+
+    if (!(l & WRITER_WAITING))
+    {
+      if (l == UNLOCKED && write_trylock())
+        return;
+      l= write_lock_wait_start() | WRITER_WAITING;
+    }
+    else
+      DBUG_ASSERT(~WRITER_WAITING & l);
+
+    wait(l);
+  }
+}
+
+void srw_lock_low::rd_unlock() { if (read_unlock()) wake_one(); }
+
+void srw_lock_low::wr_unlock() { write_unlock(); wake_all(); }
diff --git a/storage/innobase/sync/srw_lock_futex.cc b/storage/innobase/sync/srw_lock_futex.cc

Original file line number	Diff line number	Diff line change
`@@ -76,6 +76,8 @@ class rw_lock`
`76`	`76`	`write_lock_wait_start();`
`77`	`77`	`return false;`
`78`	`78`	`}`
	`79`	`+ /** @return the lock word value */`
	`80`	`+ uint32_t value() const { return lock.load(std::memory_order_acquire); }`
`79`	`81`
`80`	`82`	`public:`
`81`	`83`	`/** Default constructor */`