/*
* Print a running summary of nfs statistics for the experimental client and/or
* server.
* Repeat display every interval seconds, showing statistics
* collected over that interval. Assumes that interval is non-zero.
* First line printed at top of screen is always cumulative.
*/
void
exp_sidewaysintpr(u_int interval, int clientOnly, int serverOnly)
{
struct ext_nfsstats nfsstats, lastst, *ext_nfsstatsp;
int hdrcnt = 1;
ext_nfsstatsp = &lastst;
if (nfssvc(NFSSVC_GETSTATS, ext_nfsstatsp) < 0)
err(1, "Can't get stats");
sleep(interval);
for (;;) {
ext_nfsstatsp = &nfsstats;
if (nfssvc(NFSSVC_GETSTATS, ext_nfsstatsp) < 0)
err(1, "Can't get stats");
if (--hdrcnt == 0) {
printhdr(clientOnly, serverOnly);
if (clientOnly && serverOnly)
hdrcnt = 10;
else
hdrcnt = 20;
}
if (clientOnly) {
printf("%s %6d %6d %6d %6d %6d %6d %6d %6d",
((clientOnly && serverOnly) ? "Client:" : ""),
DELTA(attrcache_hits) + DELTA(attrcache_misses),
DELTA(lookupcache_hits) + DELTA(lookupcache_misses),
DELTA(biocache_readlinks),
DELTA(biocache_reads),
DELTA(biocache_writes),
nfsstats.rpccnt[NFSPROC_RENAME] -
lastst.rpccnt[NFSPROC_RENAME],
DELTA(accesscache_hits) + DELTA(accesscache_misses),
DELTA(biocache_readdirs)
);
if (widemode) {
printf(" %s %s %s %s %s %s",
sperc1(DELTA(attrcache_hits),
DELTA(attrcache_misses)),
sperc1(DELTA(lookupcache_hits),
DELTA(lookupcache_misses)),
sperc2(DELTA(biocache_reads),
DELTA(read_bios)),
sperc2(DELTA(biocache_writes),
DELTA(write_bios)),
sperc1(DELTA(accesscache_hits),
DELTA(accesscache_misses)),
sperc2(DELTA(biocache_readdirs),
DELTA(readdir_bios))
);
}
printf("\n");
lastst = nfsstats;
}
if (serverOnly) {
printf("%s %6d %6d %6d %6d %6d %6d %6d %6d",
((clientOnly && serverOnly) ? "Server:" : ""),
nfsstats.srvrpccnt[NFSV4OP_GETATTR] -
lastst.srvrpccnt[NFSV4OP_GETATTR],
nfsstats.srvrpccnt[NFSV4OP_LOOKUP] -
lastst.srvrpccnt[NFSV4OP_LOOKUP],
nfsstats.srvrpccnt[NFSV4OP_READLINK] -
lastst.srvrpccnt[NFSV4OP_READLINK],
nfsstats.srvrpccnt[NFSV4OP_READ] -
lastst.srvrpccnt[NFSV4OP_READ],
nfsstats.srvrpccnt[NFSV4OP_WRITE] -
lastst.srvrpccnt[NFSV4OP_WRITE],
nfsstats.srvrpccnt[NFSV4OP_RENAME] -
lastst.srvrpccnt[NFSV4OP_RENAME],
nfsstats.srvrpccnt[NFSV4OP_ACCESS] -
lastst.srvrpccnt[NFSV4OP_ACCESS],
(nfsstats.srvrpccnt[NFSV4OP_READDIR] -
lastst.srvrpccnt[NFSV4OP_READDIR]) +
(nfsstats.srvrpccnt[NFSV4OP_READDIRPLUS] -
lastst.srvrpccnt[NFSV4OP_READDIRPLUS]));
printf("\n");
lastst = nfsstats;
}
fflush(stdout);
sleep(interval);
}
/*NOTREACHED*/
}
/*
* Print a running summary of nfs statistics for the experimental client and/or
* server.
* Repeat display every interval seconds, showing statistics
* collected over that interval. Assumes that interval is non-zero.
* First line printed at top of screen is always cumulative.
*/
static void
exp_sidewaysintpr(u_int interval, int clientOnly, int serverOnly,
int newStats)
{
struct nfsstatsv1 nfsstats, lastst, *ext_nfsstatsp;
struct nfsstatsv1 curtotal, lasttotal;
struct timespec ts, lastts;
int hdrcnt = 1;
ext_nfsstatsp = &lastst;
ext_nfsstatsp->vers = NFSSTATS_V1;
if (nfssvc(NFSSVC_GETSTATS | NFSSVC_NEWSTRUCT, ext_nfsstatsp) < 0)
err(1, "Can't get stats");
clock_gettime(CLOCK_MONOTONIC, &lastts);
compute_totals(&lasttotal, ext_nfsstatsp);
sleep(interval);
for (;;) {
ext_nfsstatsp = &nfsstats;
ext_nfsstatsp->vers = NFSSTATS_V1;
if (nfssvc(NFSSVC_GETSTATS | NFSSVC_NEWSTRUCT, ext_nfsstatsp)
< 0)
err(1, "Can't get stats");
clock_gettime(CLOCK_MONOTONIC, &ts);
if (--hdrcnt == 0) {
printhdr(clientOnly, serverOnly, newStats);
if (newStats)
hdrcnt = 20;
else if (clientOnly && serverOnly)
hdrcnt = 10;
else
hdrcnt = 20;
}
if (clientOnly && newStats == 0) {
printf("%s %6ju %6ju %6ju %6ju %6ju %6ju %6ju %6ju",
((clientOnly && serverOnly) ? "Client:" : ""),
(uintmax_t)DELTA(rpccnt[NFSPROC_GETATTR]),
(uintmax_t)DELTA(rpccnt[NFSPROC_LOOKUP]),
(uintmax_t)DELTA(rpccnt[NFSPROC_READLINK]),
(uintmax_t)DELTA(rpccnt[NFSPROC_READ]),
(uintmax_t)DELTA(rpccnt[NFSPROC_WRITE]),
(uintmax_t)DELTA(rpccnt[NFSPROC_RENAME]),
(uintmax_t)DELTA(rpccnt[NFSPROC_ACCESS]),
(uintmax_t)(DELTA(rpccnt[NFSPROC_READDIR]) +
DELTA(rpccnt[NFSPROC_READDIRPLUS]))
);
if (widemode) {
printf(" %s %s %s %s %s %s",
sperc1(DELTA(attrcache_hits),
DELTA(attrcache_misses)),
sperc1(DELTA(lookupcache_hits),
DELTA(lookupcache_misses)),
sperc2(DELTA(biocache_reads),
DELTA(read_bios)),
sperc2(DELTA(biocache_writes),
DELTA(write_bios)),
sperc1(DELTA(accesscache_hits),
DELTA(accesscache_misses)),
sperc2(DELTA(biocache_readdirs),
DELTA(readdir_bios))
);
}
printf("\n");
}
if (serverOnly && newStats) {
long double cur_secs, last_secs, etime;
long double mbsec;
long double kb_per_transfer;
long double transfers_per_second;
long double ms_per_transfer;
uint64_t queue_len;
long double busy_pct;
int i;
cur_secs = ts.tv_sec +
((long double)ts.tv_nsec / 1000000000);
last_secs = lastts.tv_sec +
((long double)lastts.tv_nsec / 1000000000);
etime = cur_secs - last_secs;
compute_totals(&curtotal, &nfsstats);
for (i = 0; i < NUM_STAT_TYPES; i++) {
compute_new_stats(&nfsstats, &lastst,
STAT_TYPE_TO_NFS(i), etime, &mbsec,
&kb_per_transfer,
&transfers_per_second,
&ms_per_transfer, &queue_len,
&busy_pct);
if (i == STAT_TYPE_COMMIT) {
if (widemode == 0)
continue;
printf("%2.0Lf %7.2Lf ",
transfers_per_second,
ms_per_transfer);
} else {
printf("%5.2Lf %5.0Lf %7.2Lf ",
kb_per_transfer,
transfers_per_second, mbsec);
if (widemode)
printf("%5.2Lf ",
ms_per_transfer);
}
}
compute_new_stats(&curtotal, &lasttotal, 0, etime,
&mbsec, &kb_per_transfer, &transfers_per_second,
&ms_per_transfer, &queue_len, &busy_pct);
printf("%5.2Lf %5.0Lf %7.2Lf %5.2Lf %3ju %3.0Lf\n",
kb_per_transfer, transfers_per_second, mbsec,
ms_per_transfer, queue_len, busy_pct);
} else if (serverOnly) {
printf("%s %6ju %6ju %6ju %6ju %6ju %6ju %6ju %6ju",
((clientOnly && serverOnly) ? "Server:" : ""),
(uintmax_t)DELTA(srvrpccnt[NFSV4OP_GETATTR]),
(uintmax_t)DELTA(srvrpccnt[NFSV4OP_LOOKUP]),
(uintmax_t)DELTA(srvrpccnt[NFSV4OP_READLINK]),
(uintmax_t)DELTA(srvrpccnt[NFSV4OP_READ]),
(uintmax_t)DELTA(srvrpccnt[NFSV4OP_WRITE]),
(uintmax_t)DELTA(srvrpccnt[NFSV4OP_RENAME]),
(uintmax_t)DELTA(srvrpccnt[NFSV4OP_ACCESS]),
(uintmax_t)(DELTA(srvrpccnt[NFSV4OP_READDIR]) +
DELTA(srvrpccnt[NFSV4OP_READDIRPLUS])));
printf("\n");
}
bcopy(&nfsstats, &lastst, sizeof(lastst));
bcopy(&curtotal, &lasttotal, sizeof(lasttotal));
lastts = ts;
fflush(stdout);
sleep(interval);
}
/*NOTREACHED*/
}
/*
* Print a running summary of nfs statistics.
* Repeat display every interval seconds, showing statistics
* collected over that interval. Assumes that interval is non-zero.
* First line printed at top of screen is always cumulative.
*/
void
sidewaysintpr(u_int interval, int clientOnly, int serverOnly)
{
struct nfsstats nfsstats, lastst, *nfsstatsp;
struct nfsrvstats nfsrvstats, lastsrvst, *nfsrvstatsp;
int hdrcnt = 1;
nfsstatsp = &lastst;
nfsrvstatsp = &lastsrvst;
readstats(&nfsstatsp, &nfsrvstatsp, 0);
if (clientOnly && !nfsstatsp) {
printf("Client not present!\n");
clientOnly = 0;
}
if (serverOnly && !nfsrvstatsp) {
printf("Server not present!\n");
serverOnly = 0;
}
sleep(interval);
for (;;) {
nfsstatsp = &nfsstats;
nfsrvstatsp = &nfsrvstats;
readstats(&nfsstatsp, &nfsrvstatsp, 0);
if (--hdrcnt == 0) {
printhdr(clientOnly, serverOnly);
if (clientOnly && serverOnly)
hdrcnt = 10;
else
hdrcnt = 20;
}
if (clientOnly) {
printf("%s %6d %6d %6d %6d %6d %6d %6d %6d",
((clientOnly && serverOnly) ? "Client:" : ""),
DELTA(attrcache_hits) + DELTA(attrcache_misses),
DELTA(lookupcache_hits) + DELTA(lookupcache_misses),
DELTA(biocache_readlinks),
DELTA(biocache_reads),
DELTA(biocache_writes),
nfsstats.rpccnt[NFSPROC_RENAME]-lastst.rpccnt[NFSPROC_RENAME],
DELTA(accesscache_hits) + DELTA(accesscache_misses),
DELTA(biocache_readdirs)
);
if (widemode) {
printf(" %s %s %s %s %s %s",
sperc1(DELTA(attrcache_hits),
DELTA(attrcache_misses)),
sperc1(DELTA(lookupcache_hits),
DELTA(lookupcache_misses)),
sperc2(DELTA(biocache_reads),
DELTA(read_bios)),
sperc2(DELTA(biocache_writes),
DELTA(write_bios)),
sperc1(DELTA(accesscache_hits),
DELTA(accesscache_misses)),
sperc2(DELTA(biocache_readdirs),
DELTA(readdir_bios))
);
}
printf("\n");
lastst = nfsstats;
}
if (serverOnly) {
printf("%s %6d %6d %6d %6d %6d %6d %6d %6d",
((clientOnly && serverOnly) ? "Server:" : ""),
nfsrvstats.srvrpccnt[NFSPROC_GETATTR]-lastsrvst.srvrpccnt[NFSPROC_GETATTR],
nfsrvstats.srvrpccnt[NFSPROC_LOOKUP]-lastsrvst.srvrpccnt[NFSPROC_LOOKUP],
nfsrvstats.srvrpccnt[NFSPROC_READLINK]-lastsrvst.srvrpccnt[NFSPROC_READLINK],
nfsrvstats.srvrpccnt[NFSPROC_READ]-lastsrvst.srvrpccnt[NFSPROC_READ],
nfsrvstats.srvrpccnt[NFSPROC_WRITE]-lastsrvst.srvrpccnt[NFSPROC_WRITE],
nfsrvstats.srvrpccnt[NFSPROC_RENAME]-lastsrvst.srvrpccnt[NFSPROC_RENAME],
nfsrvstats.srvrpccnt[NFSPROC_ACCESS]-lastsrvst.srvrpccnt[NFSPROC_ACCESS],
(nfsrvstats.srvrpccnt[NFSPROC_READDIR]-lastsrvst.srvrpccnt[NFSPROC_READDIR])
+(nfsrvstats.srvrpccnt[NFSPROC_READDIRPLUS]-lastsrvst.srvrpccnt[NFSPROC_READDIRPLUS]));
printf("\n");
lastsrvst = nfsrvstats;
}
fflush(stdout);
sleep(interval);
}
/*NOTREACHED*/
}