nfsiostat: Breaks on 3.1 kernels
[nfs-utils.git] / tools / nfs-iostat / nfs-iostat.py
1 #!/usr/bin/python
2 # -*- python-mode -*-
3 """Emulate iostat for NFS mount points using /proc/self/mountstats
4 """
5
6 __copyright__ = """
7 Copyright (C) 2005, Chuck Lever <cel@netapp.com>
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License version 2 as
11 published by the Free Software Foundation.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
21 MA 02110-1301 USA
22 """
23
24 import sys, os, time
25 from optparse import OptionParser, OptionGroup
26
27 Iostats_version = '0.2'
28
29 def difference(x, y):
30     """Used for a map() function
31     """
32     return x - y
33
34 NfsEventCounters = [
35     'inoderevalidates',
36     'dentryrevalidates',
37     'datainvalidates',
38     'attrinvalidates',
39     'vfsopen',
40     'vfslookup',
41     'vfspermission',
42     'vfsupdatepage',
43     'vfsreadpage',
44     'vfsreadpages',
45     'vfswritepage',
46     'vfswritepages',
47     'vfsreaddir',
48     'vfssetattr',
49     'vfsflush',
50     'vfsfsync',
51     'vfslock',
52     'vfsrelease',
53     'congestionwait',
54     'setattrtrunc',
55     'extendwrite',
56     'sillyrenames',
57     'shortreads',
58     'shortwrites',
59     'delay'
60 ]
61
62 NfsByteCounters = [
63     'normalreadbytes',
64     'normalwritebytes',
65     'directreadbytes',
66     'directwritebytes',
67     'serverreadbytes',
68     'serverwritebytes',
69     'readpages',
70     'writepages'
71 ]
72
73 class DeviceData:
74     """DeviceData objects provide methods for parsing and displaying
75     data for a single mount grabbed from /proc/self/mountstats
76     """
77     def __init__(self):
78         self.__nfs_data = dict()
79         self.__rpc_data = dict()
80         self.__rpc_data['ops'] = []
81
82     def __parse_nfs_line(self, words):
83         if words[0] == 'device':
84             self.__nfs_data['export'] = words[1]
85             self.__nfs_data['mountpoint'] = words[4]
86             self.__nfs_data['fstype'] = words[7]
87             if words[7] == 'nfs':
88                 self.__nfs_data['statvers'] = words[8]
89         elif 'nfs' in words or 'nfs4' in words:
90             self.__nfs_data['export'] = words[0]
91             self.__nfs_data['mountpoint'] = words[3]
92             self.__nfs_data['fstype'] = words[6]
93             if words[6] == 'nfs':
94                 self.__nfs_data['statvers'] = words[7]
95         elif words[0] == 'age:':
96             self.__nfs_data['age'] = long(words[1])
97         elif words[0] == 'opts:':
98             self.__nfs_data['mountoptions'] = ''.join(words[1:]).split(',')
99         elif words[0] == 'caps:':
100             self.__nfs_data['servercapabilities'] = ''.join(words[1:]).split(',')
101         elif words[0] == 'nfsv4:':
102             self.__nfs_data['nfsv4flags'] = ''.join(words[1:]).split(',')
103         elif words[0] == 'sec:':
104             keys = ''.join(words[1:]).split(',')
105             self.__nfs_data['flavor'] = int(keys[0].split('=')[1])
106             self.__nfs_data['pseudoflavor'] = 0
107             if self.__nfs_data['flavor'] == 6:
108                 self.__nfs_data['pseudoflavor'] = int(keys[1].split('=')[1])
109         elif words[0] == 'events:':
110             i = 1
111             for key in NfsEventCounters:
112                 self.__nfs_data[key] = int(words[i])
113                 i += 1
114         elif words[0] == 'bytes:':
115             i = 1
116             for key in NfsByteCounters:
117                 self.__nfs_data[key] = long(words[i])
118                 i += 1
119
120     def __parse_rpc_line(self, words):
121         if words[0] == 'RPC':
122             self.__rpc_data['statsvers'] = float(words[3])
123             self.__rpc_data['programversion'] = words[5]
124         elif words[0] == 'xprt:':
125             self.__rpc_data['protocol'] = words[1]
126             if words[1] == 'udp':
127                 self.__rpc_data['port'] = int(words[2])
128                 self.__rpc_data['bind_count'] = int(words[3])
129                 self.__rpc_data['rpcsends'] = int(words[4])
130                 self.__rpc_data['rpcreceives'] = int(words[5])
131                 self.__rpc_data['badxids'] = int(words[6])
132                 self.__rpc_data['inflightsends'] = long(words[7])
133                 self.__rpc_data['backlogutil'] = long(words[8])
134             elif words[1] == 'tcp':
135                 self.__rpc_data['port'] = words[2]
136                 self.__rpc_data['bind_count'] = int(words[3])
137                 self.__rpc_data['connect_count'] = int(words[4])
138                 self.__rpc_data['connect_time'] = int(words[5])
139                 self.__rpc_data['idle_time'] = int(words[6])
140                 self.__rpc_data['rpcsends'] = int(words[7])
141                 self.__rpc_data['rpcreceives'] = int(words[8])
142                 self.__rpc_data['badxids'] = int(words[9])
143                 self.__rpc_data['inflightsends'] = long(words[10])
144                 self.__rpc_data['backlogutil'] = long(words[11])
145             elif words[1] == 'rdma':
146                 self.__rpc_data['port'] = words[2]
147                 self.__rpc_data['bind_count'] = int(words[3])
148                 self.__rpc_data['connect_count'] = int(words[4])
149                 self.__rpc_data['connect_time'] = int(words[5])
150                 self.__rpc_data['idle_time'] = int(words[6])
151                 self.__rpc_data['rpcsends'] = int(words[7])
152                 self.__rpc_data['rpcreceives'] = int(words[8])
153                 self.__rpc_data['badxids'] = int(words[9])
154                 self.__rpc_data['backlogutil'] = int(words[10])
155                 self.__rpc_data['read_chunks'] = int(words[11])
156                 self.__rpc_data['write_chunks'] = int(words[12])
157                 self.__rpc_data['reply_chunks'] = int(words[13])
158                 self.__rpc_data['total_rdma_req'] = int(words[14])
159                 self.__rpc_data['total_rdma_rep'] = int(words[15])
160                 self.__rpc_data['pullup'] = int(words[16])
161                 self.__rpc_data['fixup'] = int(words[17])
162                 self.__rpc_data['hardway'] = int(words[18])
163                 self.__rpc_data['failed_marshal'] = int(words[19])
164                 self.__rpc_data['bad_reply'] = int(words[20])
165         elif words[0] == 'per-op':
166             self.__rpc_data['per-op'] = words
167         else:
168             op = words[0][:-1]
169             self.__rpc_data['ops'] += [op]
170             self.__rpc_data[op] = [long(word) for word in words[1:]]
171
172     def parse_stats(self, lines):
173         """Turn a list of lines from a mount stat file into a 
174         dictionary full of stats, keyed by name
175         """
176         found = False
177         for line in lines:
178             words = line.split()
179             if len(words) == 0:
180                 continue
181             if (not found and words[0] != 'RPC'):
182                 self.__parse_nfs_line(words)
183                 continue
184
185             found = True
186             self.__parse_rpc_line(words)
187
188     def is_nfs_mountpoint(self):
189         """Return True if this is an NFS or NFSv4 mountpoint,
190         otherwise return False
191         """
192         if self.__nfs_data['fstype'] == 'nfs':
193             return True
194         elif self.__nfs_data['fstype'] == 'nfs4':
195             return True
196         return False
197
198     def compare_iostats(self, old_stats):
199         """Return the difference between two sets of stats
200         """
201         result = DeviceData()
202
203         # copy self into result
204         for key, value in self.__nfs_data.iteritems():
205             result.__nfs_data[key] = value
206         for key, value in self.__rpc_data.iteritems():
207             result.__rpc_data[key] = value
208
209         # compute the difference of each item in the list
210         # note the copy loop above does not copy the lists, just
211         # the reference to them.  so we build new lists here
212         # for the result object.
213         for op in result.__rpc_data['ops']:
214             result.__rpc_data[op] = map(difference, self.__rpc_data[op], old_stats.__rpc_data[op])
215
216         # update the remaining keys we care about
217         result.__rpc_data['rpcsends'] -= old_stats.__rpc_data['rpcsends']
218         result.__rpc_data['backlogutil'] -= old_stats.__rpc_data['backlogutil']
219
220         for key in NfsEventCounters:
221             result.__nfs_data[key] -= old_stats.__nfs_data[key]
222         for key in NfsByteCounters:
223             result.__nfs_data[key] -= old_stats.__nfs_data[key]
224
225         return result
226
227     def __print_data_cache_stats(self):
228         """Print the data cache hit rate
229         """
230         nfs_stats = self.__nfs_data
231         app_bytes_read = float(nfs_stats['normalreadbytes'])
232         if app_bytes_read != 0:
233             client_bytes_read = float(nfs_stats['serverreadbytes'] - nfs_stats['directreadbytes'])
234             ratio = ((app_bytes_read - client_bytes_read) * 100) / app_bytes_read
235
236             print
237             print 'app bytes: %f  client bytes %f' % (app_bytes_read, client_bytes_read)
238             print 'Data cache hit ratio: %4.2f%%' % ratio
239
240     def __print_attr_cache_stats(self, sample_time):
241         """Print attribute cache efficiency stats
242         """
243         nfs_stats = self.__nfs_data
244         getattr_stats = self.__rpc_data['GETATTR']
245
246         if nfs_stats['inoderevalidates'] != 0:
247             getattr_ops = float(getattr_stats[1])
248             opens = float(nfs_stats['vfsopen'])
249             revalidates = float(nfs_stats['inoderevalidates']) - opens
250             if revalidates != 0:
251                 ratio = ((revalidates - getattr_ops) * 100) / revalidates
252             else:
253                 ratio = 0.0
254
255             data_invalidates = float(nfs_stats['datainvalidates'])
256             attr_invalidates = float(nfs_stats['attrinvalidates'])
257
258             print
259             print '%d inode revalidations, hitting in cache %4.2f%% of the time' % \
260                 (revalidates, ratio)
261             print '%d open operations (mandatory GETATTR requests)' % opens
262             if getattr_ops != 0:
263                 print '%4.2f%% of GETATTRs resulted in data cache invalidations' % \
264                    ((data_invalidates * 100) / getattr_ops)
265
266     def __print_dir_cache_stats(self, sample_time):
267         """Print directory stats
268         """
269         nfs_stats = self.__nfs_data
270         lookup_ops = self.__rpc_data['LOOKUP'][0]
271         readdir_ops = self.__rpc_data['READDIR'][0]
272         if self.__rpc_data.has_key('READDIRPLUS'):
273             readdir_ops += self.__rpc_data['READDIRPLUS'][0]
274
275         dentry_revals = nfs_stats['dentryrevalidates']
276         opens = nfs_stats['vfsopen']
277         lookups = nfs_stats['vfslookup']
278         getdents = nfs_stats['vfsreaddir']
279
280         print
281         print '%d open operations (pathname lookups)' % opens
282         print '%d dentry revalidates and %d vfs lookup requests' % \
283             (dentry_revals, lookups),
284         print 'resulted in %d LOOKUPs on the wire' % lookup_ops
285         print '%d vfs getdents calls resulted in %d READDIRs on the wire' % \
286             (getdents, readdir_ops)
287
288     def __print_page_stats(self, sample_time):
289         """Print page cache stats
290         """
291         nfs_stats = self.__nfs_data
292
293         vfsreadpage = nfs_stats['vfsreadpage']
294         vfsreadpages = nfs_stats['vfsreadpages']
295         pages_read = nfs_stats['readpages']
296         vfswritepage = nfs_stats['vfswritepage']
297         vfswritepages = nfs_stats['vfswritepages']
298         pages_written = nfs_stats['writepages']
299
300         print
301         print '%d nfs_readpage() calls read %d pages' % \
302             (vfsreadpage, vfsreadpage)
303         print '%d nfs_readpages() calls read %d pages' % \
304             (vfsreadpages, pages_read - vfsreadpage),
305         if vfsreadpages != 0:
306             print '(%.1f pages per call)' % \
307                 (float(pages_read - vfsreadpage) / vfsreadpages)
308         else:
309             print
310
311         print
312         print '%d nfs_updatepage() calls' % nfs_stats['vfsupdatepage']
313         print '%d nfs_writepage() calls wrote %d pages' % \
314             (vfswritepage, vfswritepage)
315         print '%d nfs_writepages() calls wrote %d pages' % \
316             (vfswritepages, pages_written - vfswritepage),
317         if (vfswritepages) != 0:
318             print '(%.1f pages per call)' % \
319                 (float(pages_written - vfswritepage) / vfswritepages)
320         else:
321             print
322
323         congestionwaits = nfs_stats['congestionwait']
324         if congestionwaits != 0:
325             print
326             print '%d congestion waits' % congestionwaits
327
328     def __print_rpc_op_stats(self, op, sample_time):
329         """Print generic stats for one RPC op
330         """
331         if not self.__rpc_data.has_key(op):
332             return
333
334         rpc_stats = self.__rpc_data[op]
335         ops = float(rpc_stats[0])
336         retrans = float(rpc_stats[1] - rpc_stats[0])
337         kilobytes = float(rpc_stats[3] + rpc_stats[4]) / 1024
338         rtt = float(rpc_stats[6])
339         exe = float(rpc_stats[7])
340
341         # prevent floating point exceptions
342         if ops != 0:
343             kb_per_op = kilobytes / ops
344             retrans_percent = (retrans * 100) / ops
345             rtt_per_op = rtt / ops
346             exe_per_op = exe / ops
347         else:
348             kb_per_op = 0.0
349             retrans_percent = 0.0
350             rtt_per_op = 0.0
351             exe_per_op = 0.0
352
353         op += ':'
354         print '%s' % op.lower().ljust(15),
355         print '  ops/s\t\t   kB/s\t\t  kB/op\t\tretrans\t\tavg RTT (ms)\tavg exe (ms)'
356
357         print '\t\t%7.3f' % (ops / sample_time),
358         print '\t%7.3f' % (kilobytes / sample_time),
359         print '\t%7.3f' % kb_per_op,
360         print ' %7d (%3.1f%%)' % (retrans, retrans_percent),
361         print '\t%7.3f' % rtt_per_op,
362         print '\t%7.3f' % exe_per_op
363
364     def ops(self, sample_time):
365         sends = float(self.__rpc_data['rpcsends'])
366         if sample_time == 0:
367             sample_time = float(self.__nfs_data['age'])
368         return (sends / sample_time)
369
370     def display_iostats(self, sample_time, which):
371         """Display NFS and RPC stats in an iostat-like way
372         """
373         sends = float(self.__rpc_data['rpcsends'])
374         if sample_time == 0:
375             sample_time = float(self.__nfs_data['age'])
376         #  sample_time could still be zero if the export was just mounted.
377         #  Set it to 1 to avoid divide by zero errors in this case since we'll
378         #  likely still have relevant mount statistics to show.
379         #
380         if sample_time == 0:
381             sample_time = 1;
382         if sends != 0:
383             backlog = (float(self.__rpc_data['backlogutil']) / sends) / sample_time
384         else:
385             backlog = 0.0
386
387         print
388         print '%s mounted on %s:' % \
389             (self.__nfs_data['export'], self.__nfs_data['mountpoint'])
390         print
391
392         print '   op/s\t\trpc bklog'
393         print '%7.2f' % (sends / sample_time), 
394         print '\t%7.2f' % backlog
395
396         if which == 0:
397             self.__print_rpc_op_stats('READ', sample_time)
398             self.__print_rpc_op_stats('WRITE', sample_time)
399         elif which == 1:
400             self.__print_rpc_op_stats('GETATTR', sample_time)
401             self.__print_rpc_op_stats('ACCESS', sample_time)
402             self.__print_attr_cache_stats(sample_time)
403         elif which == 2:
404             self.__print_rpc_op_stats('LOOKUP', sample_time)
405             self.__print_rpc_op_stats('READDIR', sample_time)
406             if self.__rpc_data.has_key('READDIRPLUS'):
407                 self.__print_rpc_op_stats('READDIRPLUS', sample_time)
408             self.__print_dir_cache_stats(sample_time)
409         elif which == 3:
410             self.__print_rpc_op_stats('READ', sample_time)
411             self.__print_rpc_op_stats('WRITE', sample_time)
412             self.__print_page_stats(sample_time)
413
414 #
415 # Functions
416 #
417
418 def parse_stats_file(filename):
419     """pop the contents of a mountstats file into a dictionary,
420     keyed by mount point.  each value object is a list of the
421     lines in the mountstats file corresponding to the mount
422     point named in the key.
423     """
424     ms_dict = dict()
425     key = ''
426
427     f = file(filename)
428     for line in f.readlines():
429         words = line.split()
430         if len(words) == 0:
431             continue
432         if words[0] == 'device':
433             key = words[4]
434             new = [ line.strip() ]
435         elif 'nfs' in words or 'nfs4' in words:
436             key = words[3]
437             new = [ line.strip() ]
438         else:
439             new += [ line.strip() ]
440         ms_dict[key] = new
441     f.close
442
443     return ms_dict
444
445 def print_iostat_summary(old, new, devices, time, options):
446     stats = {}
447     diff_stats = {}
448     if old:
449         # Trim device list to only include intersection of old and new data,
450         # this addresses umounts due to autofs mountpoints
451         devicelist = filter(lambda x:x in devices,old)
452     else:
453         devicelist = devices
454
455     for device in devicelist:
456         stats[device] = DeviceData()
457         stats[device].parse_stats(new[device])
458         if old:
459             old_stats = DeviceData()
460             old_stats.parse_stats(old[device])
461             diff_stats[device] = stats[device].compare_iostats(old_stats)
462
463     if options.sort:
464         if old:
465             # We now have compared data and can print a comparison
466             # ordered by mountpoint ops per second
467             devicelist.sort(key=lambda x: diff_stats[x].ops(time), reverse=True)
468         else:
469             # First iteration, just sort by newly parsed ops/s
470             devicelist.sort(key=lambda x: stats[x].ops(time), reverse=True)
471
472     count = 1
473     for device in devicelist:
474         if old:
475             diff_stats[device].display_iostats(time, options.which)
476         else:
477             stats[device].display_iostats(time, options.which)
478
479         count += 1
480         if (count > options.list):
481             return
482
483
484 def list_nfs_mounts(givenlist, mountstats):
485     """return a list of NFS mounts given a list to validate or
486        return a full list if the given list is empty -
487        may return an empty list if none found
488     """
489     list = []
490     if len(givenlist) > 0:
491         for device in givenlist:
492             stats = DeviceData()
493             stats.parse_stats(mountstats[device])
494             if stats.is_nfs_mountpoint():
495                 list += [device]
496     else:
497         for device, descr in mountstats.iteritems():
498             stats = DeviceData()
499             stats.parse_stats(descr)
500             if stats.is_nfs_mountpoint():
501                 list += [device]
502     return list
503
504 def iostat_command(name):
505     """iostat-like command for NFS mount points
506     """
507     mountstats = parse_stats_file('/proc/self/mountstats')
508     devices = []
509     origdevices = []
510     interval_seen = False
511     count_seen = False
512
513     mydescription= """
514 Sample iostat-like program to display NFS client per-mount'
515 statistics.  The <interval> parameter specifies the amount of time in seconds
516 between each report.  The first report contains statistics for the time since
517 each file system was mounted.  Each subsequent report contains statistics
518 collected during the interval since the previous report.  If the <count>
519 parameter is specified, the value of <count> determines the number of reports
520 generated at <interval> seconds apart.  If the interval parameter is specified
521 without the <count> parameter, the command generates reports continuously.
522 If one or more <mount point> names are specified, statistics for only these
523 mount points will be displayed.  Otherwise, all NFS mount points on the
524 client are listed.
525 """
526     parser = OptionParser(
527         usage="usage: %prog [ <interval> [ <count> ] ] [ <options> ] [ <mount point> ]",
528         description=mydescription,
529         version='version %s' % Iostats_version)
530     parser.set_defaults(which=0, sort=False, list=sys.maxint)
531
532     statgroup = OptionGroup(parser, "Statistics Options",
533                             'File I/O is displayed unless one of the following is specified:')
534     statgroup.add_option('-a', '--attr',
535                             action="store_const",
536                             dest="which",
537                             const=1,
538                             help='displays statistics related to the attribute cache')
539     statgroup.add_option('-d', '--dir',
540                             action="store_const",
541                             dest="which",
542                             const=2,
543                             help='displays statistics related to directory operations')
544     statgroup.add_option('-p', '--page',
545                             action="store_const",
546                             dest="which",
547                             const=3,
548                             help='displays statistics related to the page cache')
549     parser.add_option_group(statgroup)
550     displaygroup = OptionGroup(parser, "Display Options",
551                                'Options affecting display format:')
552     displaygroup.add_option('-s', '--sort',
553                             action="store_true",
554                             dest="sort",
555                             help="Sort NFS mount points by ops/second")
556     displaygroup.add_option('-l','--list',
557                             action="store",
558                             type="int",
559                             dest="list",
560                             help="only print stats for first LIST mount points")
561     parser.add_option_group(displaygroup)
562
563     (options, args) = parser.parse_args(sys.argv)
564     for arg in args:
565
566         if arg == sys.argv[0]:
567             continue
568
569         if arg in mountstats:
570             origdevices += [arg]
571         elif not interval_seen:
572             try:
573                 interval = int(arg)
574             except:
575                 print 'Illegal <interval> value %s' % arg
576                 return
577             if interval > 0:
578                 interval_seen = True
579             else:
580                 print 'Illegal <interval> value %s' % arg
581                 return
582         elif not count_seen:
583             try:
584                 count = int(arg)
585             except:
586                 print 'Ilegal <count> value %s' % arg
587                 return
588             if count > 0:
589                 count_seen = True
590             else:
591                 print 'Illegal <count> value %s' % arg
592                 return
593
594     # make certain devices contains only NFS mount points
595     devices = list_nfs_mounts(origdevices, mountstats)
596     if len(devices) == 0:
597         print 'No NFS mount points were found'
598         return
599
600
601     old_mountstats = None
602     sample_time = 0.0
603
604     if not interval_seen:
605         print_iostat_summary(old_mountstats, mountstats, devices, sample_time, options)
606         return
607
608     if count_seen:
609         while count != 0:
610             print_iostat_summary(old_mountstats, mountstats, devices, sample_time, options)
611             old_mountstats = mountstats
612             time.sleep(interval)
613             sample_time = interval
614             mountstats = parse_stats_file('/proc/self/mountstats')
615             # automount mountpoints add and drop, if automount is involved
616             # we need to recheck the devices list when reparsing
617             devices = list_nfs_mounts(origdevices,mountstats)
618             if len(devices) == 0:
619                 print 'No NFS mount points were found'
620                 return
621             count -= 1
622     else: 
623         while True:
624             print_iostat_summary(old_mountstats, mountstats, devices, sample_time, options)
625             old_mountstats = mountstats
626             time.sleep(interval)
627             sample_time = interval
628             mountstats = parse_stats_file('/proc/self/mountstats')
629             # automount mountpoints add and drop, if automount is involved
630             # we need to recheck the devices list when reparsing
631             devices = list_nfs_mounts(origdevices,mountstats)
632             if len(devices) == 0:
633                 print 'No NFS mount points were found'
634                 return
635
636 #
637 # Main
638 #
639 prog = os.path.basename(sys.argv[0])
640
641 try:
642     iostat_command(prog)
643 except KeyboardInterrupt:
644     print 'Caught ^C... exiting'
645     sys.exit(1)
646
647 sys.exit(0)