6851284364

Committed 13 Nov 2023 02:22PM UTC coverage: 57.331% (-0.07%) from 57.403%

Build # 6851284364

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #13191 from rgacogne/use-unique-pointer-for-dir

Wrap `DIR*` objects in unique pointers to prevent memory leaks

Run Details

31220 of 85140 branches covered (0.0%)

Branch coverage included in aggregate %.

45 of 67 new or added lines in 6 files covered. (67.16%)

205 existing lines in 24 files now uncovered.

105368 of 153106 relevant lines covered (68.82%)

2985764.54 hits per line

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

48.42

/pdns/recursordist/recpacketcache.cc

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <iostream>
#include <cinttypes>

#include "recpacketcache.hh"
#include "cachecleaner.hh"
#include "dns.hh"
#include "namespaces.hh"
#include "rec-taskqueue.hh"

unsigned int RecursorPacketCache::s_refresh_ttlperc{0};

void RecursorPacketCache::setShardSizes(size_t shardSize)
{
  for (auto& shard : d_maps) {
    auto lock = shard.lock();
    lock->d_shardSize = shardSize;
  }
}

uint64_t RecursorPacketCache::size() const
{
  uint64_t count = 0;
  for (const auto& map : d_maps) {
    count += map.getEntriesCount();
  }
  return count;
}

uint64_t RecursorPacketCache::bytes()
{
  uint64_t sum = 0;
  for (auto& shard : d_maps) {
    auto lock = shard.lock();
    for (const auto& entry : lock->d_map) {
      sum += sizeof(entry) + entry.d_packet.length() + 4;
    }
  }
  return sum;
}

uint64_t RecursorPacketCache::getHits()
{
  uint64_t sum = 0;
  for (auto& shard : d_maps) {
    auto lock = shard.lock();
    sum += lock->d_hits;
  }
  return sum;
}

uint64_t RecursorPacketCache::getMisses()
{
  uint64_t sum = 0;
  for (auto& shard : d_maps) {
    auto lock = shard.lock();
    sum += lock->d_misses;
  }
  return sum;
}

pair<uint64_t, uint64_t> RecursorPacketCache::stats()
{
  uint64_t contended = 0;
  uint64_t acquired = 0;
  for (auto& shard : d_maps) {
    auto content = shard.lock();
    contended += content->d_contended_count;
    acquired += content->d_acquired_count;
  }
  return {contended, acquired};
}

uint64_t RecursorPacketCache::doWipePacketCache(const DNSName& name, uint16_t qtype, bool subtree)
{
  uint64_t count = 0;
  for (auto& map : d_maps) {
    auto shard = map.lock();
    auto& idx = shard->d_map.get<NameTag>();
    for (auto iter = idx.lower_bound(name); iter != idx.end();) {
      if (subtree) {
        if (!iter->d_name.isPartOf(name)) { // this is case insensitive
          break;
        }
      }
      else {
        if (iter->d_name != name) {
          break;
        }
      }
      if (qtype == 0xffff || iter->d_type == qtype) {
        iter = idx.erase(iter);
        map.decEntriesCount();
        count++;
      }
      else {
        ++iter;
      }
    }
  }
  return count;
}

bool RecursorPacketCache::qrMatch(const packetCache_t::index<HashTag>::type::iterator& iter, const std::string& queryPacket, const DNSName& qname, uint16_t qtype, uint16_t qclass)
{
  // this ignores checking on the EDNS subnet flags!
  if (qname != iter->d_name || iter->d_type != qtype || iter->d_class != qclass) {
    return false;
  }

  static const std::unordered_set<uint16_t> optionsToSkip{EDNSOptionCode::COOKIE, EDNSOptionCode::ECS};
  return queryMatches(iter->d_query, queryPacket, qname, optionsToSkip);
}

