path: root/utils/nfsstat/nfsstat.c

/*
 * nfsstat.c		Output NFS statistics
 *
 * Copyright (C) 1995-2005 Olaf Kirch <okir@suse.de>
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#define NFSSRVSTAT	"/proc/net/rpc/nfsd"
#define NFSCLTSTAT	"/proc/net/rpc/nfs"

#define MOUNTSFILE	"/proc/mounts"

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <getopt.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <time.h>

#define MAXNRVALS	32

static unsigned int	srvproc2info[20], srvproc2info_tmp[20];	/* NFSv2 call counts ([0] == 18) */
static unsigned int	cltproc2info[20], cltproc2info_tmp[20];	/* NFSv2 call counts ([0] == 18) */
static unsigned int	srvproc3info[24], srvproc3info_tmp[24];	/* NFSv3 call counts ([0] == 22) */
static unsigned int	cltproc3info[24], cltproc3info_tmp[24];	/* NFSv3 call counts ([0] == 22) */
static unsigned int	srvproc4info[4], srvproc4info_tmp[4];	/* NFSv4 call counts ([0] == 2) */
static unsigned int	cltproc4info[37], cltproc4info_tmp[37];	/* NFSv4 call counts ([0] == 35) */
static unsigned int	srvproc4opsinfo[42], srvproc4opsinfo_tmp[42];	/* NFSv4 call counts ([0] == 40) */
static unsigned int	srvnetinfo[5], srvnetinfo_tmp[5];	/* 0  # of received packets
								 * 1  UDP packets
								 * 2  TCP packets
								 * 3  TCP connections
								 */
static unsigned int	cltnetinfo[5], cltnetinfo_tmp[5];	/* 0  # of received packets
								 * 1  UDP packets
								 * 2  TCP packets
								 * 3  TCP connections
								 */

static unsigned int	srvrpcinfo[6], srvrpcinfo_tmp[6];	/* 0  total # of RPC calls
								 * 1  total # of bad calls
								 * 2  bad format
								 * 3  authentication failed
								 * 4  unknown client
								 */
static unsigned int	cltrpcinfo[4], cltrpcinfo_tmp[4];	/* 0  total # of RPC calls
								 * 1  retransmitted calls
								 * 2  cred refreshs
								 */

static unsigned int	srvrcinfo[9], srvrcinfo_tmp[9];		/* 0  repcache hits
								 * 1  repcache hits
								 * 2  uncached reqs
								 * (for pre-2.4 kernels:)
								 * 3  FH lookups
								 * 4  'anon' FHs
								 * 5  noncached non-directories
								 * 6  noncached directories
								 * 7  stale
								 */

static unsigned int	srvfhinfo[7], srvfhinfo_tmp[7];		/* (for kernels >= 2.4.0)
								 * 0  stale
								 * 1  FH lookups
								 * 2  'anon' FHs
								 * 3  noncached directories
								 * 4  noncached non-directories
								 * leave hole to relocate stale for order
								 *    compatability.
								 */

static const char *	nfsv2name[18] = {
	"null", "getattr", "setattr", "root",   "lookup",  "readlink",
	"read", "wrcache", "write",   "create", "remove",  "rename",
	"link", "symlink", "mkdir",   "rmdir",  "readdir", "fsstat"
};

static const char *	nfsv3name[22] = {
	"null",   "getattr", "setattr",  "lookup", "access",  "readlink",
	"read",   "write",   "create",   "mkdir",  "symlink", "mknod",
	"remove", "rmdir",   "rename",   "link",   "readdir", "readdirplus",
	"fsstat", "fsinfo",  "pathconf", "commit"
};

static const char *	nfssrvproc4name[2] = {
	"null",
	"compound",
};

static const char *	nfscltproc4name[35] = {
	"null",      "read",      "write",   "commit",      "open",        "open_conf",
	"open_noat", "open_dgrd", "close",   "setattr",     "fsinfo",      "renew",
	"setclntid", "confirm",   "lock",
	"lockt",     "locku",     "access",  "getattr",     "lookup",      "lookup_root",
	"remove",    "rename",    "link",    "symlink",     "create",      "pathconf",
	"statfs",    "readlink",  "readdir", "server_caps", "delegreturn", "getacl",
	"setacl",    "fs_locations"
};

