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

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

代理服务器

开发平台：

Unix_Linux

store.c：源码内容
  2. /*
  3.  * $Id: store.c,v 1.488 1999/02/02 18:14:23 wessels Exp $
  4.  *
  5.  * DEBUG: section 20    Storage Manager
  6.  * AUTHOR: Harvest Derived
  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 REBUILD_TIMESTAMP_DELTA_MAX 2
  40. #define STORE_IN_MEM_BUCKETS (229)
  42. const char *memStatusStr[] =
  43. {
  44.     "NOT_IN_MEMORY",
  45.     "IN_MEMORY"
  46. };
  48. const char *pingStatusStr[] =
  49. {
  50.     "PING_NONE",
  51.     "PING_WAITING",
  52.     "PING_TIMEOUT",
  53.     "PING_DONE"
  54. };
  56. const char *storeStatusStr[] =
  57. {
  58.     "STORE_OK",
  59.     "STORE_PENDING"
  60. };
  62. const char *swapStatusStr[] =
  63. {
  64.     "SWAPOUT_NONE",
  65.     "SWAPOUT_OPENING",
  66.     "SWAPOUT_WRITING",
  67.     "SWAPOUT_DONE"
  68. };
  70. typedef struct lock_ctrl_t {
  71.     SIH *callback;
  72.     void *callback_data;
  73.     StoreEntry *e;
  74. } lock_ctrl_t;
  76. /*
  77.  * local function prototypes
  78.  */
  79. static int storeCheckExpired(const StoreEntry *);
  80. static int storeEntryLocked(const StoreEntry *);
  81. static int storeEntryValidLength(const StoreEntry *);
  82. static void storeGetMemSpace(int);
  83. static void storeHashDelete(StoreEntry *);
  84. static MemObject *new_MemObject(const char *, const char *);
  85. static void destroy_MemObject(StoreEntry *);
  86. static FREE destroy_StoreEntry;
  87. static void storePurgeMem(StoreEntry *);
  88. static int getKeyCounter(void);
  89. static int storeKeepInMemory(const StoreEntry *);
  90. static OBJH storeCheckCachableStats;
  91. static EVH storeLateRelease;
  93. /*
  94.  * local variables
  95.  */
  96. static dlink_list inmem_list;
  97. static int store_pages_max = 0;
  98. static int store_swap_high = 0;
  99. static int store_swap_low = 0;
  100. static int store_swap_mid = 0;
  101. static int store_maintain_rate;
  102. static Stack LateReleaseStack;
  104. static MemObject *
  105. new_MemObject(const char *url, const char *log_url)
  106. {
  107.     MemObject *mem = memAllocate(MEM_MEMOBJECT);
  108.     mem->reply = httpReplyCreate();
  109.     mem->url = xstrdup(url);
  110.     mem->log_url = xstrdup(log_url);
  111.     mem->swapout.fd = -1;
  112.     mem->object_sz = -1;
  113.     mem->fd = -1;
  114.     /* XXX account log_url */
  115.     debug(20, 3) ("new_MemObject: returning %pn", mem);
  116.     return mem;
  117. }
  119. StoreEntry *
  120. new_StoreEntry(int mem_obj_flag, const char *url, const char *log_url)
  121. {
  122.     StoreEntry *e = NULL;
  123.     e = memAllocate(MEM_STOREENTRY);
  124.     if (mem_obj_flag)
  125. e->mem_obj = new_MemObject(url, log_url);
  126.     debug(20, 3) ("new_StoreEntry: returning %pn", e);
  127.     e->expires = e->lastmod = e->lastref = e->timestamp = -1;
  128.     return e;
  129. }
  131. static void
  132. destroy_MemObject(StoreEntry * e)
  133. {
  134.     MemObject *mem = e->mem_obj;
  135.     const Ctx ctx = ctx_enter(mem->url);
  136.     debug(20, 3) ("destroy_MemObject: destroying %pn", mem);
  137.     e->mem_obj = NULL;
  138.     if (!shutting_down)
  139. assert(mem->swapout.fd == -1);
  140.     stmemFree(&mem->data_hdr);
  141.     mem->inmem_hi = 0;
  142.     /* XXX account log_url */
  143. #if USE_ASYNC_IO
  144.     while (mem->clients != NULL)
  145. storeUnregister(e, mem->clients->callback_data);
  146. #endif
  147.     /*
  148.      * There is no way to abort FD-less clients, so they might
  149.      * still have mem->clients set if mem->fd == -1
  150.      */
  151.     assert(mem->fd == -1 || mem->clients == NULL);
  152.     httpReplyDestroy(mem->reply);
  153.     requestUnlink(mem->request);
  154.     mem->request = NULL;
  155.     ctx_exit(ctx); /* must exit before we free mem->url */
  156.     safe_free(mem->url);
  157.     safe_free(mem->log_url);
  158.     memFree(mem, MEM_MEMOBJECT);
  159. }
  161. static void
  162. destroy_StoreEntry(void *data)
  163. {
  164.     StoreEntry *e = data;
  165.     debug(20, 3) ("destroy_StoreEntry: destroying %pn", e);
  166.     assert(e != NULL);
  167.     if (e->mem_obj)
  168. destroy_MemObject(e);
  169.     storeHashDelete(e);
  170.     assert(e->key == NULL);
  171.     memFree(e, MEM_STOREENTRY);
  172. }
  174. /* ----- INTERFACE BETWEEN STORAGE MANAGER AND HASH TABLE FUNCTIONS --------- */
  176. void
  177. storeHashInsert(StoreEntry * e, const cache_key * key)
  178. {
  179.     debug(20, 3) ("storeHashInsert: Inserting Entry %p key '%s'n",
  180. e, storeKeyText(key));
  181.     e->key = storeKeyDup(key);
  182.     hash_join(store_table, (hash_link *) e);
  183.     dlinkAdd(e, &e->lru, &store_list);
  184. }
  186. static void
  187. storeHashDelete(StoreEntry * e)
  188. {
  189.     hash_remove_link(store_table, (hash_link *) e);
  190.     dlinkDelete(&e->lru, &store_list);
  191.     storeKeyFree(e->key);
  192.     e->key = NULL;
  193. }
  195. /* -------------------------------------------------------------------------- */
  198. /* get rid of memory copy of the object */
  199. /* Only call this if storeCheckPurgeMem(e) returns 1 */
  200. static void
  201. storePurgeMem(StoreEntry * e)
  202. {
  203.     if (e->mem_obj == NULL)
  204. return;
  205.     debug(20, 3) ("storePurgeMem: Freeing memory-copy of %sn",
  206. storeKeyText(e->key));
  207.     storeSetMemStatus(e, NOT_IN_MEMORY);
  208.     destroy_MemObject(e);
  209.     if (e->swap_status != SWAPOUT_DONE)
  210. storeRelease(e);
  211. }
  213. void
  214. storeLockObject(StoreEntry * e)
  215. {
  216.     if (e->lock_count++ == 0) {
  217. dlinkDelete(&e->lru, &store_list);
  218. dlinkAdd(e, &e->lru, &store_list);
  219.     }
  220.     debug(20, 3) ("storeLockObject: key '%s' count=%dn",
  221. storeKeyText(e->key), (int) e->lock_count);
  222.     e->lastref = squid_curtime;
  223. }
  225. void
  226. storeReleaseRequest(StoreEntry * e)
  227. {
  228.     if (EBIT_TEST(e->flags, RELEASE_REQUEST))
  229. return;
  230.     debug(20, 3) ("storeReleaseRequest: '%s'n", storeKeyText(e->key));
  231.     EBIT_SET(e->flags, RELEASE_REQUEST);
  232.     /*
  233.      * Clear cachable flag here because we might get called before
  234.      * anyone else even looks at the cachability flag.  Also, this
  235.      * prevents httpMakePublic from really setting a public key.
  236.      */
  237.     EBIT_CLR(e->flags, ENTRY_CACHABLE);
  238.     storeSetPrivateKey(e);
  239. }
  241. /* unlock object, return -1 if object get released after unlock
  242.  * otherwise lock_count */
  243. int
  244. storeUnlockObject(StoreEntry * e)
  245. {
  246.     e->lock_count--;
  247.     debug(20, 3) ("storeUnlockObject: key '%s' count=%dn",
  248. storeKeyText(e->key), e->lock_count);
  249.     if (e->lock_count)
  250. return (int) e->lock_count;
  251.     if (e->store_status == STORE_PENDING)
  252. EBIT_SET(e->flags, RELEASE_REQUEST);
  253.     assert(storePendingNClients(e) == 0);
  254.     if (EBIT_TEST(e->flags, RELEASE_REQUEST))
  255. storeRelease(e);
  256.     else if (storeKeepInMemory(e)) {
  257. storeSetMemStatus(e, IN_MEMORY);
  258. requestUnlink(e->mem_obj->request);
  259. e->mem_obj->request = NULL;
  260.     } else {
  261. storePurgeMem(e);
  262. if (EBIT_TEST(e->flags, KEY_PRIVATE)) {
  263.     dlinkDelete(&e->lru, &store_list);
  264.     dlinkAddTail(e, &e->lru, &store_list);
  265. }
  266.     }
  267.     return 0;
  268. }
  270. /* Lookup an object in the cache. 
  271.  * return just a reference to object, don't start swapping in yet. */
  272. StoreEntry *
  273. storeGet(const cache_key * key)
  274. {
  275.     debug(20, 3) ("storeGet: looking up %sn", storeKeyText(key));
  276.     return (StoreEntry *) hash_lookup(store_table, key);
  277. }
  279. StoreEntry *
  280. storeGetPublic(const char *uri, const method_t method)
  281. {
  282.     StoreEntry *e = storeGet(storeKeyPublic(uri, method));
  283.     if (e == NULL && squid_curtime < 922500000)
  284. e = storeGet(storeKeyPublicOld(uri, method));
  285.     return e;
  286. }
  288. static int
  289. getKeyCounter(void)
  290. {
  291.     static int key_counter = 0;
  292.     if (++key_counter < 0)
  293. key_counter = 1;
  294.     return key_counter;
  295. }
  297. void
  298. storeSetPrivateKey(StoreEntry * e)
  299. {
  300.     const cache_key *newkey;
  301.     MemObject *mem = e->mem_obj;
  302.     if (e->key && EBIT_TEST(e->flags, KEY_PRIVATE))
  303. return; /* is already private */
  304.     if (e->key) {
  305. if (e->swap_file_number > -1)
  306.     storeDirSwapLog(e, SWAP_LOG_DEL);
  307. storeHashDelete(e);
  308.     }
  309.     if (mem != NULL) {
  310. mem->id = getKeyCounter();
  311. newkey = storeKeyPrivate(mem->url, mem->method, mem->id);
  312.     } else {
  313. newkey = storeKeyPrivate("JUNK", METHOD_NONE, getKeyCounter());
  314.     }
  315.     assert(hash_lookup(store_table, newkey) == NULL);
  316.     EBIT_SET(e->flags, KEY_PRIVATE);
  317.     storeHashInsert(e, newkey);
  318. }
  320. void
  321. storeSetPublicKey(StoreEntry * e)
  322. {
  323.     StoreEntry *e2 = NULL;
  324.     const cache_key *newkey;
  325.     MemObject *mem = e->mem_obj;
  326.     if (e->key && !EBIT_TEST(e->flags, KEY_PRIVATE))
  327. return; /* is already public */
  328.     assert(mem);
  329.     /*
  330.      * We can't make RELEASE_REQUEST objects public.  Depending on
  331.      * when RELEASE_REQUEST gets set, we might not be swapping out
  332.      * the object.  If we're not swapping out, then subsequent
  333.      * store clients won't be able to access object data which has
  334.      * been freed from memory.
  335.      *
  336.      * If RELEASE_REQUEST is set, then ENTRY_CACHABLE should not
  337.      * be set, and storeSetPublicKey() should not be called.
  338.      */
  339.     assert(!EBIT_TEST(e->flags, RELEASE_REQUEST));
  340.     newkey = storeKeyPublic(mem->url, mem->method);
  341.     if ((e2 = (StoreEntry *) hash_lookup(store_table, newkey))) {
  342. debug(20, 3) ("storeSetPublicKey: Making old '%s' private.n", mem->url);
  343. storeSetPrivateKey(e2);
  344. storeRelease(e2);
  345. newkey = storeKeyPublic(mem->url, mem->method);
  346.     }
  347.     if (e->key)
  348. storeHashDelete(e);
  349.     EBIT_CLR(e->flags, KEY_PRIVATE);
  350.     storeHashInsert(e, newkey);
  351.     if (e->swap_file_number > -1)
  352. storeDirSwapLog(e, SWAP_LOG_ADD);
  353. }
  355. StoreEntry *
  356. storeCreateEntry(const char *url, const char *log_url, request_flags flags, method_t method)
  357. {
  358.     StoreEntry *e = NULL;
  359.     MemObject *mem = NULL;
  360.     debug(20, 3) ("storeCreateEntry: '%s'n", url);
  362.     e = new_StoreEntry(STORE_ENTRY_WITH_MEMOBJ, url, log_url);
  363.     e->lock_count = 1; /* Note lock here w/o calling storeLock() */
  364.     mem = e->mem_obj;
  365.     mem->method = method;
  366.     if (neighbors_do_private_keys || !flags.hierarchical)
  367. storeSetPrivateKey(e);
  368.     else
  369. storeSetPublicKey(e);
  370.     if (flags.cachable) {
  371. EBIT_SET(e->flags, ENTRY_CACHABLE);
  372. EBIT_CLR(e->flags, RELEASE_REQUEST);
  373.     } else {
  374. EBIT_CLR(e->flags, ENTRY_CACHABLE);
  375. storeReleaseRequest(e);
  376.     }
  377.     e->store_status = STORE_PENDING;
  378.     storeSetMemStatus(e, NOT_IN_MEMORY);
  379.     e->swap_status = SWAPOUT_NONE;
  380.     e->swap_file_number = -1;
  381.     e->refcount = 0;
  382.     e->lastref = squid_curtime;
  383.     e->timestamp = 0; /* set in storeTimestampsSet() */
  384.     e->ping_status = PING_NONE;
  385.     EBIT_SET(e->flags, ENTRY_VALIDATED);
  386.     return e;
  387. }
  389. /* Mark object as expired */
  390. void
  391. storeExpireNow(StoreEntry * e)
  392. {
  393.     debug(20, 3) ("storeExpireNow: '%s'n", storeKeyText(e->key));
  394.     e->expires = squid_curtime;
  395. }
  397. /* Append incoming data from a primary server to an entry. */
  398. void
  399. storeAppend(StoreEntry * e, const char *buf, int len)
  400. {
  401.     MemObject *mem = e->mem_obj;
  402.     assert(mem != NULL);
  403.     assert(len >= 0);
  404.     assert(e->store_status == STORE_PENDING);
  405.     if (len) {
  406. debug(20, 5) ("storeAppend: appending %d bytes for '%s'n",
  407.     len,
  408.     storeKeyText(e->key));
  409. storeGetMemSpace(len);
  410. stmemAppend(&mem->data_hdr, buf, len);
  411. mem->inmem_hi += len;
  412.     }
  413.     if (EBIT_TEST(e->flags, DELAY_SENDING))
  414. return;
  415. #ifdef OPTIMISTIC_IO
  416.     storeLockObject(e);
  417. #endif
  418.     InvokeHandlers(e);
  419.     storeCheckSwapOut(e);
  420. #ifdef OPTIMISTIC_IO
  421.     storeUnlockObject(e);
  422. #endif
  423. }
  425. void
  426. #if STDC_HEADERS
  427. storeAppendPrintf(StoreEntry * e, const char *fmt,...)
  428. #else
  429. storeAppendPrintf(va_alist)
  430.      va_dcl
  431. #endif
  432. {
  433. #if STDC_HEADERS
  434.     va_list args;
  435.     va_start(args, fmt);
  436. #else
  437.     va_list args;
  438.     StoreEntry *e = NULL;
  439.     const char *fmt = NULL;
  440.     va_start(args);
  441.     e = va_arg(args, StoreEntry *);
  442.     fmt = va_arg(args, char *);
  443. #endif
  444.     storeAppendVPrintf(e, fmt, args);
  445.     va_end(args);
  446. }
  448. /* used be storeAppendPrintf and Packer */
  449. void
  450. storeAppendVPrintf(StoreEntry * e, const char *fmt, va_list vargs)
  451. {
  452.     LOCAL_ARRAY(char, buf, 4096);
  453.     buf[0] = '';
  454.     vsnprintf(buf, 4096, fmt, vargs);
  455.     storeAppend(e, buf, strlen(buf));
  456. }
  458. struct _store_check_cachable_hist {
  459.     struct {
  460. int non_get;
  461. int not_entry_cachable;
  462. int release_request;
  463. int wrong_content_length;
  464. int negative_cached;
  465. int too_big;
  466. int private_key;
  467. int too_many_open_files;
  468. int too_many_open_fds;
  469. int lru_age_too_low;
  470.     } no;
  471.     struct {
  472. int Default;
  473.     } yes;
  474. } store_check_cachable_hist;
  476. int
  477. storeTooManyDiskFilesOpen(void)
  478. {
  479.     if (Config.max_open_disk_fds == 0)
  480. return 0;
  481.     if (store_open_disk_fd > Config.max_open_disk_fds)
  482. return 1;
  483.     return 0;
  484. }
  486. int
  487. storeCheckCachable(StoreEntry * e)
  488. {
  489. #if CACHE_ALL_METHODS
  490.     if (e->mem_obj->method != METHOD_GET) {
  491. debug(20, 2) ("storeCheckCachable: NO: non-GET methodn");
  492. store_check_cachable_hist.no.non_get++;
  493.     } else
  494. #endif
  495.     if (!EBIT_TEST(e->flags, ENTRY_CACHABLE)) {
  496. debug(20, 2) ("storeCheckCachable: NO: not cachablen");
  497. store_check_cachable_hist.no.not_entry_cachable++;
  498.     } else if (EBIT_TEST(e->flags, RELEASE_REQUEST)) {
  499. debug(20, 2) ("storeCheckCachable: NO: release requestedn");
  500. store_check_cachable_hist.no.release_request++;
  501.     } else if (e->store_status == STORE_OK && EBIT_TEST(e->flags, ENTRY_BAD_LENGTH)) {
  502. debug(20, 2) ("storeCheckCachable: NO: wrong content-lengthn");
  503. store_check_cachable_hist.no.wrong_content_length++;
  504.     } else if (EBIT_TEST(e->flags, ENTRY_NEGCACHED)) {
  505. debug(20, 3) ("storeCheckCachable: NO: negative cachedn");
  506. store_check_cachable_hist.no.negative_cached++;
  507. return 0; /* avoid release call below */
  508.     } else if (e->mem_obj->inmem_hi > Config.Store.maxObjectSize) {
  509. debug(20, 2) ("storeCheckCachable: NO: too bign");
  510. store_check_cachable_hist.no.too_big++;
  511.     } else if (EBIT_TEST(e->flags, KEY_PRIVATE)) {
  512. debug(20, 3) ("storeCheckCachable: NO: private keyn");
  513. store_check_cachable_hist.no.private_key++;
  514.     } else if (e->swap_status != SWAPOUT_NONE) {
  515. /*
  516.  * here we checked the swap_status because the remaining
  517.  * cases are only relevant only if we haven't started swapping
  518.  * out the object yet.
  519.  */
  520. return 1;
  521.     } else if (storeTooManyDiskFilesOpen()) {
  522. debug(20, 2) ("storeCheckCachable: NO: too many disk files openn");
  523. store_check_cachable_hist.no.too_many_open_files++;
  524.     } else if (fdNFree() < RESERVED_FD) {
  525. debug(20, 2) ("storeCheckCachable: NO: too many FD's openn");
  526. store_check_cachable_hist.no.too_many_open_fds++;
  527.     } else if (storeExpiredReferenceAge() < 300) {
  528. debug(20, 2) ("storeCheckCachable: NO: LRU Age = %dn",
  529.     storeExpiredReferenceAge());
  530. store_check_cachable_hist.no.lru_age_too_low++;
  531.     } else {
  532. store_check_cachable_hist.yes.Default++;
  533. return 1;
  534.     }
  535.     storeReleaseRequest(e);
  536.     EBIT_CLR(e->flags, ENTRY_CACHABLE);
  537.     return 0;
  538. }
  540. static void
  541. storeCheckCachableStats(StoreEntry * sentry)
  542. {
  543.     storeAppendPrintf(sentry, "Categoryt Countn");
  545.     storeAppendPrintf(sentry, "no.non_gett%dn",
  546. store_check_cachable_hist.no.non_get);
  547.     storeAppendPrintf(sentry, "no.not_entry_cachablet%dn",
  548. store_check_cachable_hist.no.not_entry_cachable);
  549.     storeAppendPrintf(sentry, "no.release_requestt%dn",
  550. store_check_cachable_hist.no.release_request);
  551.     storeAppendPrintf(sentry, "no.wrong_content_lengtht%dn",
  552. store_check_cachable_hist.no.wrong_content_length);
  553.     storeAppendPrintf(sentry, "no.negative_cachedt%dn",
  554. store_check_cachable_hist.no.negative_cached);
  555.     storeAppendPrintf(sentry, "no.too_bigt%dn",
  556. store_check_cachable_hist.no.too_big);
  557.     storeAppendPrintf(sentry, "no.private_keyt%dn",
  558. store_check_cachable_hist.no.private_key);
  559.     storeAppendPrintf(sentry, "no.too_many_open_filest%dn",
  560. store_check_cachable_hist.no.too_many_open_files);
  561.     storeAppendPrintf(sentry, "no.too_many_open_fdst%dn",
  562. store_check_cachable_hist.no.too_many_open_fds);
  563.     storeAppendPrintf(sentry, "no.lru_age_too_lowt%dn",
  564. store_check_cachable_hist.no.lru_age_too_low);
  565.     storeAppendPrintf(sentry, "yes.defaultt%dn",
  566. store_check_cachable_hist.yes.Default);
  567. }
  569. /* Complete transfer into the local cache.  */
  570. void
  571. storeComplete(StoreEntry * e)
  572. {
  573.     debug(20, 3) ("storeComplete: '%s'n", storeKeyText(e->key));
  574.     if (e->store_status != STORE_PENDING) {
  575. /*
  576.  * if we're not STORE_PENDING, then probably we got aborted
  577.  * and there should be NO clients on this entry
  578.  */
  579. assert(EBIT_TEST(e->flags, ENTRY_ABORTED));
  580. assert(e->mem_obj->nclients == 0);
  581. return;
  582.     }
  583.     e->mem_obj->object_sz = e->mem_obj->inmem_hi;
  584.     e->store_status = STORE_OK;
  585.     assert(e->mem_status == NOT_IN_MEMORY);
  586.     if (!storeEntryValidLength(e)) {
  587. EBIT_SET(e->flags, ENTRY_BAD_LENGTH);
  588. storeReleaseRequest(e);
  589.     }
  590. #if USE_CACHE_DIGESTS
  591.     if (e->mem_obj->request)
  592. e->mem_obj->request->hier.store_complete_stop = current_time;
  593. #endif
  594.     InvokeHandlers(e);
  595.     storeCheckSwapOut(e);
  596. }
  598. /*
  599.  * Someone wants to abort this transfer.  Set the reason in the
  600.  * request structure, call the server-side callback and mark the
  601.  * entry for releasing 
  602.  */
  603. void
  604. storeAbort(StoreEntry * e)
  605. {
  606.     MemObject *mem = e->mem_obj;
  607.     assert(e->store_status == STORE_PENDING);
  608.     assert(mem != NULL);
  609.     debug(20, 6) ("storeAbort: %sn", storeKeyText(e->key));
  610.     storeLockObject(e); /* lock while aborting */
  611.     storeNegativeCache(e);
  612.     storeReleaseRequest(e);
  613.     EBIT_SET(e->flags, ENTRY_ABORTED);
  614.     storeSetMemStatus(e, NOT_IN_MEMORY);
  615.     /* No DISK swap for negative cached object */
  616.     e->swap_status = SWAPOUT_NONE;
  617.     e->store_status = STORE_OK;
  618.     /*
  619.      * We assign an object length here.  The only other place we assign
  620.      * the object length is in storeComplete()
  621.      */
  622.     mem->object_sz = mem->inmem_hi;
  623.     /* Notify the server side */
  624.     if (mem->abort.callback) {
  625. eventAdd("mem->abort.callback",
  626.     mem->abort.callback,
  627.     mem->abort.data,
  628.     0.0,
  629.     0);
  630. mem->abort.callback = NULL;
  631. mem->abort.data = NULL;
  632.     }
  633.     /* Notify the client side */
  634.     InvokeHandlers(e);
  635.     /* Do we need to close the swapout file? */
  636.     /* Not if we never started swapping out */
  637.     /* But we may need to cancel an open/stat in progress if using ASYNC */
  638. #if USE_ASYNC_IO
  639.     aioCancel(-1, e);
  640. #endif
  641.     if (e->swap_file_number > -1) {
  642. #if USE_ASYNC_IO
  643. /* Need to cancel any pending ASYNC writes right now */
  644. if (mem->swapout.fd >= 0)
  645.     aioCancel(mem->swapout.fd, NULL);
  646. #endif
  647. /* we have to close the disk file if there is no write pending */
  648. if (!storeSwapOutWriteQueued(mem))
  649.     storeSwapOutFileClose(e);
  650.     }
  651.     storeUnlockObject(e); /* unlock */
  652. }
  654. /* Clear Memory storage to accommodate the given object len */
  655. static void
  656. storeGetMemSpace(int size)
  657. {
  658.     StoreEntry *e = NULL;
  659.     int released = 0;
  660.     static time_t last_check = 0;
  661.     int pages_needed;
  662.     dlink_node *m;
  663.     dlink_node *head;
  664.     dlink_node *prev = NULL;
  665.     if (squid_curtime == last_check)
  666. return;
  667.     last_check = squid_curtime;
  668.     pages_needed = (size / SM_PAGE_SIZE) + 1;
  669.     if (memInUse(MEM_STMEM_BUF) + pages_needed < store_pages_max)
  670. return;
  671.     if (store_rebuilding)
  672. return;
  673.     debug(20, 2) ("storeGetMemSpace: Starting, need %d pagesn", pages_needed);
  674.     head = inmem_list.head;
  675.     for (m = inmem_list.tail; m; m = prev) {
  676. if (m == head)
  677.     break;
  678. prev = m->prev;
  679. e = m->data;
  680. if (storeEntryLocked(e)) {
  681.     dlinkDelete(m, &inmem_list);
  682.     dlinkAdd(e, m, &inmem_list);
  683.     continue;
  684. }
  685. released++;
  686. storePurgeMem(e);
  687. if (memInUse(MEM_STMEM_BUF) + pages_needed < store_pages_max)
  688.     break;
  689.     }
  690.     debug(20, 3) ("storeGetMemSpace stats:n");
  691.     debug(20, 3) ("  %6d HOT objectsn", hot_obj_count);
  692.     debug(20, 3) ("  %6d were releasedn", released);
  693. }
  695. /* The maximum objects to scan for maintain storage space */
  696. #define MAINTAIN_MAX_SCAN 1024
  697. #define MAINTAIN_MAX_REMOVE 64
  699. /* 
  700.  * This routine is to be called by main loop in main.c.
  701.  * It removes expired objects on only one bucket for each time called.
  702.  * returns the number of objects removed
  703.  *
  704.  * This should get called 1/s from main().
  705.  */
  706. void
  707. storeMaintainSwapSpace(void *datanotused)
  708. {
  709.     dlink_node *m;
  710.     dlink_node *prev = NULL;
  711.     StoreEntry *e = NULL;
  712.     int scanned = 0;
  713.     int locked = 0;
  714.     int expired = 0;
  715.     int max_scan;
  716.     int max_remove;
  717.     double f;
  718.     static time_t last_warn_time = 0;
  719.     /* We can't delete objects while rebuilding swap */
  720.     if (store_rebuilding) {
  721. eventAdd("MaintainSwapSpace", storeMaintainSwapSpace, NULL, 1.0, 1);
  722. return;
  723.     } else {
  724. f = (double) (store_swap_size - store_swap_low) / (store_swap_high - store_swap_low);
  725. f = f < 0.0 ? 0.0 : f > 1.0 ? 1.0 : f;
  726. max_scan = (int) (f * 400.0 + 100.0);
  727. max_remove = (int) (f * 70.0 + 10.0);
  728. eventAdd("MaintainSwapSpace", storeMaintainSwapSpace, NULL, 1.0 - f, 1);
  729.     }
  730.     debug(20, 3) ("storeMaintainSwapSpace: f=%f, max_scan=%d, max_remove=%dn",
  731. f, max_scan, max_remove);
  732.     for (m = store_list.tail; m; m = prev) {
  733. prev = m->prev;
  734. e = m->data;
  735. scanned++;
  736. if (storeEntryLocked(e)) {
  737.     /*
  738.      * If there is a locked entry at the tail of the LRU list,
  739.      * move it to the beginning to get it out of the way.
  740.      * Theoretically, we might have all locked objects at the
  741.      * tail, and then we'll never remove anything here and the
  742.      * LRU age will go to zero.
  743.      */
  744.     if (memInUse(MEM_STOREENTRY) > max_scan) {
  745. dlinkDelete(&e->lru, &store_list);
  746. dlinkAdd(e, &e->lru, &store_list);
  747.     }
  748.     locked++;
  749. } else if (storeCheckExpired(e)) {
  750.     expired++;
  751.     storeRelease(e);
  752. }
  753. if (expired >= max_remove)
  754.     break;
  755. if (scanned >= max_scan)
  756.     break;
  757.     }
  758.     debug(20, 3) ("storeMaintainSwapSpace stats:n");
  759.     debug(20, 3) ("  %6d objectsn", memInUse(MEM_STOREENTRY));
  760.     debug(20, 3) ("  %6d were scannedn", scanned);
  761.     debug(20, 3) ("  %6d were lockedn", locked);
  762.     debug(20, 3) ("  %6d were expiredn", expired);
  763.     if (store_swap_size < Config.Swap.maxSize)
  764. return;
  765.     if (squid_curtime - last_warn_time < 10)
  766. return;
  767.     debug(20, 0) ("WARNING: Disk space over limit: %d KB > %d KBn",
  768. store_swap_size, Config.Swap.maxSize);
  769.     last_warn_time = squid_curtime;
  770. }
  773. /* release an object from a cache */
  774. /* return number of objects released. */
  775. void
  776. storeRelease(StoreEntry * e)
  777. {
  778.     debug(20, 3) ("storeRelease: Releasing: '%s'n", storeKeyText(e->key));
  779.     /* If, for any reason we can't discard this object because of an
  780.      * outstanding request, mark it for pending release */
  781.     if (storeEntryLocked(e)) {
  782. storeExpireNow(e);
  783. debug(20, 3) ("storeRelease: Only setting RELEASE_REQUEST bitn");
  784. storeReleaseRequest(e);
  785. return;
  786.     }
  787. #if USE_ASYNC_IO
  788.     /*
  789.      * Make sure all forgotten async ops are cancelled
  790.      */
  791.     aioCancel(-1, e);
  792. #endif
  793.     if (store_rebuilding) {
  794. storeSetPrivateKey(e);
  795. if (e->mem_obj) {
  796.     storeSetMemStatus(e, NOT_IN_MEMORY);
  797.     destroy_MemObject(e);
  798. }
  799. /*
  800.  * Fake a call to storeLockObject().  When rebuilding is done,
  801.  * we'll just call storeUnlockObject() on these.
  802.  */
  803. e->lock_count++;
  804. stackPush(&LateReleaseStack, e);
  805. return;
  806.     }
  807.     storeLog(STORE_LOG_RELEASE, e);
  808.     if (e->swap_file_number > -1) {
  809. storeUnlinkFileno(e->swap_file_number);
  810. storeDirMapBitReset(e->swap_file_number);
  811. if (e->swap_status == SWAPOUT_DONE)
  812.     if (EBIT_TEST(e->flags, ENTRY_VALIDATED))
  813. storeDirUpdateSwapSize(e->swap_file_number, e->swap_file_sz, -1);
  814. if (!EBIT_TEST(e->flags, KEY_PRIVATE))
  815.     storeDirSwapLog(e, SWAP_LOG_DEL);
  816.     }
  817.     storeSetMemStatus(e, NOT_IN_MEMORY);
  818.     destroy_StoreEntry(e);
  819. }
  821. static void
  822. storeLateRelease(void *unused)
  823. {
  824.     StoreEntry *e;
  825.     int i;
  826.     static int n = 0;
  827.     if (store_rebuilding) {
  828. eventAdd("storeLateRelease", storeLateRelease, NULL, 1.0, 1);
  829. return;
  830.     }
  831.     for (i = 0; i < 10; i++) {
  832. e = stackPop(&LateReleaseStack);
  833. if (e == NULL) {
  834.     /* done! */
  835.     debug(20, 1) ("storeLateRelease: released %d objectsn", n);
  836.     return;
  837. }
  838. storeUnlockObject(e);
  839. n++;
  840.     }
  841.     eventAdd("storeLateRelease", storeLateRelease, NULL, 0.0, 1);
  842. }
  844. /* return 1 if a store entry is locked */
  845. static int
  846. storeEntryLocked(const StoreEntry * e)
  847. {
  848.     if (e->lock_count)
  849. return 1;
  850.     if (e->swap_status == SWAPOUT_OPENING)
  851. return 1;
  852.     if (e->swap_status == SWAPOUT_WRITING)
  853. return 1;
  854.     if (e->store_status == STORE_PENDING)
  855. return 1;
  856.     /*
  857.      * SPECIAL, PUBLIC entries should be "locked"
  858.      */
  859.     if (EBIT_TEST(e->flags, ENTRY_SPECIAL))
  860. if (!EBIT_TEST(e->flags, KEY_PRIVATE))
  861.     return 1;
  862.     return 0;
  863. }
  865. static int
  866. storeEntryValidLength(const StoreEntry * e)
  867. {
  868.     int diff;
  869.     const HttpReply *reply;
  870.     assert(e->mem_obj != NULL);
  871.     reply = e->mem_obj->reply;
  872.     debug(20, 3) ("storeEntryValidLength: Checking '%s'n", storeKeyText(e->key));
  873.     debug(20, 5) ("storeEntryValidLength:     object_len = %dn",
  874. objectLen(e));
  875.     debug(20, 5) ("storeEntryValidLength:         hdr_sz = %dn",
  876. reply->hdr_sz);
  877.     debug(20, 5) ("storeEntryValidLength: content_length = %dn",
  878. reply->content_length);
  879.     if (reply->content_length < 0) {
  880. debug(20, 5) ("storeEntryValidLength: Unspecified content length: %sn",
  881.     storeKeyText(e->key));
  882. return 1;
  883.     }
  884.     if (reply->hdr_sz == 0) {
  885. debug(20, 5) ("storeEntryValidLength: Zero header size: %sn",
  886.     storeKeyText(e->key));
  887. return 1;
  888.     }
  889.     if (e->mem_obj->method == METHOD_HEAD) {
  890. debug(20, 5) ("storeEntryValidLength: HEAD request: %sn",
  891.     storeKeyText(e->key));
  892. return 1;
  893.     }
  894.     if (reply->sline.status == HTTP_NOT_MODIFIED)
  895. return 1;
  896.     if (reply->sline.status == HTTP_NO_CONTENT)
  897. return 1;
  898.     diff = reply->hdr_sz + reply->content_length - objectLen(e);
  899.     if (diff == 0)
  900. return 1;
  901.     debug(20, 3) ("storeEntryValidLength: %d bytes too %s; '%s'n",
  902. diff < 0 ? -diff : diff,
  903. diff < 0 ? "big" : "small",
  904. storeKeyText(e->key));
  905.     return 0;
  906. }
  908. static void
  909. storeInitHashValues(void)
  910. {
  911.     int i;
  912.     /* Calculate size of hash table (maximum currently 64k buckets).  */
  913.     i = Config.Swap.maxSize / Config.Store.avgObjectSize;
  914.     debug(20, 1) ("Swap maxSize %d KB, estimated %d objectsn",
  915. Config.Swap.maxSize, i);
  916.     i /= Config.Store.objectsPerBucket;
  917.     debug(20, 1) ("Target number of buckets: %dn", i);
  918.     /* ideally the full scan period should be configurable, for the
  919.      * moment it remains at approximately 24 hours.  */
  920.     store_hash_buckets = storeKeyHashBuckets(i);
  921.     store_maintain_rate = 86400 / store_hash_buckets;
  922.     assert(store_maintain_rate > 0);
  923.     debug(20, 1) ("Using %d Store buckets, replacement runs every %d second%sn",
  924. store_hash_buckets,
  925. store_maintain_rate,
  926. store_maintain_rate == 1 ? null_string : "s");
  927.     debug(20, 1) ("Max Mem  size: %d KBn", Config.memMaxSize >> 10);
  928.     debug(20, 1) ("Max Swap size: %d KBn", Config.Swap.maxSize);
  929. }
  931. void
  932. storeInit(void)
  933. {
  934.     storeKeyInit();
  935.     storeInitHashValues();
  936.     store_table = hash_create(storeKeyHashCmp,
  937. store_hash_buckets, storeKeyHashHash);
  938.     storeDigestInit();
  939.     storeLogOpen();
  940.     if (storeVerifyCacheDirs() < 0) {
  941. xstrncpy(tmp_error_buf,
  942.     "tFailed to verify one of the swap directories, Check cache.logn"
  943.     "tfor details.  Run 'squid -z' to create swap directoriesn"
  944.     "tif needed, or if running Squid for the first time.",
  945.     ERROR_BUF_SZ);
  946. fatal(tmp_error_buf);
  947.     }
  948.     storeDirOpenSwapLogs();
  949.     store_list.head = store_list.tail = NULL;
  950.     inmem_list.head = inmem_list.tail = NULL;
  951.     stackInit(&LateReleaseStack);
  952.     eventAdd("storeLateRelease", storeLateRelease, NULL, 1.0, 1);
  953.     storeRebuildStart();
  954.     cachemgrRegister("storedir",
  955. "Store Directory Stats",
  956. storeDirStats, 0, 1);
  957.     cachemgrRegister("store_check_cachable_stats",
  958. "storeCheckCachable() Stats",
  959. storeCheckCachableStats, 0, 1);
  960. }
  962. void
  963. storeConfigure(void)
  964. {
  965.     store_swap_high = (long) (((float) Config.Swap.maxSize *
  966.     (float) Config.Swap.highWaterMark) / (float) 100);
  967.     store_swap_low = (long) (((float) Config.Swap.maxSize *
  968.     (float) Config.Swap.lowWaterMark) / (float) 100);
  969.     store_swap_mid = (store_swap_high >> 1) + (store_swap_low >> 1);
  970.     store_pages_max = Config.memMaxSize / SM_PAGE_SIZE;
  971. }
  973. static int
  974. storeKeepInMemory(const StoreEntry * e)
  975. {
  976.     MemObject *mem = e->mem_obj;
  977.     if (mem == NULL)
  978. return 0;
  979.     if (mem->data_hdr.head == NULL)
  980. return 0;
  981.     return mem->inmem_lo == 0;
  982. }
  984. static int
  985. storeCheckExpired(const StoreEntry * e)
  986. {
  987.     if (storeEntryLocked(e))
  988. return 0;
  989.     if (EBIT_TEST(e->flags, RELEASE_REQUEST))
  990. return 1;
  991.     if (EBIT_TEST(e->flags, ENTRY_NEGCACHED) && squid_curtime >= e->expires)
  992. return 1;
  993.     if (squid_curtime - e->lastref > storeExpiredReferenceAge())
  994. return 1;
  995.     return 0;
  996. }
  998. /* 
  999.  * storeExpiredReferenceAge
  1000.  *
  1001.  * The LRU age is scaled exponentially between 1 minute and
  1002.  * Config.referenceAge , when store_swap_low < store_swap_size <
  1003.  * store_swap_high.  This keeps store_swap_size within the low and high
  1004.  * water marks.  If the cache is very busy then store_swap_size stays
  1005.  * closer to the low water mark, if it is not busy, then it will stay
  1006.  * near the high water mark.  The LRU age value can be examined on the
  1007.  * cachemgr 'info' page.
  1008.  */
  1009. time_t
  1010. storeExpiredReferenceAge(void)
  1011. {
  1012.     double x;
  1013.     double z;
  1014.     time_t age;
  1015.     x = (double) (store_swap_high - store_swap_size) / (store_swap_high - store_swap_low);
  1016.     x = x < 0.0 ? 0.0 : x > 1.0 ? 1.0 : x;
  1017.     z = pow((double) (Config.referenceAge / 60), x);
  1018.     age = (time_t) (z * 60.0);
  1019.     if (age < 60)
  1020. age = 60;
  1021.     else if (age > 31536000)
  1022. age = 31536000;
  1023.     return age;
  1024. }
  1026. void
  1027. storeNegativeCache(StoreEntry * e)
  1028. {
  1029.     e->expires = squid_curtime + Config.negativeTtl;
  1030.     EBIT_SET(e->flags, ENTRY_NEGCACHED);
  1031. }
  1033. void
  1034. storeFreeMemory(void)
  1035. {
  1036.     hashFreeItems(store_table, destroy_StoreEntry);
  1037.     hashFreeMemory(store_table);
  1038.     store_table = NULL;
  1039. #if USE_CACHE_DIGEST
  1040.     if (store_digest)
  1041. cacheDigestDestroy(store_digest);
  1042. #endif
  1043.     store_digest = NULL;
  1044. }
  1046. int
  1047. expiresMoreThan(time_t expires, time_t when)
  1048. {
  1049.     if (expires < 0) /* No Expires given */
  1050. return 1;
  1051.     return (expires > (squid_curtime + when));
  1052. }
  1054. int
  1055. storeEntryValidToSend(StoreEntry * e)
  1056. {
  1057.     if (EBIT_TEST(e->flags, RELEASE_REQUEST))
  1058. return 0;
  1059.     if (EBIT_TEST(e->flags, ENTRY_NEGCACHED))
  1060. if (e->expires <= squid_curtime)
  1061.     return 0;
  1062.     if (EBIT_TEST(e->flags, ENTRY_ABORTED))
  1063. return 0;
  1064.     return 1;
  1065. }
  1067. void
  1068. storeTimestampsSet(StoreEntry * entry)
  1069. {
  1070.     time_t served_date = -1;
  1071.     const HttpReply *reply = entry->mem_obj->reply;
  1072.     served_date = reply->date;
  1073.     if (served_date < 0)
  1074. served_date = squid_curtime;
  1075.     entry->expires = reply->expires;
  1076.     entry->lastmod = reply->last_modified;
  1077.     entry->timestamp = served_date;
  1078. }
  1080. void
  1081. storeRegisterAbort(StoreEntry * e, STABH * cb, void *data)
  1082. {
  1083.     MemObject *mem = e->mem_obj;
  1084.     assert(mem);
  1085.     assert(mem->abort.callback == NULL);
  1086.     mem->abort.callback = cb;
  1087.     mem->abort.data = data;
  1088. }
  1090. void
  1091. storeUnregisterAbort(StoreEntry * e)
  1092. {
  1093.     MemObject *mem = e->mem_obj;
  1094.     assert(mem);
  1095.     mem->abort.callback = NULL;
  1096. }
  1098. void
  1099. storeMemObjectDump(MemObject * mem)
  1100. {
  1101.     debug(20, 1) ("MemObject->data.head: %pn",
  1102. mem->data_hdr.head);
  1103.     debug(20, 1) ("MemObject->data.tail: %pn",
  1104. mem->data_hdr.tail);
  1105.     debug(20, 1) ("MemObject->data.origin_offset: %dn",
  1106. mem->data_hdr.origin_offset);
  1107.     debug(20, 1) ("MemObject->start_ping: %d.%06dn",
  1108. (int) mem->start_ping.tv_sec,
  1109. (int) mem->start_ping.tv_usec);
  1110.     debug(20, 1) ("MemObject->inmem_hi: %dn",
  1111. (int) mem->inmem_hi);
  1112.     debug(20, 1) ("MemObject->inmem_lo: %dn",
  1113. (int) mem->inmem_lo);
  1114.     debug(20, 1) ("MemObject->clients: %pn",
  1115. mem->clients);
  1116.     debug(20, 1) ("MemObject->nclients: %dn",
  1117. mem->nclients);
  1118.     debug(20, 1) ("MemObject->swapout.fd: %dn",
  1119. mem->swapout.fd);
  1120.     debug(20, 1) ("MemObject->reply: %pn",
  1121. mem->reply);
  1122.     debug(20, 1) ("MemObject->request: %pn",
  1123. mem->request);
  1124.     debug(20, 1) ("MemObject->log_url: %p %sn",
  1125. mem->log_url,
  1126. checkNullString(mem->log_url));
  1127. }
  1129. void
  1130. storeEntryDump(StoreEntry * e, int l)
  1131. {
  1132.     debug(20, l) ("StoreEntry->key: %sn", storeKeyText(e->key));
  1133.     debug(20, l) ("StoreEntry->next: %pn", e->next);
  1134.     debug(20, l) ("StoreEntry->mem_obj: %pn", e->mem_obj);
  1135.     debug(20, l) ("StoreEntry->timestamp: %dn", (int) e->timestamp);
  1136.     debug(20, l) ("StoreEntry->lastref: %dn", (int) e->lastref);
  1137.     debug(20, l) ("StoreEntry->expires: %dn", (int) e->expires);
  1138.     debug(20, l) ("StoreEntry->lastmod: %dn", (int) e->lastmod);
  1139.     debug(20, l) ("StoreEntry->swap_file_sz: %dn", (int) e->swap_file_sz);
  1140.     debug(20, l) ("StoreEntry->refcount: %dn", e->refcount);
  1141.     debug(20, l) ("StoreEntry->flags: %sn", storeEntryFlags(e));
  1142.     debug(20, l) ("StoreEntry->swap_file_number: %dn", (int) e->swap_file_number);
  1143.     debug(20, l) ("StoreEntry->lock_count: %dn", (int) e->lock_count);
  1144.     debug(20, l) ("StoreEntry->mem_status: %dn", (int) e->mem_status);
  1145.     debug(20, l) ("StoreEntry->ping_status: %dn", (int) e->ping_status);
  1146.     debug(20, l) ("StoreEntry->store_status: %dn", (int) e->store_status);
  1147.     debug(20, l) ("StoreEntry->swap_status: %dn", (int) e->swap_status);
  1148. }
  1150. /* NOTE, this function assumes only two mem states */
  1151. void
  1152. storeSetMemStatus(StoreEntry * e, int new_status)
  1153. {
  1154.     MemObject *mem = e->mem_obj;
  1155.     if (new_status == e->mem_status)
  1156. return;
  1157.     assert(mem != NULL);
  1158.     if (new_status == IN_MEMORY) {
  1159. assert(mem->inmem_lo == 0);
  1160. dlinkAdd(e, &mem->lru, &inmem_list);
  1161. hot_obj_count++;
  1162.     } else {
  1163. dlinkDelete(&mem->lru, &inmem_list);
  1164. hot_obj_count--;
  1165.     }
  1166.     e->mem_status = new_status;
  1167. }
  1169. const char *
  1170. storeUrl(const StoreEntry * e)
  1171. {
  1172.     if (e == NULL)
  1173. return "[null_entry]";
  1174.     else if (e->mem_obj == NULL)
  1175. return "[null_mem_obj]";
  1176.     else
  1177. return e->mem_obj->url;
  1178. }
  1180. void
  1181. storeCreateMemObject(StoreEntry * e, const char *url, const char *log_url)
  1182. {
  1183.     if (e->mem_obj)
  1184. return;
  1185.     e->mem_obj = new_MemObject(url, log_url);
  1186. }
  1188. /* this just sets DELAY_SENDING */
  1189. void
  1190. storeBuffer(StoreEntry * e)
  1191. {
  1192.     EBIT_SET(e->flags, DELAY_SENDING);
  1193. }
  1195. /* this just clears DELAY_SENDING and Invokes the handlers */
  1196. void
  1197. storeBufferFlush(StoreEntry * e)
  1198. {
  1199.     EBIT_CLR(e->flags, DELAY_SENDING);
  1200.     InvokeHandlers(e);
  1201.     storeCheckSwapOut(e);
  1202. }
  1204. void
  1205. storeUnlinkFileno(int fileno)
  1206. {
  1207.     debug(20, 5) ("storeUnlinkFileno: %08Xn", fileno);
  1208. #if USE_ASYNC_IO
  1209.     safeunlink(storeSwapFullPath(fileno, NULL), 1);
  1210. #else
  1211.     unlinkdUnlink(storeSwapFullPath(fileno, NULL));
  1212. #endif
  1213. }
  1215. int
  1216. objectLen(const StoreEntry * e)
  1217. {
  1218.     assert(e->mem_obj != NULL);
  1219.     return e->mem_obj->object_sz;
  1220. }
  1222. int
  1223. contentLen(const StoreEntry * e)
  1224. {
  1225.     assert(e->mem_obj != NULL);
  1226.     assert(e->mem_obj->reply != NULL);
  1227.     return e->mem_obj->object_sz - e->mem_obj->reply->hdr_sz;
  1228. }
  1230. HttpReply *
  1231. storeEntryReply(StoreEntry * e)
  1232. {
  1233.     if (NULL == e)
  1234. return NULL;
  1235.     if (NULL == e->mem_obj)
  1236. return NULL;
  1237.     return e->mem_obj->reply;
  1238. }
  1240. void
  1241. storeEntryReset(StoreEntry * e)
  1242. {
  1243.     MemObject *mem = e->mem_obj;
  1244.     debug(20, 3) ("storeEntryReset: %sn", storeUrl(e));
  1245.     assert(mem->swapout.fd == -1);
  1246.     stmemFree(&mem->data_hdr);
  1247.     mem->inmem_hi = mem->inmem_lo = 0;
  1248.     httpReplyDestroy(mem->reply);
  1249.     mem->reply = httpReplyCreate();
  1250. }