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

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

代理服务器

开发平台：

Unix_Linux

stat.c：源码内容
  2. /*
  3.  * $Id: stat.c,v 1.311.2.2 1999/02/13 07:45:28 wessels Exp $
  4.  *
  5.  * DEBUG: section 18    Cache Manager Statistics
  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.  */
  37. #include "squid.h"
  39. #define DEBUG_OPENFD 1
  41. typedef int STOBJFLT(const StoreEntry *);
  42. typedef struct {
  43.     StoreEntry *sentry;
  44.     int bucket;
  45.     STOBJFLT *filter;
  46. } StatObjectsState;
  48. /* LOCALS */
  49. static const char *describeStatuses(const StoreEntry *);
  50. static const char *describeTimestamps(const StoreEntry *);
  51. static void statAvgTick(void *notused);
  52. static void statAvgDump(StoreEntry *, int minutes, int hours);
  53. #if STAT_GRAPHS
  54. static void statGraphDump(StoreEntry *);
  55. #endif
  56. static void statCountersInit(StatCounters *);
  57. static void statCountersInitSpecial(StatCounters *);
  58. static void statCountersClean(StatCounters *);
  59. static void statCountersCopy(StatCounters * dest, const StatCounters * orig);
  60. static double statMedianSvc(int, int);
  61. static void statStoreEntry(StoreEntry * s, StoreEntry * e);
  62. static double statCPUUsage(int minutes);
  63. static OBJH stat_io_get;
  64. static OBJH stat_objects_get;
  65. static OBJH stat_vmobjects_get;
  66. #if DEBUG_OPENFD
  67. static OBJH statOpenfdObj;
  68. #endif
  69. static EVH statObjects;
  70. static OBJH info_get;
  71. static OBJH statFiledescriptors;
  72. static OBJH statCountersDump;
  73. static OBJH statPeerSelect;
  74. static OBJH statDigestBlob;
  75. static OBJH statAvg5min;
  76. static OBJH statAvg60min;
  77. static OBJH statUtilization;
  78. static OBJH statCountersHistograms;
  79. static OBJH statClientRequests;
  81. #ifdef XMALLOC_STATISTICS
  82. static void info_get_mallstat(int, int, StoreEntry *);
  83. #endif
  85. StatCounters CountHist[N_COUNT_HIST];
  86. static int NCountHist = 0;
  87. static StatCounters CountHourHist[N_COUNT_HOUR_HIST];
  88. static int NCountHourHist = 0;
  90. static void
  91. statUtilization(StoreEntry * e)
  92. {
  93.     storeAppendPrintf(e, "Cache Utilisation:n");
  94.     storeAppendPrintf(e, "n");
  95.     storeAppendPrintf(e, "Last 5 minutes:n");
  96.     if (NCountHist >= 5)
  97. statAvgDump(e, 5, 0);
  98.     else
  99. storeAppendPrintf(e, "(no values recorded yet)n");
  100.     storeAppendPrintf(e, "n");
  101.     storeAppendPrintf(e, "Last 15 minutes:n");
  102.     if (NCountHist >= 15)
  103. statAvgDump(e, 15, 0);
  104.     else
  105. storeAppendPrintf(e, "(no values recorded yet)n");
  106.     storeAppendPrintf(e, "n");
  107.     storeAppendPrintf(e, "Last hour:n");
  108.     if (NCountHist >= 60)
  109. statAvgDump(e, 60, 0);
  110.     else
  111. storeAppendPrintf(e, "(no values recorded yet)n");
  112.     storeAppendPrintf(e, "n");
  113.     storeAppendPrintf(e, "Last 8 hours:n");
  114.     if (NCountHourHist >= 8)
  115. statAvgDump(e, 0, 8);
  116.     else
  117. storeAppendPrintf(e, "(no values recorded yet)n");
  118.     storeAppendPrintf(e, "n");
  119.     storeAppendPrintf(e, "Last day:n");
  120.     if (NCountHourHist >= 24)
  121. statAvgDump(e, 0, 24);
  122.     else
  123. storeAppendPrintf(e, "(no values recorded yet)n");
  124.     storeAppendPrintf(e, "n");
  125.     storeAppendPrintf(e, "Last 3 days:n");
  126.     if (NCountHourHist >= 72)
  127. statAvgDump(e, 0, 72);
  128.     else
  129. storeAppendPrintf(e, "(no values recorded yet)n");
  130.     storeAppendPrintf(e, "n");
  131.     storeAppendPrintf(e, "Totals since cache startup:n");
  132.     statCountersDump(e);
  133. }
  135. static void
  136. stat_io_get(StoreEntry * sentry)
  137. {
  138.     int i;
  140.     storeAppendPrintf(sentry, "HTTP I/On");
  141.     storeAppendPrintf(sentry, "number of reads: %dn", IOStats.Http.reads);
  142.     storeAppendPrintf(sentry, "Read Histogram:n");
  143.     for (i = 0; i < 16; i++) {
  144. storeAppendPrintf(sentry, "%5d-%5d: %9d %2d%%n",
  145.     i ? (1 << (i - 1)) + 1 : 1,
  146.     1 << i,
  147.     IOStats.Http.read_hist[i],
  148.     percent(IOStats.Http.read_hist[i], IOStats.Http.reads));
  149.     }
  151.     storeAppendPrintf(sentry, "n");
  152.     storeAppendPrintf(sentry, "FTP I/On");
  153.     storeAppendPrintf(sentry, "number of reads: %dn", IOStats.Ftp.reads);
  154.     storeAppendPrintf(sentry, "Read Histogram:n");
  155.     for (i = 0; i < 16; i++) {
  156. storeAppendPrintf(sentry, "%5d-%5d: %9d %2d%%n",
  157.     i ? (1 << (i - 1)) + 1 : 1,
  158.     1 << i,
  159.     IOStats.Ftp.read_hist[i],
  160.     percent(IOStats.Ftp.read_hist[i], IOStats.Ftp.reads));
  161.     }
  163.     storeAppendPrintf(sentry, "n");
  164.     storeAppendPrintf(sentry, "Gopher I/On");
  165.     storeAppendPrintf(sentry, "number of reads: %dn", IOStats.Gopher.reads);
  166.     storeAppendPrintf(sentry, "Read Histogram:n");
  167.     for (i = 0; i < 16; i++) {
  168. storeAppendPrintf(sentry, "%5d-%5d: %9d %2d%%n",
  169.     i ? (1 << (i - 1)) + 1 : 1,
  170.     1 << i,
  171.     IOStats.Gopher.read_hist[i],
  172.     percent(IOStats.Gopher.read_hist[i], IOStats.Gopher.reads));
  173.     }
  175.     storeAppendPrintf(sentry, "n");
  176.     storeAppendPrintf(sentry, "WAIS I/On");
  177.     storeAppendPrintf(sentry, "number of reads: %dn", IOStats.Wais.reads);
  178.     storeAppendPrintf(sentry, "Read Histogram:n");
  179.     for (i = 0; i < 16; i++) {
  180. storeAppendPrintf(sentry, "%5d-%5d: %9d %2d%%n",
  181.     i ? (1 << (i - 1)) + 1 : 1,
  182.     1 << i,
  183.     IOStats.Wais.read_hist[i],
  184.     percent(IOStats.Wais.read_hist[i], IOStats.Wais.reads));
  185.     }
  186. }
  188. static const char *
  189. describeStatuses(const StoreEntry * entry)
  190. {
  191.     LOCAL_ARRAY(char, buf, 256);
  192.     snprintf(buf, 256, "%-13s %-13s %-12s %-12s",
  193. storeStatusStr[entry->store_status],
  194. memStatusStr[entry->mem_status],
  195. swapStatusStr[entry->swap_status],
  196. pingStatusStr[entry->ping_status]);
  197.     return buf;
  198. }
  200. const char *
  201. storeEntryFlags(const StoreEntry * entry)
  202. {
  203.     LOCAL_ARRAY(char, buf, 256);
  204.     int flags = (int) entry->flags;
  205.     char *t;
  206.     buf[0] = '';
  207.     if (EBIT_TEST(flags, ENTRY_SPECIAL))
  208. strcat(buf, "SPECIAL,");
  209.     if (EBIT_TEST(flags, ENTRY_REVALIDATE))
  210. strcat(buf, "REVALIDATE,");
  211.     if (EBIT_TEST(flags, DELAY_SENDING))
  212. strcat(buf, "DELAY_SENDING,");
  213.     if (EBIT_TEST(flags, RELEASE_REQUEST))
  214. strcat(buf, "RELEASE_REQUEST,");
  215.     if (EBIT_TEST(flags, REFRESH_REQUEST))
  216. strcat(buf, "REFRESH_REQUEST,");
  217.     if (EBIT_TEST(flags, ENTRY_CACHABLE))
  218. strcat(buf, "CACHABLE,");
  219.     if (EBIT_TEST(flags, ENTRY_DISPATCHED))
  220. strcat(buf, "DISPATCHED,");
  221.     if (EBIT_TEST(flags, KEY_PRIVATE))
  222. strcat(buf, "PRIVATE,");
  223.     if (EBIT_TEST(flags, ENTRY_FWD_HDR_WAIT))
  224. strcat(buf, "FWD_HDR_WAIT,");
  225.     if (EBIT_TEST(flags, ENTRY_NEGCACHED))
  226. strcat(buf, "NEGCACHED,");
  227.     if (EBIT_TEST(flags, ENTRY_VALIDATED))
  228. strcat(buf, "VALIDATED,");
  229.     if (EBIT_TEST(flags, ENTRY_BAD_LENGTH))
  230. strcat(buf, "BAD_LENGTH,");
  231.     if (EBIT_TEST(flags, ENTRY_ABORTED))
  232. strcat(buf, "ABORTED,");
  233.     if ((t = strrchr(buf, ',')))
  234. *t = '';
  235.     return buf;
  236. }
  238. static const char *
  239. describeTimestamps(const StoreEntry * entry)
  240. {
  241.     LOCAL_ARRAY(char, buf, 256);
  242.     snprintf(buf, 256, "LV:%-9d LU:%-9d LM:%-9d EX:%-9d",
  243. (int) entry->timestamp,
  244. (int) entry->lastref,
  245. (int) entry->lastmod,
  246. (int) entry->expires);
  247.     return buf;
  248. }
  250. static void
  251. statStoreEntry(StoreEntry * s, StoreEntry * e)
  252. {
  253.     MemObject *mem = e->mem_obj;
  254.     int i;
  255.     struct _store_client *sc;
  256.     storeAppendPrintf(s, "KEY %sn", storeKeyText(e->key));
  257.     if (mem)
  258. storeAppendPrintf(s, "t%s %sn",
  259.     RequestMethodStr[mem->method], mem->log_url);
  260.     storeAppendPrintf(s, "t%sn", describeStatuses(e));
  261.     storeAppendPrintf(s, "t%sn", storeEntryFlags(e));
  262.     storeAppendPrintf(s, "t%sn", describeTimestamps(e));
  263.     storeAppendPrintf(s, "t%d locks, %d clients, %d refsn",
  264. (int) e->lock_count,
  265. storePendingNClients(e),
  266. (int) e->refcount);
  267.     storeAppendPrintf(s, "tSwap File %#08Xn",
  268. e->swap_file_number);
  269.     if (mem != NULL) {
  270. storeAppendPrintf(s, "tinmem_lo: %dn", (int) mem->inmem_lo);
  271. storeAppendPrintf(s, "tinmem_hi: %dn", (int) mem->inmem_hi);
  272. storeAppendPrintf(s, "tswapout: %d bytes done, %d queued, FD %dn",
  273.     (int) mem->swapout.done_offset,
  274.     (int) mem->swapout.queue_offset,
  275.     mem->swapout.fd);
  276. for (i = 0, sc = &mem->clients[i]; sc != NULL; sc = sc->next, i++) {
  277.     if (sc->callback_data == NULL)
  278. continue;
  279.     storeAppendPrintf(s, "tClient #%d, %pn", i, sc->callback_data);
  280.     storeAppendPrintf(s, "ttcopy_offset: %dn",
  281. (int) sc->copy_offset);
  282.     storeAppendPrintf(s, "ttseen_offset: %dn",
  283. (int) sc->seen_offset);
  284.     storeAppendPrintf(s, "ttcopy_size: %dn",
  285. (int) sc->copy_size);
  286.     storeAppendPrintf(s, "ttswapin_fd: %dn",
  287. (int) sc->swapin_fd);
  288.     storeAppendPrintf(s, "ttflags:");
  289.     if (sc->flags.disk_io_pending)
  290. storeAppendPrintf(s, " disk_io_pending");
  291.     if (sc->flags.store_copying)
  292. storeAppendPrintf(s, " store_copying");
  293.     if (sc->flags.copy_event_pending)
  294. storeAppendPrintf(s, " copy_event_pending");
  295.     storeAppendPrintf(s, "n");
  296. }
  297.     }
  298.     storeAppendPrintf(s, "n");
  299. }
  301. /* process objects list */
  302. static void
  303. statObjects(void *data)
  304. {
  305.     StatObjectsState *state = data;
  306.     StoreEntry *e;
  307.     hash_link *link_ptr = NULL;
  308.     hash_link *link_next = NULL;
  309.     if (state->bucket >= store_hash_buckets) {
  310. storeComplete(state->sentry);
  311. storeUnlockObject(state->sentry);
  312. cbdataFree(state);
  313. return;
  314.     } else if (EBIT_TEST(state->sentry->flags, ENTRY_ABORTED)) {
  315. storeUnlockObject(state->sentry);
  316. cbdataFree(state);
  317. return;
  318.     } else if (fwdCheckDeferRead(-1, state->sentry)) {
  319. eventAdd("statObjects", statObjects, state, 0.1, 1);
  320. return;
  321.     }
  322.     storeBuffer(state->sentry);
  323.     debug(49, 3) ("statObjects: Bucket #%dn", state->bucket);
  324.     link_next = hash_get_bucket(store_table, state->bucket);
  325.     while (NULL != (link_ptr = link_next)) {
  326. link_next = link_ptr->next;
  327. e = (StoreEntry *) link_ptr;
  328. if (state->filter && 0 == state->filter(e))
  329.     continue;
  330. statStoreEntry(state->sentry, e);
  331.     }
  332.     state->bucket++;
  333.     eventAdd("statObjects", statObjects, state, 0.0, 1);
  334.     storeBufferFlush(state->sentry);
  335. }
  337. static void
  338. statObjectsStart(StoreEntry * sentry, STOBJFLT * filter)
  339. {
  340.     StatObjectsState *state = xcalloc(1, sizeof(*state));
  341.     state->sentry = sentry;
  342.     state->filter = filter;
  343.     storeLockObject(sentry);
  344.     cbdataAdd(state, cbdataXfree, 0);
  345.     eventAdd("statObjects", statObjects, state, 0.0, 1);
  346. }
  348. static void
  349. stat_objects_get(StoreEntry * sentry)
  350. {
  351.     statObjectsStart(sentry, NULL);
  352. }
  354. static int
  355. statObjectsVmFilter(const StoreEntry * e)
  356. {
  357.     return e->mem_obj ? 1 : 0;
  358. }
  360. static void
  361. stat_vmobjects_get(StoreEntry * sentry)
  362. {
  363.     statObjectsStart(sentry, statObjectsVmFilter);
  364. }
  366. #if DEBUG_OPENFD
  367. static int
  368. statObjectsOpenfdFilter(const StoreEntry * e)
  369. {
  370.     if (e->mem_obj == NULL)
  371. return 0;
  372.     if (e->mem_obj->swapout.fd < 0)
  373. return 0;;
  374.     return 1;
  375. }
  377. static void
  378. statOpenfdObj(StoreEntry * sentry)
  379. {
  380.     statObjectsStart(sentry, statObjectsOpenfdFilter);
  381. }
  383. #endif
  385. #ifdef XMALLOC_STATISTICS
  386. static void
  387. info_get_mallstat(int size, int number, StoreEntry * sentry)
  388. {
  389.     if (number > 0)
  390. storeAppendPrintf(sentry, "t%d = %dn", size, number);
  391. }
  392. #endif
  394. static const char *
  395. fdRemoteAddr(const fde * f)
  396. {
  397.     LOCAL_ARRAY(char, buf, 32);
  398.     if (f->type != FD_SOCKET)
  399. return null_string;
  400.     snprintf(buf, 32, "%s.%d", f->ipaddr, (int) f->remote_port);
  401.     return buf;
  402. }
  404. static void
  405. statFiledescriptors(StoreEntry * sentry)
  406. {
  407.     int i;
  408.     fde *f;
  409.     storeAppendPrintf(sentry, "Active file descriptors:n");
  410.     storeAppendPrintf(sentry, "%-4s %-6s %-4s %-7s %-7s %-21s %sn",
  411. "File",
  412. "Type",
  413. "Tout",
  414. "Nread",
  415. "Nwrite",
  416. "Remote Address",
  417. "Description");
  418.     storeAppendPrintf(sentry, "---- ------ ---- ------- ------- --------------------- ------------------------------n");
  419.     for (i = 0; i < Squid_MaxFD; i++) {
  420. f = &fd_table[i];
  421. if (!f->flags.open)
  422.     continue;
  423. storeAppendPrintf(sentry, "%4d %-6.6s %4d %7d %7d %-21s %sn",
  424.     i,
  425.     fdTypeStr[f->type],
  426.     f->timeout_handler ? (int) (f->timeout - squid_curtime) / 60 : 0,
  427.     f->bytes_read,
  428.     f->bytes_written,
  429.     fdRemoteAddr(f),
  430.     f->desc);
  431.     }
  432. }
  434. static void
  435. info_get(StoreEntry * sentry)
  436. {
  437.     struct rusage rusage;
  438.     double cputime;
  439.     double runtime;
  440. #if HAVE_MSTATS && HAVE_GNUMALLOC_H
  441.     struct mstats ms;
  442. #elif HAVE_MALLINFO
  443.     struct mallinfo mp;
  444.     int t;
  445. #endif
  447.     runtime = tvSubDsec(squid_start, current_time);
  448.     if (runtime == 0.0)
  449. runtime = 1.0;
  450.     storeAppendPrintf(sentry, "Squid Object Cache: Version %sn",
  451. version_string);
  452.     storeAppendPrintf(sentry, "Start Time:t%sn",
  453. mkrfc1123(squid_start.tv_sec));
  454.     storeAppendPrintf(sentry, "Current Time:t%sn",
  455. mkrfc1123(current_time.tv_sec));
  456.     storeAppendPrintf(sentry, "Connection information for %s:n",
  457. appname);
  458.     storeAppendPrintf(sentry, "tNumber of clients accessing cache:t%un",
  459. Counter.client_http.clients);
  460.     storeAppendPrintf(sentry, "tNumber of HTTP requests received:t%un",
  461. Counter.client_http.requests);
  462.     storeAppendPrintf(sentry, "tNumber of ICP messages received:t%un",
  463. Counter.icp.pkts_recv);
  464.     storeAppendPrintf(sentry, "tNumber of ICP messages sent:t%un",
  465. Counter.icp.pkts_sent);
  466.     storeAppendPrintf(sentry, "tNumber of queued ICP replies:t%un",
  467. Counter.icp.replies_queued);
  468.     storeAppendPrintf(sentry, "tRequest failure ratio:t%5.2f%%n",
  469. request_failure_ratio);
  471.     storeAppendPrintf(sentry, "tHTTP requests per minute:t%.1fn",
  472. Counter.client_http.requests / (runtime / 60.0));
  473.     storeAppendPrintf(sentry, "tICP messages per minute:t%.1fn",
  474. (Counter.icp.pkts_sent + Counter.icp.pkts_recv) / (runtime / 60.0));
  475.     storeAppendPrintf(sentry, "tSelect loop called: %d times, %0.3f ms avgn",
  476. Counter.select_loops, 1000.0 * runtime / Counter.select_loops);
  478.     storeAppendPrintf(sentry, "Cache information for %s:n",
  479. appname);
  480.     storeAppendPrintf(sentry, "tRequest Hit Ratios:t5min: %3.1f%%, 60min: %3.1f%%n",
  481. statRequestHitRatio(5),
  482. statRequestHitRatio(60));
  483.     storeAppendPrintf(sentry, "tByte Hit Ratios:t5min: %3.1f%%, 60min: %3.1f%%n",
  484. statByteHitRatio(5),
  485. statByteHitRatio(60));
  486.     storeAppendPrintf(sentry, "tStorage Swap size:t%d KBn",
  487. store_swap_size);
  488.     storeAppendPrintf(sentry, "tStorage Mem size:t%d KBn",
  489. (int) (store_mem_size >> 10));
  490.     storeAppendPrintf(sentry, "tStorage LRU Expiration Age:t%6.2f daysn",
  491. (double) storeExpiredReferenceAge() / 86400.0);
  492.     storeAppendPrintf(sentry, "tMean Object Size:t%0.2f KBn",
  493. n_disk_objects ? (double) store_swap_size / n_disk_objects : 0.0);
  494.     storeAppendPrintf(sentry, "tRequests given to unlinkd:t%dn",
  495. Counter.unlink.requests);
  497.     storeAppendPrintf(sentry, "Median Service Times (seconds)  5 min    60 min:n");
  498.     storeAppendPrintf(sentry, "tHTTP Requests (All):  %8.5f %8.5fn",
  499. statMedianSvc(5, MEDIAN_HTTP) / 1000.0,
  500. statMedianSvc(60, MEDIAN_HTTP) / 1000.0);
  501.     storeAppendPrintf(sentry, "tCache Misses:         %8.5f %8.5fn",
  502. statMedianSvc(5, MEDIAN_MISS) / 1000.0,
  503. statMedianSvc(60, MEDIAN_MISS) / 1000.0);
  504.     storeAppendPrintf(sentry, "tCache Hits:           %8.5f %8.5fn",
  505. statMedianSvc(5, MEDIAN_HIT) / 1000.0,
  506. statMedianSvc(60, MEDIAN_HIT) / 1000.0);
  507.     storeAppendPrintf(sentry, "tNear Hits:            %8.5f %8.5fn",
  508. statMedianSvc(5, MEDIAN_NH) / 1000.0,
  509. statMedianSvc(60, MEDIAN_NH) / 1000.0);
  510.     storeAppendPrintf(sentry, "tNot-Modified Replies: %8.5f %8.5fn",
  511. statMedianSvc(5, MEDIAN_NM) / 1000.0,
  512. statMedianSvc(60, MEDIAN_NM) / 1000.0);
  513.     storeAppendPrintf(sentry, "tDNS Lookups:          %8.5f %8.5fn",
  514. statMedianSvc(5, MEDIAN_DNS) / 1000.0,
  515. statMedianSvc(60, MEDIAN_DNS) / 1000.0);
  516.     storeAppendPrintf(sentry, "tICP Queries:          %8.5f %8.5fn",
  517. statMedianSvc(5, MEDIAN_ICP_QUERY) / 1000000.0,
  518. statMedianSvc(60, MEDIAN_ICP_QUERY) / 1000000.0);
  520.     squid_getrusage(&rusage);
  521.     cputime = rusage_cputime(&rusage);
  522.     storeAppendPrintf(sentry, "Resource usage for %s:n", appname);
  523.     storeAppendPrintf(sentry, "tUP Time:t%.3f secondsn", runtime);
  524.     storeAppendPrintf(sentry, "tCPU Time:t%.3f secondsn", cputime);
  525.     storeAppendPrintf(sentry, "tCPU Usage:t%.2f%%n",
  526. dpercent(cputime, runtime));
  527.     storeAppendPrintf(sentry, "tCPU Usage, 5 minute avg:t%.2f%%n",
  528. statCPUUsage(5));
  529.     storeAppendPrintf(sentry, "tCPU Usage, 60 minute avg:t%.2f%%n",
  530. statCPUUsage(60));
  531.     storeAppendPrintf(sentry, "tMaximum Resident Size: %d KBn",
  532. rusage_maxrss(&rusage));
  533.     storeAppendPrintf(sentry, "tPage faults with physical i/o: %dn",
  534. rusage_pagefaults(&rusage));
  536. #if HAVE_MSTATS && HAVE_GNUMALLOC_H
  537.     ms = mstats();
  538.     storeAppendPrintf(sentry, "Memory usage for %s via mstats():n",
  539. appname);
  540.     storeAppendPrintf(sentry, "tTotal space in arena:  %6d KBn",
  541. ms.bytes_total >> 10);
  542.     storeAppendPrintf(sentry, "tTotal free:            %6d KB %d%%n",
  543. ms.bytes_free >> 10, percent(ms.bytes_free, ms.bytes_total));
  544. #elif HAVE_MALLINFO
  545.     mp = mallinfo();
  546.     storeAppendPrintf(sentry, "Memory usage for %s via mallinfo():n",
  547. appname);
  548.     storeAppendPrintf(sentry, "tTotal space in arena:  %6d KBn",
  549. mp.arena >> 10);
  550.     storeAppendPrintf(sentry, "tOrdinary blocks:       %6d KB %6d blksn",
  551. mp.uordblks >> 10, mp.ordblks);
  552.     storeAppendPrintf(sentry, "tSmall blocks:          %6d KB %6d blksn",
  553. mp.usmblks >> 10, mp.smblks);
  554.     storeAppendPrintf(sentry, "tHolding blocks:        %6d KB %6d blksn",
  555. mp.hblkhd >> 10, mp.hblks);
  556.     storeAppendPrintf(sentry, "tFree Small blocks:     %6d KBn",
  557. mp.fsmblks >> 10);
  558.     storeAppendPrintf(sentry, "tFree Ordinary blocks:  %6d KBn",
  559. mp.fordblks >> 10);
  560.     t = mp.uordblks + mp.usmblks + mp.hblkhd;
  561.     storeAppendPrintf(sentry, "tTotal in use:          %6d KB %d%%n",
  562. t >> 10, percent(t, mp.arena));
  563.     t = mp.fsmblks + mp.fordblks;
  564.     storeAppendPrintf(sentry, "tTotal free:            %6d KB %d%%n",
  565. t >> 10, percent(t, mp.arena));
  566. #if HAVE_EXT_MALLINFO
  567.     storeAppendPrintf(sentry, "tmax size of small blocks:t%dn", mp.mxfast);
  568.     storeAppendPrintf(sentry, "tnumber of small blocks in a holding block:t%dn",
  569. mp.nlblks);
  570.     storeAppendPrintf(sentry, "tsmall block rounding factor:t%dn", mp.grain);
  571.     storeAppendPrintf(sentry, "tspace (including overhead) allocated in ord. blks:t%dn"
  572. ,mp.uordbytes);
  573.     storeAppendPrintf(sentry, "tnumber of ordinary blocks allocated:t%dn",
  574. mp.allocated);
  575.     storeAppendPrintf(sentry, "tbytes used in maintaining the free tree:t%dn",
  576. mp.treeoverhead);
  577. #endif /* HAVE_EXT_MALLINFO */
  578. #endif /* HAVE_MALLINFO */
  579.     storeAppendPrintf(sentry, "Memory accounted for:n");
  580.     storeAppendPrintf(sentry, "tTotal accounted:       %6d KBn",
  581. memTotalAllocated() >> 10);
  583.     storeAppendPrintf(sentry, "File descriptor usage for %s:n", appname);
  584.     storeAppendPrintf(sentry, "tMaximum number of file descriptors:   %4dn",
  585. Squid_MaxFD);
  586.     storeAppendPrintf(sentry, "tLargest file desc currently in use:   %4dn",
  587. Biggest_FD);
  588.     storeAppendPrintf(sentry, "tNumber of file desc currently in use: %4dn",
  589. Number_FD);
  590.     storeAppendPrintf(sentry, "tFiles queued for open:                %4dn",
  591. Opening_FD);
  592.     storeAppendPrintf(sentry, "tAvailable number of file descriptors: %4dn",
  593. fdNFree());
  594.     storeAppendPrintf(sentry, "tReserved number of file descriptors:  %4dn",
  595. RESERVED_FD);
  596.     storeAppendPrintf(sentry, "tStore Disk files open:                %4dn",
  597. store_open_disk_fd);
  599.     storeAppendPrintf(sentry, "Internal Data Structures:n");
  600.     storeAppendPrintf(sentry, "t%6d StoreEntriesn",
  601. memInUse(MEM_STOREENTRY));
  602.     storeAppendPrintf(sentry, "t%6d StoreEntries with MemObjectsn",
  603. memInUse(MEM_MEMOBJECT));
  604.     storeAppendPrintf(sentry, "t%6d Hot Object Cache Itemsn",
  605. hot_obj_count);
  606.     storeAppendPrintf(sentry, "t%6d Filemap bits setn",
  607. storeDirMapBitsInUse());
  608.     storeAppendPrintf(sentry, "t%6d on-disk objectsn",
  609. n_disk_objects);
  611. #if XMALLOC_STATISTICS
  612.     storeAppendPrintf(sentry, "Memory allocation statisticsn");
  613.     malloc_statistics(info_get_mallstat, sentry);
  614. #endif
  615. }
  617. #define XAVG(X) (dt ? (double) (f->X - l->X) / dt : 0.0)
  618. static void
  619. statAvgDump(StoreEntry * sentry, int minutes, int hours)
  620. {
  621.     StatCounters *f;
  622.     StatCounters *l;
  623.     double dt;
  624.     double ct;
  625.     double x;
  626.     assert(N_COUNT_HIST > 1);
  627.     assert(minutes > 0 || hours > 0);
  628.     f = &CountHist[0];
  629.     l = f;
  630.     if (minutes > 0 && hours == 0) {
  631. /* checking minute readings ... */
  632. if (minutes > N_COUNT_HIST - 1)
  633.     minutes = N_COUNT_HIST - 1;
  634. l = &CountHist[minutes];
  635.     } else if (minutes == 0 && hours > 0) {
  636. /* checking hour readings ... */
  637. if (hours > N_COUNT_HOUR_HIST - 1)
  638.     hours = N_COUNT_HOUR_HIST - 1;
  639. l = &CountHourHist[hours];
  640.     } else {
  641. debug(18, 1) ("statAvgDump: Invalid args, minutes=%d, hours=%dn",
  642.     minutes, hours);
  643. return;
  644.     }
  645.     dt = tvSubDsec(l->timestamp, f->timestamp);
  646.     ct = f->cputime - l->cputime;
  648.     storeAppendPrintf(sentry, "sample_start_time = %d.%d (%s)n",
  649. (int) l->timestamp.tv_sec,
  650. (int) l->timestamp.tv_usec,
  651. mkrfc1123(l->timestamp.tv_sec));
  652.     storeAppendPrintf(sentry, "sample_end_time = %d.%d (%s)n",
  653. (int) f->timestamp.tv_sec,
  654. (int) f->timestamp.tv_usec,
  655. mkrfc1123(f->timestamp.tv_sec));
  657.     storeAppendPrintf(sentry, "client_http.requests = %f/secn",
  658. XAVG(client_http.requests));
  659.     storeAppendPrintf(sentry, "client_http.hits = %f/secn",
  660. XAVG(client_http.hits));
  661.     storeAppendPrintf(sentry, "client_http.errors = %f/secn",
  662. XAVG(client_http.errors));
  663.     storeAppendPrintf(sentry, "client_http.kbytes_in = %f/secn",
  664. XAVG(client_http.kbytes_in.kb));
  665.     storeAppendPrintf(sentry, "client_http.kbytes_out = %f/secn",
  666. XAVG(client_http.kbytes_out.kb));
  668.     x = statHistDeltaMedian(&l->client_http.all_svc_time,
  669. &f->client_http.all_svc_time);
  670.     storeAppendPrintf(sentry, "client_http.all_median_svc_time = %f secondsn",
  671. x / 1000.0);
  672.     x = statHistDeltaMedian(&l->client_http.miss_svc_time,
  673. &f->client_http.miss_svc_time);
  674.     storeAppendPrintf(sentry, "client_http.miss_median_svc_time = %f secondsn",
  675. x / 1000.0);
  676.     x = statHistDeltaMedian(&l->client_http.nm_svc_time,
  677. &f->client_http.nm_svc_time);
  678.     storeAppendPrintf(sentry, "client_http.nm_median_svc_time = %f secondsn",
  679. x / 1000.0);
  680.     x = statHistDeltaMedian(&l->client_http.nh_svc_time,
  681. &f->client_http.nh_svc_time);
  682.     storeAppendPrintf(sentry, "client_http.nh_median_svc_time = %f secondsn",
  683. x / 1000.0);
  684.     x = statHistDeltaMedian(&l->client_http.hit_svc_time,
  685. &f->client_http.hit_svc_time);
  686.     storeAppendPrintf(sentry, "client_http.hit_median_svc_time = %f secondsn",
  687. x / 1000.0);
  689.     storeAppendPrintf(sentry, "server.all.requests = %f/secn",
  690. XAVG(server.all.requests));
  691.     storeAppendPrintf(sentry, "server.all.errors = %f/secn",
  692. XAVG(server.all.errors));
  693.     storeAppendPrintf(sentry, "server.all.kbytes_in = %f/secn",
  694. XAVG(server.all.kbytes_in.kb));
  695.     storeAppendPrintf(sentry, "server.all.kbytes_out = %f/secn",
  696. XAVG(server.all.kbytes_out.kb));
  698.     storeAppendPrintf(sentry, "server.http.requests = %f/secn",
  699. XAVG(server.http.requests));
  700.     storeAppendPrintf(sentry, "server.http.errors = %f/secn",
  701. XAVG(server.http.errors));
  702.     storeAppendPrintf(sentry, "server.http.kbytes_in = %f/secn",
  703. XAVG(server.http.kbytes_in.kb));
  704.     storeAppendPrintf(sentry, "server.http.kbytes_out = %f/secn",
  705. XAVG(server.http.kbytes_out.kb));
  707.     storeAppendPrintf(sentry, "server.ftp.requests = %f/secn",
  708. XAVG(server.ftp.requests));
  709.     storeAppendPrintf(sentry, "server.ftp.errors = %f/secn",
  710. XAVG(server.ftp.errors));
  711.     storeAppendPrintf(sentry, "server.ftp.kbytes_in = %f/secn",
  712. XAVG(server.ftp.kbytes_in.kb));
  713.     storeAppendPrintf(sentry, "server.ftp.kbytes_out = %f/secn",
  714. XAVG(server.ftp.kbytes_out.kb));
  716.     storeAppendPrintf(sentry, "server.other.requests = %f/secn",
  717. XAVG(server.other.requests));
  718.     storeAppendPrintf(sentry, "server.other.errors = %f/secn",
  719. XAVG(server.other.errors));
  720.     storeAppendPrintf(sentry, "server.other.kbytes_in = %f/secn",
  721. XAVG(server.other.kbytes_in.kb));
  722.     storeAppendPrintf(sentry, "server.other.kbytes_out = %f/secn",
  723. XAVG(server.other.kbytes_out.kb));
  725.     storeAppendPrintf(sentry, "icp.pkts_sent = %f/secn",
  726. XAVG(icp.pkts_sent));
  727.     storeAppendPrintf(sentry, "icp.pkts_recv = %f/secn",
  728. XAVG(icp.pkts_recv));
  729.     storeAppendPrintf(sentry, "icp.queries_sent = %f/secn",
  730. XAVG(icp.queries_sent));
  731.     storeAppendPrintf(sentry, "icp.replies_sent = %f/secn",
  732. XAVG(icp.replies_sent));
  733.     storeAppendPrintf(sentry, "icp.queries_recv = %f/secn",
  734. XAVG(icp.queries_recv));
  735.     storeAppendPrintf(sentry, "icp.replies_recv = %f/secn",
  736. XAVG(icp.replies_recv));
  737.     storeAppendPrintf(sentry, "icp.replies_queued = %f/secn",
  738. XAVG(icp.replies_queued));
  739.     storeAppendPrintf(sentry, "icp.query_timeouts = %f/secn",
  740. XAVG(icp.query_timeouts));
  741.     storeAppendPrintf(sentry, "icp.kbytes_sent = %f/secn",
  742. XAVG(icp.kbytes_sent.kb));
  743.     storeAppendPrintf(sentry, "icp.kbytes_recv = %f/secn",
  744. XAVG(icp.kbytes_recv.kb));
  745.     storeAppendPrintf(sentry, "icp.q_kbytes_sent = %f/secn",
  746. XAVG(icp.q_kbytes_sent.kb));
  747.     storeAppendPrintf(sentry, "icp.r_kbytes_sent = %f/secn",
  748. XAVG(icp.r_kbytes_sent.kb));
  749.     storeAppendPrintf(sentry, "icp.q_kbytes_recv = %f/secn",
  750. XAVG(icp.q_kbytes_recv.kb));
  751.     storeAppendPrintf(sentry, "icp.r_kbytes_recv = %f/secn",
  752. XAVG(icp.r_kbytes_recv.kb));
  753.     x = statHistDeltaMedian(&l->icp.query_svc_time, &f->icp.query_svc_time);
  754.     storeAppendPrintf(sentry, "icp.query_median_svc_time = %f secondsn",
  755. x / 1000000.0);
  756.     x = statHistDeltaMedian(&l->icp.reply_svc_time, &f->icp.reply_svc_time);
  757.     storeAppendPrintf(sentry, "icp.reply_median_svc_time = %f secondsn",
  758. x / 1000000.0);
  759.     x = statHistDeltaMedian(&l->dns.svc_time, &f->dns.svc_time);
  760.     storeAppendPrintf(sentry, "dns.median_svc_time = %f secondsn",
  761. x / 1000.0);
  762.     storeAppendPrintf(sentry, "unlink.requests = %f/secn",
  763. XAVG(unlink.requests));
  764.     storeAppendPrintf(sentry, "page_faults = %f/secn",
  765. XAVG(page_faults));
  766.     storeAppendPrintf(sentry, "select_loops = %f/secn",
  767. XAVG(select_loops));
  768.     storeAppendPrintf(sentry, "select_fds = %f/secn",
  769. XAVG(select_fds));
  770.     storeAppendPrintf(sentry, "average_select_fd_period = %f/fdn",
  771. f->select_fds > l->select_fds ?
  772. (f->select_time - l->select_time) / (f->select_fds - l->select_fds)
  773. : 0.0);
  774.     x = statHistDeltaMedian(&l->select_fds_hist, &f->select_fds_hist);
  775.     storeAppendPrintf(sentry, "median_select_fds = %fn", x);
  776.     storeAppendPrintf(sentry, "swap_files_cleaned = %f/secn",
  777. XAVG(swap_files_cleaned));
  778.     storeAppendPrintf(sentry, "aborted_requests = %f/secn",
  779. XAVG(aborted_requests));
  781. #if HAVE_POLL
  782.     storeAppendPrintf(sentry, "syscalls.polls = %f/secn", XAVG(syscalls.polls));
  783. #else
  784.     storeAppendPrintf(sentry, "syscalls.selects = %f/secn", XAVG(syscalls.selects));
  785. #endif
  786.     storeAppendPrintf(sentry, "syscalls.disk.opens = %f/secn", XAVG(syscalls.disk.opens));
  787.     storeAppendPrintf(sentry, "syscalls.disk.closes = %f/secn", XAVG(syscalls.disk.closes));
  788.     storeAppendPrintf(sentry, "syscalls.disk.reads = %f/secn", XAVG(syscalls.disk.reads));
  789.     storeAppendPrintf(sentry, "syscalls.disk.writes = %f/secn", XAVG(syscalls.disk.writes));
  790.     storeAppendPrintf(sentry, "syscalls.disk.seeks = %f/secn", XAVG(syscalls.disk.seeks));
  791.     storeAppendPrintf(sentry, "syscalls.disk.unlinks = %f/secn", XAVG(syscalls.disk.unlinks));
  792.     storeAppendPrintf(sentry, "syscalls.sock.accepts = %f/secn", XAVG(syscalls.sock.accepts));
  793.     storeAppendPrintf(sentry, "syscalls.sock.sockets = %f/secn", XAVG(syscalls.sock.sockets));
  794.     storeAppendPrintf(sentry, "syscalls.sock.connects = %f/secn", XAVG(syscalls.sock.connects));
  795.     storeAppendPrintf(sentry, "syscalls.sock.binds = %f/secn", XAVG(syscalls.sock.binds));
  796.     storeAppendPrintf(sentry, "syscalls.sock.closes = %f/secn", XAVG(syscalls.sock.closes));
  797.     storeAppendPrintf(sentry, "syscalls.sock.reads = %f/secn", XAVG(syscalls.sock.reads));
  798.     storeAppendPrintf(sentry, "syscalls.sock.writes = %f/secn", XAVG(syscalls.sock.writes));
  799.     storeAppendPrintf(sentry, "syscalls.sock.recvfroms = %f/secn", XAVG(syscalls.sock.recvfroms));
  800.     storeAppendPrintf(sentry, "syscalls.sock.sendtos = %f/secn", XAVG(syscalls.sock.sendtos));
  802.     storeAppendPrintf(sentry, "cpu_time = %f secondsn", ct);
  803.     storeAppendPrintf(sentry, "wall_time = %f secondsn", dt);
  804.     storeAppendPrintf(sentry, "cpu_usage = %f%%n", dpercent(ct, dt));
  805. }
  808. void
  809. statInit(void)
  810. {
  811.     int i;
  812.     debug(18, 5) ("statInit: Initializing...n");
  813.     for (i = 0; i < N_COUNT_HIST; i++)
  814. statCountersInit(&CountHist[i]);
  815.     for (i = 0; i < N_COUNT_HOUR_HIST; i++)
  816. statCountersInit(&CountHourHist[i]);
  817.     statCountersInit(&Counter);
  818.     eventAdd("statAvgTick", statAvgTick, NULL, (double) COUNT_INTERVAL, 1);
  819.     cachemgrRegister("info",
  820. "General Runtime Information",
  821. info_get, 0, 1);
  822.     cachemgrRegister("filedescriptors",
  823. "Process Filedescriptor Allocation",
  824. statFiledescriptors, 0, 1);
  825.     cachemgrRegister("objects",
  826. "All Cache Objects",
  827. stat_objects_get, 0, 0);
  828.     cachemgrRegister("vm_objects",
  829. "In-Memory and In-Transit Objects",
  830. stat_vmobjects_get, 0, 0);
  831. #if DEBUG_OPENFD
  832.     cachemgrRegister("openfd_objects",
  833. "Objects with Swapout files open",
  834. statOpenfdObj, 0, 0);
  835. #endif
  836.     cachemgrRegister("io",
  837. "Server-side network read() size histograms",
  838. stat_io_get, 0, 1);
  839.     cachemgrRegister("counters",
  840. "Traffic and Resource Counters",
  841. statCountersDump, 0, 1);
  842.     cachemgrRegister("peer_select",
  843. "Peer Selection Algorithms",
  844. statPeerSelect, 0, 1);
  845.     cachemgrRegister("digest_stats",
  846. "Cache Digest and ICP blob",
  847. statDigestBlob, 0, 1);
  848.     cachemgrRegister("5min",
  849. "5 Minute Average of Counters",
  850. statAvg5min, 0, 1);
  851.     cachemgrRegister("60min",
  852. "60 Minute Average of Counters",
  853. statAvg60min, 0, 1);
  854.     cachemgrRegister("utilization",
  855. "Cache Utilization",
  856. statUtilization, 0, 1);
  857. #if STAT_GRAPHS
  858.     cachemgrRegister("graph_variables",
  859. "Display cache metrics graphically",
  860. statGraphDump, 0, 1);
  861. #endif
  862.     cachemgrRegister("histograms",
  863. "Full Histogram Counts",
  864. statCountersHistograms, 0, 1);
  865.     ClientActiveRequests.head = NULL;
  866.     ClientActiveRequests.tail = NULL;
  867.     cachemgrRegister("active_requests",
  868. "Client-side Active Requests",
  869. statClientRequests, 0, 1);
  870. }
  872. static void
  873. statAvgTick(void *notused)
  874. {
  875.     StatCounters *t = &CountHist[0];
  876.     StatCounters *p = &CountHist[1];
  877.     StatCounters *c = &Counter;
  878.     struct rusage rusage;
  879.     eventAdd("statAvgTick", statAvgTick, NULL, COUNT_INTERVAL, 1);
  880.     squid_getrusage(&rusage);
  881.     c->page_faults = rusage_pagefaults(&rusage);
  882.     c->cputime = rusage_cputime(&rusage);
  883.     c->timestamp = current_time;
  884.     /* even if NCountHist is small, we already Init()ed the tail */
  885.     statCountersClean(CountHist + N_COUNT_HIST - 1);
  886.     xmemmove(p, t, (N_COUNT_HIST - 1) * sizeof(StatCounters));
  887.     statCountersCopy(t, c);
  888.     NCountHist++;
  890.     if ((NCountHist % COUNT_INTERVAL) == 0) {
  891. /* we have an hours worth of readings.  store previous hour */
  892. StatCounters *t = &CountHourHist[0];
  893. StatCounters *p = &CountHourHist[1];
  894. StatCounters *c = &CountHist[N_COUNT_HIST - 1];
  895. statCountersClean(CountHourHist + N_COUNT_HOUR_HIST - 1);
  896. xmemmove(p, t, (N_COUNT_HOUR_HIST - 1) * sizeof(StatCounters));
  897. statCountersCopy(t, c);
  898. NCountHourHist++;
  899.     }
  900. }
  902. static void
  903. statCountersInit(StatCounters * C)
  904. {
  905.     assert(C);
  906.     memset(C, 0, sizeof(*C));
  907.     C->timestamp = current_time;
  908.     statCountersInitSpecial(C);
  909. }
  911. /* add special cases here as they arrive */
  912. static void
  913. statCountersInitSpecial(StatCounters * C)
  914. {
  915.     /*
  916.      * HTTP svc_time hist is kept in milli-seconds; max of 3 hours.
  917.      */
  918.     statHistLogInit(&C->client_http.all_svc_time, 300, 0.0, 3600000.0 * 3.0);
  919.     statHistLogInit(&C->client_http.miss_svc_time, 300, 0.0, 3600000.0 * 3.0);
  920.     statHistLogInit(&C->client_http.nm_svc_time, 300, 0.0, 3600000.0 * 3.0);
  921.     statHistLogInit(&C->client_http.nh_svc_time, 300, 0.0, 3600000.0 * 3.0);
  922.     statHistLogInit(&C->client_http.hit_svc_time, 300, 0.0, 3600000.0 * 3.0);
  923.     /*
  924.      * ICP svc_time hist is kept in micro-seconds; max of 1 minute.
  925.      */
  926.     statHistLogInit(&C->icp.query_svc_time, 300, 0.0, 1000000.0 * 60.0);
  927.     statHistLogInit(&C->icp.reply_svc_time, 300, 0.0, 1000000.0 * 60.0);
  928.     /*
  929.      * DNS svc_time hist is kept in milli-seconds; max of 10 minutes.
  930.      */
  931.     statHistLogInit(&C->dns.svc_time, 300, 0.0, 60000.0 * 10.0);
  932.     /*
  933.      * Cache Digest Stuff
  934.      */
  935.     statHistEnumInit(&C->cd.on_xition_count, CacheDigestHashFuncCount);
  936.     statHistEnumInit(&C->comm_icp_incoming, INCOMING_ICP_MAX);
  937.     statHistEnumInit(&C->comm_http_incoming, INCOMING_HTTP_MAX);
  938.     statHistIntInit(&C->select_fds_hist, SQUID_MAXFD);
  939. }
  941. /* add special cases here as they arrive */
  942. static void
  943. statCountersClean(StatCounters * C)
  944. {
  945.     assert(C);
  946.     statHistClean(&C->client_http.all_svc_time);
  947.     statHistClean(&C->client_http.miss_svc_time);
  948.     statHistClean(&C->client_http.nm_svc_time);
  949.     statHistClean(&C->client_http.nh_svc_time);
  950.     statHistClean(&C->client_http.hit_svc_time);
  951.     statHistClean(&C->icp.query_svc_time);
  952.     statHistClean(&C->icp.reply_svc_time);
  953.     statHistClean(&C->dns.svc_time);
  954.     statHistClean(&C->cd.on_xition_count);
  955.     statHistClean(&C->comm_icp_incoming);
  956.     statHistClean(&C->comm_http_incoming);
  957.     statHistClean(&C->select_fds_hist);
  958. }
  960. /* add special cases here as they arrive */
  961. static void
  962. statCountersCopy(StatCounters * dest, const StatCounters * orig)
  963. {
  964.     assert(dest && orig);
  965.     /* this should take care of all the fields, but "special" ones */
  966.     memcpy(dest, orig, sizeof(*dest));
  967.     /* prepare space where to copy special entries */
  968.     statCountersInitSpecial(dest);
  969.     /* now handle special cases */
  970.     /* note: we assert that histogram capacities do not change */
  971.     statHistCopy(&dest->client_http.all_svc_time, &orig->client_http.all_svc_time);
  972.     statHistCopy(&dest->client_http.miss_svc_time, &orig->client_http.miss_svc_time);
  973.     statHistCopy(&dest->client_http.nm_svc_time, &orig->client_http.nm_svc_time);
  974.     statHistCopy(&dest->client_http.nh_svc_time, &orig->client_http.nh_svc_time);
  975.     statHistCopy(&dest->client_http.hit_svc_time, &orig->client_http.hit_svc_time);
  976.     statHistCopy(&dest->icp.query_svc_time, &orig->icp.query_svc_time);
  977.     statHistCopy(&dest->icp.reply_svc_time, &orig->icp.reply_svc_time);
  978.     statHistCopy(&dest->dns.svc_time, &orig->dns.svc_time);
  979.     statHistCopy(&dest->cd.on_xition_count, &orig->cd.on_xition_count);
  980.     statHistCopy(&dest->comm_icp_incoming, &orig->comm_icp_incoming);
  981.     statHistCopy(&dest->comm_http_incoming, &orig->comm_http_incoming);
  982.     statHistCopy(&dest->select_fds_hist, &orig->select_fds_hist);
  983. }
  985. static void
  986. statCountersHistograms(StoreEntry * sentry)
  987. {
  988.     StatCounters *f = &Counter;
  989.     storeAppendPrintf(sentry, "client_http.all_svc_time histogram:n");
  990.     statHistDump(&f->client_http.all_svc_time, sentry, NULL);
  991.     storeAppendPrintf(sentry, "client_http.miss_svc_time histogram:n");
  992.     statHistDump(&f->client_http.miss_svc_time, sentry, NULL);
  993.     storeAppendPrintf(sentry, "client_http.nm_svc_time histogram:n");
  994.     statHistDump(&f->client_http.nm_svc_time, sentry, NULL);
  995.     storeAppendPrintf(sentry, "client_http.nh_svc_time histogram:n");
  996.     statHistDump(&f->client_http.nh_svc_time, sentry, NULL);
  997.     storeAppendPrintf(sentry, "client_http.hit_svc_time histogram:n");
  998.     statHistDump(&f->client_http.hit_svc_time, sentry, NULL);
  999.     storeAppendPrintf(sentry, "icp.query_svc_time histogram:n");
  1000.     statHistDump(&f->icp.query_svc_time, sentry, NULL);
  1001.     storeAppendPrintf(sentry, "icp.reply_svc_time histogram:n");
  1002.     statHistDump(&f->icp.reply_svc_time, sentry, NULL);
  1003.     storeAppendPrintf(sentry, "dns.svc_time histogram:n");
  1004.     statHistDump(&f->dns.svc_time, sentry, NULL);
  1005. }
  1007. static void
  1008. statCountersDump(StoreEntry * sentry)
  1009. {
  1010.     StatCounters *f = &Counter;
  1011.     struct rusage rusage;
  1012.     squid_getrusage(&rusage);
  1013.     f->page_faults = rusage_pagefaults(&rusage);
  1014.     f->cputime = rusage_cputime(&rusage);
  1016.     storeAppendPrintf(sentry, "sample_time = %d.%d (%s)n",
  1017. (int) f->timestamp.tv_sec,
  1018. (int) f->timestamp.tv_usec,
  1019. mkrfc1123(f->timestamp.tv_sec));
  1020.     storeAppendPrintf(sentry, "client_http.requests = %dn",
  1021. f->client_http.requests);
  1022.     storeAppendPrintf(sentry, "client_http.hits = %dn",
  1023. f->client_http.hits);
  1024.     storeAppendPrintf(sentry, "client_http.errors = %dn",
  1025. f->client_http.errors);
  1026.     storeAppendPrintf(sentry, "client_http.kbytes_in = %dn",
  1027. (int) f->client_http.kbytes_in.kb);
  1028.     storeAppendPrintf(sentry, "client_http.kbytes_out = %dn",
  1029. (int) f->client_http.kbytes_out.kb);
  1030.     storeAppendPrintf(sentry, "client_http.hit_kbytes_out = %dn",
  1031. (int) f->client_http.hit_kbytes_out.kb);
  1033.     storeAppendPrintf(sentry, "server.all.requests = %dn",
  1034. (int) f->server.all.requests);
  1035.     storeAppendPrintf(sentry, "server.all.errors = %dn",
  1036. (int) f->server.all.errors);
  1037.     storeAppendPrintf(sentry, "server.all.kbytes_in = %dn",
  1038. (int) f->server.all.kbytes_in.kb);
  1039.     storeAppendPrintf(sentry, "server.all.kbytes_out = %dn",
  1040. (int) f->server.all.kbytes_out.kb);
  1042.     storeAppendPrintf(sentry, "server.http.requests = %dn",
  1043. (int) f->server.http.requests);
  1044.     storeAppendPrintf(sentry, "server.http.errors = %dn",
  1045. (int) f->server.http.errors);
  1046.     storeAppendPrintf(sentry, "server.http.kbytes_in = %dn",
  1047. (int) f->server.http.kbytes_in.kb);
  1048.     storeAppendPrintf(sentry, "server.http.kbytes_out = %dn",
  1049. (int) f->server.http.kbytes_out.kb);
  1051.     storeAppendPrintf(sentry, "server.ftp.requests = %dn",
  1052. (int) f->server.ftp.requests);
  1053.     storeAppendPrintf(sentry, "server.ftp.errors = %dn",
  1054. (int) f->server.ftp.errors);
  1055.     storeAppendPrintf(sentry, "server.ftp.kbytes_in = %dn",
  1056. (int) f->server.ftp.kbytes_in.kb);
  1057.     storeAppendPrintf(sentry, "server.ftp.kbytes_out = %dn",
  1058. (int) f->server.ftp.kbytes_out.kb);
  1060.     storeAppendPrintf(sentry, "server.other.requests = %dn",
  1061. (int) f->server.other.requests);
  1062.     storeAppendPrintf(sentry, "server.other.errors = %dn",
  1063. (int) f->server.other.errors);
  1064.     storeAppendPrintf(sentry, "server.other.kbytes_in = %dn",
  1065. (int) f->server.other.kbytes_in.kb);
  1066.     storeAppendPrintf(sentry, "server.other.kbytes_out = %dn",
  1067. (int) f->server.other.kbytes_out.kb);
  1069.     storeAppendPrintf(sentry, "icp.pkts_sent = %dn",
  1070. f->icp.pkts_sent);
  1071.     storeAppendPrintf(sentry, "icp.pkts_recv = %dn",
  1072. f->icp.pkts_recv);
  1073.     storeAppendPrintf(sentry, "icp.queries_sent = %dn",
  1074. f->icp.queries_sent);
  1075.     storeAppendPrintf(sentry, "icp.replies_sent = %dn",
  1076. f->icp.replies_sent);
  1077.     storeAppendPrintf(sentry, "icp.queries_recv = %dn",
  1078. f->icp.queries_recv);
  1079.     storeAppendPrintf(sentry, "icp.replies_recv = %dn",
  1080. f->icp.replies_recv);
  1081.     storeAppendPrintf(sentry, "icp.query_timeouts = %dn",
  1082. f->icp.query_timeouts);
  1083.     storeAppendPrintf(sentry, "icp.replies_queued = %dn",
  1084. f->icp.replies_queued);
  1085.     storeAppendPrintf(sentry, "icp.kbytes_sent = %dn",
  1086. (int) f->icp.kbytes_sent.kb);
  1087.     storeAppendPrintf(sentry, "icp.kbytes_recv = %dn",
  1088. (int) f->icp.kbytes_recv.kb);
  1089.     storeAppendPrintf(sentry, "icp.q_kbytes_sent = %dn",
  1090. (int) f->icp.q_kbytes_sent.kb);
  1091.     storeAppendPrintf(sentry, "icp.r_kbytes_sent = %dn",
  1092. (int) f->icp.r_kbytes_sent.kb);
  1093.     storeAppendPrintf(sentry, "icp.q_kbytes_recv = %dn",
  1094. (int) f->icp.q_kbytes_recv.kb);
  1095.     storeAppendPrintf(sentry, "icp.r_kbytes_recv = %dn",
  1096. (int) f->icp.r_kbytes_recv.kb);
  1098. #if USE_CACHE_DIGESTS
  1099.     storeAppendPrintf(sentry, "icp.times_used = %dn",
  1100. f->icp.times_used);
  1101.     storeAppendPrintf(sentry, "cd.times_used = %dn",
  1102. f->cd.times_used);
  1103.     storeAppendPrintf(sentry, "cd.msgs_sent = %dn",
  1104. f->cd.msgs_sent);
  1105.     storeAppendPrintf(sentry, "cd.msgs_recv = %dn",
  1106. f->cd.msgs_recv);
  1107.     storeAppendPrintf(sentry, "cd.memory = %dn",
  1108. (int) f->cd.memory.kb);
  1109.     storeAppendPrintf(sentry, "cd.local_memory = %dn",
  1110. (int) (store_digest ? store_digest->mask_size / 1024 : 0));
  1111.     storeAppendPrintf(sentry, "cd.kbytes_sent = %dn",
  1112. (int) f->cd.kbytes_sent.kb);
  1113.     storeAppendPrintf(sentry, "cd.kbytes_recv = %dn",
  1114. (int) f->cd.kbytes_recv.kb);
  1115. #endif
  1117.     storeAppendPrintf(sentry, "unlink.requests = %dn",
  1118. f->unlink.requests);
  1119.     storeAppendPrintf(sentry, "page_faults = %dn",
  1120. f->page_faults);
  1121.     storeAppendPrintf(sentry, "select_loops = %dn",
  1122. f->select_loops);
  1123.     storeAppendPrintf(sentry, "cpu_time = %fn",
  1124. f->cputime);
  1125.     storeAppendPrintf(sentry, "wall_time = %fn",
  1126. tvSubDsec(f->timestamp, current_time));
  1127.     storeAppendPrintf(sentry, "swap_files_cleaned = %dn",
  1128. f->swap_files_cleaned);
  1129.     storeAppendPrintf(sentry, "aborted_requests = %dn",
  1130. f->aborted_requests);
  1131. }
  1133. void
  1134. statFreeMemory(void)
  1135. {
  1136.     int i;
  1137.     for (i = 0; i < N_COUNT_HIST; i++)
  1138. statCountersClean(&CountHist[i]);
  1139.     for (i = 0; i < N_COUNT_HOUR_HIST; i++)
  1140. statCountersClean(&CountHourHist[i]);
  1141. }
  1143. static void
  1144. statPeerSelect(StoreEntry * sentry)
  1145. {
  1146. #if USE_CACHE_DIGESTS
  1147.     StatCounters *f = &Counter;
  1148.     peer *peer;
  1149.     const int tot_used = f->cd.times_used + f->icp.times_used;
  1151.     /* totals */
  1152.     cacheDigestGuessStatsReport(&f->cd.guess, sentry, "all peers");
  1153.     /* per-peer */
  1154.     storeAppendPrintf(sentry, "nPer-peer statistics:n");
  1155.     for (peer = getFirstPeer(); peer; peer = getNextPeer(peer)) {
  1156. if (peer->digest)
  1157.     peerDigestStatsReport(peer->digest, sentry);
  1158. else
  1159.     storeAppendPrintf(sentry, "nNo peer digest from %sn", peer->host);
  1160. storeAppendPrintf(sentry, "n");
  1161.     }
  1163.     storeAppendPrintf(sentry, "nAlgorithm usage:n");
  1164.     storeAppendPrintf(sentry, "Cache Digest: %7d (%3d%%)n",
  1165. f->cd.times_used, xpercentInt(f->cd.times_used, tot_used));
  1166.     storeAppendPrintf(sentry, "Icp:          %7d (%3d%%)n",
  1167. f->icp.times_used, xpercentInt(f->icp.times_used, tot_used));
  1168.     storeAppendPrintf(sentry, "Total:        %7d (%3d%%)n",
  1169. tot_used, xpercentInt(tot_used, tot_used));
  1170. #else
  1171.     storeAppendPrintf(sentry, "peer digests are disabled; no stats is available.n");
  1172. #endif
  1173. }
  1175. static void
  1176. statDigestBlob(StoreEntry * sentry)
  1177. {
  1178.     storeAppendPrintf(sentry, "nCounters:n");
  1179.     statCountersDump(sentry);
  1180.     storeAppendPrintf(sentry, "n5 Min Averages:n");
  1181.     statAvgDump(sentry, 5, 0);
  1182.     storeAppendPrintf(sentry, "nHistograms:n");
  1183.     statCountersHistograms(sentry);
  1184.     storeAppendPrintf(sentry, "nPeer Digests:n");
  1185.     statPeerSelect(sentry);
  1186.     storeAppendPrintf(sentry, "nLocal Digest:n");
  1187.     storeDigestReport(sentry);
  1188. }
  1190. static void
  1191. statAvg5min(StoreEntry * e)
  1192. {
  1193.     statAvgDump(e, 5, 0);
  1194. }
  1196. static void
  1197. statAvg60min(StoreEntry * e)
  1198. {
  1199.     statAvgDump(e, 60, 0);
  1200. }
  1202. static double
  1203. statMedianSvc(int interval, int which)
  1204. {
  1205.     StatCounters *f;
  1206.     StatCounters *l;
  1207.     double x;
  1208.     assert(interval > 0);
  1209.     if (interval > N_COUNT_HIST - 1)
  1210. interval = N_COUNT_HIST - 1;
  1211.     f = &CountHist[0];
  1212.     l = &CountHist[interval];
  1213.     assert(f);
  1214.     assert(l);
  1215.     switch (which) {
  1216.     case MEDIAN_HTTP:
  1217. x = statHistDeltaMedian(&l->client_http.all_svc_time, &f->client_http.all_svc_time);
  1218. break;
  1219.     case MEDIAN_HIT:
  1220. x = statHistDeltaMedian(&l->client_http.hit_svc_time, &f->client_http.hit_svc_time);
  1221. break;
  1222.     case MEDIAN_MISS:
  1223. x = statHistDeltaMedian(&l->client_http.miss_svc_time, &f->client_http.miss_svc_time);
  1224. break;
  1225.     case MEDIAN_NM:
  1226. x = statHistDeltaMedian(&l->client_http.nm_svc_time, &f->client_http.nm_svc_time);
  1227. break;
  1228.     case MEDIAN_NH:
  1229. x = statHistDeltaMedian(&l->client_http.nh_svc_time, &f->client_http.nh_svc_time);
  1230. break;
  1231.     case MEDIAN_ICP_QUERY:
  1232. x = statHistDeltaMedian(&l->icp.query_svc_time, &f->icp.query_svc_time);
  1233. break;
  1234.     case MEDIAN_DNS:
  1235. x = statHistDeltaMedian(&l->dns.svc_time, &f->dns.svc_time);
  1236. break;
  1237.     default:
  1238. debug(49, 5) ("get_median_val: unknown type.n");
  1239. x = 0;
  1240.     }
  1241.     return x;
  1242. }
  1244. /*
  1245.  * SNMP wants ints, ick
  1246.  */
  1247. int
  1248. get_median_svc(int interval, int which)
  1249. {
  1250.     return (int) statMedianSvc(interval, which);
  1251. }
  1253. StatCounters *
  1254. snmpStatGet(int minutes)
  1255. {
  1256.     return &CountHist[minutes];
  1257. }
  1259. int
  1260. stat5minClientRequests(void)
  1261. {
  1262.     assert(N_COUNT_HIST > 5);
  1263.     return Counter.client_http.requests - CountHist[5].client_http.requests;
  1264. }
  1266. static double
  1267. statCPUUsage(int minutes)
  1268. {
  1269.     assert(minutes < N_COUNT_HIST);
  1270.     return dpercent(CountHist[0].cputime - CountHist[minutes].cputime,
  1271. tvSubDsec(CountHist[minutes].timestamp, CountHist[0].timestamp));
  1272. }
  1274. extern double
  1275. statRequestHitRatio(int minutes)
  1276. {
  1277.     assert(minutes < N_COUNT_HIST);
  1278.     return dpercent(CountHist[0].client_http.hits -
  1279. CountHist[minutes].client_http.hits,
  1280. CountHist[0].client_http.requests -
  1281. CountHist[minutes].client_http.requests);
  1282. }
  1284. extern double
  1285. statByteHitRatio(int minutes)
  1286. {
  1287.     size_t s;
  1288.     size_t c;
  1289.     assert(minutes < N_COUNT_HIST);
  1290.     c = CountHist[0].client_http.kbytes_out.kb - CountHist[minutes].client_http.kbytes_out.kb;
  1291.     s = CountHist[0].server.all.kbytes_in.kb - CountHist[minutes].server.all.kbytes_in.kb;
  1292.     /* size_t might be unsigned */
  1293.     if (c > s)
  1294. return dpercent(c - s, c);
  1295.     else
  1296. return (-1.0 * dpercent(s - c, c));
  1297. }
  1299. static void
  1300. statClientRequests(StoreEntry * s)
  1301. {
  1302.     dlink_node *i;
  1303.     clientHttpRequest *http;
  1304.     ConnStateData *conn;
  1305.     StoreEntry *e;
  1306.     int fd;
  1307.     for (i = ClientActiveRequests.head; i; i = i->next) {
  1308. http = i->data;
  1309. assert(http);
  1310. conn = http->conn;
  1311. storeAppendPrintf(s, "Connection: %pn", conn);
  1312. if (conn) {
  1313.     fd = conn->fd;
  1314.     storeAppendPrintf(s, "tFD %d, read %d, wrote %dn", fd,
  1315. fd_table[fd].bytes_read, fd_table[fd].bytes_written);
  1316.     storeAppendPrintf(s, "tFD desc: %sn", fd_table[fd].desc);
  1317.     storeAppendPrintf(s, "tin: buf %p, offset %d, size %dn",
  1318. conn->in.buf, conn->in.offset, conn->in.size);
  1319.     storeAppendPrintf(s, "tpeer: %s:%dn",
  1320. inet_ntoa(conn->peer.sin_addr),
  1321. ntohs(conn->peer.sin_port));
  1322.     storeAppendPrintf(s, "tme: %s:%dn",
  1323. inet_ntoa(conn->me.sin_addr),
  1324. ntohs(conn->me.sin_port));
  1325.     storeAppendPrintf(s, "tnrequests: %dn",
  1326. conn->nrequests);
  1327.     storeAppendPrintf(s, "tpersistent: %dn",
  1328. conn->persistent);
  1329.     storeAppendPrintf(s, "tdefer: n %d, until %dn",
  1330. conn->defer.n, conn->defer.until);
  1331. }
  1332. storeAppendPrintf(s, "uri %sn", http->uri);
  1333. storeAppendPrintf(s, "out.offset %d, out.size %dn",
  1334.     http->out.offset, http->out.size);
  1335. storeAppendPrintf(s, "req_sz %dn", http->req_sz);
  1336. e = http->entry;
  1337. storeAppendPrintf(s, "entry %p/%sn", e, e ? storeKeyText(e->key) : "N/A");
  1338. e = http->old_entry;
  1339. storeAppendPrintf(s, "old_entry %p/%sn", e, e ? storeKeyText(e->key) : "N/A");
  1340. storeAppendPrintf(s, "start %d.%06d (%f seconds ago)n", http->start.tv_sec,
  1341.     http->start.tv_usec,
  1342.     tvSubDsec(http->start, current_time));
  1343. storeAppendPrintf(s, "n");
  1344.     }
  1345. }
  1347. #if STAT_GRAPHS
  1348. /*
  1349.  * urgh, i don't like these, but they do cut the amount of code down immensely
  1350.  */
  1352. #define GRAPH_PER_MIN(Y) 
  1353.     for (i=0;i<(N_COUNT_HIST-2);i++) { 
  1354. dt = tvSubDsec(CountHist[i].timestamp, CountHist[i+1].timestamp); 
  1355. if (dt <= 0.0) 
  1356.     break; 
  1357. storeAppendPrintf(e, "%lu,%0.2f:", 
  1358.     CountHist[i].timestamp.tv_sec, 
  1359.     ((CountHist[i].Y - CountHist[i+1].Y) / dt)); 
  1360.     }
  1362. #define GRAPH_PER_HOUR(Y) 
  1363.     for (i=0;i<(N_COUNT_HOUR_HIST-2);i++) { 
  1364. dt = tvSubDsec(CountHourHist[i].timestamp, CountHourHist[i+1].timestamp); 
  1365. if (dt <= 0.0) 
  1366.     break; 
  1367. storeAppendPrintf(e, "%lu,%0.2f:", 
  1368.     CountHourHist[i].timestamp.tv_sec, 
  1369.     ((CountHourHist[i].Y - CountHourHist[i+1].Y) / dt)); 
  1370.     }
  1372. #define GRAPH_TITLE(X,Y) storeAppendPrintf(e,"%st%st",X,Y);
  1373. #define GRAPH_END storeAppendPrintf(e,"n");
  1375. #define GENGRAPH(X,Y,Z) 
  1376.     GRAPH_TITLE(Y,Z) 
  1377.     GRAPH_PER_MIN(X) 
  1378.     GRAPH_PER_HOUR(X) 
  1379.     GRAPH_END
  1381. static void
  1382. statGraphDump(StoreEntry * e)
  1383. {
  1384.     int i;
  1385.     double dt;
  1387.     GENGRAPH(client_http.requests, "client_http.requests", "Client HTTP requests/sec");
  1388.     GENGRAPH(client_http.hits, "client_http.hits", "Client HTTP hits/sec");
  1389.     GENGRAPH(client_http.errors, "client_http.errors", "Client HTTP errors/sec");
  1390.     GENGRAPH(client_http.kbytes_in.kb, "client_http.kbytes_in", "Client HTTP kbytes_in/sec");
  1391.     GENGRAPH(client_http.kbytes_out.kb, "client_http.kbytes_out", "Client HTTP kbytes_out/sec");
  1393.     /* XXX todo: http median service times */
  1395.     GENGRAPH(server.all.requests, "server.all.requests", "Server requests/sec");
  1396.     GENGRAPH(server.all.errors, "server.all.errors", "Server errors/sec");
  1397.     GENGRAPH(server.all.kbytes_in.kb, "server.all.kbytes_in", "Server total kbytes_in/sec");
  1398.     GENGRAPH(server.all.kbytes_out.kb, "server.all.kbytes_out", "Server total kbytes_out/sec");
  1400.     GENGRAPH(server.http.requests, "server.http.requests", "Server HTTP requests/sec");
  1401.     GENGRAPH(server.http.errors, "server.http.errors", "Server HTTP errors/sec");
  1402.     GENGRAPH(server.http.kbytes_in.kb, "server.http.kbytes_in", "Server HTTP kbytes_in/sec");
  1403.     GENGRAPH(server.http.kbytes_out.kb, "server.http.kbytes_out", "Server HTTP kbytes_out/sec");
  1405.     GENGRAPH(server.ftp.requests, "server.ftp.requests", "Server FTP requests/sec");
  1406.     GENGRAPH(server.ftp.errors, "server.ftp.errors", "Server FTP errors/sec");
  1407.     GENGRAPH(server.ftp.kbytes_in.kb, "server.ftp.kbytes_in", "Server FTP kbytes_in/sec");
  1408.     GENGRAPH(server.ftp.kbytes_out.kb, "server.ftp.kbytes_out", "Server FTP kbytes_out/sec");
  1410.     GENGRAPH(server.other.requests, "server.other.requests", "Server other requests/sec");
  1411.     GENGRAPH(server.other.errors, "server.other.errors", "Server other errors/sec");
  1412.     GENGRAPH(server.other.kbytes_in.kb, "server.other.kbytes_in", "Server other kbytes_in/sec");
  1413.     GENGRAPH(server.other.kbytes_out.kb, "server.other.kbytes_out", "Server other kbytes_out/sec");
  1415.     GENGRAPH(icp.pkts_sent, "icp.pkts_sent", "ICP packets sent/sec");
  1416.     GENGRAPH(icp.pkts_recv, "icp.pkts_recv", "ICP packets received/sec");
  1417.     GENGRAPH(icp.kbytes_sent.kb, "icp.kbytes_sent", "ICP kbytes_sent/sec");
  1418.     GENGRAPH(icp.kbytes_recv.kb, "icp.kbytes_recv", "ICP kbytes_received/sec");
  1420.     /* XXX todo: icp median service times */
  1421.     /* XXX todo: dns median service times */
  1423.     GENGRAPH(unlink.requests, "unlink.requests", "Cache File unlink requests/sec");
  1424.     GENGRAPH(page_faults, "page_faults", "System Page Faults/sec");
  1425.     GENGRAPH(select_loops, "select_loops", "System Select Loop calls/sec");
  1426.     GENGRAPH(cputime, "cputime", "CPU utilisation");
  1427. }
  1429. #endif /* STAT_GRAPHS */