static const char *     nfssrvproc4opname[40] = {
        "op0-unused",   "op1-unused", "op2-future",  "access",     "close",       "commit",
        "create",       "delegpurge", "delegreturn", "getattr",    "getfh",       "link",
        "lock",         "lockt",      "locku",       "lookup",     "lookup_root", "nverify",
        "open",         "openattr",   "open_conf",   "open_dgrd",  "putfh",       "putpubfh",
        "putrootfh",    "read",       "readdir",     "readlink",   "remove",      "rename",
        "renew",        "restorefh",  "savefh",      "secinfo",    "setattr",     "setcltid",
        "setcltidconf", "verify",     "write",       "rellockowner"
};

typedef struct statinfo {
	char		*tag;
	int		nrvals;
	unsigned int *	valptr;
} statinfo;

/*
 * We now build the arrays of statinfos using macros, which will make it easier
 * to add new variables for --diff-stat.
 * e.g., SRV(net) expands into the struct statinfo:  { "net", 5, srvnetinfo }
 */
#define ARRAYSIZE(x)		sizeof(x)/sizeof(*x)
#define STATINFO(k, t, s...)	{ #t, ARRAYSIZE(k##t##info##s), k##t##info##s }
#define SRV(t, s...)		STATINFO(srv, t, s)
#define CLT(t, s...)		STATINFO(clt, t, s)
#define DECLARE_SRV(n, s...)	static statinfo n##s[] = { \
					SRV(net,s), \
					SRV(rpc,s), \
					SRV(rc,s), \
					SRV(fh,s), \
					SRV(proc2,s), \
					SRV(proc3,s),\
					SRV(proc4,s), \
					SRV(proc4ops,s),\
					{ NULL, 0, NULL }\
				}
#define DECLARE_CLT(n, s...)  	static statinfo n##s[] = { \
					CLT(net,s), \
					CLT(rpc,s), \
					CLT(proc2,s),\
					CLT(proc3,s), \
					CLT(proc4,s),\
					{ NULL, 0, NULL }\
				}
DECLARE_SRV(srvinfo);
DECLARE_SRV(srvinfo, _tmp);
DECLARE_CLT(cltinfo);
DECLARE_CLT(cltinfo, _tmp);

static void		print_numbers(const char *, unsigned int *,
					unsigned int);
static void		print_callstats(const char *, const char **,
					unsigned int *, unsigned int);
static int		parse_statfile(const char *, struct statinfo *);

static statinfo		*get_stat_info(const char *, struct statinfo *);

static int		mounts(const char *);

static void		get_stats(const char *, statinfo *, int *, int, const char *);
static int		has_stats(const unsigned int *);
static void 		copy_stats(statinfo *, statinfo *);
static void 		diff_stats(statinfo *, statinfo *);
static void 		unpause(int);

static time_t		starttime;

#define PRNT_CALLS	0x0001
#define PRNT_RPC	0x0002
#define PRNT_NET	0x0004
#define PRNT_FH		0x0008
#define PRNT_RC		0x0010
#define PRNT_AUTO	0x1000
#define PRNT_V2		0x2000
#define PRNT_V3		0x4000
#define PRNT_V4		0x8000
#define PRNT_ALL	0x0fff

int versions[] = {
	PRNT_V2,
	PRNT_V3,
	PRNT_V4
};

void usage(char *name)
{
	printf("Usage: %s [OPTION]...\n\
\n\
  -m, --mounted\t\tShow statistics on mounted NFS filesystems\n\
  -c, --client\t\tShow NFS client statistics\n\
  -s, --server\t\tShow NFS server statistics\n\
  -2\t\t\tShow NFS version 2 statistics\n\
  -3\t\t\tShow NFS version 3 statistics\n\
  -4\t\t\tShow NFS version 4 statistics\n\
  -o [facility]\t\tShow statistics on particular facilities.\n\
     nfs\tNFS protocol information\n\
     rpc\tGeneral RPC information\n\
     net\tNetwork layer statistics\n\
     fh\t\tUsage information on the server's file handle cache\n\
     rc\t\tUsage information on the server's request reply cache\n\
     all\tSelect all of the above\n\
  -v, --verbose, --all\tSame as '-o all'\n\
  -r, --rpc\t\tShow RPC statistics\n\
  -n, --nfs\t\tShow NFS statistics\n\
  -Z, --sleep\tSaves stats, pauses, diffs current and saved\n\
  --version\t\tShow program version\n\
  --help\t\tWhat you just did\n\
\n", name);
	exit(0);
}

