utils/nfsstat/nfsstat.c

   1 /*
   2  * nfsstat.c            Output NFS statistics
   3  *
   4  * Copyright (C) 1995-2005 Olaf Kirch <okir@suse.de>
   5  */
   6
   7 #ifdef HAVE_CONFIG_H
   8 #include <config.h>
   9 #endif
  10
  11 #define NFSSRVSTAT      "/proc/net/rpc/nfsd"
  12 #define NFSCLTSTAT      "/proc/net/rpc/nfs"
  13
  14 #define MOUNTSFILE      "/proc/mounts"
  15
  16 #include <stdlib.h>
  17 #include <stdio.h>
  18 #include <unistd.h>
  19 #include <getopt.h>
  20 #include <string.h>
  21 #include <fcntl.h>
  22 #include <errno.h>
  23 #include <signal.h>
  24 #include <time.h>
  25
  26 #define MAXNRVALS       32
  27
  28 enum {
  29         SRVPROC2_SZ = 18,
  30         CLTPROC2_SZ = 18,
  31         SRVPROC3_SZ = 22,
  32         CLTPROC3_SZ = 22,
  33         SRVPROC4_SZ = 2,
  34         CLTPROC4_SZ = 49,
  35         SRVPROC4OPS_SZ = 59,
  36 };
  37
  38 static unsigned int     srvproc2info[SRVPROC2_SZ+2],
  39                         srvproc2info_old[SRVPROC2_SZ+2];        /* NFSv2 call counts ([0] == 18) */
  40 static unsigned int     cltproc2info[CLTPROC2_SZ+2],
  41                         cltproc2info_old[CLTPROC2_SZ+2];        /* NFSv2 call counts ([0] == 18) */
  42 static unsigned int     srvproc3info[SRVPROC3_SZ+2],
  43                         srvproc3info_old[SRVPROC3_SZ+2];        /* NFSv3 call counts ([0] == 22) */
  44 static unsigned int     cltproc3info[CLTPROC3_SZ+2],
  45                         cltproc3info_old[CLTPROC3_SZ+2];        /* NFSv3 call counts ([0] == 22) */
  46 static unsigned int     srvproc4info[SRVPROC4_SZ+2],
  47                         srvproc4info_old[SRVPROC4_SZ+2];        /* NFSv4 call counts ([0] == 2) */
  48 static unsigned int     cltproc4info[CLTPROC4_SZ+2],
  49                         cltproc4info_old[CLTPROC4_SZ+2];        /* NFSv4 call counts ([0] == 48) */
  50 static unsigned int     srvproc4opsinfo[SRVPROC4OPS_SZ+2],
  51                         srvproc4opsinfo_old[SRVPROC4OPS_SZ+2];  /* NFSv4 call counts ([0] == 59) */
  52 static unsigned int     srvnetinfo[5], srvnetinfo_old[5];       /* 0  # of received packets
  53                                                                  * 1  UDP packets
  54                                                                  * 2  TCP packets
  55                                                                  * 3  TCP connections
  56                                                                  */
  57 static unsigned int     cltnetinfo[5], cltnetinfo_old[5];       /* 0  # of received packets
  58                                                                  * 1  UDP packets
  59                                                                  * 2  TCP packets
  60                                                                  * 3  TCP connections
  61                                                                  */
  62
  63 static unsigned int     srvrpcinfo[6], srvrpcinfo_old[6];       /* 0  total # of RPC calls
  64                                                                  * 1  total # of bad calls
  65                                                                  * 2  bad format
  66                                                                  * 3  authentication failed
  67                                                                  * 4  unknown client
  68                                                                  */
  69 static unsigned int     cltrpcinfo[4], cltrpcinfo_old[4];       /* 0  total # of RPC calls
  70                                                                  * 1  retransmitted calls
  71                                                                  * 2  cred refreshs
  72                                                                  */
  73
  74 static unsigned int     srvrcinfo[9], srvrcinfo_old[9];         /* 0  repcache hits
  75                                                                  * 1  repcache hits
  76                                                                  * 2  uncached reqs
  77                                                                  * (for pre-2.4 kernels:)
  78                                                                  * 3  FH lookups
  79                                                                  * 4  'anon' FHs
  80                                                                  * 5  noncached non-directories
  81                                                                  * 6  noncached directories
  82                                                                  * 7  stale
  83                                                                  */
  84
  85 static unsigned int     srvfhinfo[7], srvfhinfo_old[7];         /* (for kernels >= 2.4.0)
  86                                                                  * 0  stale
  87                                                                  * 1  FH lookups
  88                                                                  * 2  'anon' FHs
  89                                                                  * 3  noncached directories
  90                                                                  * 4  noncached non-directories
  91                                                                  * leave hole to relocate stale for order
  92                                                                  *    compatability.
  93                                                                  */
  94
  95 static const char *     nfsv2name[SRVPROC2_SZ] = {
  96         "null", "getattr", "setattr", "root",   "lookup",  "readlink",
  97         "read", "wrcache", "write",   "create", "remove",  "rename",
  98         "link", "symlink", "mkdir",   "rmdir",  "readdir", "fsstat"
  99 };
 100
 101 static const char *     nfsv3name[SRVPROC3_SZ] = {
 102         "null",   "getattr", "setattr",  "lookup", "access",  "readlink",
 103         "read",   "write",   "create",   "mkdir",  "symlink", "mknod",
 104         "remove", "rmdir",   "rename",   "link",   "readdir", "readdirplus",
 105         "fsstat", "fsinfo",  "pathconf", "commit"
 106 };
 107
 108 static const char *     nfssrvproc4name[SRVPROC4_SZ] = {
 109         "null",
 110         "compound",
 111 };
 112
 113 static const char *     nfscltproc4name[CLTPROC4_SZ] = {
 114         "null",      "read",      "write",   "commit",      "open",        "open_conf",
 115         "open_noat", "open_dgrd", "close",   "setattr",     "fsinfo",      "renew",
 116         "setclntid", "confirm",   "lock",
 117         "lockt",     "locku",     "access",  "getattr",     "lookup",      "lookup_root",
 118         "remove",    "rename",    "link",    "symlink",     "create",      "pathconf",
 119         "statfs",    "readlink",  "readdir", "server_caps", "delegreturn", "getacl",
 120         "setacl",    "fs_locations",
 121         "rel_lkowner",
 122         /* nfsv4.1 client ops */
 123         "exchange_id",
 124         "create_ses",
 125         "destroy_ses",
 126         "sequence",
 127         "get_lease_t",
 128         "reclaim_comp",
 129         "layoutget",
 130         "layoutcommit",
 131         "layoutreturn",
 132         "getdevlist",
 133         "getdevinfo",
 134         /* nfsv4.1 pnfs client ops to data server only */
 135         "ds_write",
 136         "ds_commit",
 137 };
 138
 139 static const char *     nfssrvproc4opname[SRVPROC4OPS_SZ] = {
 140         "op0-unused",   "op1-unused", "op2-future",  "access",     "close",       "commit",
 141         "create",       "delegpurge", "delegreturn", "getattr",    "getfh",       "link",
 142         "lock",         "lockt",      "locku",       "lookup",     "lookup_root", "nverify",
 143         "open",         "openattr",   "open_conf",   "open_dgrd",  "putfh",       "putpubfh",
 144         "putrootfh",    "read",       "readdir",     "readlink",   "remove",      "rename",
 145         "renew",        "restorefh",  "savefh",      "secinfo",    "setattr",     "setcltid",
 146         "setcltidconf", "verify",     "write",       "rellockowner",
 147         /* nfsv4.1 server ops */
 148         "bc_ctl",
 149         "bind_conn",
 150         "exchange_id",
 151         "create_ses",
 152         "destroy_ses",
 153         "free_stateid",
 154         "getdirdeleg",
 155         "getdevinfo",
 156         "getdevlist",
 157         "layoutcommit",
 158         "layoutget",
 159         "layoutreturn",
 160         "secinfononam",
 161         "sequence",
 162         "set_ssv",
 163         "test_stateid",
 164         "want_deleg",
 165         "destroy_clid",
 166         "reclaim_comp",
 167 };
 168
 169 #define LABEL_srvnet            "Server packet stats:\n"
 170 #define LABEL_srvrpc            "Server rpc stats:\n"
 171 #define LABEL_srvrc             "Server reply cache:\n"
 172 #define LABEL_srvfh             "Server file handle cache:\n"
 173 #define LABEL_srvproc2          "Server nfs v2:\n"
 174 #define LABEL_srvproc3          "Server nfs v3:\n"
 175 #define LABEL_srvproc4          "Server nfs v4:\n"
 176 #define LABEL_srvproc4ops       "Server nfs v4 operations:\n"
 177 #define LABEL_cltnet            "Client packet stats:\n"
 178 #define LABEL_cltrpc            "Client rpc stats:\n"
 179 #define LABEL_cltproc2          "Client nfs v2:\n"
 180 #define LABEL_cltproc3          "Client nfs v3:\n"
 181 #define LABEL_cltproc4          "Client nfs v4:\n"
 182
 183 typedef struct statinfo {
 184         char            *tag;
 185         char            *label;
 186         int             nrvals;
 187         unsigned int *  valptr;
 188 } statinfo;
 189
 190 /*
 191  * We now build the arrays of statinfos using macros, which will make it easier
 192  * to add new variables for --sleep.  e.g., SRV(net) expands into the struct
 193  * statinfo:  { "net", "Server packet stats:\n", 5, srvnetinfo }
 194  */
 195 #define ARRAYSIZE(x)            sizeof(x)/sizeof(*x)
 196 #define STATINFO(k, t, s...)    { #t, LABEL_##k##t, ARRAYSIZE(k##t##info##s), k##t##info##s }
 197 #define SRV(t, s...)            STATINFO(srv, t, s)
 198 #define CLT(t, s...)            STATINFO(clt, t, s)
 199 #define DECLARE_SRV(n, s...)    static statinfo n##s[] = { \
 200                                         SRV(net,s), \
 201                                         SRV(rpc,s), \
 202                                         SRV(rc,s), \
 203                                         SRV(fh,s), \
 204                                         SRV(proc2,s), \
 205                                         SRV(proc3,s),\
 206                                         SRV(proc4,s), \
 207                                         SRV(proc4ops,s),\
 208                                         { NULL, NULL, 0, NULL }\
 209                                 }
 210 #define DECLARE_CLT(n, s...)    static statinfo n##s[] = { \
 211                                         CLT(net,s), \
 212                                         CLT(rpc,s), \
 213                                         CLT(proc2,s),\
 214                                         CLT(proc3,s), \
 215                                         CLT(proc4,s),\
 216                                         { NULL, NULL, 0, NULL }\
 217                                 }
 218 DECLARE_SRV(srvinfo);
 219 DECLARE_SRV(srvinfo, _old);
 220 DECLARE_CLT(cltinfo);
 221 DECLARE_CLT(cltinfo, _old);
 222
 223 static void             print_all_stats(int, int, int);
 224 static void             print_server_stats(int, int);
 225 static void             print_client_stats(int, int);
 226 static void             print_stats_list(int, int, int);
 227 static void             print_numbers(const char *, unsigned int *,
 228                                         unsigned int);
 229 static void             print_callstats(const char *, const char **,
 230                                         unsigned int *, unsigned int);
 231 static void             print_callstats_list(const char *, const char **,
 232                                         unsigned int *, unsigned int);
 233 static int              parse_raw_statfile(const char *, struct statinfo *);
 234 static int              parse_pretty_statfile(const char *, struct statinfo *);
 235
 236 static statinfo         *get_stat_info(const char *, struct statinfo *);
 237
 238 static int              mounts(const char *);
 239
 240 static void             get_stats(const char *, struct statinfo *, int *, int,
 241                                         int);
 242 static int              has_stats(const unsigned int *);
 243 static int              has_rpcstats(const unsigned int *, int);
 244 static void             diff_stats(struct statinfo *, struct statinfo *, int);
 245 static void             unpause(int);
 246 static void             update_old_counters(struct statinfo *, struct statinfo *);
 247
 248 static time_t           starttime;
 249
 250 #define PRNT_CALLS      0x0001
 251 #define PRNT_RPC        0x0002
 252 #define PRNT_NET        0x0004
 253 #define PRNT_FH         0x0008
 254 #define PRNT_RC         0x0010
 255 #define PRNT_AUTO       0x1000
 256 #define PRNT_V2         0x2000
 257 #define PRNT_V3         0x4000
 258 #define PRNT_V4         0x8000
 259 #define PRNT_ALL        0x0fff
 260
 261 int versions[] = {
 262         PRNT_V2,
 263         PRNT_V3,
 264         PRNT_V4
 265 };
 266
 267 void usage(char *name)
 268 {
 269         printf("Usage: %s [OPTION]...\n\
 270 \n\
 271   -m, --mounts          Show statistics on mounted NFS filesystems\n\
 272   -c, --client          Show NFS client statistics\n\
 273   -s, --server          Show NFS server statistics\n\
 274   -2                    Show NFS version 2 statistics\n\
 275   -3                    Show NFS version 3 statistics\n\
 276   -4                    Show NFS version 4 statistics\n\
 277   -o [facility]         Show statistics on particular facilities.\n\
 278      nfs                NFS protocol information\n\
 279      rpc                General RPC information\n\
 280      net                Network layer statistics\n\
 281      fh                 Usage information on the server's file handle cache\n\
 282      rc                 Usage information on the server's request reply cache\n\
 283      all                Select all of the above\n\
 284   -v, --verbose, --all  Same as '-o all'\n\
 285   -r, --rpc             Show RPC statistics\n\
 286   -n, --nfs             Show NFS statistics\n\
 287   -Z[#], --sleep[=#]    Collects stats until interrupted.\n\
 288                             Cumulative stats are then printed\n\
 289                             If # is provided, stats will be output every\n\
 290                             # seconds.\n\
 291   -S, --since file      Shows difference between current stats and those in 'file'\n\
 292   -l, --list            Prints stats in list format\n\
 293   --version             Show program version\n\
 294   --help                What you just did\n\
 295 \n", name);
 296         exit(0);
 297 }
 298
 299 static struct option longopts[] =
 300 {
 301         { "acl", 0, 0, 'a' },
 302         { "all", 0, 0, 'v' },
 303         { "auto", 0, 0, '\3' },
 304         { "client", 0, 0, 'c' },
 305         { "mounted", 0, 0, 'm' },
 306         { "nfs", 0, 0, 'n' },
 307         { "rpc", 0, 0, 'r' },
 308         { "server", 0, 0, 's' },
 309         { "verbose", 0, 0, 'v' },
 310         { "zero", 0, 0, 'z' },
 311         { "help", 0, 0, '\1' },
 312         { "version", 0, 0, '\2' },
 313         { "sleep", 2, 0, 'Z' },
 314         { "since", 1, 0, 'S' },
 315         { "list", 0, 0, 'l' },
 316         { NULL, 0, 0, 0 }
 317 };
 318 int opt_sleep;
 319
 320 int
 321 main(int argc, char **argv)
 322 {
 323         int             opt_all = 0,
 324                         opt_srv = 0,
 325                         opt_clt = 0,
 326                         opt_prt = 0,
 327                         sleep_time = 0,
 328                         opt_list =0,
 329                         opt_since = 0;
 330         int             c;
 331         char           *progname,
 332                        *serverfile = NFSSRVSTAT,
 333                        *clientfile = NFSCLTSTAT;
 334
 335         struct statinfo *serverinfo = srvinfo,
 336                         *serverinfo_tmp = srvinfo_old,
 337                         *clientinfo = cltinfo,
 338                         *clientinfo_tmp = cltinfo_old;
 339
 340         struct sigaction act = {
 341                 .sa_handler = unpause,
 342                 .sa_flags = SA_ONESHOT,
 343         };
 344
 345         if ((progname = strrchr(argv[0], '/')))
 346                 progname++;
 347         else
 348                 progname = argv[0];
 349
 350         while ((c = getopt_long(argc, argv, "234acmno:Z::S:vrslz\1\2", longopts, NULL)) != EOF) {
 351                 switch (c) {
 352                 case 'a':
 353                         fprintf(stderr, "nfsstat: nfs acls are not yet supported.\n");
 354                         return -1;
 355                 case 'c':
 356                         opt_clt = 1;
 357                         break;
 358                 case 'n':
 359                         opt_prt |= PRNT_CALLS;
 360                         break;
 361                 case 'o':
 362                         if (!strcmp(optarg, "nfs"))
 363                                 opt_prt |= PRNT_CALLS;
 364                         else if (!strcmp(optarg, "rpc"))
 365                                 opt_prt |= PRNT_RPC;
 366                         else if (!strcmp(optarg, "net"))
 367                                 opt_prt |= PRNT_NET;
 368                         else if (!strcmp(optarg, "rc"))
 369                                 opt_prt |= PRNT_RC;
 370                         else if (!strcmp(optarg, "fh"))
 371                                 opt_prt |= PRNT_FH;
 372                         else if (!strcmp(optarg, "all"))
 373                                 opt_prt |= PRNT_CALLS | PRNT_RPC | PRNT_NET | PRNT_RC | PRNT_FH;
 374                         else {
 375                                 fprintf(stderr, "nfsstat: unknown category: "
 376                                                 "%s\n", optarg);
 377                                 return 2;
 378                         }
 379                         break;
 380                 case 'Z':
 381                         opt_sleep = 1;
 382                         if (optarg) {
 383                                 sleep_time = atoi(optarg);
 384                         }
 385                         break;
 386                 case 'S':
 387                         opt_since = 1;
 388                         serverfile = optarg;
 389                         clientfile = optarg;
 390                         break;
 391                 case '2':
 392                 case '3':
 393                 case '4':
 394                         opt_prt |= versions[c - '2'];
 395                         break;
 396                 case 'v':
 397                         opt_all = 1;
 398                         break;
 399                 case '\3':
 400                         opt_prt |= PRNT_AUTO;
 401                         break;
 402                 case 'r':
 403                         opt_prt |= PRNT_RPC;
 404                         break;
 405                 case 's':
 406                         opt_srv = 1;
 407                         break;
 408                 case 'l':
 409                         opt_list = 1;
 410                         break;
 411                 case 'z':
 412                         fprintf(stderr, "nfsstat: zeroing of nfs statistics "
 413                                         "not yet supported\n");
 414                         return 2;
 415                 case 'm':
 416                         return mounts(MOUNTSFILE);
 417                 case '\1':
 418                         usage(progname);
 419                         return 0;
 420                 case '\2':
 421                         fprintf(stdout, "nfsstat: " VERSION "\n");
 422                         return 0;
 423                 default:
 424                         printf("Try `%s --help' for more information.\n", progname);
 425                         return -1;
 426                 }
 427         }
 428
 429         if (opt_all) {
 430                 opt_srv = opt_clt = 1;
 431                 opt_prt |= PRNT_ALL;
 432         }
 433         if (!(opt_srv + opt_clt))
 434                 opt_srv = opt_clt = 1;
 435         if (!(opt_prt & 0xfff)) {
 436                 opt_prt |= PRNT_CALLS + PRNT_RPC;
 437         }
 438         if (!(opt_prt & 0xe000)) {
 439                 opt_prt |= PRNT_AUTO;
 440         }
 441         if ((opt_prt & (PRNT_FH|PRNT_RC)) && !opt_srv) {
 442                 fprintf(stderr,
 443                         "You requested file handle or request cache "
 444                         "statistics while using the -c option.\n"
 445                         "This information is available only for the NFS "
 446                         "server.\n");
 447         }
 448
 449         if (opt_since || opt_sleep) {
 450                 serverinfo = srvinfo_old;
 451                 serverinfo_tmp = srvinfo;
 452                 clientinfo = cltinfo_old;
 453                 clientinfo_tmp = cltinfo;
 454         }
 455
 456         if (opt_srv)
 457                 get_stats(serverfile, serverinfo, &opt_srv, opt_clt, 1);
 458         if (opt_clt)
 459                 get_stats(clientfile, clientinfo, &opt_clt, opt_srv, 0);
 460
 461         if (opt_sleep && !sleep_time) {
 462                 starttime = time(NULL);
 463                 printf("Collecting statistics; press CTRL-C to view results from interval (i.e., from pause to CTRL-C).\n");
 464                 if (sigaction(SIGINT, &act, NULL) != 0) {
 465                         fprintf(stderr, "Error: couldn't register for signal and pause.\n");
 466                         return 1;
 467                 }
 468                 pause();
 469         }
 470
 471         if (opt_since || opt_sleep) {
 472                 if (opt_srv) {
 473                         get_stats(NFSSRVSTAT, serverinfo_tmp, &opt_srv, opt_clt, 1);
 474                         diff_stats(serverinfo_tmp, serverinfo, 1);
 475                 }
 476                 if (opt_clt) {
 477                         get_stats(NFSCLTSTAT, clientinfo_tmp, &opt_clt, opt_srv, 0);
 478                         diff_stats(clientinfo_tmp, clientinfo, 0);
 479                 }
 480         }
 481         if(sleep_time) {
 482                 while(1) {
 483                         if (opt_srv) {
 484                                 get_stats(NFSSRVSTAT, serverinfo_tmp , &opt_srv, opt_clt, 1);
 485                                 diff_stats(serverinfo_tmp, serverinfo, 1);
 486                         }
 487                         if (opt_clt) {
 488                                 get_stats(NFSCLTSTAT, clientinfo_tmp, &opt_clt, opt_srv, 0);
 489                                 diff_stats(clientinfo_tmp, clientinfo, 0);
 490                         }
 491                         if (opt_list) {
 492                                 print_stats_list(opt_srv, opt_clt, opt_prt);
 493                         } else {
 494                                 print_all_stats(opt_srv, opt_clt, opt_prt);
 495                         }
 496                         fflush(stdout);
 497
 498                         if (opt_srv)
 499                                 update_old_counters(serverinfo_tmp, serverinfo);
 500                         if (opt_clt)
 501                                 update_old_counters(clientinfo_tmp, clientinfo);
 502
 503                         sleep(sleep_time);
 504                 }
 505         } else {
 506                 if (opt_list) {
 507                         print_stats_list(opt_srv, opt_clt, opt_prt);
 508                 } else {
 509                         print_all_stats(opt_srv, opt_clt, opt_prt);
 510                 }
 511         }
 512
 513         return 0;
 514 }
 515
 516 static void
 517 print_all_stats (int opt_srv, int opt_clt, int opt_prt)
 518 {
 519         print_server_stats(opt_srv, opt_prt);
 520         print_client_stats(opt_clt, opt_prt);
 521 }
 522
 523 static void
 524 print_server_stats(int opt_srv, int opt_prt)
 525 {
 526         if (!opt_srv)
 527                 return;
 528
 529         if (opt_prt & PRNT_NET) {
 530                 if (opt_sleep && !has_rpcstats(srvnetinfo, 4)) {
 531                 } else {
 532                         print_numbers( LABEL_srvnet
 533                                 "packets    udp        tcp        tcpconn\n",
 534                         srvnetinfo, 4);
 535                         printf("\n");
 536                 }
 537         }
 538         if (opt_prt & PRNT_RPC) {
 539                 if (opt_sleep && !has_rpcstats(srvrpcinfo, 5)) {
 540                         ;
 541                 } else {
 542                         print_numbers(LABEL_srvrpc
 543                                 "calls      badcalls   badauth    badclnt    xdrcall\n",
 544                                 srvrpcinfo, 5);
 545                         printf("\n");
 546                 }
 547         }
 548         if (opt_prt & PRNT_RC) {
 549                 if (opt_sleep && !has_rpcstats(srvrcinfo, 3)) {
 550                         ;
 551                 } else {
 552                         print_numbers(LABEL_srvrc
 553                                 "hits       misses     nocache\n",
 554                                 srvrcinfo, 3);
 555                         printf("\n");
 556                 }
 557         }
 558
 559         /*
 560          * 2.2 puts all fh-related info after the 'rc' header
 561          * 2.4 puts all fh-related info after the 'fh' header, but relocates
 562          *     'stale' to the start and swaps dir and nondir :-(
 563          *     We preseve the 2.2 order
 564          */
 565         if (opt_prt & PRNT_FH) {
 566                 if (get_stat_info("fh", srvinfo)) {     /* >= 2.4 */
 567                         int t = srvfhinfo[3];
 568                         srvfhinfo[3]=srvfhinfo[4];
 569                         srvfhinfo[4]=t;
 570
 571                         srvfhinfo[5]=srvfhinfo[0]; /* relocate 'stale' */
 572
 573                         print_numbers(
 574                                 LABEL_srvfh
 575                                 "lookup     anon       ncachedir  ncachedir  stale\n",
 576                                 srvfhinfo + 1, 5);
 577                 } else                                  /* < 2.4 */
 578                         print_numbers(
 579                                 LABEL_srvfh
 580                                 "lookup     anon       ncachedir  ncachedir  stale\n",
 581                                 srvrcinfo + 3, 5);
 582                 printf("\n");
 583         }
 584         if (opt_prt & PRNT_CALLS) {
 585                 if ((opt_prt & PRNT_V2) ||
 586                                 ((opt_prt & PRNT_AUTO) && has_stats(srvproc2info))) {
 587                         if (opt_sleep && !has_stats(srvproc2info)) {
 588                                 ;
 589                         } else {
 590                                 print_callstats(LABEL_srvproc2,
 591                                         nfsv2name, srvproc2info + 1,
 592                                         sizeof(nfsv2name)/sizeof(char *));
 593                         }
 594                 }
 595                 if ((opt_prt & PRNT_V3) ||
 596                                 ((opt_prt & PRNT_AUTO) && has_stats(srvproc3info))) {
 597                         if (opt_sleep && !has_stats(srvproc3info)) {
 598                                 ;
 599                         } else {
 600                                 print_callstats(LABEL_srvproc3,
 601                                         nfsv3name, srvproc3info + 1,
 602                                         sizeof(nfsv3name)/sizeof(char *));
 603                         }
 604                 }
 605                 if ((opt_prt & PRNT_V4) ||
 606                                 ((opt_prt & PRNT_AUTO) && has_stats(srvproc4info))) {
 607                         if (opt_sleep && !has_stats(srvproc4info)) {
 608                                 ;
 609                         } else {
 610                                 print_callstats( LABEL_srvproc4,
 611                                         nfssrvproc4name, srvproc4info + 1,
 612                                         sizeof(nfssrvproc4name)/sizeof(char *));
 613                                 print_callstats(LABEL_srvproc4ops,
 614                                         nfssrvproc4opname, srvproc4opsinfo + 1,
 615                                         sizeof(nfssrvproc4opname)/sizeof(char *));
 616                         }
 617                 }
 618         }
 619 }
 620 static void
 621 print_client_stats(int opt_clt, int opt_prt)
 622 {
 623         if (!opt_clt)
 624                 return;
 625
 626         if (opt_prt & PRNT_NET) {
 627                 if (opt_sleep && !has_rpcstats(cltnetinfo, 4)) {
 628                         ;
 629                 } else {
 630                         print_numbers(LABEL_cltnet
 631                                 "packets    udp        tcp        tcpconn\n",
 632                                 cltnetinfo, 4);
 633                         printf("\n");
 634                 }
 635         }
 636         if (opt_prt & PRNT_RPC) {
 637                 if (opt_sleep && !has_rpcstats(cltrpcinfo, 3)) {
 638                         ;
 639                 } else {
 640                         print_numbers(LABEL_cltrpc
 641                                 "calls      retrans    authrefrsh\n",
 642                                 cltrpcinfo, 3);
 643                         printf("\n");
 644                 }
 645         }
 646         if (opt_prt & PRNT_CALLS) {
 647                 if ((opt_prt & PRNT_V2) ||
 648                                 ((opt_prt & PRNT_AUTO) && has_stats(cltproc2info))) {
 649                         if (opt_sleep && !has_stats(cltproc2info)) {
 650                                 ;
 651                         } else {
 652                                 print_callstats(LABEL_cltproc2,
 653                                         nfsv2name, cltproc2info + 1,
 654                                         sizeof(nfsv2name)/sizeof(char *));
 655                         }
 656                 }
 657                 if ((opt_prt & PRNT_V3) ||
 658                                 ((opt_prt & PRNT_AUTO) && has_stats(cltproc3info))) {
 659                         if (opt_sleep && !has_stats(cltproc3info)) {
 660                                 ;
 661                         } else {
 662                                 print_callstats(LABEL_cltproc3,
 663                                         nfsv3name, cltproc3info + 1,
 664                                         sizeof(nfsv3name)/sizeof(char *));
 665                         }
 666                 }
 667                 if ((opt_prt & PRNT_V4) ||
 668                                 ((opt_prt & PRNT_AUTO) && has_stats(cltproc4info))) {
 669                         if (opt_sleep && !has_stats(cltproc4info)) {
 670                                 ;
 671                         } else {
 672                                 print_callstats(LABEL_cltproc4,
 673                                         nfscltproc4name, cltproc4info + 1,
 674                                         sizeof(nfscltproc4name)/sizeof(char *));
 675                         }
 676                 }
 677         }
 678 }
 679
 680 static void
 681 print_clnt_list(int opt_prt)
 682 {
 683         if (opt_prt & PRNT_CALLS) {
 684                 if ((opt_prt & PRNT_V2) ||
 685                                 ((opt_prt & PRNT_AUTO) && has_stats(cltproc2info))) {
 686                         if (opt_sleep && !has_stats(cltproc2info)) {
 687                                 ;
 688                         } else {
 689                                 print_callstats_list("nfs v2 client",
 690                                         nfsv2name, cltproc2info + 1,
 691                                         sizeof(nfsv2name)/sizeof(char *));
 692                         }
 693                 }
 694                 if ((opt_prt & PRNT_V3) ||
 695                                 ((opt_prt & PRNT_AUTO) && has_stats(cltproc3info))) {
 696                         if (opt_sleep && !has_stats(cltproc3info)) {
 697                                 ;
 698                         } else {
 699                                 print_callstats_list("nfs v3 client",
 700                                         nfsv3name, cltproc3info + 1,
 701                                         sizeof(nfsv3name)/sizeof(char *));
 702                         }
 703                 }
 704                 if ((opt_prt & PRNT_V4) ||
 705                                 ((opt_prt & PRNT_AUTO) && has_stats(cltproc4info))) {
 706                         if (opt_sleep && !has_stats(cltproc4info)) {
 707                                 ;
 708                         } else {
 709                                 print_callstats_list("nfs v4 ops",
 710                                         nfssrvproc4opname, srvproc4opsinfo + 1,
 711                                         sizeof(nfssrvproc4opname)/sizeof(char *));
 712                                 print_callstats_list("nfs v4 client",
 713                                         nfscltproc4name, cltproc4info + 1,
 714                                         sizeof(nfscltproc4name)/sizeof(char *));
 715                         }
 716                 }
 717         }
 718 }
 719 static void
 720 print_serv_list(int opt_prt)
 721 {
 722         if (opt_prt & PRNT_CALLS) {
 723                 if ((opt_prt & PRNT_V2) ||
 724                                 ((opt_prt & PRNT_AUTO) && has_stats(srvproc2info))) {
 725                         if (opt_sleep && !has_stats(srvproc2info)) {
 726                                 ;
 727                         } else {
 728                                 print_callstats_list("nfs v2 server",
 729                                         nfsv2name, srvproc2info + 1,
 730                                         sizeof(nfsv2name)/sizeof(char *));
 731                         }
 732                 }
 733                 if ((opt_prt & PRNT_V3) ||
 734                                 ((opt_prt & PRNT_AUTO) && has_stats(srvproc3info))) {
 735                         if (opt_sleep && !has_stats(srvproc3info)) {
 736                                 ;
 737                         } else {
 738                                 print_callstats_list("nfs v3 server",
 739                                         nfsv3name, srvproc3info + 1,
 740                                         sizeof(nfsv3name)/sizeof(char *));
 741                         }
 742                 }
 743                 if ((opt_prt & PRNT_V4) ||
 744                                 ((opt_prt & PRNT_AUTO) && has_stats(srvproc4opsinfo))) {
 745                         if (opt_sleep && !has_stats(srvproc4info)) {
 746                                 ;
 747                         } else {
 748                                 print_callstats_list("nfs v4 ops",
 749                                         nfssrvproc4opname, srvproc4opsinfo + 1,
 750                                         sizeof(nfssrvproc4opname)/sizeof(char *));
 751                         }
 752                 }
 753         }
 754 }
 755 static void
 756 print_stats_list(int opt_srv, int opt_clt, int opt_prt)
 757 {
 758         if (opt_srv)
 759                 print_serv_list(opt_prt);
 760
 761         if (opt_clt)
 762                 print_clnt_list(opt_prt);
 763 }
 764
 765 static statinfo *
 766 get_stat_info(const char *sp, struct statinfo *statp)
 767 {
 768         struct statinfo *ip;
 769
 770         for (ip = statp; ip->tag; ip++) {
 771                 if (!strcmp(sp, ip->tag))
 772                         return ip;
 773         }
 774
 775         return NULL;
 776 }
 777
 778 static void
 779 print_numbers(const char *hdr, unsigned int *info, unsigned int nr)
 780 {
 781         unsigned int    i;
 782
 783         fputs(hdr, stdout);
 784         for (i = 0; i < nr; i++)
 785                 printf("%s%-8u", i? "   " : "", info[i]);
 786         printf("\n");
 787 }
 788
 789 static void
 790 print_callstats(const char *hdr, const char **names,
 791                                  unsigned int *info, unsigned int nr)
 792 {
 793         unsigned long long      total;
 794         unsigned long long      pct;
 795         unsigned int            i, j;
 796
 797         fputs(hdr, stdout);
 798         for (i = 0, total = 0; i < nr; i++)
 799                 total += info[i];
 800         if (!total)
 801                 total = 1;
 802         for (i = 0; i < nr; i += 6) {
 803                 for (j = 0; j < 6 && i + j < nr; j++)
 804                         printf("%-13s", names[i+j]);
 805                 printf("\n");
 806                 for (j = 0; j < 6 && i + j < nr; j++) {
 807                         pct = ((unsigned long long) info[i+j]*100)/total;
 808                         printf("%-8u%3llu%% ", info[i+j], pct);
 809                 }
 810                 printf("\n");
 811         }
 812         printf("\n");
 813 }
 814
 815 static void
 816 print_callstats_list(const char *hdr, const char **names,
 817                         unsigned int *callinfo, unsigned int nr)
 818 {
 819         unsigned long long      calltotal;
 820         unsigned int                    i;
 821
 822         for (i = 0, calltotal = 0; i < nr; i++) {
 823                 calltotal += callinfo[i];
 824         }
 825         if (!calltotal)
 826                 return;
 827         printf("%13s %13s %8llu \n", hdr, "total:", calltotal);
 828         printf("------------- ------------- --------\n");
 829         for (i = 0; i < nr; i++) {
 830                         if (callinfo[i])
 831                                 printf("%13s %12s: %8u \n", hdr, names[i], callinfo[i]);
 832         }
 833         printf("\n");
 834
 835 }
 836
 837
 838 /* returns 0 on success, 1 otherwise */
 839 static int
 840 parse_raw_statfile(const char *name, struct statinfo *statp)
 841 {
 842         char    buffer[4096], *next;
 843         FILE    *fp;
 844
 845         /* Being unable to read e.g. the nfsd stats file shouldn't
 846          * be a fatal error -- it usually means the module isn't loaded.
 847          */
 848         if ((fp = fopen(name, "r")) == NULL) {
 849                 // fprintf(stderr, "Warning: %s: %m\n", name);
 850                 return 1;
 851         }
 852
 853         while (fgets(buffer, sizeof(buffer), fp) != NULL) {
 854                 struct statinfo *ip;
 855                 char            *sp, *line = buffer;
 856                 unsigned int    i, cnt;
 857                 unsigned int    total = 0;
 858
 859                 if ((next = strchr(line, '\n')) != NULL)
 860                         *next++ = '\0';
 861                 if (!(sp = strtok(line, " \t")))
 862                         continue;
 863
 864                 ip = get_stat_info(sp, statp);
 865                 if (!ip)
 866                         continue;
 867
 868                 cnt = ip->nrvals;
 869
 870                 for (i = 0; i < cnt; i++) {
 871                         if (!(sp = strtok(NULL, " \t")))
 872                                 break;
 873                         ip->valptr[i] = (unsigned int) strtoul(sp, NULL, 0);
 874                         total += ip->valptr[i];
 875                 }
 876                 ip->valptr[cnt - 1] = total;
 877         }
 878
 879         fclose(fp);
 880         return 0;
 881 }
 882
 883 /* returns 0 on success, 1 otherwise */
 884 static int
 885 parse_pretty_statfile(const char *filename, struct statinfo *info)
 886 {
 887         int numvals, curindex, numconsumed, n, err = 1;
 888         unsigned int sum;
 889         char buf[4096], *bufp, *fmt, is_proc;
 890         FILE *fp = NULL;
 891         struct statinfo *ip;
 892
 893         if ((fp = fopen(filename, "r")) == NULL)
 894                 //err(2, "Unable to open statfile '%s'.\n", filename);
 895                 goto out;
 896
 897         while (fgets(buf, sizeof(buf), fp) != NULL) {
 898                 for (ip = info; ip->tag; ip++) {
 899                         if (strcmp(buf, ip->label))
 900                                 continue;
 901
 902                         sum = 0;
 903                         numvals = ip->nrvals - 1;
 904                         is_proc = strncmp("proc", ip->tag, 4) ? 0 : 1;
 905                         if (is_proc) {
 906                                 fmt = " %u %*u%% %n";
 907                                 curindex = 1;
 908                                 ip->valptr[0] = 0;
 909                         } else {
 910                                 fmt = " %u %n";
 911                                 curindex = 0;
 912                         }
 913 more_stats:
 914                         /* get (and skip) header */
 915                         if (fgets(buf, sizeof(buf), fp) == NULL) {
 916                                 fprintf(stderr, "Failed to locate header after "
 917                                                 "label for '%s' in %s.\n",
 918                                                 ip->tag, filename);
 919                                 goto out;
 920                         }
 921                         /* no header -- done with this "tag" */
 922                         if (*buf == '\n') {
 923                                 ip->valptr[numvals] = sum;
 924                                 break;
 925                         }
 926                         /* get stats */
 927                         if (fgets(buf, sizeof(buf), fp) == NULL) {
 928                                 fprintf(stderr, "Failed to locate stats after "
 929                                                 "header for '%s' in %s.\n",
 930                                                 ip->tag, filename);
 931                                 goto out;
 932                         }
 933                         bufp = buf;
 934                         for (; curindex < numvals; curindex++) {
 935                                 n = sscanf(bufp, fmt, &ip->valptr[curindex],
 936                                                 &numconsumed);
 937                                 if (n != 1)
 938                                         break;
 939                                 if (is_proc) {
 940                                         ip->valptr[0]++;
 941                                         sum++;
 942                                 }
 943                                 sum += ip->valptr[curindex];
 944                                 bufp += numconsumed;
 945                         }
 946                         goto more_stats;
 947                 }
 948         }
 949         err = 0;
 950 out:
 951         if (fp)
 952                 fclose(fp);
 953         return err;
 954 }
 955
 956 static int
 957 mounts(const char *name)
 958 {
 959         char    buffer[4096], *next;
 960         FILE    *fp;
 961
 962         /* Being unable to read e.g. the nfsd stats file shouldn't
 963          * be a fatal error -- it usually means the module isn't loaded.
 964          */
 965         if ((fp = fopen(name, "r")) == NULL) {
 966                 fprintf(stderr, "Warning: %s: %m\n", name);
 967                 return 0;
 968         }
 969
 970         while (fgets(buffer, sizeof(buffer), fp) != NULL) {
 971                 char          *line = buffer;
 972                 char          *device, *mount, *type, *flags;
 973
 974                 if ((next = strchr(line, '\n')) != NULL)
 975                         *next = '\0';
 976
 977                 if (!(device = strtok(line, " \t")))
 978                         continue;
 979
 980                 if (!(mount = strtok(NULL, " \t")))
 981                         continue;
 982
 983                 if (!(type = strtok(NULL, " \t")))
 984                         continue;
 985
 986                 if (strcmp(type, "nfs") && strcmp(type,"nfs4")) {
 987                     continue;
 988                 }
 989
 990                 if (!(flags = strtok(NULL, " \t")))
 991                         continue;
 992
 993                 printf("%s from %s\n", mount, device);
 994                 printf(" Flags:\t%s\n", flags);
 995                 printf("\n");
 996
 997                 continue;
 998         }
 999
1000         fclose(fp);
1001         return 1;
1002 }
1003
1004 static void
1005 get_stats(const char *file, struct statinfo *info, int *opt, int other_opt,
1006                 int is_srv)
1007 {
1008         FILE *fp;
1009         char buf[10];
1010         int err = 1;
1011         char *label = is_srv ? "Server" : "Client";
1012
1013         /* try to guess what type of stat file we're dealing with */
1014         if ((fp = fopen(file, "r")) == NULL)
1015                 goto out;
1016         if (fgets(buf, 10, fp) == NULL)
1017                 goto out;
1018         if (!strncmp(buf, "net ", 4)) {
1019                 /* looks like raw client stats */
1020                 if (is_srv) {
1021                         fprintf(stderr, "Warning: no server info present in "
1022                                         "raw client stats file.\n");
1023                         *opt = 0;
1024                 } else
1025                         err = parse_raw_statfile(file, info);
1026         } else if (!strncmp(buf, "rc ", 3)) {
1027                 /* looks like raw server stats */
1028                 if (!is_srv) {
1029                         fprintf(stderr, "Warning: no client info present in "
1030                                         "raw server stats file.\n");
1031                         *opt = 0;
1032                 } else
1033                         err = parse_raw_statfile(file, info);
1034         } else
1035                 /* looks like pretty client and server stats */
1036                 err = parse_pretty_statfile(file, info);
1037 out:
1038         if (fp)
1039                 fclose(fp);
1040         if (err) {
1041                 if (!other_opt) {
1042                         fprintf(stderr, "Error: No %s Stats (%s: %m). \n",
1043                                         label, file);
1044                         exit(2);
1045                 }
1046                 *opt = 0;
1047         }
1048 }
1049
1050 /*
1051  * This is for proc2/3/4-type stats, where, in the /proc files, the first entry's value
1052  * denotes the number of subsequent entries.  statinfo value arrays contain an additional
1053  * field at the end which contains the sum of all previous elements in the array -- so,
1054  * there are stats if the sum's greater than the entry-count.
1055  */
1056 static int
1057 has_stats(const unsigned int *info)
1058 {
1059         return (info[0] && info[info[0] + 1] > info[0]);
1060 }
1061 static int
1062 has_rpcstats(const unsigned int *info, int size)
1063 {
1064         int i, cnt;
1065
1066         for (i=0, cnt=0; i < size; i++)
1067                 cnt += info[i];
1068         return cnt;
1069 }
1070
1071 /*
1072  * take the difference of each individual stat value in 'new' and 'old'
1073  * and store the results back into 'new'
1074  */
1075 static void
1076 diff_stats(struct statinfo *new, struct statinfo *old, int is_srv)
1077 {
1078         int i, j, nodiff_first_index, should_diff;
1079
1080         /*
1081          * Different stat types have different formats in the /proc
1082          * files: for the proc2/3/4-type stats, the first entry has
1083          * the total number of subsequent entries; one does not want
1084          * to diff that first entry.  The other stat types aren't like
1085          * this.  So, we diff a given entry if it's not of one of the
1086          * procX types ("i" < 2 for clt, < 4 for srv), or if it's not
1087          * the first entry ("j" > 0).
1088          */
1089         nodiff_first_index = 2 + (2 * is_srv);
1090
1091         for (i = 0; old[i].tag; i++) {
1092                 for (j = 0; j < new[i].nrvals; j++) {
1093                         should_diff = (i < nodiff_first_index || j > 0);
1094                         if (should_diff)
1095                                 new[i].valptr[j] -= old[i].valptr[j];
1096                 }
1097
1098                 /*
1099                  * Make sure that the "totals" entry (last value in
1100                  * each stat array) for the procX-type stats has the
1101                  * "numentries" entry's (first value in procX-type
1102                  * stat arrays) constant value added-back after the
1103                  * diff -- i.e., it should always be included in the
1104                  * total.
1105                  */
1106                 if (!strncmp("proc", new[i].tag, 4) && old[i].valptr[0])
1107                         new[i].valptr[new[i].nrvals - 1] += new[i].valptr[0];
1108         }
1109 }
1110
1111 static void
1112 unpause(int sig)
1113 {
1114         double time_diff;
1115         int minutes, seconds;
1116         time_t endtime;
1117
1118         endtime = time(NULL);
1119         time_diff = difftime(endtime, starttime);
1120         minutes = time_diff / 60;
1121         seconds = (int)time_diff % 60;
1122         printf("Signal %d received; displaying (only) statistics gathered over the last %d minutes, %d seconds:\n\n", sig, minutes, seconds);
1123 }
1124
1125 static void
1126 update_old_counters(struct statinfo *new, struct statinfo *old)
1127 {
1128         int z, i;
1129         for (z = 0; old[z].tag; z++)
1130                 for (i = 0; i <= old[z].nrvals; i++)
1131                         old[z].valptr[i] += new[z].valptr[i];
1132
1133 }