/*      $NetBSD: nfsstat.c,v 1.25 2014/04/24 18:40:35 christos Exp $    */

/*
 * Copyright (c) 1983, 1989, 1993
 *      The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Rick Macklem at The University of Guelph.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#ifndef lint
__COPYRIGHT("@(#) Copyright (c) 1983, 1989, 1993\
 The Regents of the University of California.  All rights reserved.");
#endif /* not lint */

#ifndef lint
#if 0
static char sccsid[] = "from: @(#)nfsstat.c     8.1 (Berkeley) 6/6/93";
#else
__RCSID("$NetBSD: nfsstat.c,v 1.25 2014/04/24 18:40:35 christos Exp $");
#endif
#endif /* not lint */

#include <sys/param.h>
#include <sys/mount.h>
#include <sys/sysctl.h>

#include <nfs/rpcv2.h>
#include <nfs/nfsproto.h>
#include <nfs/nfs.h>

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <kvm.h>
#include <limits.h>
#include <nlist.h>
#include <paths.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

static struct nlist nl[] = {
#define N_NFSSTAT       0
        { "_nfsstats", 0, 0, 0, 0 },
        { "", 0, 0, 0, 0 },
};

#define MASK(a) (1 << NFSPROC_##a)
#define ALLMASK                                                         \
        (MASK(GETATTR) | MASK(SETATTR) | MASK(LOOKUP) | MASK(READ) |    \
        MASK(WRITE) | MASK(RENAME)| MASK(ACCESS) | MASK(READDIR) |      \
        MASK(READDIRPLUS))
#define OTHERMASK       (((1 << NFS_NPROCS) - 1) & ~ALLMASK)
static const struct shortprocs {
        int mask;
        const char *name;
} shortprocs[] = {
        {MASK(GETATTR), "Getattr"},
        {MASK(SETATTR), "Setattr"},
        {MASK(LOOKUP),  "Lookup"},
        {MASK(READ),    "Read"},
        {MASK(WRITE),   "Write"},
        {MASK(RENAME),  "Rename"},
        {MASK(ACCESS),  "Access"},
        {MASK(READDIR) | MASK(READDIRPLUS), "Readdir"},
        {OTHERMASK, "Others"},
};

#define NSHORTPROC      (sizeof(shortprocs)/sizeof(shortprocs[0]))

static void     catchalarm(int);
static void     getstats(struct nfsstats *);
static void     intpr(void);
static void     printhdr(void);
__dead static void      sidewaysintpr(u_int);
__dead static void      usage(void);

static kvm_t  *kd;
static int     printall, clientinfo, serverinfo;
static u_long   nfsstataddr;

int
main(int argc, char **argv)
{
        u_int interval;
        int ch;
        char *memf, *nlistf;
        char errbuf[_POSIX2_LINE_MAX];

        interval = 0;
        memf = nlistf = NULL;
        printall = 1;
        while ((ch = getopt(argc, argv, "M:N:w:cs")) != -1)
                switch(ch) {
                case 'M':
                        memf = optarg;
                        break;
                case 'N':
                        nlistf = optarg;
                        break;
                case 'w':
                        interval = atoi(optarg);
                        break;
                case 's':
                        serverinfo = 1;
                        printall = 0;
                        break;
                case 'c':
                        clientinfo = 1;
                        printall = 0;
                        break;
                case '?':
                default:
                        usage();
                }
        argc -= optind;
        argv += optind;

#define BACKWARD_COMPATIBILITY
#ifdef  BACKWARD_COMPATIBILITY
        if (*argv) {
                interval = atoi(*argv);
                if (*++argv) {
                        nlistf = *argv;
                        if (*++argv)
                                memf = *argv;
                }
        }
#endif
        if (nlistf || memf) {
                if ((kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, errbuf))
                    == 0)
                        errx(1, "kvm_openfiles: %s", errbuf);

                if (kvm_nlist(kd, nl) != 0)
                        errx(1, "kvm_nlist: can't get names");
                nfsstataddr = nl[N_NFSSTAT].n_value;
        } else {
                kd = NULL;
        }

        if (interval)
                sidewaysintpr(interval);
        else
                intpr();
        exit(0);
}

static void
getstats(struct nfsstats *ns)
{
        size_t size;
        int mib[3];

        if (kd) {
                if (kvm_read(kd, (u_long)nfsstataddr, ns, sizeof(*ns))
                    != sizeof(*ns))
                        errx(1, "kvm_read failed");
        } else {
                mib[0] = CTL_VFS;
                mib[1] = 2;     /* XXX from CTL_VFS_NAMES in <sys/mount.h> */
                mib[2] = NFS_NFSSTATS;

                size = sizeof(*ns);
                if (sysctl(mib, 3, ns, &size, NULL, 0) == -1)
                        err(1, "sysctl(NFS_NFSSTATS) failed");
        }
}

