11214913022

Committed 07 Oct 2024 11:52AM UTC coverage: 64.68% (-0.02%) from 64.696%

Build # 11214913022

Build Type

Pull #14722

github

Committed by

web-flow

Commit Message

Merge 769333989 into 3fe9be026

Pull Request Pull Request #14722: rec: generate metrics related files from a single source

Run Details

37117 of 88074 branches covered (42.14%)

Branch coverage included in aggregate %.

6 of 22 new or added lines in 3 files covered. (27.27%)

1249 existing lines in 26 files now uncovered.

124684 of 162081 relevant lines covered (76.93%)

4476599.85 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.07

/pdns/recursordist/recursor_cache.hh

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * 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-1301 USA.
 */
#pragma once
#include <string>
#include <set>
#include "dns.hh"
#include "qtype.hh"
#include "misc.hh"
#include "dnsname.hh"
#include <iostream>
#include "dnsrecords.hh"
#include <boost/utility.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/key_extractors.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/version.hpp>
#include "iputils.hh"
#include "lock.hh"
#include "stat_t.hh"
#include "validate.hh"
#undef max

#include "namespaces.hh"
using namespace ::boost::multi_index;

class MemRecursorCache : public boost::noncopyable //  : public RecursorCache
{
public:
  MemRecursorCache(size_t mapsCount = 1024);

  // The number of times a stale cache entry is extended
  static uint16_t s_maxServedStaleExtensions;
  // The time a stale cache entry is extended
  static constexpr uint32_t s_serveStaleExtensionPeriod = 30;

  // Maximum size of RRSet we are willing to cache. If the RRSet is larger, we do create an entry,
  // but mark it as too big. Subsequent gets will cause an ImmediateServFailException to be thrown.
  static uint16_t s_maxRRSetSize;
  static bool s_limitQTypeAny;

  [[nodiscard]] size_t size() const;
  [[nodiscard]] size_t bytes();
  [[nodiscard]] pair<uint64_t, uint64_t> stats();
  [[nodiscard]] size_t ecsIndexSize();

  using OptTag = boost::optional<std::string>;

  using Flags = uint8_t;
  static constexpr Flags None = 0;
  static constexpr Flags RequireAuth = 1 << 0;
  static constexpr Flags Refresh = 1 << 1;
  static constexpr Flags ServeStale = 1 << 2;

  [[nodiscard]] time_t get(time_t, const DNSName& qname, QType qtype, Flags flags, vector<DNSRecord>* res, const ComboAddress& who, const OptTag& routingTag = boost::none, vector<std::shared_ptr<const RRSIGRecordContent>>* signatures = nullptr, std::vector<std::shared_ptr<DNSRecord>>* authorityRecs = nullptr, bool* variable = nullptr, vState* state = nullptr, bool* wasAuth = nullptr, DNSName* fromAuthZone = nullptr, ComboAddress* fromAuthIP = nullptr);

  void replace(time_t, const DNSName& qname, QType qtype, const vector<DNSRecord>& content, const vector<shared_ptr<const RRSIGRecordContent>>& signatures, const std::vector<std::shared_ptr<DNSRecord>>& authorityRecs, bool auth, const DNSName& authZone, boost::optional<Netmask> ednsmask = boost::none, const OptTag& routingTag = boost::none, vState state = vState::Indeterminate, boost::optional<ComboAddress> from = boost::none, bool refresh = false, time_t ttl_time = time(nullptr));

  void doPrune(time_t now, size_t keep);
  uint64_t doDump(int fileDesc, size_t maxCacheEntries);

  size_t doWipeCache(const DNSName& name, bool sub, QType qtype = 0xffff);
  bool doAgeCache(time_t now, const DNSName& name, QType qtype, uint32_t newTTL);
  bool updateValidationStatus(time_t now, const DNSName& qname, QType qtype, const ComboAddress& who, const OptTag& routingTag, bool requireAuth, vState newState, boost::optional<time_t> capTTD);

  static void resetStaticsForTests();

  [[nodiscard]] auto getCacheHits() const
  {
    return cacheHits.load();
  }
  [[nodiscard]] auto getCacheMisses() const
  {
    return cacheMisses.load();
  }

