[2202] Drop support for recursive mutexes

They are not needed currently.

diff --git a/src/lib/util/threads/lock.cc b/src/lib/util/threads/lock.cc
index d5c32d417966cd2598e81cb84a5e9f018d022e7f..a1434e19127f18b6e15493c366b60fd4bbb45faf 100644 (file)
--- a/src/lib/util/threads/lock.cc
+++ b/src/lib/util/threads/lock.cc
@@ -56,7 +56,7 @@ struct Deinitializer {
 
 }
 
-Mutex::Mutex(bool recursive) :
+Mutex::Mutex() :
     impl_(NULL)
 {
     pthread_mutexattr_t attributes;
@@ -72,11 +72,7 @@ Mutex::Mutex(bool recursive) :
     Deinitializer deinitializer(attributes);
     // TODO: Distinguish if debug mode is enabled in compilation.
     // If so, it should be PTHREAD_MUTEX_NORMAL or NULL
-    int type = PTHREAD_MUTEX_ERRORCHECK;
-    if (recursive) {
-        type = PTHREAD_MUTEX_RECURSIVE;
-    }
-    result = pthread_mutexattr_settype(&attributes, type);
+    result = pthread_mutexattr_settype(&attributes, PTHREAD_MUTEX_ERRORCHECK);
     if (result != 0) {
         isc_throw(isc::InvalidOperation, strerror(result));
     }

diff --git a/src/lib/util/threads/lock.h b/src/lib/util/threads/lock.h
index 3a28f1a53a7670d1250795cb973d8d8968fb976b..75bff65b1c9343b95a793cb35a8fe8a413c20a50 100644 (file)
--- a/src/lib/util/threads/lock.h
+++ b/src/lib/util/threads/lock.h
@@ -44,23 +44,18 @@ class Mutex : public boost::noncopyable {
 public:
     /// \brief Constructor.
     ///
-    /// Creates a mutex. Depending on the parameter, it is either recursive
-    /// (the same thread may lock it multiple times, others wait; it must be
-    /// unlocked as many times to become really unlocked) or normal (can be
-    /// locked just once, if the same threads tries to lock it again, Bad
-    /// Things Happen).
+    /// Creates a mutex. It is a non-recursive mutex (can be locked just once,
+    /// if the same threads tries to lock it again, Bad Things Happen).
     ///
     /// Depending on compilation parameters and OS, the mutex may or may not
     /// do some error and sanity checking. However, such checking is meant
     /// only to aid development, not rely on it as a feature.
     ///
-    /// \param recursive If the thread should be recursive (lockable multiple
-    ///     times from the same thread) or not.
     /// \throw std::bad_alloc In case allocation of something (memory, the
     ///     OS mutex) fails.
     /// \throw isc::InvalidOperation Other unspecified errors around the mutex.
     ///     This should be rare.
-    Mutex(bool recursive = false);
+    Mutex();
 
     /// \brief Destructor.
     ///
@@ -86,8 +81,7 @@ public:
         ///
         /// \throw isc::InvalidOperation when OS reports error. This usually
         ///     means an attempt to use the mutex in a wrong way (locking
-        ///     a non-recursive mutex a second time from the same thread,
-        ///     for example).
+        ///     a mutex second time from the same thread, for example).
         Locker(Mutex& mutex) :
             mutex_(NULL)
         {

diff --git a/src/lib/util/threads/tests/lock_unittest.cc b/src/lib/util/threads/tests/lock_unittest.cc
index e1edd701f21698d8c35130a5b94f1cf917d19d57..cc959f5433f873298a0c7216b809a262de912c37 100644 (file)
--- a/src/lib/util/threads/tests/lock_unittest.cc
+++ b/src/lib/util/threads/tests/lock_unittest.cc
@@ -25,18 +25,6 @@ using namespace isc::util::thread;
 
 namespace {
 
-// Test a recursive mutex can be locked multiple times
-TEST(MutexTest, recursiveLockMultiple) {
-    Mutex mutex(true);
-    EXPECT_FALSE(mutex.locked()); // Debug-only build
-    Mutex::Locker l1(mutex);
-    EXPECT_TRUE(mutex.locked()); // Debug-only build
-    Mutex::Locker l2(mutex);
-    Mutex::Locker l3(mutex);
-    Mutex::Locker l4(mutex);
-    Mutex::Locker l5(mutex);
-}
-
 // If we try to lock the debug mutex multiple times, it should throw.
 TEST(MutexTest, lockMultiple) {
     // TODO: Once we support non-debug mutexes, disable the test if we compile