auth: Convert DNSSECKeeper to SharedLockGuarded

diff --git a/pdns/dbdnsseckeeper.cc b/pdns/dbdnsseckeeper.cc
index 650580a53ee639910a35744d45016a368d7fd851..20e9d43d366ef2762d4bab200117433003eaf529 100644 (file)
--- a/pdns/dbdnsseckeeper.cc
+++ b/pdns/dbdnsseckeeper.cc
@@ -46,11 +46,9 @@ using namespace boost::assign;
 #include "namespaces.hh"
 
 
-DNSSECKeeper::keycache_t DNSSECKeeper::s_keycache;
-DNSSECKeeper::metacache_t DNSSECKeeper::s_metacache;
+SharedLockGuarded<DNSSECKeeper::keycache_t> DNSSECKeeper::s_keycache;
+SharedLockGuarded<DNSSECKeeper::metacache_t> DNSSECKeeper::s_metacache;
 int64_t DNSSECKeeper::s_metaCacheCleanActions = 0;
-ReadWriteLock DNSSECKeeper::s_metacachelock;
-ReadWriteLock DNSSECKeeper::s_keycachelock;
 AtomicCounter DNSSECKeeper::s_ops;
 time_t DNSSECKeeper::s_last_prune;
 size_t DNSSECKeeper::s_maxEntries = 0;
@@ -119,26 +117,20 @@ bool DNSSECKeeper::addKey(const DNSName& name, bool setSEPBit, int algorithm, in
 }
 
 void DNSSECKeeper::clearAllCaches() {
-  {
-    WriteLock l(&s_keycachelock);
-    s_keycache.clear();
-  }
-  WriteLock l(&s_metacachelock);
-  s_metacache.clear();
+  s_keycache.write_lock()->clear();
+  s_metacache.write_lock()->clear();
 }
 
 
 bool DNSSECKeeper::clearKeyCache(const DNSName& name)
 {
-  WriteLock l(&s_keycachelock);
-  s_keycache.erase(name);
+  s_keycache.write_lock()->erase(name);
   return true;
 }
 
 bool DNSSECKeeper::clearMetaCache(const DNSName& name)
 {
-  WriteLock l(&s_metacachelock);
-  s_metacache.erase(name);
+  s_metacache.write_lock()->erase(name);
   ++s_metaCacheCleanActions;
   return true;
 }
@@ -244,9 +236,9 @@ bool DNSSECKeeper::getFromMeta(const DNSName& zname, const std::string& key, std
   METAValues meta;
 
   if (ttl) {
-    ReadLock l(&s_metacachelock);
-    auto iter = s_metacache.find(zname);
-    if(iter != s_metacache.end() && iter->d_ttd > now) {
+    auto metacache = s_metacache.read_lock();
+    auto iter = metacache->find(zname);
+    if(iter != metacache->end() && iter->d_ttd > now) {
       meta = iter->d_value;
       fromCache = true;
     }
@@ -273,11 +265,11 @@ bool DNSSECKeeper::getFromMeta(const DNSName& zname, const std::string& key, std
     nce.d_ttd = now + ttl;
     nce.d_value = std::move(meta);
     {
-      WriteLock l(&s_metacachelock);
+      auto metacache = s_metacache.write_lock();
       if(d_metaCacheCleanAction != s_metaCacheCleanActions) {
         return false;
       }
-      lruReplacingInsert<SequencedTag>(s_metacache, nce);
+      lruReplacingInsert<SequencedTag>(*metacache, nce);
     }
   }
 
@@ -321,12 +313,10 @@ void DNSSECKeeper::getSoaEdit(const DNSName& zname, std::string& value, bool use
 uint64_t DNSSECKeeper::dbdnssecCacheSizes(const std::string& str)
 {
   if(str=="meta-cache-size") {
-    ReadLock l(&s_metacachelock);
-    return s_metacache.size();
+    return s_metacache.read_lock()->size();
   }
   else if(str=="key-cache-size") {
-    ReadLock l(&s_keycachelock);
-    return s_keycache.size();
+    return s_keycache.read_lock()->size();
   }
   return (uint64_t)-1;
 }
@@ -553,10 +543,10 @@ DNSSECKeeper::keyset_t DNSSECKeeper::getKeys(const DNSName& zone, bool useCache)
   }
 
   if (useCache && ttl > 0) {
-    ReadLock l(&s_keycachelock);
-    keycache_t::const_iterator iter = s_keycache.find(zone);
+    auto keycache = s_keycache.read_lock();
+    auto iter = keycache->find(zone);
 
-    if(iter != s_keycache.end() && iter->d_ttd > now) {
+    if (iter != keycache->end() && iter->d_ttd > now) {
       keyset_t ret;
       ret.reserve(iter->d_keys.size());
       for(const keyset_t::value_type& value :  iter->d_keys)
@@ -623,8 +613,7 @@ DNSSECKeeper::keyset_t DNSSECKeeper::getKeys(const DNSName& zone, bool useCache)
     kce.d_keys = retkeyset;
     kce.d_ttd = now + ttl;
     {
-      WriteLock l(&s_keycachelock);
-      lruReplacingInsert<SequencedTag>(s_keycache, kce);
+      lruReplacingInsert<SequencedTag>(*(s_keycache.write_lock()), kce);
     }
   }
 
@@ -978,12 +967,10 @@ void DNSSECKeeper::cleanup()
 
   if(now.tv_sec - s_last_prune > (time_t)(30)) {
     {
-        WriteLock l(&s_metacachelock);
-        pruneCollection<SequencedTag>(*this, s_metacache, s_maxEntries);
+      pruneCollection<SequencedTag>(*this, (*s_metacache.write_lock()), s_maxEntries);
     }
     {
-        WriteLock l(&s_keycachelock);
-        pruneCollection<SequencedTag>(*this, s_keycache, s_maxEntries);
+      pruneCollection<SequencedTag>(*this, (*s_keycache.write_lock()), s_maxEntries);
     }
     s_last_prune = time(nullptr);
   }
@@ -993,7 +980,6 @@ void DNSSECKeeper::setMaxEntries(size_t maxEntries)
 {
   s_maxEntries = maxEntries;
 #if BOOST_VERSION >= 105600
-  WriteLock wl(&s_keycachelock);
-  s_keycache.get<KeyCacheTag>().reserve(s_maxEntries);
+  s_keycache.write_lock()->get<KeyCacheTag>().reserve(s_maxEntries);
 #endif /* BOOST_VERSION >= 105600 */
 }

diff --git a/pdns/dnsseckeeper.hh b/pdns/dnsseckeeper.hh
index edae2152f7a3954b453afda26277a7abbec49fe2..29f2fd0cbb8991c66a5515c4f0895baf82240c56 100644 (file)
--- a/pdns/dnsseckeeper.hh
+++ b/pdns/dnsseckeeper.hh
@@ -296,11 +296,9 @@ private:
 
   void cleanup();
 
-  static keycache_t s_keycache;
-  static metacache_t s_metacache;
+  static SharedLockGuarded<keycache_t> s_keycache;
+  static SharedLockGuarded<metacache_t> s_metacache;
   static int64_t s_metaCacheCleanActions;
-  static ReadWriteLock s_metacachelock;
-  static ReadWriteLock s_keycachelock;
   static AtomicCounter s_ops;
   static time_t s_last_prune;
   static size_t s_maxEntries;