  void incCacheHits()
  {
    ++cacheHits;
  }
  void incCacheMisses()
  {
    ++cacheMisses;
  }

private:
  pdns::stat_t cacheHits{0}, cacheMisses{0};

  struct CacheEntry
  {
    CacheEntry(const std::tuple<DNSName, QType, OptTag, Netmask>& key, bool auth) :
      d_qname(std::get<0>(key)), d_netmask(std::get<3>(key).getNormalized()), d_rtag(std::get<2>(key)), d_qtype(std::get<1>(key)), d_auth(auth)
    {
    }

    using records_t = vector<std::shared_ptr<const DNSRecordContent>>;

    bool isStale(time_t now) const
    {
      // We like to keep things in cache when we (potentially) should serve stale
      if (s_maxServedStaleExtensions > 0) {
        return d_ttd + static_cast<time_t>(s_maxServedStaleExtensions) * std::min(s_serveStaleExtensionPeriod, d_orig_ttl) < now;
      }
      return d_ttd < now;
    }

    bool isEntryUsable(time_t now, bool serveStale) const
    {
      // When serving stale, we consider expired records
      return d_ttd > now || serveStale || d_servedStale != 0;
    }

    bool shouldReplace(time_t now, bool auth, vState state, bool refresh);

    records_t d_records;
    std::vector<std::shared_ptr<const RRSIGRecordContent>> d_signatures;
    std::vector<std::shared_ptr<DNSRecord>> d_authorityRecs;
    DNSName d_qname;
    DNSName d_authZone;
    ComboAddress d_from;
    Netmask d_netmask;
    OptTag d_rtag;
    mutable vState d_state{vState::Indeterminate};
    mutable time_t d_ttd{0};
    uint32_t d_orig_ttl{0};
    mutable uint16_t d_servedStale{0};
    QType d_qtype;
    bool d_auth;
    mutable bool d_submitted{false}; // whether this entry has been queued for refetch
    bool d_tooBig{false};
  };

  /* The ECS Index (d_ecsIndex) keeps track of whether there is any ECS-specific
     entry for a given (qname,qtype) entry in the cache (d_map), and if so
     provides a NetmaskTree of those ECS entries.
     This allows figuring out quickly if we should look for an entry
     specific to the requestor IP, and if so which entry is the most
     specific one.
     Keeping the entries in the regular cache is currently necessary
     because of the way we manage expired entries (moving them to the
     front of the expunge queue to be deleted at a regular interval).
  */
  class ECSIndexEntry
  {
  public:
    ECSIndexEntry(DNSName qname, QType qtype) :
      d_qname(std::move(qname)), d_qtype(qtype)
    {
    }

    [[nodiscard]] Netmask lookupBestMatch(const ComboAddress& addr) const
    {
      const auto* best = d_nmt.lookup(addr);
      if (best != nullptr) {
        return best->first;
      }

      return {};
    }

    void addMask(const Netmask& netmask) const
    {
      d_nmt.insert(netmask).second = true;
    }

    void removeNetmask(const Netmask& netmask) const
    {
      d_nmt.erase(netmask);
    }

    [[nodiscard]] bool isEmpty() const
    {
      return d_nmt.empty();
    }

    mutable NetmaskTree<bool> d_nmt;
    DNSName d_qname;
    QType d_qtype;
  };

  struct HashedTag
  {
  };
  struct SequencedTag
  {
  };
  struct NameAndRTagOnlyHashedTag
  {
  };
  struct OrderedTag
  {
  };

  using cache_t = multi_index_container<
    CacheEntry,
    indexed_by<
      ordered_unique<tag<OrderedTag>,
                     composite_key<
                       CacheEntry,
                       member<CacheEntry, DNSName, &CacheEntry::d_qname>,
                       member<CacheEntry, QType, &CacheEntry::d_qtype>,
                       member<CacheEntry, OptTag, &CacheEntry::d_rtag>,
                       member<CacheEntry, Netmask, &CacheEntry::d_netmask>>,
                     composite_key_compare<CanonDNSNameCompare, std::less<>, std::less<>, std::less<>>>,
      sequenced<tag<SequencedTag>>,
      hashed_non_unique<tag<NameAndRTagOnlyHashedTag>,
                        composite_key<
                          CacheEntry,
                          member<CacheEntry, DNSName, &CacheEntry::d_qname>,
                          member<CacheEntry, OptTag, &CacheEntry::d_rtag>>>>>;