bool RecursorPacketCache::checkResponseMatches(MapCombo::LockedContent& shard, std::pair<packetCache_t::index<HashTag>::type::iterator, packetCache_t::index<HashTag>::type::iterator> range, const std::string& queryPacket, const DNSName& qname, uint16_t qtype, uint16_t qclass, time_t now, std::string* responsePacket, uint32_t* age, vState* valState, OptPBData* pbdata)
{
  for (auto iter = range.first; iter != range.second; ++iter) {
    // the possibility is VERY real that we get hits that are not right - birthday paradox
    if (!qrMatch(iter, queryPacket, qname, qtype, qclass)) {
      continue;
    }

    if (now < iter->d_ttd) { // it is right, it is fresh!
      *age = static_cast<uint32_t>(now - iter->d_creation);
      // we know ttl is > 0
      auto ttl = static_cast<uint32_t>(iter->d_ttd - now);
      if (s_refresh_ttlperc > 0 && !iter->d_submitted && taskQTypeIsSupported(qtype)) {
        const dnsheader_aligned header(iter->d_packet.data());
        const auto* headerPtr = header.get();
        if (headerPtr->rcode == RCode::NoError) {
          const uint32_t deadline = iter->getOrigTTL() * s_refresh_ttlperc / 100;
          const bool almostExpired = ttl <= deadline;
          if (almostExpired) {
            iter->d_submitted = true;
            pushAlmostExpiredTask(qname, qtype, iter->d_ttd, Netmask());
          }
        }
      }
      *responsePacket = iter->d_packet;
      responsePacket->replace(0, 2, queryPacket.c_str(), 2);
      *valState = iter->d_vstate;

      const size_t wirelength = qname.wirelength();
      if (responsePacket->size() > (sizeof(dnsheader) + wirelength)) {
        responsePacket->replace(sizeof(dnsheader), wirelength, queryPacket, sizeof(dnsheader), wirelength);
      }

      shard.d_hits++;
      moveCacheItemToBack<SequencedTag>(shard.d_map, iter);

      if (pbdata != nullptr) {
        if (iter->d_pbdata) {
          *pbdata = iter->d_pbdata;
        }
        else {
          *pbdata = boost::none;
        }
      }

      return true;
    }
    // We used to move the item to the front of "the to be deleted" sequence,
    // but we very likely will update the entry very soon, so leave it
    shard.d_misses++;
    break;
  }

  return false;
}

static const std::unordered_set<uint16_t> s_skipOptions = {EDNSOptionCode::ECS, EDNSOptionCode::COOKIE};

bool RecursorPacketCache::getResponsePacket(unsigned int tag, const std::string& queryPacket, const DNSName& qname, uint16_t qtype, uint16_t qclass, time_t now,
                                            std::string* responsePacket, uint32_t* age, vState* valState, uint32_t* qhash, OptPBData* pbdata, bool tcp)
{
  *qhash = canHashPacket(queryPacket, s_skipOptions);
  auto& map = getMap(tag, *qhash, tcp);
  auto shard = map.lock();
  const auto& idx = shard->d_map.get<HashTag>();
  auto range = idx.equal_range(std::tie(tag, *qhash, tcp));

  if (range.first == range.second) {
    shard->d_misses++;
    return false;
  }

  return checkResponseMatches(*shard, range, queryPacket, qname, qtype, qclass, now, responsePacket, age, valState, pbdata);
}

bool RecursorPacketCache::getResponsePacket(unsigned int tag, const std::string& queryPacket, DNSName& qname, uint16_t* qtype, uint16_t* qclass, time_t now,
                                            std::string* responsePacket, uint32_t* age, vState* valState, uint32_t* qhash, OptPBData* pbdata, bool tcp)
{
  *qhash = canHashPacket(queryPacket, s_skipOptions);
  auto& map = getMap(tag, *qhash, tcp);
  auto shard = map.lock();
  const auto& idx = shard->d_map.get<HashTag>();
  auto range = idx.equal_range(std::tie(tag, *qhash, tcp));

  if (range.first == range.second) {
    shard->d_misses++;
    return false;
  }

  qname = DNSName(queryPacket.c_str(), static_cast<int>(queryPacket.length()), sizeof(dnsheader), false, qtype, qclass);

  return checkResponseMatches(*shard, range, queryPacket, qname, *qtype, *qclass, now, responsePacket, age, valState, pbdata);
}

