2 * DEBUG: section 47 Store Directory Routines
3 * AUTHOR: Robert Collins
5 * SQUID Web Proxy Cache http://www.squid-cache.org/
6 * ----------------------------------------------------------
8 * Squid is the result of efforts by numerous individuals from
9 * the Internet community; see the CONTRIBUTORS file for full
10 * details. Many organizations have provided support for Squid's
11 * development; see the SPONSORS file for full details. Squid is
12 * Copyrighted (C) 2001 by the Regents of the University of
13 * California; see the COPYRIGHT file for full details. Squid
14 * incorporates software developed and/or copyrighted by other
15 * sources; see the CREDITS file for full details.
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation; either version 2 of the License, or
20 * (at your option) any later version.
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
36 #include "RebuildState.h"
37 #include "SquidConfig.h"
38 #include "SquidTime.h"
39 #include "store_key_md5.h"
40 #include "store_rebuild.h"
41 #include "StoreSwapLogData.h"
43 #include "UFSSwapLogParser.h"
51 CBDATA_NAMESPACED_CLASS_INIT(Fs::Ufs
,RebuildState
);
53 Fs::Ufs::RebuildState::RebuildState(RefCount
<UFSSwapDir
> aSwapDir
) :
54 sd (aSwapDir
), LogParser(NULL
), e(NULL
), fromLog(true), _done (false)
57 * If the swap.state file exists in the cache_dir, then
58 * we'll use commonUfsDirRebuildFromSwapLog(), otherwise we'll
59 * use commonUfsDirRebuildFromDirectory() to open up each file
60 * and suck in the meta data.
62 int clean
= 0; //TODO: change to bool
63 int zeroLengthLog
= 0;
64 FILE *fp
= sd
->openTmpSwapLog(&clean
, &zeroLengthLog
);
66 if (fp
&& !zeroLengthLog
)
67 LogParser
= Fs::Ufs::UFSSwapLogParser::GetUFSSwapLogParser(fp
);
69 if (LogParser
== NULL
) {
77 flags
.clean
= (clean
!= 0);
81 flags
.need_to_validate
= true;
83 debugs(47, DBG_IMPORTANT
, "Rebuilding storage in " << sd
->path
<< " (" <<
84 (clean
? "clean log" : (LogParser
? "dirty log" : "no log")) << ")");
87 Fs::Ufs::RebuildState::~RebuildState()
89 sd
->closeTmpSwapLog();
96 Fs::Ufs::RebuildState::RebuildStep(void *data
)
98 RebuildState
*rb
= (RebuildState
*)data
;
102 eventAdd("storeRebuild", RebuildStep
, rb
, 0.01, 1);
104 -- StoreController::store_dirs_rebuilding
;
105 storeRebuildComplete(&rb
->counts
);
110 /// load entries from swap.state or files until we run out of entries or time
112 Fs::Ufs::RebuildState::rebuildStep()
116 // Balance our desire to maximize the number of entries processed at once
117 // (and, hence, minimize overheads and total rebuild time) with a
118 // requirement to also process Coordinator events, disk I/Os, etc.
119 const int maxSpentMsec
= 50; // keep small: most RAM I/Os are under 1ms
120 const timeval loopStart
= current_time
;
122 const int totalEntries
= LogParser
? LogParser
->SwapLogEntries() : -1;
126 rebuildFromSwapLog();
128 rebuildFromDirectory();
130 // TODO: teach storeRebuildProgress to handle totalEntries <= 0
131 if (totalEntries
> 0 && (n_read
% 4000 == 0))
132 storeRebuildProgress(sd
->index
, totalEntries
, n_read
);
134 if (opt_foreground_rebuild
)
135 continue; // skip "few entries at a time" check below
138 const double elapsedMsec
= tvSubMsec(loopStart
, current_time
);
139 if (elapsedMsec
> maxSpentMsec
|| elapsedMsec
< 0) {
140 debugs(47, 5, HERE
<< "pausing after " << n_read
<< " entries in " <<
141 elapsedMsec
<< "ms; " << (elapsedMsec
/n_read
) << "ms per entry");
147 /// process one cache file
149 Fs::Ufs::RebuildState::rebuildFromDirectory()
151 cache_key key
[SQUID_MD5_DIGEST_LENGTH
];
155 assert(this != NULL
);
156 debugs(47, 3, HERE
<< "DIR #" << sd
->index
);
161 fd
= getNextFile(&filn
, &size
);
164 debugs(47, DBG_IMPORTANT
, "Done scanning " << sd
->path
<< " dir (" <<
165 n_read
<< " entries)");
173 /* lets get file stats here */
177 if (fstat(fd
, &sb
) < 0) {
178 debugs(47, DBG_IMPORTANT
, HERE
<< "fstat(FD " << fd
<< "): " << xstrerror());
180 --store_open_disk_fd
;
186 buf
.init(SM_PAGE_SIZE
, SM_PAGE_SIZE
);
187 if (!storeRebuildLoadEntry(fd
, sd
->index
, buf
, counts
))
190 const uint64_t expectedSize
= sb
.st_size
> 0 ?
191 static_cast<uint64_t>(sb
.st_size
) : 0;
194 const bool parsed
= storeRebuildParseEntry(buf
, tmpe
, key
, counts
,
198 --store_open_disk_fd
;
201 bool accepted
= parsed
&& tmpe
.swap_file_sz
> 0;
202 if (parsed
&& !accepted
) {
203 debugs(47, DBG_IMPORTANT
, "WARNING: Ignoring ufs cache entry with " <<
204 "unknown size: " << tmpe
);
209 // XXX: shouldn't this be a call to commonUfsUnlink?
210 sd
->unlinkFile(filn
); // should we unlink in all failure cases?
214 if (!storeRebuildKeepEntry(tmpe
, key
, counts
))
219 currentEntry(sd
->addDiskRestore(key
,
226 tmpe
.refcount
, /* refcount */
227 tmpe
.flags
, /* flags */
229 storeDirSwapLog(currentEntry(), SWAP_LOG_ADD
);
233 Fs::Ufs::RebuildState::currentEntry() const
239 Fs::Ufs::RebuildState::currentEntry(StoreEntry
*newValue
)
244 /// process one swap log entry
246 Fs::Ufs::RebuildState::rebuildFromSwapLog()
248 StoreSwapLogData swapData
;
250 if (LogParser
->ReadRecord(swapData
) != 1) {
251 debugs(47, DBG_IMPORTANT
, "Done reading " << sd
->path
<< " swaplog (" << n_read
<< " entries)");
261 if (!swapData
.sane()) {
267 * BC: during 2.4 development, we changed the way swap file
268 * numbers are assigned and stored. The high 16 bits used
269 * to encode the SD index number. There used to be a call
270 * to storeDirProperFileno here that re-assigned the index
271 * bits. Now, for backwards compatibility, we just need
274 swapData
.swap_filen
&= 0x00FFFFFF;
276 debugs(47, 3, HERE
<< swap_log_op_str
[(int) swapData
.op
] << " " <<
277 storeKeyText(swapData
.key
) << " "<< std::setfill('0') <<
278 std::hex
<< std::uppercase
<< std::setw(8) <<
279 swapData
.swap_filen
);
281 if (swapData
.op
== SWAP_LOG_ADD
) {
283 } else if (swapData
.op
== SWAP_LOG_DEL
) {
284 /* Delete unless we already have a newer copy anywhere in any store */
285 /* this needs to become
287 * 2) make synthetic request with headers ?? or otherwise search
288 * for a matching object in the store
289 * TODO FIXME change to new async api
291 currentEntry (Store::Root().get(swapData
.key
));
293 if (currentEntry() != NULL
&& swapData
.lastref
>= e
->lastref
) {
296 ++counts
.cancelcount
;
301 x
= ::log(static_cast<double>(++counts
.bad_log_op
)) / ::log(10.0);
303 if (0.0 == x
- (double) (int) x
)
304 debugs(47, DBG_IMPORTANT
, "WARNING: " << counts
.bad_log_op
<< " invalid swap log entries found");
311 ++counts
.scancount
; // XXX: should not this be incremented earlier?
313 if (!sd
->validFileno(swapData
.swap_filen
, 0)) {
318 if (EBIT_TEST(swapData
.flags
, KEY_PRIVATE
)) {
323 /* this needs to become
325 * 2) make synthetic request with headers ?? or otherwise search
326 * for a matching object in the store
327 * TODO FIXME change to new async api
329 currentEntry (Store::Root().get(swapData
.key
));
331 int used
; /* is swapfile already in use? */
333 used
= sd
->mapBitTest(swapData
.swap_filen
);
335 /* If this URL already exists in the cache, does the swap log
336 * appear to have a newer entry? Compare 'lastref' from the
337 * swap log to e->lastref. */
338 /* is the log entry newer than current entry? */
339 int disk_entry_newer
= currentEntry() ? (swapData
.lastref
> currentEntry()->lastref
? 1 : 0) : 0;
341 if (used
&& !disk_entry_newer
) {
342 /* log entry is old, ignore it */
345 } else if (used
&& currentEntry() && currentEntry()->swap_filen
== swapData
.swap_filen
&& currentEntry()->swap_dirn
== sd
->index
) {
346 /* swapfile taken, same URL, newer, update meta */
348 if (currentEntry()->store_status
== STORE_OK
) {
349 currentEntry()->lastref
= swapData
.timestamp
;
350 currentEntry()->timestamp
= swapData
.timestamp
;
351 currentEntry()->expires
= swapData
.expires
;
352 currentEntry()->lastmod
= swapData
.lastmod
;
353 currentEntry()->flags
= swapData
.flags
;
354 currentEntry()->refcount
+= swapData
.refcount
;
355 sd
->dereference(*currentEntry(), false);
357 debug_trap("commonUfsDirRebuildFromSwapLog: bad condition");
358 debugs(47, DBG_IMPORTANT
, HERE
<< "bad condition");
362 /* swapfile in use, not by this URL, log entry is newer */
363 /* This is sorta bad: the log entry should NOT be newer at this
364 * point. If the log is dirty, the filesize check should have
365 * caught this. If the log is clean, there should never be a
367 debugs(47, DBG_IMPORTANT
, "WARNING: newer swaplog entry for dirno " <<
368 sd
->index
<< ", fileno "<< std::setfill('0') << std::hex
<<
369 std::uppercase
<< std::setw(8) << swapData
.swap_filen
);
371 /* I'm tempted to remove the swapfile here just to be safe,
372 * but there is a bad race condition in the NOVM version if
373 * the swapfile has recently been opened for writing, but
374 * not yet opened for reading. Because we can't map
375 * swapfiles back to StoreEntrys, we don't know the state
376 * of the entry using that file. */
377 /* We'll assume the existing entry is valid, probably because
378 * were in a slow rebuild and the the swap file number got taken
379 * and the validation procedure hasn't run. */
380 assert(flags
.need_to_validate
);
383 } else if (currentEntry() && !disk_entry_newer
) {
384 /* key already exists, current entry is newer */
385 /* keep old, ignore new */
388 } else if (currentEntry()) {
389 /* key already exists, this swapfile not being used */
390 /* junk old, load new */
395 /* URL doesnt exist, swapfile not in use */
402 currentEntry(sd
->addDiskRestore(swapData
.key
,
404 swapData
.swap_file_sz
,
413 storeDirSwapLog(currentEntry(), SWAP_LOG_ADD
);
416 /// undo the effects of adding an entry in rebuildFromSwapLog()
418 Fs::Ufs::RebuildState::undoAdd()
420 StoreEntry
*added
= currentEntry();
424 // TODO: Why bother with these two if we are going to release?!
426 added
->releaseRequest();
428 if (added
->swap_filen
> -1) {
429 SwapDir
*someDir
= INDEXSD(added
->swap_dirn
);
431 if (UFSSwapDir
*ufsDir
= dynamic_cast<UFSSwapDir
*>(someDir
))
432 ufsDir
->undoAddDiskRestore(added
);
433 // else the entry was loaded from and/or is currently in a non-UFS dir
434 // Thus, there is no use in preserving its disk file (the only purpose
435 // of undoAddDiskRestore!), even if we could. Instead, we release the
436 // the entry and [eventually] unlink its disk file or free its slot.
443 Fs::Ufs::RebuildState::getNextFile(sfileno
* filn_p
, int *size
)
447 debugs(47, 3, HERE
<< "flag=" << flags
.init
<< ", " <<
448 sd
->index
<< ": /"<< std::setfill('0') << std::hex
<<
449 std::uppercase
<< std::setw(2) << curlvl1
<< "/" << std::setw(2) <<
455 while (fd
< 0 && done
== 0) {
458 if (!flags
.init
) { /* initialize, open first file */
464 assert(Config
.cacheSwap
.n_configured
> 0);
467 if (0 == in_dir
) { /* we need to read in a new directory */
468 snprintf(fullpath
, MAXPATHLEN
, "%s/%02X/%02X",
475 td
= opendir(fullpath
);
480 debugs(47, DBG_IMPORTANT
, HERE
<< "error in opendir (" << fullpath
<< "): " << xstrerror());
482 entry
= readdir(td
); /* skip . and .. */
485 if (entry
== NULL
&& errno
== ENOENT
)
486 debugs(47, DBG_IMPORTANT
, HERE
<< "WARNING: directory does not exist!");
487 debugs(47, 3, HERE
<< "Directory " << fullpath
);
491 if (td
!= NULL
&& (entry
= readdir(td
)) != NULL
) {
494 if (sscanf(entry
->d_name
, "%x", &fn
) != 1) {
495 debugs(47, 3, HERE
<< "invalid entry " << entry
->d_name
);
499 if (!UFSSwapDir::FilenoBelongsHere(fn
, sd
->index
, curlvl1
, curlvl2
)) {
500 debugs(47, 3, HERE
<< std::setfill('0') <<
501 std::hex
<< std::uppercase
<< std::setw(8) << fn
<<
502 " does not belong in " << std::dec
<< sd
->index
<< "/" <<
503 curlvl1
<< "/" << curlvl2
);
508 if (sd
->mapBitTest(fn
)) {
509 debugs(47, 3, HERE
<< "Locked, continuing with next.");
513 snprintf(fullfilename
, MAXPATHLEN
, "%s/%s",
514 fullpath
, entry
->d_name
);
515 debugs(47, 3, HERE
<< "Opening " << fullfilename
);
516 fd
= file_open(fullfilename
, O_RDONLY
| O_BINARY
);
519 debugs(47, DBG_IMPORTANT
, HERE
<< "error opening " << fullfilename
<< ": " << xstrerror());
521 ++store_open_disk_fd
;
533 if (sd
->validL2(++curlvl2
))
538 if (sd
->validL1(++curlvl1
))
551 Fs::Ufs::RebuildState::error() const
557 Fs::Ufs::RebuildState::isDone() const
563 Fs::Ufs::RebuildState::currentItem()
565 return currentEntry();