Changed some operator++ from postfix to prefix.
*/
#include "squid.h"
-#include "StatHist.h"
+#include "StatCounters.h"
#include "Store.h"
#if USE_CACHE_DIGESTS
#include "DiskIO/IORequestor.h"
#include "DiskIO/ReadRequest.h"
#include "DiskIO/WriteRequest.h"
+#include "StatCounters.h"
CBDATA_CLASS_INIT(DiskdFile);
void *
void
DiskdFile::openDone(diomsg *M)
{
- statCounter.syscalls.disk.opens++;
+ ++statCounter.syscalls.disk.opens;
debugs(79, 3, "storeDiskdOpenDone: status " << M->status);
if (M->status < 0) {
void
DiskdFile::createDone(diomsg *M)
{
- statCounter.syscalls.disk.opens++;
+ ++statCounter.syscalls.disk.opens;
debugs(79, 3, "storeDiskdCreateDone: status " << M->status);
if (M->status < 0) {
void
DiskdFile::closeDone(diomsg * M)
{
- statCounter.syscalls.disk.closes++;
+ ++statCounter.syscalls.disk.closes;
debugs(79, 3, "DiskdFile::closeDone: status " << M->status);
if (M->status < 0) {
void
DiskdFile::readDone(diomsg * M)
{
- statCounter.syscalls.disk.reads++;
+ ++statCounter.syscalls.disk.reads;
debugs(79, 3, "DiskdFile::readDone: status " << M->status);
assert (M->requestor);
ReadRequest::Pointer readRequest = dynamic_cast<ReadRequest *>(M->requestor);
void
DiskdFile::writeDone(diomsg *M)
{
- statCounter.syscalls.disk.writes++;
+ ++statCounter.syscalls.disk.writes;
debugs(79, 3, "storeDiskdWriteDone: status " << M->status);
assert (M->requestor);
WriteRequest::Pointer writeRequest = dynamic_cast<WriteRequest *>(M->requestor);
#include "diomsg.h"
/* for statfs */
#include "Store.h"
+#include "StatCounters.h"
#include "SquidTime.h"
diskd_stats_t diskd_stats;
DiskdIOStrategy::unlinkDone(diomsg * M)
{
debugs(79, 3, "storeDiskdUnlinkDone: file " << shm.buf + M->shm_offset << " status " << M->status);
- statCounter.syscalls.disk.unlinks++;
+ ++statCounter.syscalls.disk.unlinks;
if (M->status < 0)
diskd_stats.unlink.fail++;
#include "DiskIO/IORequestor.h"
#include "DiskIO/ReadRequest.h"
#include "DiskIO/WriteRequest.h"
+#include "StatCounters.h"
/* === PUBLIC =========================================================== */
void
DiskThreadsDiskFile::open(int flags, mode_t mode, RefCount<IORequestor> callback)
{
- statCounter.syscalls.disk.opens++;
+ ++statCounter.syscalls.disk.opens;
#if !ASYNC_OPEN
fd = file_open(path_, flags);
debugs(79, 3, "DiskThreadsDiskFile::read: " << this << ", size " << request->len);
assert (fd > -1);
assert (ioRequestor.getRaw());
- statCounter.syscalls.disk.reads++;
+ ++statCounter.syscalls.disk.reads;
++inProgressIOs;
#if ASYNC_READ
void
DiskThreadsDiskFile::create(int flags, mode_t mode, RefCount<IORequestor> callback)
{
- statCounter.syscalls.disk.opens++;
+ ++statCounter.syscalls.disk.opens;
#if !ASYNC_CREATE
int fd = file_open(path_, flags);
void DiskThreadsDiskFile::doClose()
{
if (fd > -1) {
- statCounter.syscalls.disk.closes++;
+ ++statCounter.syscalls.disk.closes;
#if ASYNC_CLOSE
aioClose(fd);
DiskThreadsDiskFile::write(WriteRequest * writeRequest)
{
debugs(79, 3, "DiskThreadsDiskFile::write: FD " << fd);
- statCounter.syscalls.disk.writes++;
+ ++statCounter.syscalls.disk.writes;
++inProgressIOs;
#if ASYNC_WRITE
#include "DiskThreadsIOStrategy.h"
#include "fde.h"
#include "mgr/Registration.h"
+#include "StatCounters.h"
/* for statfs */
#include "Store.h"
void
DiskThreadsIOStrategy::unlinkFile(char const *path)
{
- statCounter.syscalls.disk.unlinks++;
+ ++statCounter.syscalls.disk.unlinks;
aioUnlink(path, NULL, NULL);
}
#include "ipc/StrandSearch.h"
#include "ipc/UdsOp.h"
#include "ipc/mem/Pages.h"
+#include "StatCounters.h"
#include "SquidTime.h"
CBDATA_CLASS_INIT(IpcIoFile);
char *const buf = Ipc::Mem::PagePointer(ipcIo.page);
const ssize_t read = pread(TheFile, buf, min(ipcIo.len, Ipc::Mem::PageSize()), ipcIo.offset);
- statCounter.syscalls.disk.reads++;
+ ++statCounter.syscalls.disk.reads;
fd_bytes(TheFile, read, FD_READ);
if (read >= 0) {
{
const char *const buf = Ipc::Mem::PagePointer(ipcIo.page);
const ssize_t wrote = pwrite(TheFile, buf, min(ipcIo.len, Ipc::Mem::PageSize()), ipcIo.offset);
- statCounter.syscalls.disk.writes++;
+ ++statCounter.syscalls.disk.writes;
fd_bytes(TheFile, wrote, FD_WRITE);
if (wrote >= 0) {
SquidNew.cc \
stat.cc \
StatCounters.h \
+ StatCounters.cc \
StatHist.h \
StatHist.cc \
String.cc \
tests/stub_debug.cc \
tests/stub_HelperChildConfig.cc \
StatCounters.h \
+ StatCounters.cc \
StatHist.h \
tests/stub_StatHist.cc \
tests/stub_store.cc \
SquidMath.cc \
stat.cc \
StatCounters.h \
+ StatCounters.cc \
StatHist.h \
StatHist.cc \
stmem.cc \
refresh.cc \
RemovalPolicy.cc \
StatCounters.h \
+ StatCounters.cc \
StatHist.h \
StatHist.cc \
stmem.cc \
SquidMath.h \
stat.cc \
StatCounters.h \
+ StatCounters.cc \
StatHist.h \
StatHist.cc \
stmem.cc \
SquidMath.cc \
stat.cc \
StatCounters.h \
+ StatCounters.cc \
StatHist.h \
StatHist.cc \
stmem.cc \
SquidMath.cc \
stat.cc \
StatCounters.h \
+ StatCounters.cc \
StatHist.h \
StatHist.cc \
stmem.cc \
SquidMath.cc \
stat.cc \
StatCounters.h \
+ StatCounters.cc \
StatHist.h \
StatHist.cc \
stmem.cc \
RemovalPolicy.cc \
refresh.cc \
StatCounters.h \
+ StatCounters.cc \
StatHist.h \
StatHist.cc \
stmem.cc \
HttpHdrScTarget.cc \
url.cc \
StatCounters.h \
+ StatCounters.cc \
StatHist.h \
StatHist.cc \
HttpHdrRange.cc \
Parsing.cc \
RemovalPolicy.cc \
StatCounters.h \
+ StatCounters.cc \
StatHist.h \
StatHist.cc \
stmem.cc \
HttpHdrScTarget.cc \
url.cc \
StatCounters.h \
+ StatCounters.cc \
StatHist.h \
StatHist.cc \
HttpHdrRange.cc \
HttpHdrScTarget.cc \
url.cc \
StatCounters.h \
+ StatCounters.cc \
StatHist.h \
StatHist.cc \
HttpHdrRange.cc \
SquidMath.cc \
stat.cc \
StatCounters.h \
+ StatCounters.cc \
StatHist.h \
StatHist.cc \
stmem.cc \
#if USE_CACHE_DIGESTS
#include "cbdata.h"
+#include "StatCounters.h" /* for cd_guess_stats */
struct _Version {
short int current; /* current version */
#include "HttpReply.h"
#include "errorpage.h"
#include "err_detail_type.h"
+#include "StatCounters.h"
#include "SquidTime.h"
#if USE_ADAPTATION
if (io.size > 0) {
fd_bytes(io.fd, io.size, FD_WRITE);
- kb_incr(&statCounter.server.all.kbytes_out, io.size);
+ kb_incr(&(statCounter.server.all.kbytes_out), io.size);
// kids should increment their counters
}
--- /dev/null
+/*
+ * SQUID Web Proxy Cache http://www.squid-cache.org/
+ * ----------------------------------------------------------
+ *
+ * Squid is the result of efforts by numerous individuals from
+ * the Internet community; see the CONTRIBUTORS file for full
+ * details. Many organizations have provided support for Squid's
+ * development; see the SPONSORS file for full details. Squid is
+ * Copyrighted (C) 2001 by the Regents of the University of
+ * California; see the COPYRIGHT file for full details. Squid
+ * incorporates software developed and/or copyrighted by other
+ * sources; see the CREDITS file for full details.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
+ *
+ * AUTHOR: Francesco Chemolli (Harvest-derived)
+ *
+ */
+
+#include "config.h"
+#include "StatCounters.h"
+
+StatCounters *StatCounters::counters;
+StatCounters statCounter;
/*
- * StatCounters.h
+ * SQUID Web Proxy Cache http://www.squid-cache.org/
+ * ----------------------------------------------------------
+ *
+ * Squid is the result of efforts by numerous individuals from
+ * the Internet community; see the CONTRIBUTORS file for full
+ * details. Many organizations have provided support for Squid's
+ * development; see the SPONSORS file for full details. Squid is
+ * Copyrighted (C) 2001 by the Regents of the University of
+ * California; see the COPYRIGHT file for full details. Squid
+ * incorporates software developed and/or copyrighted by other
+ * sources; see the CREDITS file for full details.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
+ *
+ * AUTHOR: Francesco Chemolli (Harvest-derived)
*
- * Created on: Dec 9, 2011
- * Author: kinkie
*/
-
#ifndef STATCOUNTERS_H_
#define STATCOUNTERS_H_
*/
class StatCounters {
public:
-
struct {
int clients;
int requests;
int outs;
int ins;
} swap;
+
+private:
};
+extern StatCounters statCounter;
#endif /* STATCOUNTERS_H_ */
#include "mgr/Registration.h"
#include "SquidMath.h"
#include "SquidTime.h"
+#include "StatCounters.h"
#include "Store.h"
c->prevTime=current_dtime;/* put current time to have something sensible here */
#endif
hash_join(client_table, &c->hash);
- statCounter.client_http.clients++;
+ ++statCounter.client_http.clients;
if ((statCounter.client_http.clients > max_clients) && !cleanup_running && cleanup_scheduled < 2) {
cleanup_scheduled++;
clientdbFreeItem(c);
- statCounter.client_http.clients--;
+ --statCounter.client_http.clients;
cleanup_removed++;
}
void
clientUpdateStatCounters(log_type logType)
{
- statCounter.client_http.requests++;
+ ++statCounter.client_http.requests;
if (logTypeIsATcpHit(logType))
- statCounter.client_http.hits++;
+ ++statCounter.client_http.hits;
if (logType == LOG_TCP_HIT)
- statCounter.client_http.disk_hits++;
+ ++statCounter.client_http.disk_hits;
else if (logType == LOG_TCP_MEM_HIT)
- statCounter.client_http.mem_hits++;
+ ++statCounter.client_http.mem_hits;
}
void
if (io.flag == COMM_OK) {
if (io.size > 0) {
- kb_incr(&statCounter.client_http.kbytes_in, io.size);
+ kb_incr(&(statCounter.client_http.kbytes_in), io.size);
// may comm_close or setReplyToError
if (!handleReadData(io.buf, io.size))
#include "ip/QosConfig.h"
#include "ip/tools.h"
#include "ClientInfo.h"
+#include "StatCounters.h"
#if USE_SSL
#include "ssl/support.h"
#endif
#include "ICP.h"
#include "mgr/Registration.h"
#include "SquidTime.h"
-#include "StatHist.h"
+#include "StatCounters.h"
#include "Store.h"
#if HAVE_POLL_H
static void
commIncomingStats(StoreEntry * sentry)
{
- StatCounters *f = &statCounter;
+ StatCounters *f = StatCounters::GetCounters();
storeAppendPrintf(sentry, "Current incoming_icp_interval: %d\n",
incoming_icp_interval >> INCOMING_FACTOR);
storeAppendPrintf(sentry, "Current incoming_dns_interval: %d\n",
#include "ip/Intercept.h"
#include "protos.h"
#include "SquidTime.h"
+#include "StatCounters.h"
namespace Comm
{
Comm::TcpAcceptor::oldAccept(Comm::ConnectionPointer &details)
{
PROF_start(comm_accept);
- statCounter.syscalls.sock.accepts++;
+ ++statCounter.syscalls.sock.accepts;
int sock;
struct addrinfo *gai = NULL;
details->local.InitAddrInfo(gai);
#include "comm/IoCallback.h"
#include "comm/Write.h"
#include "fde.h"
+#include "StatCounters.h"
#include "SquidTime.h"
#include "MemBuf.h"
#endif /* USE_DELAY_POOLS */
fd_bytes(fd, len, FD_WRITE);
- statCounter.syscalls.sock.writes++;
+ ++statCounter.syscalls.sock.writes;
// After each successful partial write,
// reset fde::writeStart to the current time.
fd_table[fd].writeStart = squid_curtime;
#include "comm/Loops.h"
#include "fde.h"
#include "MemBuf.h"
+#include "StatCounters.h"
static PF diskHandleRead;
static PF diskHandleWrite;
#endif
debugs(6, 3, "diskHandleRead: FD " << fd << " seeking to offset " << ctrl_dat->offset);
lseek(fd, ctrl_dat->offset, SEEK_SET); /* XXX ignore return? */
- statCounter.syscalls.disk.seeks++;
+ ++statCounter.syscalls.disk.seeks;
F->disk.offset = ctrl_dat->offset;
}
#include "event.h"
#include "mgr/Registration.h"
#include "SquidTime.h"
-#include "StatHist.h"
+#include "StatCounters.h"
#include "Store.h"
#include "wordlist.h"
#include "Parsing.h"
#include "SquidMath.h"
#include "SquidTime.h"
+#include "StatCounters.h"
#include "SwapDir.h"
#include "swap_log_op.h"
debugs(36, 3, "storeDirClean: Cleaning file "<< std::setfill('0') << std::hex << std::uppercase << std::setw(8) << files[n]);
snprintf(p2, MAXPATHLEN + 1, "%s/%08X", p1, files[n]);
safeunlink(p2, 0);
- statCounter.swap.files_cleaned++;
+ ++statCounter.swap.files_cleaned;
}
debugs(36, 3, "Cleaned " << k << " unused files from " << p1);
#include "Server.h"
#include "SquidString.h"
#include "SquidTime.h"
+#include "StatCounters.h"
#include "Store.h"
#include "URLScheme.h"
#include "wordlist.h"
debugs(9, 3, HERE << "ftpDataRead: FD " << io.fd << " Read " << io.size << " bytes");
if (io.size > 0) {
- kb_incr(&statCounter.server.all.kbytes_in, io.size);
- kb_incr(&statCounter.server.ftp.kbytes_in, io.size);
+ kb_incr(&(statCounter.server.all.kbytes_in), io.size);
+ kb_incr(&(statCounter.server.ftp.kbytes_in), io.size);
}
if (io.flag == COMM_ERR_CLOSING)
if (io.size > 0) {
fd_bytes(io.fd, io.size, FD_WRITE);
- kb_incr(&statCounter.server.all.kbytes_out, io.size);
- kb_incr(&statCounter.server.ftp.kbytes_out, io.size);
+ kb_incr(&(statCounter.server.all.kbytes_out), io.size);
+ kb_incr(&(statCounter.server.ftp.kbytes_out), io.size);
}
if (io.flag == COMM_ERR_CLOSING)
debugs(9, 3, "ftpReadControlReply: FD " << io.fd << ", Read " << io.size << " bytes");
if (io.size > 0) {
- kb_incr(&statCounter.server.all.kbytes_in, io.size);
- kb_incr(&statCounter.server.ftp.kbytes_in, io.size);
+ kb_incr(&(statCounter.server.all.kbytes_in), io.size);
+ kb_incr(&(statCounter.server.ftp.kbytes_in), io.size);
}
if (io.flag == COMM_ERR_CLOSING)
FtpStateData::sentRequestBody(const CommIoCbParams &io)
{
if (io.size > 0)
- kb_incr(&statCounter.server.ftp.kbytes_out, io.size);
+ kb_incr(&(statCounter.server.ftp.kbytes_out), io.size);
ServerStateData::sentRequestBody(io);
}
/* for ERROR_BUF_SZ, BUFSIZ, MAXHTTPPORTS */
#include "defines.h"
-#include "StatCounters.h"
/* for iostats */
#include "structs.h"
extern int shutting_down; /* 0 */
extern int reconfiguring; /* 0 */
extern time_t hit_only_mode_until; /* 0 */
- extern StatCounters statCounter;
extern double request_failure_ratio; /* 0.0 */
extern int store_hash_buckets; /* 0 */
extern hash_table *store_table; /* NULL */
#include "MemBuf.h"
#include "forward.h"
#include "rfc1738.h"
+#include "StatCounters.h"
#include "SquidTime.h"
/**
delayId.bytesIn(len);
#endif
- kb_incr(&statCounter.server.all.kbytes_in, len);
- kb_incr(&statCounter.server.other.kbytes_in, len);
+ kb_incr(&(statCounter.server.all.kbytes_in), len);
+ kb_incr(&(statCounter.server.other.kbytes_in), len);
}
debugs(10, 5, HERE << conn << " read len=" << len);
if (size > 0) {
fd_bytes(conn->fd, size, FD_WRITE);
- kb_incr(&statCounter.server.all.kbytes_out, size);
- kb_incr(&statCounter.server.other.kbytes_out, size);
+ kb_incr(&(statCounter.server.all.kbytes_out), size);
+ kb_incr(&(statCounter.server.other.kbytes_out), size);
}
if (errflag) {
#include "ip/tools.h"
#include "MemBuf.h"
#include "SquidTime.h"
+#include "StatCounters.h"
#include "Store.h"
#include "StoreClient.h"
#include "compat/xalloc.h"
#include "protos.h"
#include "rfc1738.h"
#include "SquidTime.h"
+#include "StatCounters.h"
#include "Store.h"
delayId.bytesIn(len);
#endif
- kb_incr(&statCounter.server.all.kbytes_in, len);
- kb_incr(&statCounter.server.http.kbytes_in, len);
+ kb_incr(&(statCounter.server.all.kbytes_in), len);
+ kb_incr(&(statCounter.server.http.kbytes_in), len);
IOStats.Http.reads++;
for (clen = len - 1, bin = 0; clen; bin++)
if (io.size > 0) {
fd_bytes(io.fd, io.size, FD_WRITE);
- kb_incr(&statCounter.server.all.kbytes_out, io.size);
- kb_incr(&statCounter.server.http.kbytes_out, io.size);
+ kb_incr(&(statCounter.server.all.kbytes_out), io.size);
+ kb_incr(&(statCounter.server.http.kbytes_out), io.size);
}
if (io.flag == COMM_ERR_CLOSING)
#include "acl/Acl.h"
#include "AccessLogEntry.h"
#include "wordlist.h"
-#include "StatHist.h"
+#include "StatCounters.h"
#include "SquidTime.h"
#include "SwapDir.h"
#include "icmp/net_db.h"
#include "ipcache.h"
#include "mgr/Registration.h"
#include "SquidTime.h"
-#include "StatHist.h"
+#include "StatCounters.h"
#include "Store.h"
#include "wordlist.h"
#include "ipc/Strand.h"
#include "ip/tools.h"
#include "SquidTime.h"
+#include "StatCounters.h"
#include "SwapDir.h"
#include "forward.h"
#include "MemPool.h"
#include "MemBuf.h"
#include "SquidMath.h"
#include "SquidTime.h"
-#include "StatHist.h"
+#include "StatCounters.h"
#include "mgr/CountersAction.h"
#include "mgr/FunAction.h"
#include "mgr/InfoAction.h"
#include "HttpRequest.h"
#include "MemObject.h"
#include "mem_node.h"
+#include "StatCounters.h"
#include "StoreMeta.h"
#include "SwapDir.h"
#include "StoreIOState.h"
#include "Store.h"
#include "HttpReply.h"
#include "MemObject.h"
+#include "StatCounters.h"
#include "StoreMeta.h"
#include "StoreMetaUnpacker.h"
#if USE_DELAY_POOLS
#include "squid.h"
#include "event.h"
+#include "StatCounters.h"
#include "Store.h"
#include "SwapDir.h"
#include "StoreSearch.h"
*/
#include "squid.h"
+#include "StatCounters.h"
#include "StoreClient.h"
#include "Store.h"
sc->callback(0, errflag ? true : false);
}
- statCounter.swap.ins++;
+ ++statCounter.swap.ins;
}
static void
#include "mem_node.h"
#include "MemObject.h"
#include "SwapDir.h"
+#include "StatCounters.h"
#include "swap_log_op.h"
static void storeSwapOutStart(StoreEntry * e);
storeDirSwapLog(e, SWAP_LOG_ADD);
}
- statCounter.swap.outs++;
+ ++statCounter.swap.outs;
}
debugs(20, 3, "storeSwapOutFileClosed: " << __FILE__ << ":" << __LINE__);
#include "MemBuf.h"
#include "http.h"
#include "PeerSelectState.h"
+#include "StatCounters.h"
class TunnelStateData
{
if (len > 0) {
server.bytesIn(len);
- kb_incr(&statCounter.server.all.kbytes_in, len);
- kb_incr(&statCounter.server.other.kbytes_in, len);
+ kb_incr(&(statCounter.server.all.kbytes_in), len);
+ kb_incr(&(statCounter.server.other.kbytes_in), len);
}
copy (len, errcode, xerrno, server, client, WriteClientDone);
if (len > 0) {
client.bytesIn(len);
- kb_incr(&statCounter.client_http.kbytes_in, len);
+ kb_incr(&(statCounter.client_http.kbytes_in), len);
}
copy (len, errcode, xerrno, client, server, WriteServerDone);
}
/* Valid data */
- kb_incr(&statCounter.server.all.kbytes_out, len);
- kb_incr(&statCounter.server.other.kbytes_out, len);
+ kb_incr(&(statCounter.server.all.kbytes_out), len);
+ kb_incr(&(statCounter.server.other.kbytes_out), len);
client.dataSent(len);
/* If the other end has closed, so should we */
}
/* Valid data */
- kb_incr(&statCounter.client_http.kbytes_out, len);
+ kb_incr(&(statCounter.client_http.kbytes_out), len);
server.dataSent(len);
/* If the other end has closed, so should we */
#include "squid.h"
#include "SquidTime.h"
+#include "StatCounters.h"
#include "SwapDir.h"
#include "fde.h"
#include "xusleep.h"
return;
}
- statCounter.unlink.requests++;
+ ++statCounter.unlink.requests;
/*
* Increment this syscalls counter here, even though the syscall
* is executed by the helper process. We try to be consistent
* in counting unlink operations.
*/
- statCounter.syscalls.disk.unlinks++;
+ ++statCounter.syscalls.disk.unlinks;
queuelen++;
}
#include "comm.h"
#include "HttpRequest.h"
#include "forward.h"
+#include "StatCounters.h"
#define WHOIS_PORT 43
if (!dataWritten)
setReplyToOK(entry);
- kb_incr(&statCounter.server.all.kbytes_in, aBufferLength);
- kb_incr(&statCounter.server.http.kbytes_in, aBufferLength);
+ kb_incr(&(statCounter.server.all.kbytes_in), aBufferLength);
+ kb_incr(&(statCounter.server.http.kbytes_in), aBufferLength);
/* No range support, we always grab it all */
dataWritten = true;