static void
idnsCheckQueue(void *unused)
{
dlink_node *n;
dlink_node *p = NULL;
idns_query *q;
event_queued = 0;
for (n = lru_list.tail; n; n = p) {
q = n->data;
if (tvSubDsec(q->sent_t, current_time) < 5.0)
break;
debug(78, 3) ("idnsCheckQueue: ID %#04x timeout\n",
q->id);
p = n->prev;
dlinkDelete(&q->lru, &lru_list);
if (q->nsends < IDNS_MAX_TRIES) {
idnsSendQuery(q);
} else {
int v = cbdataValid(q->callback_data);
debug(78, 1) ("idnsCheckQueue: ID %x: giving up after %d tries and %5.1f seconds\n",
(int) q->id, q->nsends,
tvSubDsec(q->start_t, current_time));
cbdataUnlock(q->callback_data);
if (v)
q->callback(q->callback_data, NULL, 0);
memFree(q, MEM_IDNS_QUERY);
}
}
idnsTickleQueue();
}
static void
idnsStats(StoreEntry * sentry)
{
dlink_node *n;
idns_query *q;
int i;
int j;
storeAppendPrintf(sentry, "Internal DNS Statistics:\n");
storeAppendPrintf(sentry, "\nThe Queue:\n");
storeAppendPrintf(sentry, " DELAY SINCE\n");
storeAppendPrintf(sentry, " ID SIZE SENDS FIRST SEND LAST SEND\n");
storeAppendPrintf(sentry, "------ ---- ----- ---------- ---------\n");
for (n = lru_list.head; n; n = n->next)
{
q = n->data;
storeAppendPrintf(sentry, "%#06x %4d %5d %10.3f %9.3f\n",
(int) q->id, (int) q->sz, q->nsends,
tvSubDsec(q->start_t, current_time),
tvSubDsec(q->sent_t, current_time));
}
storeAppendPrintf(sentry, "\nNameservers:\n");
storeAppendPrintf(sentry, "IP ADDRESS # QUERIES # REPLIES\n");
storeAppendPrintf(sentry, "--------------- --------- ---------\n");
for (i = 0; i < nns; i++)
{
storeAppendPrintf(sentry, "%-15s %9d %9d\n",
inet_ntoa(nameservers[i].S.sin_addr),
nameservers[i].nqueries,
nameservers[i].nreplies);
}
storeAppendPrintf(sentry, "\nRcode Matrix:\n");
storeAppendPrintf(sentry, "RCODE");
for (i = 0; i < MAX_ATTEMPT; i++)
storeAppendPrintf(sentry, " ATTEMPT%d", i + 1);
storeAppendPrintf(sentry, "\n");
for (j = 0; j < MAX_RCODE; j++)
{
storeAppendPrintf(sentry, "%5d", j);
for (i = 0; i < MAX_ATTEMPT; i++)
storeAppendPrintf(sentry, " %8d", RcodeMatrix[j][i]);
storeAppendPrintf(sentry, "\n");
}
if (npc)
{
storeAppendPrintf(sentry, "\nSearch list:\n");
for (i = 0; i < npc; i++)
storeAppendPrintf(sentry, "%s\n", searchpath[i].domain);
storeAppendPrintf(sentry, "\n");
}
}
variable_list *
snmp_sysFn(variable_list * Var, snint * ErrP)
{
variable_list *Answer = NULL;
debug(49, 5) ("snmp_sysFn: Processing request:\n");
snmpDebugOid(5, Var->name, Var->name_length);
*ErrP = SNMP_ERR_NOERROR;
switch (Var->name[LEN_SQ_SYS]) {
case SYSVMSIZ:
Answer = snmp_var_new_integer(Var->name, Var->name_length,
store_mem_size >> 10,
ASN_INTEGER);
break;
case SYSSTOR:
Answer = snmp_var_new_integer(Var->name, Var->name_length,
store_swap_size,
ASN_INTEGER);
break;
case SYS_UPTIME:
Answer = snmp_var_new_integer(Var->name, Var->name_length,
tvSubDsec(squid_start, current_time) * 100,
SMI_TIMETICKS);
break;
default:
*ErrP = SNMP_ERR_NOSUCHNAME;
break;
}
return Answer;
}
static void
idnsCheckQueue(void *unused)
{
dlink_node *n;
dlink_node *p = NULL;
idns_query *q;
event_queued = 0;
if (0 == nns)
/* name servers went away; reconfiguring or shutting down */
return;
for (n = lru_list.tail; n; n = p)
{
p = n->prev;
q = n->data;
/* Anything to process in the queue? */
if (tvSubDsec(q->queue_t, current_time) < Config.Timeout.idns_retransmit)
break;
/* Query timer expired? */
if (tvSubDsec(q->sent_t, current_time) < Config.Timeout.idns_retransmit * 1 << ((q->nsends - 1) / nns))
{
dlinkDelete(&q->lru, &lru_list);
q->queue_t = current_time;
dlinkAdd(q, &q->lru, &lru_list);
continue;
}
debug(78, 3) ("idnsCheckQueue: ID %#04x timeout\n",
q->id);
dlinkDelete(&q->lru, &lru_list);
if (tvSubDsec(q->start_t, current_time) < Config.Timeout.idns_query)
{
idnsSendQuery(q);
}
else
{
debug(78, 2) ("idnsCheckQueue: ID %x: giving up after %d tries and %5.1f seconds\n",
(int) q->id, q->nsends,
tvSubDsec(q->start_t, current_time));
if (q->rcode != 0)
idnsCallback(q, NULL, -q->rcode, q->error);
else
idnsCallback(q, NULL, -16, "Timeout");
idnsTcpCleanup(q);
cbdataFree(q);
}
}
idnsTickleQueue();
}
/* re-digests currently hashed entries */
static void
cacheResetDigest(Cache * cache)
{
CacheEntry *e = NULL;
hash_table *hash;
struct timeval t_start, t_end;
assert(cache);
fprintf(stderr, "%s: init-ing digest with %d entries\n", cache->name, cache->count);
if (cache->digest)
cacheDigestDestroy(cache->digest);
hash = cache->hash;
cache->digest = cacheDigestCreate(cache->count + 1, 6);
if (!cache->count)
return;
gettimeofday(&t_start, NULL);
hash_first(hash);
while (e = hash_next(hash)) {
cacheDigestAdd(cache->digest, e->key);
}
gettimeofday(&t_end, NULL);
assert(cache->digest->count == cache->count);
fprintf(stderr, "%s: init-ed digest with %d entries\n",
cache->name, cache->digest->count);
fprintf(stderr, "%s: init took: %f sec, %f sec/M\n",
cache->name,
tvSubDsec(t_start, t_end),
(double) 1e6 * tvSubDsec(t_start, t_end) / cache->count);
/* check how long it takes to traverse the hash */
gettimeofday(&t_start, NULL);
for (e = hash_first(hash); e; e = hash_next(hash)) {
}
gettimeofday(&t_end, NULL);
fprintf(stderr, "%s: hash scan took: %f sec, %f sec/M\n",
cache->name,
tvSubDsec(t_start, t_end),
(double) 1e6 * tvSubDsec(t_start, t_end) / cache->count);
}
/* meta data recreated from disk image in swap directory */
void
storeRebuildComplete(struct _store_rebuild_data *dc)
{
double dt;
counts.objcount += dc->objcount;
counts.expcount += dc->expcount;
counts.scancount += dc->scancount;
counts.clashcount += dc->clashcount;
counts.dupcount += dc->dupcount;
counts.cancelcount += dc->cancelcount;
counts.invalid += dc->invalid;
counts.badflags += dc->badflags;
counts.bad_log_op += dc->bad_log_op;
counts.zero_object_sz += dc->zero_object_sz;
/*
* When store_dirs_rebuilding == 1, it means we are done reading
* or scanning all cache_dirs. Now report the stats and start
* the validation (storeCleanup()) thread.
*/
if (store_dirs_rebuilding > 1)
return;
dt = tvSubDsec(rebuild_start, current_time);
debug(20, 1) ("Finished rebuilding storage from disk.\n");
debug(20, 1) (" %7d Entries scanned\n", counts.scancount);
debug(20, 1) (" %7d Invalid entries.\n", counts.invalid);
debug(20, 1) (" %7d With invalid flags.\n", counts.badflags);
debug(20, 1) (" %7d Objects loaded.\n", counts.objcount);
debug(20, 1) (" %7d Objects expired.\n", counts.expcount);
debug(20, 1) (" %7d Objects cancelled.\n", counts.cancelcount);
debug(20, 1) (" %7d Duplicate URLs purged.\n", counts.dupcount);
debug(20, 1) (" %7d Swapfile clashes avoided.\n", counts.clashcount);
debug(20, 1) (" Took %3.1f seconds (%6.1f objects/sec).\n", dt,
(double) counts.objcount / (dt > 0.0 ? dt : 1.0));
debug(20, 1) ("Beginning Validation Procedure\n");
eventAdd("storeCleanup", storeCleanup, NULL, 0.0, 1);
safe_free(RebuildProgress);
//Kim Taehee added start
//initializing YouTubeChunkTable
youtubeTable.head = NULL;
youtubeTable.size = 0;
readChunkFromTableFile();
//Kim Taehee added end
}
static double get_avg_conn_stat(int minutes)
{
StatCounters *f;
StatCounters *l;
double dt;
double ct;
assert(N_COUNT_HIST > 1);
assert(minutes > 0 );
f = &CountHist[0];
l = f;
if (minutes > N_COUNT_HIST - 1)
minutes = N_COUNT_HIST - 1;
l = &CountHist[minutes];
dt = tvSubDsec(l->timestamp, f->timestamp);
ct = f->cputime - l->cputime;
return XAVG(client_http.requests);
}
int
storeDirWriteCleanLogs(int reopen)
{
StoreEntry *e = NULL;
int n = 0;
struct timeval start;
double dt;
SwapDir *sd;
int dirn;
int N = Config.cacheSwap.n_configured;
#if HEAP_REPLACEMENT
int node;
#else
dlink_node *m;
#endif
if (store_dirs_rebuilding) {
debug(20, 1) ("Not currently OK to rewrite swap log.\n");
debug(20, 1) ("storeDirWriteCleanLogs: Operation aborted.\n");
return 0;
}
debug(20, 1) ("storeDirWriteCleanLogs: Starting...\n");
getCurrentTime();
start = current_time;
for (dirn = 0; dirn < Config.cacheSwap.n_configured; dirn++) {
sd = &Config.cacheSwap.swapDirs[dirn];
if (sd->log.clean.open(sd) < 0) {
debug(20, 1) ("log.clean.open() failed for dir #%d\n", sd->index);
continue;
}
}
#if HEAP_REPLACEMENT
if (NULL == store_heap)
return 0;
for (node = 0; node < heap_nodes(store_heap); node++)
#else
for (m = store_list.tail; m; m = m->prev)
#endif
{
#if HEAP_REPLACEMENT
e = (StoreEntry *) heap_peep(store_heap, node);
#else
e = m->data;
#endif
if (e->swap_file_number < 0)
continue;
if (e->swap_status != SWAPOUT_DONE)
continue;
if (e->swap_file_sz <= 0)
continue;
if (EBIT_TEST(e->flags, RELEASE_REQUEST))
continue;
if (EBIT_TEST(e->flags, KEY_PRIVATE))
continue;
if (EBIT_TEST(e->flags, ENTRY_SPECIAL))
continue;
dirn = storeDirNumber(e->swap_file_number);
sd = &Config.cacheSwap.swapDirs[dirn];
if (NULL == sd->log.clean.write)
continue;
sd->log.clean.write(e, sd);
if ((++n & 0xFFFF) == 0) {
getCurrentTime();
debug(20, 1) (" %7d entries written so far.\n", n);
}
}
/* flush */
for (dirn = 0; dirn < N; dirn++) {
sd = &Config.cacheSwap.swapDirs[dirn];
if (NULL == sd->log.clean.write)
continue;
sd->log.clean.write(NULL, sd);
}
if (reopen)
storeDirOpenSwapLogs();
getCurrentTime();
dt = tvSubDsec(start, current_time);
debug(20, 1) (" Finished. Wrote %d entries.\n", n);
debug(20, 1) (" Took %3.1f seconds (%6.1f entries/sec).\n",
dt, (double) n / (dt > 0.0 ? dt : 1.0));
return n;
}
variable_list *
snmp_prfSysFn(variable_list * Var, snint * ErrP)
{
variable_list *Answer = NULL;
static struct rusage rusage;
debug(49, 5) ("snmp_prfSysFn: Processing request with magic %d!\n", Var->name[LEN_SQ_PRF + 1]);
*ErrP = SNMP_ERR_NOERROR;
switch (Var->name[LEN_SQ_PRF + 1]) {
case PERF_SYS_PF:
squid_getrusage(&rusage);
Answer = snmp_var_new_integer(Var->name, Var->name_length,
rusage_pagefaults(&rusage),
SMI_COUNTER32);
break;
case PERF_SYS_NUMR:
Answer = snmp_var_new_integer(Var->name, Var->name_length,
IOStats.Http.reads,
SMI_COUNTER32);
break;
case PERF_SYS_MEMUSAGE:
Answer = snmp_var_new_integer(Var->name, Var->name_length,
(snint) statMemoryAccounted() >> 10,
ASN_INTEGER);
break;
case PERF_SYS_CPUTIME:
squid_getrusage(&rusage);
Answer = snmp_var_new_integer(Var->name, Var->name_length,
(snint) rusage_cputime(&rusage),
ASN_INTEGER);
break;
case PERF_SYS_CPUUSAGE:
squid_getrusage(&rusage);
Answer = snmp_var_new_integer(Var->name, Var->name_length,
(snint) dpercent(rusage_cputime(&rusage), tvSubDsec(squid_start, current_time)),
ASN_INTEGER);
break;
case PERF_SYS_MAXRESSZ:
squid_getrusage(&rusage);
Answer = snmp_var_new_integer(Var->name, Var->name_length,
(snint) rusage_maxrss(&rusage),
ASN_INTEGER);
break;
case PERF_SYS_CURLRUEXP:
/* No global LRU info anymore */
Answer = snmp_var_new_integer(Var->name, Var->name_length,
0,
SMI_TIMETICKS);
break;
case PERF_SYS_CURUNLREQ:
Answer = snmp_var_new_integer(Var->name, Var->name_length,
(snint) statCounter.unlink.requests,
SMI_COUNTER32);
break;
case PERF_SYS_CURUNUSED_FD:
Answer = snmp_var_new_integer(Var->name, Var->name_length,
(snint) Squid_MaxFD - Number_FD,
SMI_GAUGE32);
break;
case PERF_SYS_CURRESERVED_FD:
Answer = snmp_var_new_integer(Var->name, Var->name_length,
(snint) RESERVED_FD,
SMI_GAUGE32);
break;
case PERF_SYS_NUMOBJCNT:
Answer = snmp_var_new_integer(Var->name, Var->name_length,
(snint) memInUse(MEM_STOREENTRY),
SMI_GAUGE32);
break;
default:
*ErrP = SNMP_ERR_NOSUCHNAME;
break;
}
return Answer;
}