/*
 * Print a description of the nfs stats.
 */
static void
intpr(void)
{
        struct nfsstats nfsstats;
        uint64_t        total;
        int     i;

#define PCT(x,y)        ((y) == 0 ? 0 : (int)((int64_t)(x) * 100 / (y)))
#define NUMPCT(x,y)     (x), PCT(x, (x)+(y))
#define RPCSTAT(x)      (x), PCT(x, total)

        getstats(&nfsstats);

        if (printall || clientinfo) {
                total = 0;
                for (i = 0; i < NFS_NPROCS; i++)
                        total += nfsstats.rpccnt[i];
                printf("Client Info:\n");
                printf("RPC Counts: (%" PRIu64 " call%s)\n", total,
                    total == 1 ? "" : "s");

                printf("%10s  %14s  %14s  %14s  %14s\n",
                    "null", "getattr", "setattr", "lookup", "access");
                printf(
            "%10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%\n",
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_NULL]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_GETATTR]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_SETATTR]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_LOOKUP]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_ACCESS]));
                printf("%10s  %14s  %14s  %14s  %14s\n",
                    "readlink", "read", "write", "create", "mkdir");
                printf(
            "%10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%\n",
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_READLINK]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_READ]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_WRITE]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_CREATE]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_MKDIR]));
                printf("%10s  %14s  %14s  %14s  %14s\n",
                    "symlink", "mknod", "remove", "rmdir", "rename");
                printf(
            "%10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%\n",
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_SYMLINK]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_MKNOD]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_REMOVE]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_RMDIR]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_RENAME]));
                printf("%10s  %14s  %14s  %14s  %14s\n",
                    "link", "readdir", "readdirplus", "fsstat", "fsinfo");
                printf(
            "%10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%\n",
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_LINK]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_READDIR]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_READDIRPLUS]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_FSSTAT]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_FSINFO]));
                printf("%10s  %14s\n",
                    "pathconf", "commit");
                printf("%10u %2u%%  %10u %2u%%\n",
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_PATHCONF]),
                    RPCSTAT(nfsstats.rpccnt[NFSPROC_COMMIT]));

                printf("RPC Info:\n");
                printf("%10s  %14s  %14s  %14s  %14s\n",
                    "timeout", "invalid", "unexpected", "retries", "requests");
                printf("%10u  %14u  %14u  %14u  %14u\n",
                    nfsstats.rpctimeouts,
                    nfsstats.rpcinvalid,
                    nfsstats.rpcunexpected,
                    nfsstats.rpcretries,
                    nfsstats.rpcrequests);

                printf("Cache Info:\n");
                printf("%10s  %14s  %14s  %14s  %14s\n",
                    "attrcache", "lookupcache", "read", "write", "readlink");
                printf(
            "%10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%\n",
                    NUMPCT(nfsstats.attrcache_hits,
                        nfsstats.attrcache_misses),
                    NUMPCT(nfsstats.lookupcache_hits,
                        nfsstats.lookupcache_misses),
                    NUMPCT(nfsstats.biocache_reads - nfsstats.read_bios,
                        nfsstats.read_bios),
                    NUMPCT(nfsstats.biocache_writes - nfsstats.write_bios,
                        nfsstats.write_bios),
                    NUMPCT(nfsstats.biocache_readlinks - nfsstats.readlink_bios,
                        nfsstats.readlink_bios));
                printf("%10s  %14s\n",
                    "readdir", "direofcache");
                printf("%10u %2u%%  %10u %2u%%\n",
                    NUMPCT(nfsstats.biocache_readdirs - nfsstats.readdir_bios,
                        nfsstats.readdir_bios),
                    NUMPCT(nfsstats.direofcache_hits,
                        nfsstats.direofcache_misses));
        }

        if (printall || (clientinfo && serverinfo))
                printf("\n");

        if (printall || serverinfo) {
                total = 0;
                for (i = 0; i < NFS_NPROCS; i++)
                        total += nfsstats.srvrpccnt[i];
                printf("Server Info:\n");
                printf("RPC Counts: (%" PRIu64 " call%s)\n", total,
                    total == 1 ? "" : "s");

                printf("%10s  %14s  %14s  %14s  %14s\n",
                    "null", "getattr", "setattr", "lookup", "access");
                printf(
            "%10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%\n",
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_NULL]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_GETATTR]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_SETATTR]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_LOOKUP]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_ACCESS]));
                printf("%10s  %14s  %14s  %14s  %14s\n",
                    "readlink", "read", "write", "create", "mkdir");
                printf(
            "%10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%\n",
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_READLINK]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_READ]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_WRITE]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_CREATE]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_MKDIR]));
                printf("%10s  %14s  %14s  %14s  %14s\n",
                    "symlink", "mknod", "remove", "rmdir", "rename");
                printf(
            "%10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%\n",
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_SYMLINK]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_MKNOD]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_REMOVE]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_RMDIR]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_RENAME]));
                printf("%10s  %14s  %14s  %14s  %14s\n",
                    "link", "readdir", "readdirplus", "fsstat", "fsinfo");
                printf(
            "%10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%  %10u %2u%%\n",
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_LINK]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_READDIR]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_READDIRPLUS]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_FSSTAT]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_FSINFO]));
                printf("%10s  %14s\n",
                    "pathconf", "commit");
                printf("%10u %2u%%  %10u %2u%%\n",
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_PATHCONF]),
                    RPCSTAT(nfsstats.srvrpccnt[NFSPROC_COMMIT]));

                printf("Server Errors:\n");
                printf("%10s  %14s\n",
                    "RPC errors", "faults");
                printf("%10u  %14u\n",
                    nfsstats.srvrpc_errs,
                    nfsstats.srv_errs);
                printf("Server Cache Stats:\n");
                printf("%10s  %14s  %14s  %14s\n",
                    "inprogress", "idem", "non-idem", "misses");
                printf("%10u  %14u  %14u  %14u\n",
                    nfsstats.srvcache_inproghits,
                    nfsstats.srvcache_idemdonehits,
                    nfsstats.srvcache_nonidemdonehits,
                    nfsstats.srvcache_misses);
                printf("Server Write Gathering:\n");
                printf("%10s  %14s  %14s\n",
                    "writes", "write RPC", "OPs saved");
                printf("%10u  %14u  %14u %2u%%\n",
                    nfsstats.srvvop_writes,
                    nfsstats.srvrpccnt[NFSPROC_WRITE],
                    NUMPCT(
                      nfsstats.srvrpccnt[NFSPROC_WRITE]-nfsstats.srvvop_writes,
                      nfsstats.srvrpccnt[NFSPROC_WRITE]));
        }
}