static struct option longopts[] =
{
	{ "acl", 0, 0, 'a' },
	{ "all", 0, 0, 'v' },
	{ "auto", 0, 0, '\3' },
	{ "client", 0, 0, 'c' },
	{ "mounts", 0, 0, 'm' },
	{ "nfs", 0, 0, 'n' },
	{ "rpc", 0, 0, 'r' },
	{ "server", 0, 0, 's' },
	{ "verbose", 0, 0, 'v' },
	{ "zero", 0, 0, 'z' },
	{ "help", 0, 0, '\1' },
	{ "version", 0, 0, '\2' },
	{ "sleep", 0, 0, 'Z' },
	{ NULL, 0, 0, 0 }
};

int
main(int argc, char **argv)
{
	int		opt_all = 0,
			opt_srv = 0,
			opt_clt = 0,
			opt_prt = 0,
			opt_sleep = 0;
	int		c;
	char           *progname;

	struct sigaction act = {
		.sa_handler = unpause,
		.sa_flags = SA_ONESHOT,
	};

	if ((progname = strrchr(argv[0], '/')))
		progname++;
	else
		progname = argv[0];

	while ((c = getopt_long(argc, argv, "234acmno:Zvrsz\1\2", longopts, NULL)) != EOF) {
		switch (c) {
		case 'a':
			fprintf(stderr, "nfsstat: nfs acls are not yet supported.\n");
			return -1;
		case 'c':
			opt_clt = 1;
			break;
		case 'n':
			opt_prt |= PRNT_CALLS;
			break;
		case 'o':
			if (!strcmp(optarg, "nfs"))
				opt_prt |= PRNT_CALLS;
			else if (!strcmp(optarg, "rpc"))
				opt_prt |= PRNT_RPC;
			else if (!strcmp(optarg, "net"))
				opt_prt |= PRNT_NET;
			else if (!strcmp(optarg, "rc"))
				opt_prt |= PRNT_RC;
			else if (!strcmp(optarg, "fh"))
				opt_prt |= PRNT_FH;
			else if (!strcmp(optarg, "all"))
				opt_prt |= PRNT_CALLS | PRNT_RPC | PRNT_NET | PRNT_RC | PRNT_FH;
			else {
				fprintf(stderr, "nfsstat: unknown category: "
						"%s\n", optarg);
				return 2;
			}
			break;
		case 'Z':
			opt_sleep = 1;
			break;
		case '2':
		case '3':
		case '4':
			opt_prt |= versions[c - '2'];
			break;
		case 'v':
			opt_all = 1;
			break;
		case '\3':
			opt_prt |= PRNT_AUTO;
			break;
		case 'r':
			opt_prt |= PRNT_RPC;
			break;
		case 's':
			opt_srv = 1;
			break;
		case 'z':
			fprintf(stderr, "nfsstat: zeroing of nfs statistics "
					"not yet supported\n");
			return 2;
		case 'm':
			return mounts(MOUNTSFILE);
		case '\1':
			usage(progname);
			return 0;
		case '\2':
			fprintf(stdout, "nfsstat: " VERSION "\n");
			return 0;
		default:
			printf("Try `%s --help' for more information.\n", progname);
			return -1;
		}
	}

	if (opt_all) {
		opt_srv = opt_clt = 1;
		opt_prt |= PRNT_ALL;
	}
	if (!(opt_srv + opt_clt))
		opt_srv = opt_clt = 1;
	if (!(opt_prt & 0xfff)) {
		opt_prt |= PRNT_CALLS + PRNT_RPC;
	}
	if (!(opt_prt & 0xe000)) {
		opt_prt |= PRNT_AUTO;
	}
	if ((opt_prt & (PRNT_FH|PRNT_RC)) && !opt_srv) {
		fprintf(stderr,
			"You requested file handle or request cache "
			"statistics while using the -c option.\n"
			"This information is available only for the NFS "
			"server.\n");
	}

	if (opt_srv)
		get_stats(NFSSRVSTAT, srvinfo, &opt_srv, opt_clt, "Server");
	if (opt_clt)
		get_stats(NFSCLTSTAT, cltinfo, &opt_clt, opt_srv, "Client");

	/* save stat snapshots; wait for signal; then diff current and saved stats */
	if (opt_sleep) {
		starttime = time(NULL);
		printf("Collecting statistics; press CTRL-C to view results from interval (i.e., from pause to CTRL-C).\n");
		if (opt_srv)
			copy_stats(srvinfo_tmp, srvinfo);
		if (opt_clt)
			copy_stats(cltinfo_tmp, cltinfo);
		if (sigaction(SIGINT, &act, NULL) != 0) {
			fprintf(stderr, "Error: couldn't register for signal and pause.\n");
			return 1;
		}
		pause();
		if (opt_srv) {
			get_stats(NFSSRVSTAT, srvinfo, &opt_srv, opt_clt, "Server");
			diff_stats(srvinfo, srvinfo_tmp);
		}
		if (opt_clt) {
			get_stats(NFSCLTSTAT, cltinfo, &opt_clt, opt_srv, "Client");
			diff_stats(cltinfo, cltinfo_tmp);
		}
	}

	if (opt_srv) {
		if (opt_prt & PRNT_NET) {
			print_numbers(
			"Server packet stats:\n"
			"packets    udp        tcp        tcpconn\n",
			srvnetinfo, 4
			);
			printf("\n");
		}
		if (opt_prt & PRNT_RPC) {
			print_numbers(
			"Server rpc stats:\n"
			"calls      badcalls   badauth    badclnt    xdrcall\n",
			srvrpcinfo, 5
			);
			printf("\n");
		}
		if (opt_prt & PRNT_RC) {
			print_numbers(
			"Server reply cache:\n"
			"hits       misses     nocache\n",
			srvrcinfo, 3
			);
			printf("\n");
		}

		/*
		 * 2.2 puts all fh-related info after the 'rc' header
		 * 2.4 puts all fh-related info after the 'fh' header, but relocates
		 *     'stale' to the start and swaps dir and nondir :-(  
		 *     We preseve the 2.2 order
		 */
		if (opt_prt & PRNT_FH) {
			if (get_stat_info("fh", srvinfo)) {	/* >= 2.4 */
				int t = srvfhinfo[3];
				srvfhinfo[3]=srvfhinfo[4];
				srvfhinfo[4]=t;
				
				srvfhinfo[5]=srvfhinfo[0]; /* relocate 'stale' */
				
				print_numbers(
					"Server file handle cache:\n"
					"lookup     anon       ncachedir  ncachedir  stale\n",
					srvfhinfo + 1, 5);
			} else					/* < 2.4 */
				print_numbers(
					"Server file handle cache:\n"
					"lookup     anon       ncachedir  ncachedir  stale\n",
					srvrcinfo + 3, 5);
			printf("\n");
		}
		if (opt_prt & PRNT_CALLS) {
			if ((opt_prt & PRNT_V2) || ((opt_prt & PRNT_AUTO) && has_stats(srvproc2info)))
				print_callstats(
				"Server nfs v2:\n",
				    nfsv2name, srvproc2info + 1, sizeof(nfsv2name)/sizeof(char *)
				);
			if ((opt_prt & PRNT_V3) || ((opt_prt & PRNT_AUTO) && has_stats(srvproc3info)))
				print_callstats(
				"Server nfs v3:\n",
				nfsv3name, srvproc3info + 1, sizeof(nfsv3name)/sizeof(char *)
				);
			if ((opt_prt & PRNT_V4) || ((opt_prt & PRNT_AUTO) && has_stats(srvproc4info))) {
				print_callstats(
				"Server nfs v4:\n",
				nfssrvproc4name, srvproc4info + 1, sizeof(nfssrvproc4name)/sizeof(char *)
				);
				print_callstats(
				"Server nfs v4 operations:\n",
				nfssrvproc4opname, srvproc4opsinfo + 1, sizeof(nfssrvproc4opname)/sizeof(char *)
				);
			}
		}
	}

	if (opt_clt) {
		if (opt_prt & PRNT_NET) {
			print_numbers(
			"Client packet stats:\n"
			"packets    udp        tcp        tcpconn\n",
			cltnetinfo, 4
			);
			printf("\n");
		}
		if (opt_prt & PRNT_RPC) {
			print_numbers(
			"Client rpc stats:\n"
			"calls      retrans    authrefrsh\n",
			cltrpcinfo, 3
			);
			printf("\n");
		}
		if (opt_prt & PRNT_CALLS) {
			if ((opt_prt & PRNT_V2) || ((opt_prt & PRNT_AUTO) && has_stats(cltproc2info)))
				print_callstats(
				"Client nfs v2:\n",
				nfsv2name, cltproc2info + 1,  sizeof(nfsv2name)/sizeof(char *)
				);
			if ((opt_prt & PRNT_V3) || ((opt_prt & PRNT_AUTO) && has_stats(cltproc3info)))
				print_callstats(
				"Client nfs v3:\n",
				nfsv3name, cltproc3info + 1, sizeof(nfsv3name)/sizeof(char *)
				);
			if ((opt_prt & PRNT_V4) || ((opt_prt & PRNT_AUTO) && has_stats(cltproc4info)))
				print_callstats(
				"Client nfs v4:\n",
				nfscltproc4name, cltproc4info + 1,  sizeof(nfscltproc4name)/sizeof(char *)
				);
		}
	}

	return 0;
}

