nfs-utils: Fix source code character encoding
[nfs-utils.git] / 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 }