static u_char   signalled;                      /* set if alarm goes off "early" */

/*
 * 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.
 */
static void
sidewaysintpr(u_int interval)
{
        struct nfsstats nfsstats;
        int hdrcnt, oldmask;
        struct stats {
                int client[NSHORTPROC];
                int server[NSHORTPROC];
        } current, last;

        (void)signal(SIGALRM, catchalarm);
        signalled = 0;
        (void)alarm(interval);
        memset(&last, 0, sizeof(last));

        for (hdrcnt = 1;;) {
                size_t i;

                if (!--hdrcnt) {
                        printhdr();
                        hdrcnt = 20;
                }
                getstats(&nfsstats);
                memset(&current, 0, sizeof(current));
                for (i = 0; i < NSHORTPROC; i++) {
                        int mask = shortprocs[i].mask;
                        int idx;

                        while ((idx = ffs(mask)) != 0) {
                                idx--;
                                mask &= ~(1 << idx);
                                current.client[i] += nfsstats.rpccnt[idx];
                                current.server[i] += nfsstats.srvrpccnt[idx];
                        }
                }

                if (printall || clientinfo) {
                        printf("Client:");
                        for (i = 0; i < NSHORTPROC; i++)
                                printf(" %7u",
                                    current.client[i] - last.client[i]);
                        printf("\n");
                }
                if (printall || serverinfo) {
                        printf("Server:");
                        for (i = 0; i < NSHORTPROC; i++)
                                printf(" %7u",
                                    current.server[i] - last.server[i]);
                        printf("\n");
                }
                memcpy(&last, &current, sizeof(last));
                fflush(stdout);
                oldmask = sigblock(sigmask(SIGALRM));
                if (!signalled)
                        sigpause(0);
                sigsetmask(oldmask);
                signalled = 0;
                (void)alarm(interval);
        }
        /*NOTREACHED*/
}

static void
printhdr(void)
{
        size_t i;

        printf("        ");
        for (i = 0; i < NSHORTPROC; i++)
                printf("%7.7s ", shortprocs[i].name);
        printf("\n");
        fflush(stdout);
}

/*
 * Called if an interval expires before sidewaysintpr has completed a loop.
 * Sets a flag to not wait for the alarm.
 */
static void
catchalarm(int dummy)
{

        signalled = 1;
}

static void
usage(void)
{

        (void)fprintf(stderr,
              "Usage: %s [-cs] [-M core] [-N system] [-w interval]\n",
              getprogname());
        exit(1);
}