static statinfo *
get_stat_info(const char *sp, struct statinfo *statp)
{
	struct statinfo *ip;

	for (ip = statp; ip->tag; ip++) {
		if (!strcmp(sp, ip->tag))
			return ip;
	}

	return NULL;
}

static void
print_numbers(const char *hdr, unsigned int *info, unsigned int nr)
{
	unsigned int	i;

	fputs(hdr, stdout);
	for (i = 0; i < nr; i++)
		printf("%s%-8d", i? "   " : "", info[i]);
	printf("\n");
}

static void
print_callstats(const char *hdr, const char **names,
				 unsigned int *info, unsigned int nr)
{
	unsigned long long	total;
	unsigned long long	pct;
	int		i, j;

	fputs(hdr, stdout);
	for (i = 0, total = 0; i < nr; i++)
		total += info[i];
	if (!total)
		total = 1;
	for (i = 0; i < nr; i += 6) {
		for (j = 0; j < 6 && i + j < nr; j++)
			printf("%-13s", names[i+j]);
		printf("\n");
		for (j = 0; j < 6 && i + j < nr; j++) {
			pct = ((unsigned long long) info[i+j]*100)/total;
			printf("%-8d%3llu%% ", info[i+j], pct);
		}
		printf("\n");
	}
	printf("\n");
}


