scripts/kvm/kvm_stat

   1 #!/usr/bin/python
   2 #
   3 # top-like utility for displaying kvm statistics
   4 #
   5 # Copyright 2006-2008 Qumranet Technologies
   6 # Copyright 2008-2011 Red Hat, Inc.
   7 #
   8 # Authors:
   9 #  Avi Kivity <avi@redhat.com>
  10 #
  11 # This work is licensed under the terms of the GNU GPL, version 2.  See
  12 # the COPYING file in the top-level directory.
  13
  14 import curses
  15 import sys, os, time, optparse
  16
  17 class DebugfsProvider(object):
  18     def __init__(self):
  19         self.base = '/sys/kernel/debug/kvm'
  20         self._fields = os.listdir(self.base)
  21     def fields(self):
  22         return self._fields
  23     def select(self, fields):
  24         self._fields = fields
  25     def read(self):
  26         def val(key):
  27             return int(file(self.base + '/' + key).read())
  28         return dict([(key, val(key)) for key in self._fields])
  29
  30 vmx_exit_reasons = {
  31     0: 'EXCEPTION_NMI',
  32     1: 'EXTERNAL_INTERRUPT',
  33     2: 'TRIPLE_FAULT',
  34     7: 'PENDING_INTERRUPT',
  35     8: 'NMI_WINDOW',
  36     9: 'TASK_SWITCH',
  37     10: 'CPUID',
  38     12: 'HLT',
  39     14: 'INVLPG',
  40     15: 'RDPMC',
  41     16: 'RDTSC',
  42     18: 'VMCALL',
  43     19: 'VMCLEAR',
  44     20: 'VMLAUNCH',
  45     21: 'VMPTRLD',
  46     22: 'VMPTRST',
  47     23: 'VMREAD',
  48     24: 'VMRESUME',
  49     25: 'VMWRITE',
  50     26: 'VMOFF',
  51     27: 'VMON',
  52     28: 'CR_ACCESS',
  53     29: 'DR_ACCESS',
  54     30: 'IO_INSTRUCTION',
  55     31: 'MSR_READ',
  56     32: 'MSR_WRITE',
  57     33: 'INVALID_STATE',
  58     36: 'MWAIT_INSTRUCTION',
  59     39: 'MONITOR_INSTRUCTION',
  60     40: 'PAUSE_INSTRUCTION',
  61     41: 'MCE_DURING_VMENTRY',
  62     43: 'TPR_BELOW_THRESHOLD',
  63     44: 'APIC_ACCESS',
  64     48: 'EPT_VIOLATION',
  65     49: 'EPT_MISCONFIG',
  66     54: 'WBINVD',
  67     55: 'XSETBV',
  68 }
  69
  70 svm_exit_reasons = {
  71     0x000: 'READ_CR0',
  72     0x003: 'READ_CR3',
  73     0x004: 'READ_CR4',
  74     0x008: 'READ_CR8',
  75     0x010: 'WRITE_CR0',
  76     0x013: 'WRITE_CR3',
  77     0x014: 'WRITE_CR4',
  78     0x018: 'WRITE_CR8',
  79     0x020: 'READ_DR0',
  80     0x021: 'READ_DR1',
  81     0x022: 'READ_DR2',
  82     0x023: 'READ_DR3',
  83     0x024: 'READ_DR4',
  84     0x025: 'READ_DR5',
  85     0x026: 'READ_DR6',
  86     0x027: 'READ_DR7',
  87     0x030: 'WRITE_DR0',
  88     0x031: 'WRITE_DR1',
  89     0x032: 'WRITE_DR2',
  90     0x033: 'WRITE_DR3',
  91     0x034: 'WRITE_DR4',
  92     0x035: 'WRITE_DR5',
  93     0x036: 'WRITE_DR6',
  94     0x037: 'WRITE_DR7',
  95     0x040: 'EXCP_BASE',
  96     0x060: 'INTR',
  97     0x061: 'NMI',
  98     0x062: 'SMI',
  99     0x063: 'INIT',
 100     0x064: 'VINTR',
 101     0x065: 'CR0_SEL_WRITE',
 102     0x066: 'IDTR_READ',
 103     0x067: 'GDTR_READ',
 104     0x068: 'LDTR_READ',
 105     0x069: 'TR_READ',
 106     0x06a: 'IDTR_WRITE',
 107     0x06b: 'GDTR_WRITE',
 108     0x06c: 'LDTR_WRITE',
 109     0x06d: 'TR_WRITE',
 110     0x06e: 'RDTSC',
 111     0x06f: 'RDPMC',
 112     0x070: 'PUSHF',
 113     0x071: 'POPF',
 114     0x072: 'CPUID',
 115     0x073: 'RSM',
 116     0x074: 'IRET',
 117     0x075: 'SWINT',
 118     0x076: 'INVD',
 119     0x077: 'PAUSE',
 120     0x078: 'HLT',
 121     0x079: 'INVLPG',
 122     0x07a: 'INVLPGA',
 123     0x07b: 'IOIO',
 124     0x07c: 'MSR',
 125     0x07d: 'TASK_SWITCH',
 126     0x07e: 'FERR_FREEZE',
 127     0x07f: 'SHUTDOWN',
 128     0x080: 'VMRUN',
 129     0x081: 'VMMCALL',
 130     0x082: 'VMLOAD',
 131     0x083: 'VMSAVE',
 132     0x084: 'STGI',
 133     0x085: 'CLGI',
 134     0x086: 'SKINIT',
 135     0x087: 'RDTSCP',
 136     0x088: 'ICEBP',
 137     0x089: 'WBINVD',
 138     0x08a: 'MONITOR',
 139     0x08b: 'MWAIT',
 140     0x08c: 'MWAIT_COND',
 141     0x400: 'NPF',
 142 }
 143
 144 s390_exit_reasons = {
 145         0x000: 'UNKNOWN',
 146         0x001: 'EXCEPTION',
 147         0x002: 'IO',
 148         0x003: 'HYPERCALL',
 149         0x004: 'DEBUG',
 150         0x005: 'HLT',
 151         0x006: 'MMIO',
 152         0x007: 'IRQ_WINDOW_OPEN',
 153         0x008: 'SHUTDOWN',
 154         0x009: 'FAIL_ENTRY',
 155         0x010: 'INTR',
 156         0x011: 'SET_TPR',
 157         0x012: 'TPR_ACCESS',
 158         0x013: 'S390_SIEIC',
 159         0x014: 'S390_RESET',
 160         0x015: 'DCR',
 161         0x016: 'NMI',
 162         0x017: 'INTERNAL_ERROR',
 163         0x018: 'OSI',
 164         0x019: 'PAPR_HCALL',
 165 }
 166
 167 vendor_exit_reasons = {
 168     'vmx': vmx_exit_reasons,
 169     'svm': svm_exit_reasons,
 170     'IBM/S390': s390_exit_reasons,
 171 }
 172
 173 syscall_numbers = {
 174     'IBM/S390': 331,
 175 }
 176
 177 sc_perf_evt_open = 298
 178
 179 exit_reasons = None
 180
 181 for line in file('/proc/cpuinfo').readlines():
 182     if line.startswith('flags') or line.startswith('vendor_id'):
 183         for flag in line.split():
 184             if flag in vendor_exit_reasons:
 185                 exit_reasons = vendor_exit_reasons[flag]
 186             if flag in syscall_numbers:
 187                 sc_perf_evt_open = syscall_numbers[flag]
 188 filters = {
 189     'kvm_exit': ('exit_reason', exit_reasons)
 190 }
 191
 192 def invert(d):
 193     return dict((x[1], x[0]) for x in d.iteritems())
 194
 195 for f in filters:
 196     filters[f] = (filters[f][0], invert(filters[f][1]))
 197
 198 import ctypes, struct, array
 199
 200 libc = ctypes.CDLL('libc.so.6')
 201 syscall = libc.syscall
 202 class perf_event_attr(ctypes.Structure):
 203     _fields_ = [('type', ctypes.c_uint32),
 204                 ('size', ctypes.c_uint32),
 205                 ('config', ctypes.c_uint64),
 206                 ('sample_freq', ctypes.c_uint64),
 207                 ('sample_type', ctypes.c_uint64),
 208                 ('read_format', ctypes.c_uint64),
 209                 ('flags', ctypes.c_uint64),
 210                 ('wakeup_events', ctypes.c_uint32),
 211                 ('bp_type', ctypes.c_uint32),
 212                 ('bp_addr', ctypes.c_uint64),
 213                 ('bp_len', ctypes.c_uint64),
 214                 ]
 215 def _perf_event_open(attr, pid, cpu, group_fd, flags):
 216     return syscall(sc_perf_evt_open, ctypes.pointer(attr), ctypes.c_int(pid),
 217                    ctypes.c_int(cpu), ctypes.c_int(group_fd),
 218                    ctypes.c_long(flags))
 219
 220 PERF_TYPE_HARDWARE              = 0
 221 PERF_TYPE_SOFTWARE              = 1
 222 PERF_TYPE_TRACEPOINT            = 2
 223 PERF_TYPE_HW_CACHE              = 3
 224 PERF_TYPE_RAW                   = 4
 225 PERF_TYPE_BREAKPOINT            = 5
 226
 227 PERF_SAMPLE_IP                  = 1 << 0
 228 PERF_SAMPLE_TID                 = 1 << 1
 229 PERF_SAMPLE_TIME                = 1 << 2
 230 PERF_SAMPLE_ADDR                = 1 << 3
 231 PERF_SAMPLE_READ                = 1 << 4
 232 PERF_SAMPLE_CALLCHAIN           = 1 << 5
 233 PERF_SAMPLE_ID                  = 1 << 6
 234 PERF_SAMPLE_CPU                 = 1 << 7
 235 PERF_SAMPLE_PERIOD              = 1 << 8
 236 PERF_SAMPLE_STREAM_ID           = 1 << 9
 237 PERF_SAMPLE_RAW                 = 1 << 10
 238
 239 PERF_FORMAT_TOTAL_TIME_ENABLED  = 1 << 0
 240 PERF_FORMAT_TOTAL_TIME_RUNNING  = 1 << 1
 241 PERF_FORMAT_ID                  = 1 << 2
 242 PERF_FORMAT_GROUP               = 1 << 3
 243
 244 import re
 245
 246 sys_tracing = '/sys/kernel/debug/tracing'
 247
 248 class Group(object):
 249     def __init__(self, cpu):
 250         self.events = []
 251         self.group_leader = None
 252         self.cpu = cpu
 253     def add_event(self, name, event_set, tracepoint, filter = None):
 254         self.events.append(Event(group = self,
 255                                  name = name, event_set = event_set,
 256                                  tracepoint = tracepoint, filter = filter))
 257         if len(self.events) == 1:
 258             self.file = os.fdopen(self.events[0].fd)
 259     def read(self):
 260         bytes = 8 * (1 + len(self.events))
 261         fmt = 'xxxxxxxx' + 'q' * len(self.events)
 262         return dict(zip([event.name for event in self.events],
 263                         struct.unpack(fmt, self.file.read(bytes))))
 264
 265 class Event(object):
 266     def __init__(self, group, name, event_set, tracepoint, filter = None):
 267         self.name = name
 268         attr = perf_event_attr()
 269         attr.type = PERF_TYPE_TRACEPOINT
 270         attr.size = ctypes.sizeof(attr)
 271         id_path = os.path.join(sys_tracing, 'events', event_set,
 272                                tracepoint, 'id')
 273         id = int(file(id_path).read())
 274         attr.config = id
 275         attr.sample_type = (PERF_SAMPLE_RAW
 276                             | PERF_SAMPLE_TIME
 277                             | PERF_SAMPLE_CPU)
 278         attr.sample_period = 1
 279         attr.read_format = PERF_FORMAT_GROUP
 280         group_leader = -1
 281         if group.events:
 282             group_leader = group.events[0].fd
 283         fd = _perf_event_open(attr, -1, group.cpu, group_leader, 0)
 284         if fd == -1:
 285             raise Exception('perf_event_open failed')
 286         if filter:
 287             import fcntl
 288             fcntl.ioctl(fd, 0x40082406, filter)
 289         self.fd = fd
 290     def enable(self):
 291         import fcntl
 292         fcntl.ioctl(self.fd, 0x00002400, 0)
 293     def disable(self):
 294         import fcntl
 295         fcntl.ioctl(self.fd, 0x00002401, 0)
 296
 297 class TracepointProvider(object):
 298     def __init__(self):
 299         path = os.path.join(sys_tracing, 'events', 'kvm')
 300         fields = [f
 301                   for f in os.listdir(path)
 302                   if os.path.isdir(os.path.join(path, f))]
 303         extra = []
 304         for f in fields:
 305             if f in filters:
 306                 subfield, values = filters[f]
 307                 for name, number in values.iteritems():
 308                     extra.append(f + '(' + name + ')')
 309         fields += extra
 310         self._setup(fields)
 311         self.select(fields)
 312     def fields(self):
 313         return self._fields
 314
 315     def _online_cpus(self):
 316         l = []
 317         pattern = r'cpu([0-9]+)'
 318         basedir = '/sys/devices/system/cpu'
 319         for entry in os.listdir(basedir):
 320             match = re.match(pattern, entry)
 321             if not match:
 322                 continue
 323             path = os.path.join(basedir, entry, 'online')
 324             if os.path.exists(path) and open(path).read().strip() != '1':
 325                 continue
 326             l.append(int(match.group(1)))
 327         return l
 328
 329     def _setup(self, _fields):
 330         self._fields = _fields
 331         cpus = self._online_cpus()
 332         import resource
 333         nfiles = len(cpus) * 1000
 334         resource.setrlimit(resource.RLIMIT_NOFILE, (nfiles, nfiles))
 335         events = []
 336         self.group_leaders = []
 337         for cpu in cpus:
 338             group = Group(cpu)
 339             for name in _fields:
 340                 tracepoint = name
 341                 filter = None
 342                 m = re.match(r'(.*)\((.*)\)', name)
 343                 if m:
 344                     tracepoint, sub = m.groups()
 345                     filter = '%s==%d\0' % (filters[tracepoint][0],
 346                                            filters[tracepoint][1][sub])
 347                 event = group.add_event(name, event_set = 'kvm',
 348                                         tracepoint = tracepoint,
 349                                         filter = filter)
 350             self.group_leaders.append(group)
 351     def select(self, fields):
 352         for group in self.group_leaders:
 353             for event in group.events:
 354                 if event.name in fields:
 355                     event.enable()
 356                 else:
 357                     event.disable()
 358     def read(self):
 359         from collections import defaultdict
 360         ret = defaultdict(int)
 361         for group in self.group_leaders:
 362             for name, val in group.read().iteritems():
 363                 ret[name] += val
 364         return ret
 365
 366 class Stats:
 367     def __init__(self, providers, fields = None):
 368         self.providers = providers
 369         self.fields_filter = fields
 370         self._update()
 371     def _update(self):
 372         def wanted(key):
 373             import re
 374             if not self.fields_filter:
 375                 return True
 376             return re.match(self.fields_filter, key) is not None
 377         self.values = dict()
 378         for d in providers:
 379             provider_fields = [key for key in d.fields() if wanted(key)]
 380             for key in provider_fields:
 381                 self.values[key] = None
 382             d.select(provider_fields)
 383     def set_fields_filter(self, fields_filter):
 384         self.fields_filter = fields_filter
 385         self._update()
 386     def get(self):
 387         for d in providers:
 388             new = d.read()
 389             for key in d.fields():
 390                 oldval = self.values.get(key, (0, 0))
 391                 newval = new[key]
 392                 newdelta = None
 393                 if oldval is not None:
 394                     newdelta = newval - oldval[0]
 395                 self.values[key] = (newval, newdelta)
 396         return self.values
 397
 398 if not os.access('/sys/kernel/debug', os.F_OK):
 399     print 'Please enable CONFIG_DEBUG_FS in your kernel'
 400     sys.exit(1)
 401 if not os.access('/sys/kernel/debug/kvm', os.F_OK):
 402     print "Please mount debugfs ('mount -t debugfs debugfs /sys/kernel/debug')"
 403     print "and ensure the kvm modules are loaded"
 404     sys.exit(1)
 405
 406 label_width = 40
 407 number_width = 10
 408
 409 def tui(screen, stats):
 410     curses.use_default_colors()
 411     curses.noecho()
 412     drilldown = False
 413     fields_filter = stats.fields_filter
 414     def update_drilldown():
 415         if not fields_filter:
 416             if drilldown:
 417                 stats.set_fields_filter(None)
 418             else:
 419                 stats.set_fields_filter(r'^[^\(]*$')
 420     update_drilldown()
 421     def refresh(sleeptime):
 422         screen.erase()
 423         screen.addstr(0, 0, 'kvm statistics')
 424         row = 2
 425         s = stats.get()
 426         def sortkey(x):
 427             if s[x][1]:
 428                 return (-s[x][1], -s[x][0])
 429             else:
 430                 return (0, -s[x][0])
 431         for key in sorted(s.keys(), key = sortkey):
 432             if row >= screen.getmaxyx()[0]:
 433                 break
 434             values = s[key]
 435             if not values[0] and not values[1]:
 436                 break
 437             col = 1
 438             screen.addstr(row, col, key)
 439             col += label_width
 440             screen.addstr(row, col, '%10d' % (values[0],))
 441             col += number_width
 442             if values[1] is not None:
 443                 screen.addstr(row, col, '%8d' % (values[1] / sleeptime,))
 444             row += 1
 445         screen.refresh()
 446
 447     sleeptime = 0.25
 448     while True:
 449         refresh(sleeptime)
 450         curses.halfdelay(int(sleeptime * 10))
 451         sleeptime = 3
 452         try:
 453             c = screen.getkey()
 454             if c == 'x':
 455                 drilldown = not drilldown
 456                 update_drilldown()
 457             if c == 'q':
 458                 break
 459         except KeyboardInterrupt:
 460             break
 461         except curses.error:
 462             continue
 463
 464 def batch(stats):
 465     s = stats.get()
 466     time.sleep(1)
 467     s = stats.get()
 468     for key in sorted(s.keys()):
 469         values = s[key]
 470         print '%-22s%10d%10d' % (key, values[0], values[1])
 471
 472 def log(stats):
 473     keys = sorted(stats.get().iterkeys())
 474     def banner():
 475         for k in keys:
 476             print '%10s' % k[0:9],
 477         print
 478     def statline():
 479         s = stats.get()
 480         for k in keys:
 481             print ' %9d' % s[k][1],
 482         print
 483     line = 0
 484     banner_repeat = 20
 485     while True:
 486         time.sleep(1)
 487         if line % banner_repeat == 0:
 488             banner()
 489         statline()
 490         line += 1
 491
 492 options = optparse.OptionParser()
 493 options.add_option('-1', '--once', '--batch',
 494                    action = 'store_true',
 495                    default = False,
 496                    dest = 'once',
 497                    help = 'run in batch mode for one second',
 498                    )
 499 options.add_option('-l', '--log',
 500                    action = 'store_true',
 501                    default = False,
 502                    dest = 'log',
 503                    help = 'run in logging mode (like vmstat)',
 504                    )
 505 options.add_option('-t', '--tracepoints',
 506                    action = 'store_true',
 507                    default = False,
 508                    dest = 'tracepoints',
 509                    help = 'retrieve statistics from tracepoints',
 510                    )
 511 options.add_option('-d', '--debugfs',
 512                    action = 'store_true',
 513                    default = False,
 514                    dest = 'debugfs',
 515                    help = 'retrieve statistics from debugfs',
 516                    )
 517 options.add_option('-f', '--fields',
 518                    action = 'store',
 519                    default = None,
 520                    dest = 'fields',
 521                    help = 'fields to display (regex)',
 522                    )
 523 (options, args) = options.parse_args(sys.argv)
 524
 525 providers = []
 526 if options.tracepoints:
 527     providers.append(TracepointProvider())
 528 if options.debugfs:
 529     providers.append(DebugfsProvider())
 530
 531 if len(providers) == 0:
 532     try:
 533         providers = [TracepointProvider()]
 534     except:
 535         providers = [DebugfsProvider()]
 536
 537 stats = Stats(providers, fields = options.fields)
 538
 539 if options.log:
 540     log(stats)
 541 elif not options.once:
 542     import curses.wrapper
 543     curses.wrapper(tui, stats)
 544 else:
 545     batch(stats)