From: Remi Gacogne Date: Wed, 24 Mar 2021 17:49:02 +0000 (+0100) Subject: Replace pthread_rwlock with std::shared_mutex X-Git-Tag: dnsdist-1.6.0-rc1~42^2~2 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=0898164e7ee262225cff04a85611a66bfa3cf342;p=thirdparty%2Fpdns.git Replace pthread_rwlock with std::shared_mutex --- diff --git a/pdns/cachecleaner.hh b/pdns/cachecleaner.hh index a06a35e086..4962ff6357 100644 --- a/pdns/cachecleaner.hh +++ b/pdns/cachecleaner.hh @@ -22,6 +22,9 @@ #pragma once #include +#include + +#include "dnsname.hh" #include "lock.hh" // this function can clean any cache that has a getTTD() method on its entries, a preRemoval() method and a 'sequence' index as its second index @@ -96,7 +99,7 @@ template void moveCacheItemToBack(T& collection, typena moveCacheItemToFrontOrBack(collection, iter, false); } -template uint64_t pruneLockedCollectionsVector(vector& maps) +template uint64_t pruneLockedCollectionsVector(std::vector& maps) { uint64_t totErased = 0; time_t now = time(nullptr); @@ -122,7 +125,7 @@ template uint64_t pruneLockedCollectionsVector(vector uint64_t pruneMutexCollectionsVector(C& container, vector& maps, uint64_t maxCached, uint64_t cacheSize) +template uint64_t pruneMutexCollectionsVector(C& container, std::vector& maps, uint64_t maxCached, uint64_t cacheSize) { time_t now = time(nullptr); uint64_t totErased = 0; @@ -197,7 +200,7 @@ template uint64_t pruneMutexCollectionsVect return totErased; } -template uint64_t purgeLockedCollectionsVector(vector& maps) +template uint64_t purgeLockedCollectionsVector(std::vector& maps) { uint64_t delcount=0; @@ -210,10 +213,10 @@ template uint64_t purgeLockedCollectionsVector(vector& maps) return delcount; } -template uint64_t purgeLockedCollectionsVector(vector& maps, const std::string& match) +template uint64_t purgeLockedCollectionsVector(std::vector& maps, const std::string& match) { uint64_t delcount=0; - string prefix(match); + std::string prefix(match); prefix.resize(prefix.size()-1); DNSName dprefix(prefix); for(auto& mc : maps) { diff --git a/pdns/libssl.cc b/pdns/libssl.cc index 9b43c91050..372e40db0a 100644 --- a/pdns/libssl.cc +++ b/pdns/libssl.cc @@ -578,7 +578,7 @@ OpenSSLTLSTicketKey::OpenSSLTLSTicketKey() #endif /* HAVE_LIBSODIUM */ } -OpenSSLTLSTicketKey::OpenSSLTLSTicketKey(ifstream& file) +OpenSSLTLSTicketKey::OpenSSLTLSTicketKey(std::ifstream& file) { file.read(reinterpret_cast(d_name), sizeof(d_name)); file.read(reinterpret_cast(d_cipherKey), sizeof(d_cipherKey)); diff --git a/pdns/libssl.hh b/pdns/libssl.hh index c95ea99f0c..b6e6dc1e1e 100644 --- a/pdns/libssl.hh +++ b/pdns/libssl.hh @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include diff --git a/pdns/lock.hh b/pdns/lock.hh index 98f386dc3d..09299d7979 100644 --- a/pdns/lock.hh +++ b/pdns/lock.hh @@ -20,35 +20,26 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #pragma once -#include -#include -#include "misc.hh" -#include "pdnsexception.hh" +#include class ReadWriteLock { public: ReadWriteLock() { - if (pthread_rwlock_init(&d_lock, nullptr) != 0) { - throw std::runtime_error("Error creating a read-write lock: " + stringerror()); - } - } - - ~ReadWriteLock() { - pthread_rwlock_destroy(&d_lock); } ReadWriteLock(const ReadWriteLock& rhs) = delete; + ReadWriteLock(ReadWriteLock&& rhs) = delete; ReadWriteLock& operator=(const ReadWriteLock& rhs) = delete; - pthread_rwlock_t* getLock() + std::shared_mutex& getLock() { - return &d_lock; + return d_lock; } private: - pthread_rwlock_t d_lock; + std::shared_mutex d_lock; }; class ReadLock @@ -62,30 +53,19 @@ public: { } - ~ReadLock() - { - if(d_lock) // may have been moved - pthread_rwlock_unlock(d_lock); - } - + ReadLock(const ReadLock& rhs) = delete; + ReadLock& operator=(const ReadLock& rhs) = delete; ReadLock(ReadLock&& rhs) { - d_lock = rhs.d_lock; - rhs.d_lock = nullptr; + d_lock = std::move(rhs.d_lock); } - ReadLock(const ReadLock& rhs) = delete; - ReadLock& operator=(const ReadLock& rhs) = delete; private: - ReadLock(pthread_rwlock_t *lock) : d_lock(lock) + ReadLock(std::shared_mutex& lock) : d_lock(lock) { - int err; - if((err = pthread_rwlock_rdlock(d_lock))) { - throw PDNSException("error acquiring rwlock readlock: "+stringerror(err)); - } } - pthread_rwlock_t *d_lock; + std::shared_lock d_lock; }; class WriteLock @@ -99,31 +79,19 @@ public: { } + WriteLock(const WriteLock& rhs) = delete; + WriteLock& operator=(const WriteLock& rhs) = delete; WriteLock(WriteLock&& rhs) { - d_lock = rhs.d_lock; - rhs.d_lock=0; + d_lock = std::move(rhs.d_lock); } - ~WriteLock() - { - if(d_lock) // might have been moved - pthread_rwlock_unlock(d_lock); - } - - WriteLock(const WriteLock& rhs) = delete; - WriteLock& operator=(const WriteLock& rhs) = delete; - private: - WriteLock(pthread_rwlock_t *lock) : d_lock(lock) + WriteLock(std::shared_mutex& lock) : d_lock(lock) { - int err; - if((err = pthread_rwlock_wrlock(d_lock))) { - throw PDNSException("error acquiring rwlock wrlock: "+stringerror(err)); - } } - pthread_rwlock_t *d_lock; + std::unique_lock d_lock; }; class TryReadLock @@ -137,40 +105,20 @@ public: { } - TryReadLock(TryReadLock&& rhs) - { - d_lock = rhs.d_lock; - rhs.d_lock = nullptr; - d_havelock = rhs.d_havelock; - rhs.d_havelock = false; - } - - ~TryReadLock() - { - if(d_havelock && d_lock) - pthread_rwlock_unlock(d_lock); - } - TryReadLock(const TryReadLock& rhs) = delete; TryReadLock& operator=(const TryReadLock& rhs) = delete; - bool gotIt() + bool gotIt() const { - return d_havelock; + return d_lock.owns_lock(); } private: - TryReadLock(pthread_rwlock_t *lock) : d_lock(lock) + TryReadLock(std::shared_mutex& lock) : d_lock(lock, std::try_to_lock) { - int err; - if((err = pthread_rwlock_tryrdlock(d_lock)) && err!=EBUSY) { - throw PDNSException("error acquiring rwlock tryrdlock: "+stringerror(err)); - } - d_havelock=(err==0); } - pthread_rwlock_t *d_lock; - bool d_havelock; + std::shared_lock d_lock; }; class TryWriteLock @@ -184,40 +132,18 @@ public: { } - TryWriteLock(TryWriteLock&& rhs) - { - d_lock = rhs.d_lock; - rhs.d_lock = nullptr; - d_havelock = rhs.d_havelock; - rhs.d_havelock = false; - } - - ~TryWriteLock() - { - if(d_havelock && d_lock) // we might be moved - pthread_rwlock_unlock(d_lock); - } - TryWriteLock(const TryWriteLock& rhs) = delete; TryWriteLock& operator=(const TryWriteLock& rhs) = delete; - bool gotIt() + bool gotIt() const { - return d_havelock; + return d_lock.owns_lock(); } private: - TryWriteLock(pthread_rwlock_t *lock) : d_lock(lock) + TryWriteLock(std::shared_mutex& lock) : d_lock(lock, std::try_to_lock) { - d_havelock=false; - int err; - if((err = pthread_rwlock_trywrlock(d_lock)) && err!=EBUSY) { - throw PDNSException("error acquiring rwlock tryrwlock: "+stringerror(err)); - } - d_havelock=(err==0); } - pthread_rwlock_t *d_lock; - bool d_havelock; + std::unique_lock d_lock; }; - diff --git a/pdns/test-lock_hh.cc b/pdns/test-lock_hh.cc index 46e844c60a..112be6f016 100644 --- a/pdns/test-lock_hh.cc +++ b/pdns/test-lock_hh.cc @@ -4,9 +4,11 @@ #include "config.h" #endif #include -#include "lock.hh" #include +#include "lock.hh" +#include "pdnsexception.hh" + using namespace boost; BOOST_AUTO_TEST_SUITE(test_lock_hh) @@ -16,8 +18,9 @@ static std::vector g_locks(1000); static void lthread() { std::vector rlocks; - for(auto& pp : g_locks) + for(auto& pp : g_locks) { rlocks.emplace_back(pp); + } } BOOST_AUTO_TEST_CASE(test_pdns_lock)