  using OrderedTagIterator_t = MemRecursorCache::cache_t::index<MemRecursorCache::OrderedTag>::type::iterator;
  using NameAndRTagOnlyHashedTagIterator_t = MemRecursorCache::cache_t::index<MemRecursorCache::NameAndRTagOnlyHashedTag>::type::iterator;

  using ecsIndex_t = multi_index_container<
    ECSIndexEntry,
    indexed_by<
      hashed_unique<tag<HashedTag>,
                    composite_key<
                      ECSIndexEntry,
                      member<ECSIndexEntry, DNSName, &ECSIndexEntry::d_qname>,
                      member<ECSIndexEntry, QType, &ECSIndexEntry::d_qtype>>>,
      ordered_unique<tag<OrderedTag>,
                     composite_key<
                       ECSIndexEntry,
                       member<ECSIndexEntry, DNSName, &ECSIndexEntry::d_qname>,
                       member<ECSIndexEntry, QType, &ECSIndexEntry::d_qtype>>,
                     composite_key_compare<CanonDNSNameCompare, std::less<>>>>>;

  using Entries = std::pair<NameAndRTagOnlyHashedTagIterator_t, NameAndRTagOnlyHashedTagIterator_t>;

  struct MapCombo
  {
    MapCombo() = default;
    ~MapCombo() = default;
    MapCombo(const MapCombo&) = delete;
    MapCombo& operator=(const MapCombo&) = delete;
    MapCombo(MapCombo&&) = delete;
    MapCombo& operator=(MapCombo&&) = delete;

    struct LockedContent
    {
      cache_t d_map;
      ecsIndex_t d_ecsIndex;
      DNSName d_cachedqname;
      OptTag d_cachedrtag;
      Entries d_cachecache;
      uint64_t d_contended_count{0};
      uint64_t d_acquired_count{0};
      bool d_cachecachevalid{false};

      void invalidate()
      {
        d_cachecachevalid = false;
      }

      void preRemoval(const CacheEntry& entry)
      {
        if (entry.d_netmask.empty()) {
          return;
        }

        auto key = std::tie(entry.d_qname, entry.d_qtype);
        auto ecsIndexEntry = d_ecsIndex.find(key);
        if (ecsIndexEntry != d_ecsIndex.end()) {
          ecsIndexEntry->removeNetmask(entry.d_netmask);
          if (ecsIndexEntry->isEmpty()) {
            d_ecsIndex.erase(ecsIndexEntry);
          }
        }
      }
    };

    LockGuardedTryHolder<LockedContent> lock()
    {
      auto locked = d_content.try_lock();
      if (!locked.owns_lock()) {
        locked.lock();
        ++locked->d_contended_count;
      }
      ++locked->d_acquired_count;
      return locked;
    }

    [[nodiscard]] auto getEntriesCount() const
    {
      return d_entriesCount.load();
    }

    void incEntriesCount()
    {
      ++d_entriesCount;
    }

    void decEntriesCount()
    {
      --d_entriesCount;
    }

    void clearEntriesCount()
    {
      d_entriesCount = 0;
    }

  private:
    LockGuarded<LockedContent> d_content;
    pdns::stat_t d_entriesCount{0};
  };

  vector<MapCombo> d_maps;
  MapCombo& getMap(const DNSName& qname)
  {
    return d_maps.at(qname.hash() % d_maps.size());
  }

  static time_t fakeTTD(OrderedTagIterator_t& entry, const DNSName& qname, QType qtype, time_t ret, time_t now, uint32_t origTTL, bool refresh);

  static bool entryMatches(OrderedTagIterator_t& entry, QType qtype, bool requireAuth, const ComboAddress& who);
  static Entries getEntries(MapCombo::LockedContent& map, const DNSName& qname, QType qtype, const OptTag& rtag);
  static cache_t::const_iterator getEntryUsingECSIndex(MapCombo::LockedContent& map, time_t now, const DNSName& qname, QType qtype, bool requireAuth, const ComboAddress& who, bool serveStale);