void RecursorPacketCache::insertResponsePacket(unsigned int tag, uint32_t qhash, std::string&& query, const DNSName& qname, uint16_t qtype, uint16_t qclass, std::string&& responsePacket, time_t now, uint32_t ttl, const vState& valState, OptPBData&& pbdata, bool tcp)
{
  auto& map = getMap(tag, qhash, tcp);
  auto shard = map.lock();
  auto& idx = shard->d_map.get<HashTag>();
  auto range = idx.equal_range(std::tie(tag, qhash, tcp));
  auto iter = range.first;

  for (; iter != range.second; ++iter) {
    if (iter->d_type != qtype || iter->d_class != qclass || iter->d_name != qname) {
      continue;
    }

    moveCacheItemToBack<SequencedTag>(shard->d_map, iter);
    iter->d_packet = std::move(responsePacket);
    iter->d_query = std::move(query);
    iter->d_ttd = now + ttl;
    iter->d_creation = now;
    iter->d_vstate = valState;
    iter->d_submitted = false;
    if (pbdata) {
      iter->d_pbdata = std::move(*pbdata);
    }

    return;
  }

  struct Entry entry(DNSName(qname), qtype, qclass, std::move(responsePacket), std::move(query), tcp, qhash, now + ttl, now, tag, valState);
  if (pbdata) {
    entry.d_pbdata = std::move(*pbdata);
  }

  shard->d_map.insert(entry);
  map.incEntriesCount();

  if (shard->d_map.size() > shard->d_shardSize) {
    auto& seq_idx = shard->d_map.get<SequencedTag>();
    seq_idx.erase(seq_idx.begin());
    map.decEntriesCount();
  }
  assert(map.getEntriesCount() == shard->d_map.size()); // NOLINT(cppcoreguidelines-pro-bounds-array-to-pointer-decay): clib implementation
}

void RecursorPacketCache::doPruneTo(time_t now, size_t maxSize)
{
  size_t cacheSize = size();
  pruneMutexCollectionsVector<SequencedTag>(now, d_maps, maxSize, cacheSize);
}

uint64_t RecursorPacketCache::doDump(int file)
{
  int fdupped = dup(file);
  if (fdupped == -1) {
    return 0;
  }
  auto filePtr = std::unique_ptr<FILE, decltype(&fclose)>(fdopen(fdupped, "w"), fclose);
  if (!filePtr) {
    close(fdupped);
    return 0;
  }

  uint64_t count = 0;
  time_t now = time(nullptr);

  size_t shardNum = 0;
  size_t min = std::numeric_limits<size_t>::max();
  size_t max = 0;
  uint64_t maxSize = 0;

  for (auto& shard : d_maps) {
    auto lock = shard.lock();
    const auto& sidx = lock->d_map.get<SequencedTag>();
    const auto shardSize = lock->d_map.size();
    fprintf(filePtr.get(), "; packetcache shard %zu; size %zu/%zu\n", shardNum, shardSize, lock->d_shardSize);
    min = std::min(min, shardSize);
    max = std::max(max, shardSize);
    maxSize += lock->d_shardSize;
    shardNum++;
    for (const auto& entry : sidx) {
      count++;
      try {
        fprintf(filePtr.get(), "%s %" PRId64 " %s  ; tag %d %s\n", entry.d_name.toString().c_str(), static_cast<int64_t>(entry.d_ttd - now), DNSRecordContent::NumberToType(entry.d_type).c_str(), entry.d_tag, entry.d_tcp ? "tcp" : "udp");
      }
      catch (...) {
        fprintf(filePtr.get(), "; error printing '%s'\n", entry.d_name.empty() ? "EMPTY" : entry.d_name.toString().c_str());
      }
    }
  }
  fprintf(filePtr.get(), "; packetcache size: %" PRIu64 "/%" PRIu64 " shards: %zu min/max shard size: %zu/%zu\n", size(), maxSize, d_maps.size(), min, max);
  return count;
}

1	#ifdef HAVE_CONFIG_H
2	#include "config.h"
3	#endif
4	#include <iostream>
5	#include <cinttypes>
6
7	#include "recpacketcache.hh"
8	#include "cachecleaner.hh"
9	#include "dns.hh"
10	#include "namespaces.hh"
11	#include "rec-taskqueue.hh"
12
13	unsigned int RecursorPacketCache::s_refresh_ttlperc{0};
14
15	void RecursorPacketCache::setShardSizes(size_t shardSize)
16	{	6✔
17	for (auto& shard : d_maps) {	6,144✔
18	auto lock = shard.lock();	6,144✔
19	lock->d_shardSize = shardSize;	6,144✔
20	}	6,144✔
21	}	6✔
22
23	uint64_t RecursorPacketCache::size() const
24	{	38✔
25	uint64_t count = 0;	38✔
26	for (const auto& map : d_maps) {	38,912✔
27	count += map.getEntriesCount();	38,912✔
28	}	38,912✔
29	return count;	38✔
30	}	38✔
31
32	uint64_t RecursorPacketCache::bytes()
33	{	×
34	uint64_t sum = 0;	×
35	for (auto& shard : d_maps) {	×
36	auto lock = shard.lock();	×
37	for (const auto& entry : lock->d_map) {	×
38	sum += sizeof(entry) + entry.d_packet.length() + 4;	×
39	}	×
40	}	×
41	return sum;	×
42	}	×
43
44	uint64_t RecursorPacketCache::getHits()
UNCOV 45	{	×
UNCOV 46	uint64_t sum = 0;	×
UNCOV 47	for (auto& shard : d_maps) {	×
UNCOV 48	auto lock = shard.lock();	×
UNCOV 49	sum += lock->d_hits;	×
UNCOV 50	}	×
UNCOV 51	return sum;	×
UNCOV 52	}	×
53
54	uint64_t RecursorPacketCache::getMisses()
55	{	×
56	uint64_t sum = 0;	×
57	for (auto& shard : d_maps) {	×
58	auto lock = shard.lock();	×
59	sum += lock->d_misses;	×
60	}	×
61	return sum;	×
62	}	×
63
64	pair<uint64_t, uint64_t> RecursorPacketCache::stats()
UNCOV 65	{	×
UNCOV 66	uint64_t contended = 0;	×
UNCOV 67	uint64_t acquired = 0;	×
UNCOV 68	for (auto& shard : d_maps) {	×
UNCOV 69	auto content = shard.lock();	×
UNCOV 70	contended += content->d_contended_count;	×
UNCOV 71	acquired += content->d_acquired_count;	×
UNCOV 72	}	×
UNCOV 73	return {contended, acquired};	×
UNCOV 74	}	×
75
76	uint64_t RecursorPacketCache::doWipePacketCache(const DNSName& name, uint16_t qtype, bool subtree)
77	{	6✔
78	uint64_t count = 0;	6✔
79	for (auto& map : d_maps) {	6,144✔
80	auto shard = map.lock();	6,144✔
81	auto& idx = shard->d_map.get<NameTag>();	6,144✔
82	for (auto iter = idx.lower_bound(name); iter != idx.end();) {	6,152✔
83	if (subtree) {	8✔
84	if (!iter->d_name.isPartOf(name)) { // this is case insensitive	2!
85	break;	×
86	}	×
87	}	2✔
88	else {	6✔
89	if (iter->d_name != name) {	6!
90	break;	×
91	}	×
92	}	6✔
93	if (qtype == 0xffff \|\| iter->d_type == qtype) {	8!
94	iter = idx.erase(iter);	8✔
95	map.decEntriesCount();	8✔
96	count++;	8✔
97	}	8✔
98	else {	×
99	++iter;	×
100	}	×
101	}	8✔
102	}	6,144✔
103	return count;	6✔
104	}	6✔
105
106	bool RecursorPacketCache::qrMatch(const packetCache_t::index<HashTag>::type::iterator& iter, const std::string& queryPacket, const DNSName& qname, uint16_t qtype, uint16_t qclass)
107	{	19✔
108	// this ignores checking on the EDNS subnet flags!
109	if (qname != iter->d_name \|\| iter->d_type != qtype \|\| iter->d_class != qclass) {	19!
110	return false;	×
111	}	×
112
113	static const std::unordered_set<uint16_t> optionsToSkip{EDNSOptionCode::COOKIE, EDNSOptionCode::ECS};	19✔
114	return queryMatches(iter->d_query, queryPacket, qname, optionsToSkip);	19✔
115	}	19✔
116
117	bool RecursorPacketCache::checkResponseMatches(MapCombo::LockedContent& shard, std::pair<packetCache_t::index<HashTag>::type::iterator, packetCache_t::index<HashTag>::type::iterator> range, const std::string& queryPacket, const DNSName& qname, uint16_t qtype, uint16_t qclass, time_t now, std::string* responsePacket, uint32_t* age, vState* valState, OptPBData* pbdata)
118	{	19✔
119	for (auto iter = range.first; iter != range.second; ++iter) {	19!
120	// the possibility is VERY real that we get hits that are not right - birthday paradox
121	if (!qrMatch(iter, queryPacket, qname, qtype, qclass)) {	19!
122	continue;	×
123	}	×
124
125	if (now < iter->d_ttd) { // it is right, it is fresh!	19✔
126	*age = static_cast<uint32_t>(now - iter->d_creation);	17✔
127	// we know ttl is > 0
128	auto ttl = static_cast<uint32_t>(iter->d_ttd - now);	17✔
129	if (s_refresh_ttlperc > 0 && !iter->d_submitted && taskQTypeIsSupported(qtype)) {	17!
130	const dnsheader_aligned header(iter->d_packet.data());	13✔
131	const auto* headerPtr = header.get();	13✔
132	if (headerPtr->rcode == RCode::NoError) {	13!
133	const uint32_t deadline = iter->getOrigTTL() * s_refresh_ttlperc / 100;	13✔
134	const bool almostExpired = ttl <= deadline;	13✔
135	if (almostExpired) {	13✔
136	iter->d_submitted = true;	1✔
137	pushAlmostExpiredTask(qname, qtype, iter->d_ttd, Netmask());	1✔
138	}	1✔
139	}	13✔
140	}	13✔
141	*responsePacket = iter->d_packet;	17✔
142	responsePacket->replace(0, 2, queryPacket.c_str(), 2);	17✔
143	*valState = iter->d_vstate;	17✔
144
145	const size_t wirelength = qname.wirelength();	17✔
146	if (responsePacket->size() > (sizeof(dnsheader) + wirelength)) {	17!
147	responsePacket->replace(sizeof(dnsheader), wirelength, queryPacket, sizeof(dnsheader), wirelength);	17✔
148	}	17✔
149
150	shard.d_hits++;	17✔
151	moveCacheItemToBack<SequencedTag>(shard.d_map, iter);	17✔
152
153	if (pbdata != nullptr) {	17!
154	if (iter->d_pbdata) {	×
155	*pbdata = iter->d_pbdata;	×
156	}	×
157	else {	×
158	*pbdata = boost::none;	×
159	}	×
160	}	×
161
162	return true;	17✔
163	}	17✔
164	// We used to move the item to the front of "the to be deleted" sequence,
165	// but we very likely will update the entry very soon, so leave it
166	shard.d_misses++;	2✔
167	break;	2✔
168	}	19✔
169
170	return false;	2✔
171	}	19✔
172
173	static const std::unordered_set<uint16_t> s_skipOptions = {EDNSOptionCode::ECS, EDNSOptionCode::COOKIE};
174
175	bool RecursorPacketCache::getResponsePacket(unsigned int tag, const std::string& queryPacket, const DNSName& qname, uint16_t qtype, uint16_t qclass, time_t now,
176	std::string* responsePacket, uint32_t* age, vState* valState, uint32_t* qhash, OptPBData* pbdata, bool tcp)
177	{	23✔
178	*qhash = canHashPacket(queryPacket, s_skipOptions);	23✔
179	auto& map = getMap(tag, *qhash, tcp);	23✔
180	auto shard = map.lock();	23✔
181	const auto& idx = shard->d_map.get<HashTag>();	23✔
182	auto range = idx.equal_range(std::tie(tag, *qhash, tcp));	23✔
183
184	if (range.first == range.second) {	23✔
185	shard->d_misses++;	11✔
186	return false;	11✔
187	}	11✔
188
189	return checkResponseMatches(*shard, range, queryPacket, qname, qtype, qclass, now, responsePacket, age, valState, pbdata);	12✔
190	}	23✔
191
192	bool RecursorPacketCache::getResponsePacket(unsigned int tag, const std::string& queryPacket, DNSName& qname, uint16_t* qtype, uint16_t* qclass, time_t now,
193	std::string* responsePacket, uint32_t* age, vState* valState, uint32_t* qhash, OptPBData* pbdata, bool tcp)
194	{	16✔
195	*qhash = canHashPacket(queryPacket, s_skipOptions);	16✔
196	auto& map = getMap(tag, *qhash, tcp);	16✔
197	auto shard = map.lock();	16✔
198	const auto& idx = shard->d_map.get<HashTag>();	16✔
199	auto range = idx.equal_range(std::tie(tag, *qhash, tcp));	16✔
200
201	if (range.first == range.second) {	16✔
202	shard->d_misses++;	9✔
203	return false;	9✔
204	}	9✔
205
206	qname = DNSName(queryPacket.c_str(), static_cast<int>(queryPacket.length()), sizeof(dnsheader), false, qtype, qclass);	7✔
207
208	return checkResponseMatches(shard, range, queryPacket, qname, qtype, *qclass, now, responsePacket, age, valState, pbdata);	7✔
209	}	16✔
210
211	void RecursorPacketCache::insertResponsePacket(unsigned int tag, uint32_t qhash, std::string&& query, const DNSName& qname, uint16_t qtype, uint16_t qclass, std::string&& responsePacket, time_t now, uint32_t ttl, const vState& valState, OptPBData&& pbdata, bool tcp)
212	{	19✔
213	auto& map = getMap(tag, qhash, tcp);	19✔
214	auto shard = map.lock();	19✔
215	auto& idx = shard->d_map.get<HashTag>();	19✔
216	auto range = idx.equal_range(std::tie(tag, qhash, tcp));	19✔
217	auto iter = range.first;	19✔
218
219	for (; iter != range.second; ++iter) {	19!
220	if (iter->d_type != qtype \|\| iter->d_class != qclass \|\| iter->d_name != qname) {	×
221	continue;	×
222	}	×
223
224	moveCacheItemToBack<SequencedTag>(shard->d_map, iter);	×
225	iter->d_packet = std::move(responsePacket);	×
226	iter->d_query = std::move(query);	×
227	iter->d_ttd = now + ttl;	×
228	iter->d_creation = now;	×
229	iter->d_vstate = valState;	×
230	iter->d_submitted = false;	×
231	if (pbdata) {	×
232	iter->d_pbdata = std::move(*pbdata);	×
233	}	×
234
235	return;	×
236	}	×
237
238	struct Entry entry(DNSName(qname), qtype, qclass, std::move(responsePacket), std::move(query), tcp, qhash, now + ttl, now, tag, valState);	19✔
239	if (pbdata) {	19!
240	entry.d_pbdata = std::move(*pbdata);	×
241	}	×
242
243	shard->d_map.insert(entry);	19✔
244	map.incEntriesCount();	19✔
245
246	if (shard->d_map.size() > shard->d_shardSize) {	19!
247	auto& seq_idx = shard->d_map.get<SequencedTag>();	×
248	seq_idx.erase(seq_idx.begin());	×
249	map.decEntriesCount();	×
250	}	×
251	assert(map.getEntriesCount() == shard->d_map.size()); // NOLINT(cppcoreguidelines-pro-bounds-array-to-pointer-decay): clib implementation	19✔
252	}	19✔
253
254	void RecursorPacketCache::doPruneTo(time_t now, size_t maxSize)
255	{	4✔
256	size_t cacheSize = size();	4✔
257	pruneMutexCollectionsVector<SequencedTag>(now, d_maps, maxSize, cacheSize);	4✔
258	}	4✔
259
260	uint64_t RecursorPacketCache::doDump(int file)
261	{	×
262	int fdupped = dup(file);	×
263	if (fdupped == -1) {	×
264	return 0;	×
265	}	×
266	auto filePtr = std::unique_ptr<FILE, decltype(&fclose)>(fdopen(fdupped, "w"), fclose);	×
267	if (!filePtr) {	×
268	close(fdupped);	×
269	return 0;	×
270	}	×
271
272	uint64_t count = 0;	×
273	time_t now = time(nullptr);	×
274
275	size_t shardNum = 0;	×
276	size_t min = std::numeric_limits<size_t>::max();	×
277	size_t max = 0;	×
278	uint64_t maxSize = 0;	×
279
280	for (auto& shard : d_maps) {	×
281	auto lock = shard.lock();	×
282	const auto& sidx = lock->d_map.get<SequencedTag>();	×
283	const auto shardSize = lock->d_map.size();	×
284	fprintf(filePtr.get(), "; packetcache shard %zu; size %zu/%zu\n", shardNum, shardSize, lock->d_shardSize);	×
285	min = std::min(min, shardSize);	×
286	max = std::max(max, shardSize);	×
287	maxSize += lock->d_shardSize;	×
288	shardNum++;	×
289	for (const auto& entry : sidx) {	×
290	count++;	×
291	try {	×
292	fprintf(filePtr.get(), "%s %" PRId64 " %s ; tag %d %s\n", entry.d_name.toString().c_str(), static_cast<int64_t>(entry.d_ttd - now), DNSRecordContent::NumberToType(entry.d_type).c_str(), entry.d_tag, entry.d_tcp ? "tcp" : "udp");	×
293	}	×
294	catch (...) {	×
295	fprintf(filePtr.get(), "; error printing '%s'\n", entry.d_name.empty() ? "EMPTY" : entry.d_name.toString().c_str());	×
296	}	×
297	}	×
298	}	×
299	fprintf(filePtr.get(), "; packetcache size: %" PRIu64 "/%" PRIu64 " shards: %zu min/max shard size: %zu/%zu\n", size(), maxSize, d_maps.size(), min, max);	×
300	return count;	×
301	}	×

PowerDNS / pdns / 6851284364

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