static int
parse_statfile(const char *name, struct statinfo *statp)
{
	char	buffer[4096], *next;
	FILE	*fp;

	/* Being unable to read e.g. the nfsd stats file shouldn't
	 * be a fatal error -- it usually means the module isn't loaded.
	 */
	if ((fp = fopen(name, "r")) == NULL) {
		// fprintf(stderr, "Warning: %s: %m\n", name);
		return 0;
	}

	while (fgets(buffer, sizeof(buffer), fp) != NULL) {
		struct statinfo	*ip;
		char		*sp, *line = buffer;
		unsigned int    i, cnt;
		unsigned int	total = 0;

		if ((next = strchr(line, '\n')) != NULL)
			*next++ = '\0';
		if (!(sp = strtok(line, " \t")))
			continue;

		ip = get_stat_info(sp, statp);
		if (!ip)
			continue;

		cnt = ip->nrvals;

		for (i = 0; i < cnt; i++) {
			if (!(sp = strtok(NULL, " \t")))
				break;
			ip->valptr[i] = atoi(sp);
			total += ip->valptr[i];
		}
		ip->valptr[cnt - 1] = total;
	}

	fclose(fp);
	return 1;
}

static int
mounts(const char *name)
{
	char	buffer[4096], *next;
	FILE	*fp;

	/* Being unable to read e.g. the nfsd stats file shouldn't
	 * be a fatal error -- it usually means the module isn't loaded.
	 */
	if ((fp = fopen(name, "r")) == NULL) {
		fprintf(stderr, "Warning: %s: %m\n", name);
		return 0;
	}

	while (fgets(buffer, sizeof(buffer), fp) != NULL) {
		char	      *line = buffer;
		char          *device, *mount, *type, *flags;

		if ((next = strchr(line, '\n')) != NULL)
			*next = '\0';

		if (!(device = strtok(line, " \t")))
			continue;

		if (!(mount = strtok(NULL, " \t")))
			continue;

		if (!(type = strtok(NULL, " \t")))
			continue;

		if (strcmp(type, "nfs")) {
		    continue;
		}

		if (!(flags = strtok(NULL, " \t")))
			continue;

		printf("%s from %s\n", mount, device);
		printf(" Flags:\t%s\n", flags);
		printf("\n");

		continue;
	}

	fclose(fp);
	return 1;
}