  static time_t handleHit(time_t now, MapCombo::LockedContent& content, OrderedTagIterator_t& entry, const DNSName& qname, uint32_t& origTTL, vector<DNSRecord>* res, vector<std::shared_ptr<const RRSIGRecordContent>>* signatures, std::vector<std::shared_ptr<DNSRecord>>* authorityRecs, bool* variable, boost::optional<vState>& state, bool* wasAuth, DNSName* authZone, ComboAddress* fromAuthIP);
  static void updateStaleEntry(time_t now, OrderedTagIterator_t& entry);
  static void handleServeStaleBookkeeping(time_t, bool, OrderedTagIterator_t&);
};

namespace boost
{
size_t hash_value(const MemRecursorCache::OptTag& rtag);
}

1	/*
2	* This file is part of PowerDNS or dnsdist.
3	* Copyright -- PowerDNS.COM B.V. and its contributors
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of version 2 of the GNU General Public License as
7	* published by the Free Software Foundation.
8	*
9	* In addition, for the avoidance of any doubt, permission is granted to
10	* link this program with OpenSSL and to (re)distribute the binaries
11	* produced as the result of such linking.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21	*/
22	#pragma once
23	#include <string>
24	#include <set>
25	#include "dns.hh"
26	#include "qtype.hh"
27	#include "misc.hh"
28	#include "dnsname.hh"
29	#include <iostream>
30	#include "dnsrecords.hh"
31	#include <boost/utility.hpp>
32	#include <boost/multi_index_container.hpp>
33	#include <boost/multi_index/ordered_index.hpp>
34	#include <boost/multi_index/hashed_index.hpp>
35	#include <boost/multi_index/key_extractors.hpp>
36	#include <boost/multi_index/sequenced_index.hpp>
37	#include <boost/version.hpp>
38	#include "iputils.hh"
39	#include "lock.hh"
40	#include "stat_t.hh"
41	#include "validate.hh"
42	#undef max
43
44	#include "namespaces.hh"
45	using namespace ::boost::multi_index;
46
47	class MemRecursorCache : public boost::noncopyable // : public RecursorCache
48	{
49	public:
50	MemRecursorCache(size_t mapsCount = 1024);
51
52	// The number of times a stale cache entry is extended
53	static uint16_t s_maxServedStaleExtensions;
54	// The time a stale cache entry is extended
55	static constexpr uint32_t s_serveStaleExtensionPeriod = 30;
56
57	// Maximum size of RRSet we are willing to cache. If the RRSet is larger, we do create an entry,
58	// but mark it as too big. Subsequent gets will cause an ImmediateServFailException to be thrown.
59	static uint16_t s_maxRRSetSize;
60	static bool s_limitQTypeAny;
61
62	[[nodiscard]] size_t size() const;
63	[[nodiscard]] size_t bytes();
64	[[nodiscard]] pair<uint64_t, uint64_t> stats();
65	[[nodiscard]] size_t ecsIndexSize();
66
67	using OptTag = boost::optional<std::string>;
68
69	using Flags = uint8_t;
70	static constexpr Flags None = 0;
71	static constexpr Flags RequireAuth = 1 << 0;
72	static constexpr Flags Refresh = 1 << 1;
73	static constexpr Flags ServeStale = 1 << 2;
74
75	[[nodiscard]] time_t get(time_t, const DNSName& qname, QType qtype, Flags flags, vector<DNSRecord>* res, const ComboAddress& who, const OptTag& routingTag = boost::none, vector<std::shared_ptr<const RRSIGRecordContent>>* signatures = nullptr, std::vector<std::shared_ptr<DNSRecord>>* authorityRecs = nullptr, bool* variable = nullptr, vState* state = nullptr, bool* wasAuth = nullptr, DNSName* fromAuthZone = nullptr, ComboAddress* fromAuthIP = nullptr);
76
77	void replace(time_t, const DNSName& qname, QType qtype, const vector<DNSRecord>& content, const vector<shared_ptr<const RRSIGRecordContent>>& signatures, const std::vector<std::shared_ptr<DNSRecord>>& authorityRecs, bool auth, const DNSName& authZone, boost::optional<Netmask> ednsmask = boost::none, const OptTag& routingTag = boost::none, vState state = vState::Indeterminate, boost::optional<ComboAddress> from = boost::none, bool refresh = false, time_t ttl_time = time(nullptr));
78
79	void doPrune(time_t now, size_t keep);
80	uint64_t doDump(int fileDesc, size_t maxCacheEntries);
81
82	size_t doWipeCache(const DNSName& name, bool sub, QType qtype = 0xffff);
83	bool doAgeCache(time_t now, const DNSName& name, QType qtype, uint32_t newTTL);
84	bool updateValidationStatus(time_t now, const DNSName& qname, QType qtype, const ComboAddress& who, const OptTag& routingTag, bool requireAuth, vState newState, boost::optional<time_t> capTTD);
85
86	static void resetStaticsForTests();
87
88	[[nodiscard]] auto getCacheHits() const
89	{	172✔
90	return cacheHits.load();	172✔
91	}	172✔
92	[[nodiscard]] auto getCacheMisses() const
93	{	172✔
94	return cacheMisses.load();	172✔
95	}	172✔
96
97	void incCacheHits()
98	{	439✔
99	++cacheHits;	439✔
100	}	439✔
101	void incCacheMisses()
102	{	1,867✔
103	++cacheMisses;	1,867✔
104	}	1,867✔
105
106	private:
107	pdns::stat_t cacheHits{0}, cacheMisses{0};
108
109	struct CacheEntry
110	{
111	CacheEntry(const std::tuple<DNSName, QType, OptTag, Netmask>& key, bool auth) :
112	d_qname(std::get<0>(key)), d_netmask(std::get<3>(key).getNormalized()), d_rtag(std::get<2>(key)), d_qtype(std::get<1>(key)), d_auth(auth)
113	{	1,247,325✔
114	}	1,247,325✔
115
116	using records_t = vector<std::shared_ptr<const DNSRecordContent>>;
117
118	bool isStale(time_t now) const
119	{	8,365✔
120	// We like to keep things in cache when we (potentially) should serve stale
121	if (s_maxServedStaleExtensions > 0) {	8,365!
UNCOV 122	return d_ttd + static_cast<time_t>(s_maxServedStaleExtensions) * std::min(s_serveStaleExtensionPeriod, d_orig_ttl) < now;	×
UNCOV 123	}	×
124	return d_ttd < now;	8,365✔
125	}	8,365✔
126
127	bool isEntryUsable(time_t now, bool serveStale) const
128	{	799,831✔
129	// When serving stale, we consider expired records
130	return d_ttd > now \|\| serveStale \|\| d_servedStale != 0;	799,831✔
131	}	799,831✔
132
133	bool shouldReplace(time_t now, bool auth, vState state, bool refresh);
134
135	records_t d_records;
136	std::vector<std::shared_ptr<const RRSIGRecordContent>> d_signatures;
137	std::vector<std::shared_ptr<DNSRecord>> d_authorityRecs;
138	DNSName d_qname;
139	DNSName d_authZone;
140	ComboAddress d_from;
141	Netmask d_netmask;
142	OptTag d_rtag;
143	mutable vState d_state{vState::Indeterminate};
144	mutable time_t d_ttd{0};
145	uint32_t d_orig_ttl{0};
146	mutable uint16_t d_servedStale{0};
147	QType d_qtype;
148	bool d_auth;
149	mutable bool d_submitted{false}; // whether this entry has been queued for refetch
150	bool d_tooBig{false};
151	};
152
153	/* The ECS Index (d_ecsIndex) keeps track of whether there is any ECS-specific
154	entry for a given (qname,qtype) entry in the cache (d_map), and if so
155	provides a NetmaskTree of those ECS entries.
156	This allows figuring out quickly if we should look for an entry
157	specific to the requestor IP, and if so which entry is the most
158	specific one.
159	Keeping the entries in the regular cache is currently necessary
160	because of the way we manage expired entries (moving them to the
161	front of the expunge queue to be deleted at a regular interval).
162	*/
163	class ECSIndexEntry
164	{
165	public:
166	ECSIndexEntry(DNSName qname, QType qtype) :
167	d_qname(std::move(qname)), d_qtype(qtype)
168	{	83✔
169	}	83✔
170
171	[[nodiscard]] Netmask lookupBestMatch(const ComboAddress& addr) const
172	{	681✔
173	const auto* best = d_nmt.lookup(addr);	681✔
174	if (best != nullptr) {	681✔
175	return best->first;	365✔
176	}	365✔
177
178	return {};	316✔
179	}	681✔
180
181	void addMask(const Netmask& netmask) const
182	{	620✔
183	d_nmt.insert(netmask).second = true;	620✔
184	}	620✔
185
186	void removeNetmask(const Netmask& netmask) const
187	{	524✔
188	d_nmt.erase(netmask);	524✔
189	}	524✔
190
191	[[nodiscard]] bool isEmpty() const
192	{	1,203✔
193	return d_nmt.empty();	1,203✔
194	}	1,203✔
195
196	mutable NetmaskTree<bool> d_nmt;
197	DNSName d_qname;
198	QType d_qtype;
199	};
200
201	struct HashedTag
202	{
203	};
204	struct SequencedTag
205	{
206	};
207	struct NameAndRTagOnlyHashedTag
208	{
209	};
210	struct OrderedTag
211	{
212	};
213
214	using cache_t = multi_index_container<
215	CacheEntry,
216	indexed_by<
217	ordered_unique<tag<OrderedTag>,
218	composite_key<
219	CacheEntry,
220	member<CacheEntry, DNSName, &CacheEntry::d_qname>,
221	member<CacheEntry, QType, &CacheEntry::d_qtype>,
222	member<CacheEntry, OptTag, &CacheEntry::d_rtag>,
223	member<CacheEntry, Netmask, &CacheEntry::d_netmask>>,
224	composite_key_compare<CanonDNSNameCompare, std::less<>, std::less<>, std::less<>>>,
225	sequenced<tag<SequencedTag>>,
226	hashed_non_unique<tag<NameAndRTagOnlyHashedTag>,
227	composite_key<
228	CacheEntry,
229	member<CacheEntry, DNSName, &CacheEntry::d_qname>,
230	member<CacheEntry, OptTag, &CacheEntry::d_rtag>>>>>;
231
232	using OrderedTagIterator_t = MemRecursorCache::cache_t::index<MemRecursorCache::OrderedTag>::type::iterator;
233	using NameAndRTagOnlyHashedTagIterator_t = MemRecursorCache::cache_t::index<MemRecursorCache::NameAndRTagOnlyHashedTag>::type::iterator;
234
235	using ecsIndex_t = multi_index_container<
236	ECSIndexEntry,
237	indexed_by<
238	hashed_unique<tag<HashedTag>,
239	composite_key<
240	ECSIndexEntry,
241	member<ECSIndexEntry, DNSName, &ECSIndexEntry::d_qname>,
242	member<ECSIndexEntry, QType, &ECSIndexEntry::d_qtype>>>,
243	ordered_unique<tag<OrderedTag>,
244	composite_key<
245	ECSIndexEntry,
246	member<ECSIndexEntry, DNSName, &ECSIndexEntry::d_qname>,
247	member<ECSIndexEntry, QType, &ECSIndexEntry::d_qtype>>,
248	composite_key_compare<CanonDNSNameCompare, std::less<>>>>>;
249
250	using Entries = std::pair<NameAndRTagOnlyHashedTagIterator_t, NameAndRTagOnlyHashedTagIterator_t>;
251
252	struct MapCombo
253	{
254	MapCombo() = default;	812,050✔
255	~MapCombo() = default;	663,558✔
256	MapCombo(const MapCombo&) = delete;
257	MapCombo& operator=(const MapCombo&) = delete;
258	MapCombo(MapCombo&&) = delete;
259	MapCombo& operator=(MapCombo&&) = delete;
260
261	struct LockedContent
262	{
263	cache_t d_map;
264	ecsIndex_t d_ecsIndex;
265	DNSName d_cachedqname;
266	OptTag d_cachedrtag;
267	Entries d_cachecache;
268	uint64_t d_contended_count{0};
269	uint64_t d_acquired_count{0};
270	bool d_cachecachevalid{false};
271
272	void invalidate()
273	{	92,233✔
274	d_cachecachevalid = false;	92,233✔
275	}	92,233✔
276
277	void preRemoval(const CacheEntry& entry)
278	{	541✔
279	if (entry.d_netmask.empty()) {	541✔
280	return;	21✔
281	}	21✔
282
283	auto key = std::tie(entry.d_qname, entry.d_qtype);	520✔
284	auto ecsIndexEntry = d_ecsIndex.find(key);	520✔
285	if (ecsIndexEntry != d_ecsIndex.end()) {	520!
286	ecsIndexEntry->removeNetmask(entry.d_netmask);	520✔
287	if (ecsIndexEntry->isEmpty()) {	520✔
288	d_ecsIndex.erase(ecsIndexEntry);	8✔
289	}	8✔
290	}	520✔
291	}	520✔
292	};
293
294	LockGuardedTryHolder<LockedContent> lock()
295	{	3,738,690✔
296	auto locked = d_content.try_lock();	3,738,690✔
297	if (!locked.owns_lock()) {	3,738,690✔
298	locked.lock();	3,902✔
299	++locked->d_contended_count;	3,902✔
300	}	3,902✔
301	++locked->d_acquired_count;	3,738,690✔
302	return locked;	3,738,690✔
303	}	3,738,690✔
304
305	[[nodiscard]] auto getEntriesCount() const
306	{	502,991✔
307	return d_entriesCount.load();	502,991✔
308	}	502,991✔
309
310	void incEntriesCount()
311	{	1,247,325✔
312	++d_entriesCount;	1,247,325✔
313	}	1,247,325✔
314
315	void decEntriesCount()
316	{	1,202,912✔
317	--d_entriesCount;	1,202,912✔
318	}	1,202,912✔
319
320	void clearEntriesCount()
UNCOV 321	{	×
UNCOV 322	d_entriesCount = 0;	×
UNCOV 323	}	×
324
325	private:
326	LockGuarded<LockedContent> d_content;
327	pdns::stat_t d_entriesCount{0};
328	};
329
330	vector<MapCombo> d_maps;
331	MapCombo& getMap(const DNSName& qname)
332	{	2,635,599✔
333	return d_maps.at(qname.hash() % d_maps.size());	2,635,599✔
334	}	2,635,599✔
335
336	static time_t fakeTTD(OrderedTagIterator_t& entry, const DNSName& qname, QType qtype, time_t ret, time_t now, uint32_t origTTL, bool refresh);
337
338	static bool entryMatches(OrderedTagIterator_t& entry, QType qtype, bool requireAuth, const ComboAddress& who);
339	static Entries getEntries(MapCombo::LockedContent& map, const DNSName& qname, QType qtype, const OptTag& rtag);
340	static cache_t::const_iterator getEntryUsingECSIndex(MapCombo::LockedContent& map, time_t now, const DNSName& qname, QType qtype, bool requireAuth, const ComboAddress& who, bool serveStale);
341
342	static time_t handleHit(time_t now, MapCombo::LockedContent& content, OrderedTagIterator_t& entry, const DNSName& qname, uint32_t& origTTL, vector<DNSRecord>* res, vector<std::shared_ptr<const RRSIGRecordContent>>* signatures, std::vector<std::shared_ptr<DNSRecord>>* authorityRecs, bool* variable, boost::optional<vState>& state, bool* wasAuth, DNSName* authZone, ComboAddress* fromAuthIP);
343	static void updateStaleEntry(time_t now, OrderedTagIterator_t& entry);
344	static void handleServeStaleBookkeeping(time_t, bool, OrderedTagIterator_t&);
345	};
346
347	namespace boost
348	{
349	size_t hash_value(const MemRecursorCache::OptTag& rtag);
350	}

PowerDNS / pdns / 11214913022

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous