store_digest.cc
Go to the documentation of this file.
1 /*
2  * Copyright (C) 1996-2018 The Squid Software Foundation and contributors
3  *
4  * Squid software is distributed under GPLv2+ license and includes
5  * contributions from numerous individuals and organizations.
6  * Please see the COPYING and CONTRIBUTORS files for details.
7  */
8 
9 /* DEBUG: section 71 Store Digest Manager */
10 
11 /*
12  * TODO: We probably do not track all the cases when
13  * storeDigestNoteStoreReady() must be called; this may prevent
14  * storeDigestRebuild/write schedule to be activated
15  */
16 
17 #include "squid.h"
18 #include "Debug.h"
19 #include "event.h"
20 #include "globals.h"
21 #include "mgr/Registration.h"
22 #include "store_digest.h"
23 
24 #if USE_CACHE_DIGESTS
25 #include "CacheDigest.h"
26 #include "HttpReply.h"
27 #include "HttpRequest.h"
28 #include "internal.h"
29 #include "MemObject.h"
30 #include "PeerDigest.h"
31 #include "refresh.h"
32 #include "SquidConfig.h"
33 #include "SquidTime.h"
34 #include "Store.h"
35 #include "StoreSearch.h"
36 #include "util.h"
37 
38 #include <cmath>
39 
40 /*
41  * local types
42  */
43 
45 {
46 public:
48  int rebuild_lock = 0;
49  StoreEntry * rewrite_lock = nullptr;
51  int rewrite_offset = 0;
52  int rebuild_count = 0;
53  int rewrite_count = 0;
54 };
55 
57 {
58 public:
59  int del_count = 0; /* #store entries deleted from store_digest */
60  int del_lost_count = 0; /* #store entries not found in store_digest on delete */
61  int add_count = 0; /* #store entries accepted to store_digest */
62  int add_coll_count = 0; /* #accepted entries that collided with existing ones */
63  int rej_count = 0; /* #store entries not accepted to store_digest */
64  int rej_coll_count = 0; /* #not accepted entries that collided with existing ones */
65 };
66 
67 /* local vars */
70 
71 /* local prototypes */
72 static void storeDigestRebuildStart(void *datanotused);
73 static void storeDigestRebuildResume(void);
74 static void storeDigestRebuildFinish(void);
75 static void storeDigestRebuildStep(void *datanotused);
76 static void storeDigestRewriteStart(void *);
77 static void storeDigestRewriteResume(void);
78 static void storeDigestRewriteFinish(StoreEntry * e);
80 static void storeDigestCBlockSwapOut(StoreEntry * e);
81 static void storeDigestAdd(const StoreEntry *);
82 
84 static uint64_t
86 {
87  /*
88  * To-Do: Bloom proved that the optimal filter utilization is 50% (half of
89  * the bits are off). However, we do not have a formula to calculate the
90  * number of _entries_ we want to pre-allocate for.
91  */
92  const uint64_t hi_cap = Store::Root().maxSize() / Config.Store.avgObjectSize;
93  const uint64_t lo_cap = 1 + Store::Root().currentSize() / Config.Store.avgObjectSize;
94  const uint64_t e_count = StoreEntry::inUseCount();
95  uint64_t cap = e_count ? e_count : hi_cap;
96  debugs(71, 2, "have: " << e_count << ", want " << cap <<
97  " entries; limits: [" << lo_cap << ", " << hi_cap << "]");
98 
99  if (cap < lo_cap)
100  cap = lo_cap;
101 
102  /* do not enforce hi_cap limit, average-based estimation may be wrong
103  *if (cap > hi_cap)
104  * cap = hi_cap;
105  */
106 
107  // Bug 4534: we still have to set an upper-limit at some reasonable value though.
108  // this matches cacheDigestCalcMaskSize doing (cap*bpe)+7 < INT_MAX
109  const uint64_t absolute_max = (INT_MAX -8) / Config.digest.bits_per_entry;
110  if (cap > absolute_max) {
111  static time_t last_loud = 0;
112  if (last_loud < squid_curtime - 86400) {
113  debugs(71, DBG_IMPORTANT, "WARNING: Cache Digest cannot store " << cap << " entries. Limiting to " << absolute_max);
114  last_loud = squid_curtime;
115  } else {
116  debugs(71, 3, "WARNING: Cache Digest cannot store " << cap << " entries. Limiting to " << absolute_max);
117  }
118  cap = absolute_max;
119  }
120 
121  return cap;
122 }
123 #endif /* USE_CACHE_DIGESTS */
124 
125 void
127 {
128  Mgr::RegisterAction("store_digest", "Store Digest", storeDigestReport, 0, 1);
129 
130 #if USE_CACHE_DIGESTS
132  store_digest = NULL;
133  debugs(71, 3, "Local cache digest generation disabled");
134  return;
135  }
136 
137  const uint64_t cap = storeDigestCalcCap();
139  debugs(71, DBG_IMPORTANT, "Local cache digest enabled; rebuild/rewrite every " <<
140  (int) Config.digest.rebuild_period << "/" <<
141  (int) Config.digest.rewrite_period << " sec");
142 
143  sd_state = StoreDigestState();
144 #else
145  store_digest = NULL;
146  debugs(71, 3, "Local cache digest is 'off'");
147 #endif
148 }
149 
150 /* called when store_rebuild completes */
151 void
153 {
154 #if USE_CACHE_DIGESTS
155 
159  }
160 
161 #endif
162 }
163 
164 //TODO: this seems to be dead code. Is it needed?
165 void
167 {
168 #if USE_CACHE_DIGESTS
169 
171  return;
172  }
173 
174  assert(entry && store_digest);
175  debugs(71, 6, "storeDigestDel: checking entry, key: " << entry->getMD5Text());
176 
177  if (!EBIT_TEST(entry->flags, KEY_PRIVATE)) {
178  if (!store_digest->contains(static_cast<const cache_key *>(entry->key))) {
179  ++sd_stats.del_lost_count;
180  debugs(71, 6, "storeDigestDel: lost entry, key: " << entry->getMD5Text() << " url: " << entry->url() );
181  } else {
182  ++sd_stats.del_count;
183  store_digest->remove(static_cast<const cache_key *>(entry->key));
184  debugs(71, 6, "storeDigestDel: deled entry, key: " << entry->getMD5Text());
185  }
186  }
187 #endif //USE_CACHE_DIGESTS
188 }
189 
190 void
192 {
193 #if USE_CACHE_DIGESTS
194 
196  return;
197  }
198 
199  if (store_digest) {
200  static const SBuf label("store");
201  cacheDigestReport(store_digest, label, e);
202  storeAppendPrintf(e, "\t added: %d rejected: %d ( %.2f %%) del-ed: %d\n",
203  sd_stats.add_count,
204  sd_stats.rej_count,
205  xpercent(sd_stats.rej_count, sd_stats.rej_count + sd_stats.add_count),
206  sd_stats.del_count);
207  storeAppendPrintf(e, "\t collisions: on add: %.2f %% on rej: %.2f %%\n",
208  xpercent(sd_stats.add_coll_count, sd_stats.add_count),
209  xpercent(sd_stats.rej_coll_count, sd_stats.rej_count));
210  } else {
211  storeAppendPrintf(e, "store digest: disabled.\n");
212  }
213 
214 #endif //USE_CACHE_DIGESTS
215 }
216 
217 /*
218  * LOCAL FUNCTIONS
219  */
220 
221 #if USE_CACHE_DIGESTS
222 
223 /* should we digest this entry? used by storeDigestAdd() */
224 static int
226 {
227  /* add some stats! XXX */
228 
229  debugs(71, 6, "storeDigestAddable: checking entry, key: " << e->getMD5Text());
230 
231  /* check various entry flags (mimics StoreEntry::checkCachable XXX) */
232 
233  if (EBIT_TEST(e->flags, KEY_PRIVATE)) {
234  debugs(71, 6, "storeDigestAddable: NO: private key");
235  return 0;
236  }
237 
238  if (EBIT_TEST(e->flags, ENTRY_NEGCACHED)) {
239  debugs(71, 6, "storeDigestAddable: NO: negative cached");
240  return 0;
241  }
242 
243  if (EBIT_TEST(e->flags, RELEASE_REQUEST)) {
244  debugs(71, 6, "storeDigestAddable: NO: release requested");
245  return 0;
246  }
247 
249  debugs(71, 6, "storeDigestAddable: NO: wrong content-length");
250  return 0;
251  }
252 
253  /* do not digest huge objects */
254  if (e->swap_file_sz > (uint64_t )Config.Store.maxObjectSize) {
255  debugs(71, 6, "storeDigestAddable: NO: too big");
256  return 0;
257  }
258 
259  /* still here? check staleness */
260  /* Note: We should use the time of the next rebuild, not (cur_time+period) */
262  debugs(71, 6, "storeDigestAdd: entry expires within " << Config.digest.rebuild_period << " secs, ignoring");
263  return 0;
264  }
265 
266  /*
267  * idea: how about also skipping very fresh (thus, potentially
268  * unstable) entries? Should be configurable through
269  * cd_refresh_pattern, of course.
270  */
271  /*
272  * idea: skip objects that are going to be purged before the next
273  * update.
274  */
275  return 1;
276 }
277 
278 static void
280 {
281  assert(entry && store_digest);
282 
283  if (storeDigestAddable(entry)) {
284  ++sd_stats.add_count;
285 
286  if (store_digest->contains(static_cast<const cache_key *>(entry->key)))
287  ++sd_stats.add_coll_count;
288 
289  store_digest->add(static_cast<const cache_key *>(entry->key));
290 
291  debugs(71, 6, "storeDigestAdd: added entry, key: " << entry->getMD5Text());
292  } else {
293  ++sd_stats.rej_count;
294 
295  if (store_digest->contains(static_cast<const cache_key *>(entry->key)))
296  ++sd_stats.rej_coll_count;
297  }
298 }
299 
300 /* rebuilds digest from scratch */
301 static void
302 storeDigestRebuildStart(void *datanotused)
303 {
305  /* prevent overlapping if rebuild schedule is too tight */
306 
307  if (sd_state.rebuild_lock) {
308  debugs(71, DBG_IMPORTANT, "storeDigestRebuildStart: overlap detected, consider increasing rebuild period");
309  return;
310  }
311 
312  sd_state.rebuild_lock = 1;
313  debugs(71, 2, "storeDigestRebuildStart: rebuild #" << sd_state.rebuild_count + 1);
314 
315  if (sd_state.rewrite_lock) {
316  debugs(71, 2, "storeDigestRebuildStart: waiting for Rewrite to finish.");
317  return;
318  }
319 
321 }
322 
324 static bool
326 {
327  const uint64_t cap = storeDigestCalcCap();
329  uint64_t diff;
330  if (cap > store_digest->capacity)
331  diff = cap - store_digest->capacity;
332  else
333  diff = store_digest->capacity - cap;
334  debugs(71, 2, store_digest->capacity << " -> " << cap << "; change: " <<
335  diff << " (" << xpercentInt(diff, store_digest->capacity) << "%)" );
336  /* avoid minor adjustments */
337 
338  if (diff <= store_digest->capacity / 10) {
339  debugs(71, 2, "small change, will not resize.");
340  return false;
341  } else {
342  debugs(71, 2, "big change, resizing.");
344  }
345  return true;
346 }
347 
348 /* called be Rewrite to push Rebuild forward */
349 static void
351 {
352  assert(sd_state.rebuild_lock);
353  assert(!sd_state.rewrite_lock);
354  sd_state.theSearch = Store::Root().search();
355  /* resize or clear */
356 
357  if (!storeDigestResize())
358  store_digest->clear(); /* not clean()! */
359 
360  sd_stats = StoreDigestStats();
361 
362  eventAdd("storeDigestRebuildStep", storeDigestRebuildStep, NULL, 0.0, 1);
363 }
364 
365 /* finishes swap out sequence for the digest; schedules next rebuild */
366 static void
368 {
369  assert(sd_state.rebuild_lock);
370  sd_state.rebuild_lock = 0;
371  ++sd_state.rebuild_count;
372  debugs(71, 2, "storeDigestRebuildFinish: done.");
373  eventAdd("storeDigestRebuildStart", storeDigestRebuildStart, NULL, (double)
375  /* resume pending Rewrite if any */
376 
377  if (sd_state.rewrite_lock)
379 }
380 
381 /* recalculate a few hash buckets per invocation; schedules next step */
382 static void
383 storeDigestRebuildStep(void *datanotused)
384 {
385  /* TODO: call Store::Root().size() to determine this.. */
386  int count = Config.Store.objectsPerBucket * (int) ceil((double) store_hash_buckets *
387  (double) Config.digest.rebuild_chunk_percentage / 100.0);
388  assert(sd_state.rebuild_lock);
389 
390  debugs(71, 3, "storeDigestRebuildStep: buckets: " << store_hash_buckets << " entries to check: " << count);
391 
392  while (count-- && !sd_state.theSearch->isDone() && sd_state.theSearch->next())
393  storeDigestAdd(sd_state.theSearch->currentItem());
394 
395  /* are we done ? */
396  if (sd_state.theSearch->isDone())
398  else
399  eventAdd("storeDigestRebuildStep", storeDigestRebuildStep, NULL, 0.0, 1);
400 }
401 
402 /* starts swap out sequence for the digest */
403 static void
404 storeDigestRewriteStart(void *datanotused)
405 {
407  /* prevent overlapping if rewrite schedule is too tight */
408 
409  if (sd_state.rewrite_lock) {
410  debugs(71, DBG_IMPORTANT, "storeDigestRewrite: overlap detected, consider increasing rewrite period");
411  return;
412  }
413 
414  debugs(71, 2, "storeDigestRewrite: start rewrite #" << sd_state.rewrite_count + 1);
415 
416  const char *url = internalLocalUri("/squid-internal-periodic/", SBuf(StoreDigestFileName));
418  auto req = HttpRequest::FromUrl(url, mx);
419 
420  RequestFlags flags;
421  flags.cachable = true;
422 
423  StoreEntry *e = storeCreateEntry(url, url, flags, Http::METHOD_GET);
424  assert(e);
425  sd_state.rewrite_lock = e;
426  debugs(71, 3, "storeDigestRewrite: url: " << url << " key: " << e->getMD5Text());
427  e->mem_obj->request = req;
428 
429  /* wait for rebuild (if any) to finish */
430  if (sd_state.rebuild_lock) {
431  debugs(71, 2, "storeDigestRewriteStart: waiting for rebuild to finish.");
432  return;
433  }
434 
436 }
437 
438 static void
440 {
441  StoreEntry *e;
442 
443  assert(sd_state.rewrite_lock);
444  assert(!sd_state.rebuild_lock);
445  e = sd_state.rewrite_lock;
446  sd_state.rewrite_offset = 0;
448  /* setting public key will purge old digest entry if any */
449  e->setPublicKey();
450  /* fake reply */
451  HttpReply *rep = new HttpReply;
452  rep->setHeaders(Http::scOkay, "Cache Digest OK",
453  "application/cache-digest", (store_digest->mask_size + sizeof(sd_state.cblock)),
455  debugs(71, 3, "storeDigestRewrite: entry expires on " << rep->expires <<
456  " (" << std::showpos << (int) (rep->expires - squid_curtime) << ")");
457  e->buffer();
458  e->replaceHttpReply(rep);
460  e->flush();
461  eventAdd("storeDigestSwapOutStep", storeDigestSwapOutStep, sd_state.rewrite_lock, 0.0, 1, false);
462 }
463 
464 /* finishes swap out sequence for the digest; schedules next rewrite */
465 static void
467 {
468  assert(e == sd_state.rewrite_lock);
469  e->complete();
470  e->timestampsSet();
471  debugs(71, 2, "storeDigestRewriteFinish: digest expires at " << e->expires <<
472  " (" << std::showpos << (int) (e->expires - squid_curtime) << ")");
473  /* is this the write order? @?@ */
474  e->mem_obj->unlinkRequest();
475  e->unlock("storeDigestRewriteFinish");
476  sd_state.rewrite_lock = NULL;
477  ++sd_state.rewrite_count;
478  eventAdd("storeDigestRewriteStart", storeDigestRewriteStart, NULL, (double)
480  /* resume pending Rebuild if any */
481 
482  if (sd_state.rebuild_lock)
484 }
485 
486 /* swaps out one digest "chunk" per invocation; schedules next swap out */
487 static void
489 {
490  StoreEntry *e = static_cast<StoreEntry *>(data);
491  int chunk_size = Config.digest.swapout_chunk_size;
492  assert(e == sd_state.rewrite_lock);
493  assert(e);
494  /* _add_ check that nothing bad happened while we were waiting @?@ @?@ */
495 
496  if (static_cast<uint32_t>(sd_state.rewrite_offset + chunk_size) > store_digest->mask_size)
497  chunk_size = store_digest->mask_size - sd_state.rewrite_offset;
498 
499  e->append(store_digest->mask + sd_state.rewrite_offset, chunk_size);
500 
501  debugs(71, 3, "storeDigestSwapOutStep: size: " << store_digest->mask_size <<
502  " offset: " << sd_state.rewrite_offset << " chunk: " <<
503  chunk_size << " bytes");
504 
505  sd_state.rewrite_offset += chunk_size;
506 
507  /* are we done ? */
508  if (static_cast<uint32_t>(sd_state.rewrite_offset) >= store_digest->mask_size)
510  else
511  eventAdd("storeDigestSwapOutStep", storeDigestSwapOutStep, data, 0.0, 1, false);
512 }
513 
514 static void
516 {
517  memset(&sd_state.cblock, 0, sizeof(sd_state.cblock));
518  sd_state.cblock.ver.current = htons(CacheDigestVer.current);
519  sd_state.cblock.ver.required = htons(CacheDigestVer.required);
520  sd_state.cblock.capacity = htonl(store_digest->capacity);
521  sd_state.cblock.count = htonl(store_digest->count);
522  sd_state.cblock.del_count = htonl(store_digest->del_count);
523  sd_state.cblock.mask_size = htonl(store_digest->mask_size);
525  sd_state.cblock.hash_func_count = (unsigned char) CacheDigestHashFuncCount;
526  e->append((char *) &sd_state.cblock, sizeof(sd_state.cblock));
527 }
528 
529 #endif /* USE_CACHE_DIGESTS */
530 
const char * getMD5Text() const
Definition: store.cc:184
static void storeDigestRebuildResume(void)
int bits_per_entry
Definition: SquidConfig.h:484
int rebuild_lock
bucket number
Definition: store_digest.cc:48
virtual void next(void(callback)(void *cbdata), void *cbdata)=0
StoreSearch * search()
Definition: Controller.cc:215
#define assert(EX)
Definition: assert.h:17
uint64_t count
Definition: CacheDigest.h:55
void storeDigestReport(StoreEntry *e)
SQUIDCEXTERN double xpercent(double part, double whole)
Definition: util.c:54
static void storeDigestRewriteStart(void *)
int unlock(const char *context)
Definition: store.cc:457
static uint64_t storeDigestCalcCap()
calculates digest capacity
Definition: store_digest.cc:85
virtual StoreEntry * currentItem()=0
void unlinkRequest()
Definition: MemObject.h:56
virtual bool isDone() const =0
bool timestampsSet()
Definition: store.cc:1454
Definition: SBuf.h:86
virtual void append(char const *, int)
Appends a c-string to existing packed data.
Definition: store.cc:823
virtual void buffer()
Definition: store.cc:1635
Cache Digest fetching code.
static size_t inUseCount()
Definition: store.cc:176
virtual void flush()
Definition: store.cc:1646
struct SquidConfig::@110 Store
static void storeDigestAdd(const StoreEntry *)
static int storeDigestAddable(const StoreEntry *e)
Controller & Root()
safely access controller singleton
Definition: Controller.cc:877
int64_t maxObjectSize
Definition: SquidConfig.h:266
time_t expires
Definition: Store.h:202
void storeDigestNoteStoreReady(void)
StoreSearchPointer theSearch
Definition: store_digest.cc:50
int store_hash_buckets
time_t squid_curtime
Definition: stub_time.cc:17
void replaceHttpReply(HttpReply *, bool andStartWriting=true)
Definition: store.cc:1782
CacheDigest * store_digest
int digest_generation
Definition: SquidConfig.h:311
void complete()
Definition: store.cc:1058
virtual uint64_t maxSize() const override
Definition: Controller.cc:163
unsigned char bits_per_entry
Definition: PeerDigest.h:34
SQUIDCEXTERN int xpercentInt(double part, double whole)
Definition: util.c:60
static EVH storeDigestSwapOutStep
Definition: store_digest.cc:79
unsigned char hash_func_count
Definition: PeerDigest.h:35
int rebuild_chunk_percentage
Definition: SquidConfig.h:488
uint64_t swap_file_sz
Definition: Store.h:206
int64_t avgObjectSize
Definition: SquidConfig.h:265
void const char HLPCB void * data
Definition: stub_helper.cc:16
int CacheDigestHashFuncCount
static void storeDigestRewriteResume(void)
void EVH(void *)
Definition: event.h:19
Version const CacheDigestVer
Definition: peer_digest.cc:56
#define debugs(SECTION, LEVEL, CONTENT)
Definition: Debug.h:124
void setHeaders(Http::StatusCode status, const char *reason, const char *ctype, int64_t clen, time_t lmt, time_t expires)
Definition: HttpReply.cc:161
const char * url() const
Definition: store.cc:1600
StoreEntry * storeCreateEntry(const char *url, const char *logUrl, const RequestFlags &flags, const HttpRequestMethod &method)
Definition: store.cc:776
#define DBG_IMPORTANT
Definition: Debug.h:46
void RegisterAction(char const *action, char const *desc, OBJH *handler, int pw_req_flag, int atomic)
Definition: Registration.cc:16
void add(const cache_key *key)
Definition: CacheDigest.cc:107
StoreEntry * rewrite_lock
points to store entry with the digest
Definition: store_digest.cc:49
size_t swapout_chunk_size
Definition: SquidConfig.h:487
void remove(const cache_key *key)
Definition: CacheDigest.cc:151
bool setPublicKey(const KeyScope keyScope=ksDefault)
Definition: store.cc:587
static void storeDigestRebuildFinish(void)
uint32_t mask_size
Definition: CacheDigest.h:59
uint16_t flags
Definition: Store.h:208
bool contains(const cache_key *key) const
Definition: CacheDigest.cc:93
short int current
Definition: PeerDigest.h:20
MemObject * mem_obj
Definition: Store.h:197
static StoreDigestStats sd_stats
Definition: store_digest.cc:69
int objectsPerBucket
Definition: SquidConfig.h:264
struct SquidConfig::@120 digest
void updateCapacity(uint64_t newCapacity)
changes mask size to fit newCapacity, resets bits to 0
Definition: CacheDigest.cc:86
char * internalLocalUri(const char *dir, const SBuf &name)
Definition: internal.cc:133
static HttpRequest * FromUrl(const char *url, const MasterXaction::Pointer &, const HttpRequestMethod &method=Http::METHOD_GET)
Definition: HttpRequest.cc:523
struct SquidConfig::@112 onoff
static void storeDigestRebuildStart(void *datanotused)
Definition: enums.h:46
bool SIGHDLR int STUB void int
Definition: stub_tools.cc:68
static void storeDigestRebuildStep(void *datanotused)
void eventAdd(const char *name, EVH *func, void *arg, double when, int weight, bool cbdata)
Definition: event.cc:109
#define EBIT_SET(flag, bit)
Definition: defines.h:105
store_status_t store_status
Definition: Store.h:220
prohibits making the key public
Definition: enums.h:90
static StoreDigestState sd_state
Definition: store_digest.cc:68
time_t rewrite_period
Definition: SquidConfig.h:486
time_t rebuild_period
Definition: SquidConfig.h:485
short int required
Definition: PeerDigest.h:21
void storeDigestInit(void)
uint64_t del_count
Definition: CacheDigest.h:56
int refreshCheckDigest(const StoreEntry *entry, time_t delta)
Definition: refresh.cc:624
static void storeDigestCBlockSwapOut(StoreEntry *e)
static void storeDigestRewriteFinish(StoreEntry *e)
void clear()
reset the digest mask and counters
Definition: CacheDigest.cc:79
#define INT_MAX
Definition: types.h:76
time_t expires
Definition: HttpReply.h:48
StoreDigestCBlock cblock
Definition: store_digest.cc:47
uint64_t capacity
Definition: CacheDigest.h:57
void cacheDigestReport(CacheDigest *cd, const SBuf &label, StoreEntry *e)
Definition: CacheDigest.cc:256
void storeAppendPrintf(StoreEntry *e, const char *fmt,...)
Definition: store.cc:875
HttpRequestPointer request
Definition: MemObject.h:155
#define EBIT_TEST(flag, bit)
Definition: defines.h:107
char * mask
Definition: CacheDigest.h:58
virtual uint64_t currentSize() const override
current size
Definition: Controller.cc:177
class SquidConfig Config
Definition: SquidConfig.cc:12
#define NULL
Definition: types.h:166
static bool storeDigestResize()
const char * StoreDigestFileName
void storeDigestDel(const StoreEntry *entry)

 

Introduction

Documentation

Support

Miscellaneous

Web Site Translations

Mirrors