开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
store_rebuild.c
资源名称：squid-2.2.devel3-src.tar.gz　[点击查看]
上传用户：liugui
上传日期：2007-01-04
资源大小：822k
文件大小：23k
源码类别：

代理服务器

开发平台：

Unix_Linux

store_rebuild.c：源码内容
  2. /*
  3.  * $Id: store_rebuild.c,v 1.56 1999/01/24 02:26:25 wessels Exp $
  4.  *
  5.  * DEBUG: section 20    Store Rebuild Routines
  6.  * AUTHOR: Duane Wessels
  7.  *
  8.  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
  9.  * ----------------------------------------------------------
  10.  *
  11.  *  Squid is the result of efforts by numerous individuals from the
  12.  *  Internet community.  Development is led by Duane Wessels of the
  13.  *  National Laboratory for Applied Network Research and funded by the
  14.  *  National Science Foundation.  Squid is Copyrighted (C) 1998 by
  15.  *  Duane Wessels and the University of California San Diego.  Please
  16.  *  see the COPYRIGHT file for full details.  Squid incorporates
  17.  *  software developed and/or copyrighted by other sources.  Please see
  18.  *  the CREDITS file for full details.
  19.  *
  20.  *  This program is free software; you can redistribute it and/or modify
  21.  *  it under the terms of the GNU General Public License as published by
  22.  *  the Free Software Foundation; either version 2 of the License, or
  23.  *  (at your option) any later version.
  24.  *  
  25.  *  This program is distributed in the hope that it will be useful,
  26.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28.  *  GNU General Public License for more details.
  29.  *  
  30.  *  You should have received a copy of the GNU General Public License
  31.  *  along with this program; if not, write to the Free Software
  32.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  33.  *
  34.  */
  36. #include "squid.h"
  38. #define STORE_META_BUFSZ 4096
  41. typedef struct _rebuild_dir rebuild_dir;
  42. typedef int RBHD(rebuild_dir * d);
  44. struct _rebuild_dir {
  45.     int dirn;
  46.     int n_read;
  47.     FILE *log;
  48.     int speed;
  49.     int clean;
  50.     int curlvl1;
  51.     int curlvl2;
  52.     int flag;
  53.     int done;
  54.     int in_dir;
  55.     int fn;
  56.     struct dirent *entry;
  57.     DIR *td;
  58.     RBHD *rebuild_func;
  59.     rebuild_dir *next;
  60.     char fullpath[SQUID_MAXPATHLEN];
  61.     char fullfilename[SQUID_MAXPATHLEN];
  62. };
  64. struct storeRebuildState {
  65.     rebuild_dir *rebuild_dir;
  66.     int objcount; /* # objects successfully reloaded */
  67.     int expcount; /* # objects expired */
  68.     int linecount; /* # lines parsed from cache logfile */
  69.     int statcount; /* # entries from directory walking */
  70.     int clashcount; /* # swapfile clashes avoided */
  71.     int dupcount; /* # duplicates purged */
  72.     int cancelcount; /* # SWAP_LOG_DEL objects purged */
  73.     int invalid; /* # bad lines */
  74.     int badflags; /* # bad e->flags */
  75.     int need_to_validate;
  76.     int bad_log_op;
  77.     int zero_object_sz;
  78.     time_t start;
  79.     time_t stop;
  80. } RebuildState;
  82. typedef struct valid_ctrl_t {
  83.     struct stat *sb;
  84.     StoreEntry *e;
  85.     STVLDCB *callback;
  86.     void *callback_data;
  87. } valid_ctrl_t;
  89. static RBHD storeRebuildFromDirectory;
  90. static RBHD storeRebuildFromSwapLog;
  91. static void storeRebuildComplete(void);
  92. static EVH storeRebuildADirectory;
  93. static int storeGetNextFile(rebuild_dir *, int *sfileno, int *size);
  94. static StoreEntry *storeAddDiskRestore(const cache_key * key,
  95.     int file_number,
  96.     size_t swap_file_sz,
  97.     time_t expires,
  98.     time_t timestamp,
  99.     time_t lastref,
  100.     time_t lastmod,
  101.     u_num32 refcount,
  102.     u_short flags,
  103.     int clean);
  104. static AIOCB storeValidateComplete;
  106. static int
  107. storeRebuildFromDirectory(rebuild_dir * d)
  108. {
  109.     LOCAL_ARRAY(char, hdr_buf, DISK_PAGE_SIZE);
  110.     StoreEntry *e = NULL;
  111.     StoreEntry tmpe;
  112.     cache_key key[MD5_DIGEST_CHARS];
  113.     int sfileno = 0;
  114.     int count;
  115.     int size;
  116.     struct stat sb;
  117.     int swap_hdr_len;
  118.     int fd = -1;
  119.     tlv *tlv_list;
  120.     tlv *t;
  121.     assert(d != NULL);
  122.     debug(20, 3) ("storeRebuildFromDirectory: DIR #%dn", d->dirn);
  123.     for (count = 0; count < d->speed; count++) {
  124. assert(fd == -1);
  125. fd = storeGetNextFile(d, &sfileno, &size);
  126. if (fd == -2) {
  127.     debug(20, 1) ("storeRebuildFromDirectory: DIR #%d done!n", d->dirn);
  128.     storeDirCloseTmpSwapLog(d->dirn);
  129.     store_rebuilding = 0;
  130.     return -1;
  131. } else if (fd < 0) {
  132.     continue;
  133. }
  134. assert(fd > -1);
  135. /* lets get file stats here */
  136. if (fstat(fd, &sb) < 0) {
  137.     debug(20, 1) ("storeRebuildFromDirectory: fstat(FD %d): %sn",
  138. fd, xstrerror());
  139.     file_close(fd);
  140.     store_open_disk_fd--;
  141.     fd = -1;
  142.     continue;
  143. }
  144. if ((++RebuildState.statcount & 0xFFFF) == 0)
  145.     debug(20, 1) ("  %7d files opened so far.n",
  146. RebuildState.statcount);
  147. debug(20, 9) ("file_in: fd=%d %08Xn", fd, sfileno);
  148. Counter.syscalls.disk.reads++;
  149. if (read(fd, hdr_buf, DISK_PAGE_SIZE) < 0) {
  150.     debug(20, 1) ("storeRebuildFromDirectory: read(FD %d): %sn",
  151. fd, xstrerror());
  152.     file_close(fd);
  153.     store_open_disk_fd--;
  154.     fd = -1;
  155.     continue;
  156. }
  157. file_close(fd);
  158. store_open_disk_fd--;
  159. fd = -1;
  160. swap_hdr_len = 0;
  161. #if USE_TRUNCATE_NOT_UNLINK
  162. if (sb.st_size == 0)
  163.     continue;
  164. #endif
  165. tlv_list = storeSwapMetaUnpack(hdr_buf, &swap_hdr_len);
  166. if (tlv_list == NULL) {
  167.     debug(20, 1) ("storeRebuildFromDirectory: failed to get meta datan");
  168.     storeUnlinkFileno(sfileno);
  169.     continue;
  170. }
  171. debug(20, 3) ("storeRebuildFromDirectory: successful swap meta unpackingn");
  172. memset(key, '', MD5_DIGEST_CHARS);
  173. memset(&tmpe, '', sizeof(StoreEntry));
  174. for (t = tlv_list; t; t = t->next) {
  175.     switch (t->type) {
  176.     case STORE_META_KEY:
  177. assert(t->length == MD5_DIGEST_CHARS);
  178. xmemcpy(key, t->value, MD5_DIGEST_CHARS);
  179. break;
  180.     case STORE_META_STD:
  181. assert(t->length == STORE_HDR_METASIZE);
  182. xmemcpy(&tmpe.timestamp, t->value, STORE_HDR_METASIZE);
  183. break;
  184.     default:
  185. break;
  186.     }
  187. }
  188. storeSwapTLVFree(tlv_list);
  189. tlv_list = NULL;
  190. if (storeKeyNull(key)) {
  191.     debug(20, 1) ("storeRebuildFromDirectory: NULL keyn");
  192.     storeUnlinkFileno(sfileno);
  193.     continue;
  194. }
  195. tmpe.key = key;
  196. /* check sizes */
  197. if (tmpe.swap_file_sz == 0) {
  198.     tmpe.swap_file_sz = sb.st_size;
  199. } else if (tmpe.swap_file_sz == sb.st_size - swap_hdr_len) {
  200.     tmpe.swap_file_sz = sb.st_size;
  201. } else if (tmpe.swap_file_sz != sb.st_size) {
  202.     debug(20, 1) ("storeRebuildFromDirectory: SIZE MISMATCH %d!=%dn",
  203. tmpe.swap_file_sz, (int) sb.st_size);
  204.     storeUnlinkFileno(sfileno);
  205.     continue;
  206. }
  207. if (EBIT_TEST(tmpe.flags, KEY_PRIVATE)) {
  208.     storeUnlinkFileno(sfileno);
  209.     RebuildState.badflags++;
  210.     continue;
  211. }
  212. e = storeGet(key);
  213. if (e && e->lastref >= tmpe.lastref) {
  214.     /* key already exists, current entry is newer */
  215.     /* keep old, ignore new */
  216.     RebuildState.dupcount++;
  217.     continue;
  218. } else if (NULL != e) {
  219.     /* URL already exists, this swapfile not being used */
  220.     /* junk old, load new */
  221.     storeRelease(e); /* release old entry */
  222.     RebuildState.dupcount++;
  223. }
  224. RebuildState.objcount++;
  225. storeEntryDump(&tmpe, 5);
  226. e = storeAddDiskRestore(key,
  227.     sfileno,
  228.     tmpe.swap_file_sz,
  229.     tmpe.expires,
  230.     tmpe.timestamp,
  231.     tmpe.lastref,
  232.     tmpe.lastmod,
  233.     tmpe.refcount, /* refcount */
  234.     tmpe.flags, /* flags */
  235.     d->clean);
  236.     }
  237.     return count;
  238. }
  240. static int
  241. storeRebuildFromSwapLog(rebuild_dir * d)
  242. {
  243.     StoreEntry *e = NULL;
  244.     storeSwapLogData s;
  245.     size_t ss = sizeof(storeSwapLogData);
  246.     int count;
  247.     int used; /* is swapfile already in use? */
  248.     int disk_entry_newer; /* is the log entry newer than current entry? */
  249.     double x;
  250.     assert(d != NULL);
  251.     /* load a number of objects per invocation */
  252.     for (count = 0; count < d->speed; count++) {
  253. if (fread(&s, ss, 1, d->log) != 1) {
  254.     debug(20, 1) ("Done reading Cache Dir #%d swaplog (%d entries)n",
  255. d->dirn, d->n_read);
  256.     fclose(d->log);
  257.     d->log = NULL;
  258.     storeDirCloseTmpSwapLog(d->dirn);
  259.     return -1;
  260. }
  261. d->n_read++;
  262. if (s.op <= SWAP_LOG_NOP)
  263.     continue;
  264. if (s.op >= SWAP_LOG_MAX)
  265.     continue;
  266. s.swap_file_number = storeDirProperFileno(d->dirn, s.swap_file_number);
  267. debug(20, 3) ("storeRebuildFromSwapLog: %s %s %08Xn",
  268.     swap_log_op_str[(int) s.op],
  269.     storeKeyText(s.key),
  270.     s.swap_file_number);
  271. if (s.op == SWAP_LOG_ADD) {
  272.     (void) 0;
  273. } else if (s.op == SWAP_LOG_DEL) {
  274.     if ((e = storeGet(s.key)) != NULL) {
  275. /*
  276.  * Make sure we don't unlink the file, it might be
  277.  * in use by a subsequent entry.  Also note that
  278.  * we don't have to subtract from store_swap_size
  279.  * because adding to store_swap_size happens in
  280.  * the cleanup procedure.
  281.  */
  282. storeExpireNow(e);
  283. storeReleaseRequest(e);
  284. if (e->swap_file_number > -1) {
  285.     storeDirMapBitReset(e->swap_file_number);
  286.     e->swap_file_number = -1;
  287. }
  288. RebuildState.objcount--;
  289. RebuildState.cancelcount++;
  290.     }
  291.     continue;
  292. } else {
  293.     x = log(++RebuildState.bad_log_op) / log(10.0);
  294.     if (0.0 == x - (double) (int) x)
  295. debug(20, 1) ("WARNING: %d invalid swap log entries foundn",
  296.     RebuildState.bad_log_op);
  297.     RebuildState.invalid++;
  298.     continue;
  299. }
  300. if ((++RebuildState.linecount & 0xFFFF) == 0)
  301.     debug(20, 1) ("  %7d Entries read so far.n",
  302. RebuildState.linecount);
  303. if (!storeDirValidFileno(s.swap_file_number)) {
  304.     RebuildState.invalid++;
  305.     continue;
  306. }
  307. if (EBIT_TEST(s.flags, KEY_PRIVATE)) {
  308.     RebuildState.badflags++;
  309.     continue;
  310. }
  311. e = storeGet(s.key);
  312. used = storeDirMapBitTest(s.swap_file_number);
  313. /* If this URL already exists in the cache, does the swap log
  314.  * appear to have a newer entry?  Compare 'lastref' from the
  315.  * swap log to e->lastref. */
  316. disk_entry_newer = e ? (s.lastref > e->lastref ? 1 : 0) : 0;
  317. if (used && !disk_entry_newer) {
  318.     /* log entry is old, ignore it */
  319.     RebuildState.clashcount++;
  320.     continue;
  321. } else if (used && e && e->swap_file_number == s.swap_file_number) {
  322.     /* swapfile taken, same URL, newer, update meta */
  323.     if (e->store_status == STORE_OK) {
  324. e->lastref = s.timestamp;
  325. e->timestamp = s.timestamp;
  326. e->expires = s.expires;
  327. e->lastmod = s.lastmod;
  328. e->flags = s.flags;
  329. e->refcount += s.refcount;
  330.     } else {
  331. debug_trap("storeRebuildFromSwapLog: bad condition");
  332. debug(20, 1) ("tSee %s:%dn", __FILE__, __LINE__);
  333.     }
  334.     continue;
  335. } else if (used) {
  336.     /* swapfile in use, not by this URL, log entry is newer */
  337.     /* This is sorta bad: the log entry should NOT be newer at this
  338.      * point.  If the log is dirty, the filesize check should have
  339.      * caught this.  If the log is clean, there should never be a
  340.      * newer entry. */
  341.     debug(20, 1) ("WARNING: newer swaplog entry for fileno %08Xn",
  342. s.swap_file_number);
  343.     /* I'm tempted to remove the swapfile here just to be safe,
  344.      * but there is a bad race condition in the NOVM version if
  345.      * the swapfile has recently been opened for writing, but
  346.      * not yet opened for reading.  Because we can't map
  347.      * swapfiles back to StoreEntrys, we don't know the state
  348.      * of the entry using that file.  */
  349.     /* We'll assume the existing entry is valid, probably because
  350.      * were in a slow rebuild and the the swap file number got taken
  351.      * and the validation procedure hasn't run. */
  352.     assert(RebuildState.need_to_validate);
  353.     RebuildState.clashcount++;
  354.     continue;
  355. } else if (e && !disk_entry_newer) {
  356.     /* key already exists, current entry is newer */
  357.     /* keep old, ignore new */
  358.     RebuildState.dupcount++;
  359.     continue;
  360. } else if (e) {
  361.     /* key already exists, this swapfile not being used */
  362.     /* junk old, load new */
  363.     storeExpireNow(e);
  364.     storeReleaseRequest(e);
  365.     if (e->swap_file_number > -1) {
  366. storeDirMapBitReset(e->swap_file_number);
  367. e->swap_file_number = -1;
  368.     }
  369.     RebuildState.dupcount++;
  370. } else {
  371.     /* URL doesnt exist, swapfile not in use */
  372.     /* load new */
  373.     (void) 0;
  374. }
  375. /* update store_swap_size */
  376. RebuildState.objcount++;
  377. e = storeAddDiskRestore(s.key,
  378.     s.swap_file_number,
  379.     s.swap_file_sz,
  380.     s.expires,
  381.     s.timestamp,
  382.     s.lastref,
  383.     s.lastmod,
  384.     s.refcount,
  385.     s.flags,
  386.     d->clean);
  387. storeDirSwapLog(e, SWAP_LOG_ADD);
  388.     }
  389.     return count;
  390. }
  392. static void
  393. storeRebuildADirectory(void *unused)
  394. {
  395.     int count;
  396.     rebuild_dir *d;
  397.     rebuild_dir **D;
  398.     if ((d = RebuildState.rebuild_dir) == NULL) {
  399. storeRebuildComplete();
  400. return;
  401.     }
  402.     count = d->rebuild_func(d);
  403.     RebuildState.rebuild_dir = d->next;
  404.     if (count < 0) {
  405. xfree(d);
  406.     } else {
  407. for (D = &RebuildState.rebuild_dir; *D; D = &(*D)->next);
  408. *D = d;
  409. d->next = NULL;
  410.     }
  411.     if (opt_foreground_rebuild)
  412. storeRebuildADirectory(NULL);
  413.     else
  414. eventAdd("storeRebuild", storeRebuildADirectory, NULL, 0.0, 1);
  415. }
  417. #if TEMP_UNUSED_CODE
  418. static void
  419. storeConvertFile(const cache_key * key,
  420.     int file_number,
  421.     size_t swap_file_sz,
  422.     time_t expires,
  423.     time_t timestamp,
  424.     time_t lastref,
  425.     time_t lastmod,
  426.     u_short refcount,
  427.     u_short flags,
  428.     int clean)
  429. {
  430.     int fd_r, fd_w;
  431.     int hdr_len, x, y;
  432.     LOCAL_ARRAY(char, swapfilename, SQUID_MAXPATHLEN);
  433.     LOCAL_ARRAY(char, copybuf, DISK_PAGE_SIZE);
  434.     char *buf;
  435.     tlv *tlv_list;
  436.     StoreEntry e;
  437.     e.key = key;
  438.     e.swap_file_sz = swap_file_sz;
  439.     e.expires = expires;
  440.     e.lastref = lastref;
  441.     e.refcount = refcount;
  442.     e.flag = flags;
  443.     storeSwapFullPath(file_number, swapfilename);
  444.     fd_r = file_open(swapfilename, O_RDONLY, NULL, NULL, NULL);
  445.     if (fd_r < 0)
  446. return;
  447.     safeunlink(swapfilename, 1);
  448.     fd_w = file_open(swapfilename, O_CREAT | O_WRONLY | O_TRUNC, NULL, NULL, NULL);
  449.     tlv_list = storeSwapMetaBuild(&e);
  450.     buf = storeSwapMetaPack(tlv_list, &hdr_len);
  451.     x = write(fd_w, buf, hdr_len);
  452.     while (x > 0) {
  453. y = read(fd_r, copybuf, DISK_PAGE_SIZE);
  454. x = write(fd_w, copybuf, y);
  455.     }
  456.     file_close(fd_r);
  457.     file_close(fd_w);
  458.     xfree(buf);
  459.     storeSwapTLVFree(tlv_list);
  460. }
  461. #endif
  463. static int
  464. storeGetNextFile(rebuild_dir * d, int *sfileno, int *size)
  465. {
  466.     int fd = -1;
  467.     int used = 0;
  468.     debug(20, 3) ("storeGetNextFile: flag=%d, %d: /%02X/%02Xn",
  469. d->flag,
  470. d->dirn,
  471. d->curlvl1,
  472. d->curlvl2);
  473.     if (d->done)
  474. return -2;
  475.     while (fd < 0 && d->done == 0) {
  476. fd = -1;
  477. if (0 == d->flag) { /* initialize, open first file */
  478.     d->done = 0;
  479.     d->curlvl1 = 0;
  480.     d->curlvl2 = 0;
  481.     d->in_dir = 0;
  482.     d->flag = 1;
  483.     assert(Config.cacheSwap.n_configured > 0);
  484. }
  485. if (0 == d->in_dir) { /* we need to read in a new directory */
  486.     snprintf(d->fullpath, SQUID_MAXPATHLEN, "%s/%02X/%02X",
  487. Config.cacheSwap.swapDirs[d->dirn].path,
  488. d->curlvl1, d->curlvl2);
  489.     if (d->flag && d->td != NULL)
  490. closedir(d->td);
  491.     d->td = opendir(d->fullpath);
  492.     if (d->td == NULL) {
  493. debug(50, 1) ("storeGetNextFile: opendir: %s: %sn",
  494.     d->fullpath, xstrerror());
  495. break;
  496.     }
  497.     d->entry = readdir(d->td); /* skip . and .. */
  498.     d->entry = readdir(d->td);
  499.     if (d->entry == NULL && errno == ENOENT)
  500. debug(20, 1) ("storeGetNextFile: directory does not exist!.n");
  501.     debug(20, 3) ("storeGetNextFile: Directory %sn", d->fullpath);
  502. }
  503. if (d->td != NULL && (d->entry = readdir(d->td)) != NULL) {
  504.     d->in_dir++;
  505.     if (sscanf(d->entry->d_name, "%x", &d->fn) != 1) {
  506. debug(20, 3) ("storeGetNextFile: invalid %sn",
  507.     d->entry->d_name);
  508. continue;
  509.     }
  510.     if (!storeFilenoBelongsHere(d->fn, d->dirn, d->curlvl1, d->curlvl2)) {
  511. debug(20, 3) ("storeGetNextFile: %08X does not belong in %d/%d/%dn",
  512.     d->fn, d->dirn, d->curlvl1, d->curlvl2);
  513. continue;
  514.     }
  515.     d->fn = storeDirProperFileno(d->dirn, d->fn);
  516.     used = storeDirMapBitTest(d->fn);
  517.     if (used) {
  518. debug(20, 3) ("storeGetNextFile: Locked, continuing with next.n");
  519. continue;
  520.     }
  521.     snprintf(d->fullfilename, SQUID_MAXPATHLEN, "%s/%s",
  522. d->fullpath, d->entry->d_name);
  523.     debug(20, 3) ("storeGetNextFile: Opening %sn", d->fullfilename);
  524.     fd = file_open(d->fullfilename, O_RDONLY, NULL, NULL, NULL);
  525.     if (fd < 0)
  526. debug(50, 1) ("storeGetNextFile: %s: %sn", d->fullfilename, xstrerror());
  527.     continue;
  528.     store_open_disk_fd++;
  529. }
  530. d->in_dir = 0;
  531. if (++d->curlvl2 < Config.cacheSwap.swapDirs[d->dirn].l2)
  532.     continue;
  533. d->curlvl2 = 0;
  534. if (++d->curlvl1 < Config.cacheSwap.swapDirs[d->dirn].l1)
  535.     continue;
  536. d->curlvl1 = 0;
  537. d->done = 1;
  538.     }
  539.     *sfileno = d->fn;
  540.     return fd;
  541. }
  543. /* Add a new object to the cache with empty memory copy and pointer to disk
  544.  * use to rebuild store from disk. */
  545. static StoreEntry *
  546. storeAddDiskRestore(const cache_key * key,
  547.     int file_number,
  548.     size_t swap_file_sz,
  549.     time_t expires,
  550.     time_t timestamp,
  551.     time_t lastref,
  552.     time_t lastmod,
  553.     u_num32 refcount,
  554.     u_short flags,
  555.     int clean)
  556. {
  557.     StoreEntry *e = NULL;
  558.     debug(20, 5) ("StoreAddDiskRestore: %s, fileno=%08Xn", storeKeyText(key), file_number);
  559.     /* if you call this you'd better be sure file_number is not 
  560.      * already in use! */
  561.     e = new_StoreEntry(STORE_ENTRY_WITHOUT_MEMOBJ, NULL, NULL);
  562.     e->store_status = STORE_OK;
  563.     storeSetMemStatus(e, NOT_IN_MEMORY);
  564.     e->swap_status = SWAPOUT_DONE;
  565.     e->swap_file_number = file_number;
  566.     e->swap_file_sz = swap_file_sz;
  567.     e->lock_count = 0;
  568.     e->refcount = 0;
  569.     e->lastref = lastref;
  570.     e->timestamp = timestamp;
  571.     e->expires = expires;
  572.     e->lastmod = lastmod;
  573.     e->refcount = refcount;
  574.     e->flags = flags;
  575.     EBIT_SET(e->flags, ENTRY_CACHABLE);
  576.     EBIT_CLR(e->flags, RELEASE_REQUEST);
  577.     EBIT_CLR(e->flags, KEY_PRIVATE);
  578.     e->ping_status = PING_NONE;
  579.     EBIT_CLR(e->flags, ENTRY_VALIDATED);
  580.     storeDirMapBitSet(e->swap_file_number);
  581.     storeHashInsert(e, key); /* do it after we clear KEY_PRIVATE */
  582.     return e;
  583. }
  585. static void
  586. storeCleanup(void *datanotused)
  587. {
  588.     static int bucketnum = -1;
  589.     static int validnum = 0;
  590.     static int store_errors = 0;
  591.     StoreEntry *e;
  592.     hash_link *link_ptr = NULL;
  593.     hash_link *link_next = NULL;
  594.     if (++bucketnum >= store_hash_buckets) {
  595. debug(20, 1) ("  Completed Validation Proceduren");
  596. debug(20, 1) ("  Validated %d Entriesn", validnum);
  597. debug(20, 1) ("  store_swap_size = %dkn", store_swap_size);
  598. store_rebuilding = 0;
  599. if (opt_store_doublecheck)
  600.     assert(store_errors == 0);
  601. if (store_digest)
  602.     storeDigestNoteStoreReady();
  603. return;
  604.     }
  605.     link_next = hash_get_bucket(store_table, bucketnum);
  606.     while (NULL != (link_ptr = link_next)) {
  607. link_next = link_ptr->next;
  608. e = (StoreEntry *) link_ptr;
  609. if (EBIT_TEST(e->flags, ENTRY_VALIDATED))
  610.     continue;
  611. /*
  612.  * Calling storeRelease() has no effect because we're
  613.  * still in 'store_rebuilding' state
  614.  */
  615. if (e->swap_file_number < 0)
  616.     continue;
  617. if (opt_store_doublecheck) {
  618.     struct stat sb;
  619.     if (stat(storeSwapFullPath(e->swap_file_number, NULL), &sb) < 0) {
  620. store_errors++;
  621. debug(20, 0) ("storeCleanup: MISSING SWAP FILEn");
  622. debug(20, 0) ("storeCleanup: FILENO %08Xn", e->swap_file_number);
  623. debug(20, 0) ("storeCleanup: PATH %sn",
  624.     storeSwapFullPath(e->swap_file_number, NULL));
  625. storeEntryDump(e, 0);
  626. continue;
  627.     }
  628.     if (e->swap_file_sz != sb.st_size) {
  629. store_errors++;
  630. debug(20, 0) ("storeCleanup: SIZE MISMATCHn");
  631. debug(20, 0) ("storeCleanup: FILENO %08Xn", e->swap_file_number);
  632. debug(20, 0) ("storeCleanup: PATH %sn",
  633.     storeSwapFullPath(e->swap_file_number, NULL));
  634. debug(20, 0) ("storeCleanup: ENTRY SIZE: %d, FILE SIZE: %dn",
  635.     e->swap_file_sz, (int) sb.st_size);
  636. storeEntryDump(e, 0);
  637. continue;
  638.     }
  639. }
  640. EBIT_SET(e->flags, ENTRY_VALIDATED);
  641. /* Only set the file bit if we know its a valid entry */
  642. /* otherwise, set it in the validation procedure */
  643. storeDirUpdateSwapSize(e->swap_file_number, e->swap_file_sz, 1);
  644. if ((++validnum & 0xFFFF) == 0)
  645.     debug(20, 1) ("  %7d Entries Validated so far.n", validnum);
  646.     }
  647.     eventAdd("storeCleanup", storeCleanup, NULL, 0.0, 1);
  648. }
  650. void
  651. storeValidate(StoreEntry * e, STVLDCB * callback, void *callback_data, void *tag)
  652. {
  653.     valid_ctrl_t *ctrlp;
  654.     char *path;
  655.     struct stat *sb;
  656. #if !USE_ASYNC_IO
  657.     int x;
  658. #endif
  659.     assert(!EBIT_TEST(e->flags, ENTRY_VALIDATED));
  660.     if (e->swap_file_number < 0) {
  661. EBIT_CLR(e->flags, ENTRY_VALIDATED);
  662. callback(callback_data, 0, 0);
  663. return;
  664.     }
  665.     path = storeSwapFullPath(e->swap_file_number, NULL);
  666.     sb = xmalloc(sizeof(struct stat));
  667.     ctrlp = xmalloc(sizeof(valid_ctrl_t));
  668.     ctrlp->sb = sb;
  669.     ctrlp->e = e;
  670.     ctrlp->callback = callback;
  671.     ctrlp->callback_data = callback_data;
  672. #if USE_ASYNC_IO
  673.     aioStat(path, sb, storeValidateComplete, ctrlp, tag);
  674. #else
  675.     /*
  676.      * When evaluating the actual arguments in a function call, the order
  677.      * in which the arguments and the function expression are evaluated is
  678.      * not specified;
  679.      */
  680.     x = stat(path, sb);
  681.     storeValidateComplete(-1, ctrlp, x, errno);
  682. #endif
  683.     return;
  684. }
  686. static void
  687. storeValidateComplete(int fd, void *data, int retcode, int errcode)
  688. {
  689.     valid_ctrl_t *ctrlp = data;
  690.     struct stat *sb = ctrlp->sb;
  691.     StoreEntry *e = ctrlp->e;
  692.     char *path;
  694.     if (retcode == -2 && errcode == -2) {
  695. xfree(sb);
  696. xfree(ctrlp);
  697. ctrlp->callback(ctrlp->callback_data, retcode, errcode);
  698. return;
  699.     }
  700.     if (retcode < 0 && errcode == EWOULDBLOCK) {
  701. path = storeSwapFullPath(e->swap_file_number, NULL);
  702. retcode = stat(path, sb);
  703.     }
  704.     if (retcode < 0 || sb->st_size == 0 || sb->st_size != e->swap_file_sz) {
  705. EBIT_CLR(e->flags, ENTRY_VALIDATED);
  706.     } else {
  707. EBIT_SET(e->flags, ENTRY_VALIDATED);
  708. storeDirUpdateSwapSize(e->swap_file_number, e->swap_file_sz, 1);
  709.     }
  710.     errno = errcode;
  711.     ctrlp->callback(ctrlp->callback_data, retcode, errcode);
  712.     xfree(sb);
  713.     xfree(ctrlp);
  714. }
  716. /* meta data recreated from disk image in swap directory */
  717. static void
  718. storeRebuildComplete(void)
  719. {
  720.     time_t r;
  721.     time_t stop;
  722.     stop = squid_curtime;
  723.     r = stop - RebuildState.start;
  724.     debug(20, 1) ("Finished rebuilding storage disk.n");
  725.     debug(20, 1) ("  %7d Entries read from previous logfile.n",
  726. RebuildState.linecount);
  727.     debug(20, 1) ("  %7d Entries scanned from swap files.n",
  728. RebuildState.statcount);
  729.     debug(20, 1) ("  %7d Invalid entries.n", RebuildState.invalid);
  730.     debug(20, 1) ("  %7d With invalid flags.n", RebuildState.badflags);
  731.     debug(20, 1) ("  %7d Objects loaded.n", RebuildState.objcount);
  732.     debug(20, 1) ("  %7d Objects expired.n", RebuildState.expcount);
  733.     debug(20, 1) ("  %7d Objects cancelled.n", RebuildState.cancelcount);
  734.     debug(20, 1) ("  %7d Duplicate URLs purged.n", RebuildState.dupcount);
  735.     debug(20, 1) ("  %7d Swapfile clashes avoided.n", RebuildState.clashcount);
  736.     debug(20, 1) ("  Took %d seconds (%6.1f objects/sec).n",
  737. r > 0 ? (int) r : 0,
  738. (double) RebuildState.objcount / (r > 0 ? r : 1));
  739.     debug(20, 1) ("Beginning Validation Proceduren");
  740.     eventAdd("storeCleanup", storeCleanup, NULL, 0.0, 1);
  741. }
  743. void
  744. storeRebuildStart(void)
  745. {
  746.     rebuild_dir *d;
  747.     int clean = 0;
  748.     int zero = 0;
  749.     FILE *fp;
  750.     int i;
  751.     memset(&RebuildState, '', sizeof(RebuildState));
  752.     RebuildState.start = squid_curtime;
  753.     for (i = 0; i < Config.cacheSwap.n_configured; i++) {
  754. d = xcalloc(1, sizeof(rebuild_dir));
  755. d->dirn = i;
  756. d->speed = opt_foreground_rebuild ? 1 << 30 : 50;
  757. /*
  758.  * If the swap.state file exists in the cache_dir, then
  759.  * we'll use storeRebuildFromSwapLog(), otherwise we'll
  760.  * use storeRebuildFromDirectory() to open up each file
  761.  * and suck in the meta data.
  762.  */
  763. fp = storeDirOpenTmpSwapLog(i, &clean, &zero);
  764. if (fp == NULL || zero) {
  765.     if (fp != NULL)
  766. fclose(fp);
  767.     d->rebuild_func = storeRebuildFromDirectory;
  768. } else {
  769.     d->rebuild_func = storeRebuildFromSwapLog;
  770.     d->log = fp;
  771.     d->clean = clean;
  772. }
  773. d->next = RebuildState.rebuild_dir;
  774. RebuildState.rebuild_dir = d;
  775. if (!clean)
  776.     RebuildState.need_to_validate = 1;
  777. debug(20, 1) ("Rebuilding storage in Cache Dir #%d (%s)n",
  778.     i, clean ? "CLEAN" : "DIRTY");
  779.     }
  780.     eventAdd("storeRebuild", storeRebuildADirectory, NULL, 0.0, 1);
  781. }