static void
get_stats(const char *file, statinfo *info, int *opt, int other_opt, const char *label)
{
	if (!parse_statfile(file, info)) {
		if (!other_opt) {
			fprintf(stderr, "Warning: No %s Stats (%s: %m). \n", label, file);
			exit(2);
		}
		*opt = 0;
	}
}

/*
 * This is for proc2/3/4-type stats, where, in the /proc files, the first entry's value
 * denotes the number of subsequent entries.  statinfo value arrays contain an additional
 * field at the end which contains the sum of all previous elements in the array -- so,
 * there are stats if the sum's greater than the entry-count.
 */
static int
has_stats(const unsigned int *info)
{
	return (info[0] && info[info[0] + 1] > info[0]);
}

/* clone 'src' to 'dest' */
static void
copy_stats(struct statinfo *dest, struct statinfo *src)
{
	int i, j;

	for (i = 0; src[i].tag; i++) {
		dest[i].tag = src[i].tag;
		dest[i].nrvals = src[i].nrvals;
		for (j = 0; j < dest[i].nrvals; j++)
			dest[i].valptr[j] = src[i].valptr[j];
	}
}

/*
 * take the difference of each individual stat value in 'new' and 'old'
 * and store the results back into 'new'
 */
static void
diff_stats(struct statinfo *new, struct statinfo *old)
{
	int i, j, is_srv, nodiff_first_index, should_diff;

	/*
	 * Different stat types have different formats in the /proc
	 * files: for the proc2/3/4-type stats, the first entry has
	 * the total number of subsequent entries; one does not want
	 * to diff that first entry.  The other stat types aren't like
	 * this.  So, we diff a given entry if it's not of one of the
	 * procX types ("i" < 2 for clt, < 4 for srv), or if it's not
	 * the first entry ("j" > 0).
	 */
	is_srv = (new == srvinfo);
	nodiff_first_index = 2 + (2 * is_srv);

	for (i = 0; old[i].tag; i++) {
		for (j = 0; j < new[i].nrvals; j++) {
			should_diff = (i < nodiff_first_index || j > 0);
			if (should_diff)
				new[i].valptr[j] -= old[i].valptr[j];
		}

		/*
		 * Make sure that the "totals" entry (last value in
		 * each stat array) for the procX-type stats has the
		 * "numentries" entry's (first value in procX-type
		 * stat arrays) constant value added-back after the
		 * diff -- i.e., it should always be included in the
		 * total.
		 */
		if (!strncmp("proc", new[i].tag, 4))
			new[i].valptr[new[i].nrvals - 1] += new[i].valptr[0];
	}
}

static void
unpause(int sig)
{
	double time_diff;
	int minutes, seconds;
	time_t endtime;

	endtime = time(NULL);
	time_diff = difftime(endtime, starttime);
	minutes = time_diff / 60;
	seconds = (int)time_diff % 60;
	printf("Signal received; displaying (only) statistics gathered over the last %d minutes, %d seconds:\n\n", minutes, seconds);
}