5adb571a7c6858b9e36f20a7e39ffd73def4c9f1
[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 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 }