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