[qemu.git] / scripts / kvm / kvm_stat

#!/usr/bin/python
#
# top-like utility for displaying kvm statistics
#
# Copyright 2006-2008 Qumranet Technologies
# Copyright 2008-2011 Red Hat, Inc.
#
# Authors:
#  Avi Kivity <avi@redhat.com>
#
# This work is licensed under the terms of the GNU GPL, version 2.  See
# the COPYING file in the top-level directory.

import curses
import sys, os, time, optparse

class DebugfsProvider(object):
    def __init__(self):
        self.base = '/sys/kernel/debug/kvm'
        self._fields = os.listdir(self.base)
    def fields(self):
        return self._fields
    def select(self, fields):
        self._fields = fields
    def read(self):
        def val(key):
            return int(file(self.base + '/' + key).read())
        return dict([(key, val(key)) for key in self._fields])

vmx_exit_reasons = {
    0: 'EXCEPTION_NMI',
    1: 'EXTERNAL_INTERRUPT',
    2: 'TRIPLE_FAULT',
    7: 'PENDING_INTERRUPT',
    8: 'NMI_WINDOW',
    9: 'TASK_SWITCH',
    10: 'CPUID',
    12: 'HLT',
    14: 'INVLPG',
    15: 'RDPMC',
    16: 'RDTSC',
    18: 'VMCALL',
    19: 'VMCLEAR',
    20: 'VMLAUNCH',
    21: 'VMPTRLD',
    22: 'VMPTRST',
    23: 'VMREAD',
    24: 'VMRESUME',
    25: 'VMWRITE',
    26: 'VMOFF',
    27: 'VMON',
    28: 'CR_ACCESS',
    29: 'DR_ACCESS',
    30: 'IO_INSTRUCTION',
    31: 'MSR_READ',
    32: 'MSR_WRITE',
    33: 'INVALID_STATE',
    36: 'MWAIT_INSTRUCTION',
    39: 'MONITOR_INSTRUCTION',
    40: 'PAUSE_INSTRUCTION',
    41: 'MCE_DURING_VMENTRY',
    43: 'TPR_BELOW_THRESHOLD',
    44: 'APIC_ACCESS',
    48: 'EPT_VIOLATION',
    49: 'EPT_MISCONFIG',
    54: 'WBINVD',
    55: 'XSETBV',
}

svm_exit_reasons = {
    0x000: 'READ_CR0',
    0x003: 'READ_CR3',
    0x004: 'READ_CR4',
    0x008: 'READ_CR8',
    0x010: 'WRITE_CR0',
    0x013: 'WRITE_CR3',
    0x014: 'WRITE_CR4',
    0x018: 'WRITE_CR8',
    0x020: 'READ_DR0',
    0x021: 'READ_DR1',
    0x022: 'READ_DR2',
    0x023: 'READ_DR3',
    0x024: 'READ_DR4',
    0x025: 'READ_DR5',
    0x026: 'READ_DR6',
    0x027: 'READ_DR7',
    0x030: 'WRITE_DR0',
    0x031: 'WRITE_DR1',
    0x032: 'WRITE_DR2',
    0x033: 'WRITE_DR3',
    0x034: 'WRITE_DR4',
    0x035: 'WRITE_DR5',
    0x036: 'WRITE_DR6',
    0x037: 'WRITE_DR7',
    0x040: 'EXCP_BASE',
    0x060: 'INTR',
    0x061: 'NMI',
    0x062: 'SMI',
    0x063: 'INIT',
    0x064: 'VINTR',
    0x065: 'CR0_SEL_WRITE',
    0x066: 'IDTR_READ',
    0x067: 'GDTR_READ',
    0x068: 'LDTR_READ',
    0x069: 'TR_READ',
    0x06a: 'IDTR_WRITE',
    0x06b: 'GDTR_WRITE',
    0x06c: 'LDTR_WRITE',
    0x06d: 'TR_WRITE',
    0x06e: 'RDTSC',
    0x06f: 'RDPMC',
    0x070: 'PUSHF',
    0x071: 'POPF',
    0x072: 'CPUID',
    0x073: 'RSM',
    0x074: 'IRET',
    0x075: 'SWINT',
    0x076: 'INVD',
    0x077: 'PAUSE',
    0x078: 'HLT',
    0x079: 'INVLPG',
    0x07a: 'INVLPGA',
    0x07b: 'IOIO',
    0x07c: 'MSR',
    0x07d: 'TASK_SWITCH',
    0x07e: 'FERR_FREEZE',
    0x07f: 'SHUTDOWN',
    0x080: 'VMRUN',
    0x081: 'VMMCALL',
    0x082: 'VMLOAD',
    0x083: 'VMSAVE',
    0x084: 'STGI',
    0x085: 'CLGI',
    0x086: 'SKINIT',
    0x087: 'RDTSCP',
    0x088: 'ICEBP',
    0x089: 'WBINVD',
    0x08a: 'MONITOR',
    0x08b: 'MWAIT',
    0x08c: 'MWAIT_COND',
    0x400: 'NPF',
}

vendor_exit_reasons = {
    'vmx': vmx_exit_reasons,
    'svm': svm_exit_reasons,
}

exit_reasons = None

for line in file('/proc/cpuinfo').readlines():
    if line.startswith('flags'):
        for flag in line.split():
            if flag in vendor_exit_reasons:
                exit_reasons = vendor_exit_reasons[flag]

filters = {
    'kvm_exit': ('exit_reason', exit_reasons)
}

def invert(d):
    return dict((x[1], x[0]) for x in d.iteritems())

for f in filters:
    filters[f] = (filters[f][0], invert(filters[f][1]))

import ctypes, struct, array

libc = ctypes.CDLL('libc.so.6')
syscall = libc.syscall
class perf_event_attr(ctypes.Structure):
    _fields_ = [('type', ctypes.c_uint32),
                ('size', ctypes.c_uint32),
                ('config', ctypes.c_uint64),
                ('sample_freq', ctypes.c_uint64),
                ('sample_type', ctypes.c_uint64),
                ('read_format', ctypes.c_uint64),
                ('flags', ctypes.c_uint64),
                ('wakeup_events', ctypes.c_uint32),
                ('bp_type', ctypes.c_uint32),
                ('bp_addr', ctypes.c_uint64),
                ('bp_len', ctypes.c_uint64),
                ]
def _perf_event_open(attr, pid, cpu, group_fd, flags):
    return syscall(298, ctypes.pointer(attr), ctypes.c_int(pid),
                   ctypes.c_int(cpu), ctypes.c_int(group_fd),
                   ctypes.c_long(flags))

PERF_TYPE_HARDWARE              = 0
PERF_TYPE_SOFTWARE              = 1
PERF_TYPE_TRACEPOINT            = 2
PERF_TYPE_HW_CACHE              = 3
PERF_TYPE_RAW                   = 4
PERF_TYPE_BREAKPOINT            = 5

PERF_SAMPLE_IP                  = 1 << 0
PERF_SAMPLE_TID                 = 1 << 1
PERF_SAMPLE_TIME                = 1 << 2
PERF_SAMPLE_ADDR                = 1 << 3
PERF_SAMPLE_READ                = 1 << 4
PERF_SAMPLE_CALLCHAIN           = 1 << 5
PERF_SAMPLE_ID                  = 1 << 6
PERF_SAMPLE_CPU                 = 1 << 7
PERF_SAMPLE_PERIOD              = 1 << 8
PERF_SAMPLE_STREAM_ID           = 1 << 9
PERF_SAMPLE_RAW                 = 1 << 10

PERF_FORMAT_TOTAL_TIME_ENABLED  = 1 << 0
PERF_FORMAT_TOTAL_TIME_RUNNING  = 1 << 1
PERF_FORMAT_ID                  = 1 << 2
PERF_FORMAT_GROUP               = 1 << 3

import re

sys_tracing = '/sys/kernel/debug/tracing'

class Group(object):
    def __init__(self, cpu):
        self.events = []
        self.group_leader = None
        self.cpu = cpu
    def add_event(self, name, event_set, tracepoint, filter = None):
        self.events.append(Event(group = self,
                                 name = name, event_set = event_set,
                                 tracepoint = tracepoint, filter = filter))
        if len(self.events) == 1:
            self.file = os.fdopen(self.events[0].fd)
    def read(self):
        bytes = 8 * (1 + len(self.events))
        fmt = 'xxxxxxxx' + 'q' * len(self.events)
        return dict(zip([event.name for event in self.events],
                        struct.unpack(fmt, self.file.read(bytes))))

class Event(object):
    def __init__(self, group, name, event_set, tracepoint, filter = None):
        self.name = name
        attr = perf_event_attr()
        attr.type = PERF_TYPE_TRACEPOINT
        attr.size = ctypes.sizeof(attr)
        id_path = os.path.join(sys_tracing, 'events', event_set,
                               tracepoint, 'id')
        id = int(file(id_path).read())
        attr.config = id
        attr.sample_type = (PERF_SAMPLE_RAW
                            | PERF_SAMPLE_TIME
                            | PERF_SAMPLE_CPU)
        attr.sample_period = 1
        attr.read_format = PERF_FORMAT_GROUP
        group_leader = -1
        if group.events:
            group_leader = group.events[0].fd
        fd = _perf_event_open(attr, -1, group.cpu, group_leader, 0)
        if fd == -1:
            raise Exception('perf_event_open failed')
        if filter:
            import fcntl
            fcntl.ioctl(fd, 0x40082406, filter)
        self.fd = fd
    def enable(self):
        import fcntl
        fcntl.ioctl(self.fd, 0x00002400, 0)
    def disable(self):
        import fcntl
        fcntl.ioctl(self.fd, 0x00002401, 0)

class TracepointProvider(object):
    def __init__(self):
        path = os.path.join(sys_tracing, 'events', 'kvm')
        fields = [f
                  for f in os.listdir(path)
                  if os.path.isdir(os.path.join(path, f))]
        extra = []
        for f in fields:
            if f in filters:
                subfield, values = filters[f]
                for name, number in values.iteritems():
                    extra.append(f + '(' + name + ')')
        fields += extra
        self._setup(fields)
        self.select(fields)
    def fields(self):
        return self._fields
    def _setup(self, _fields):
        self._fields = _fields
        cpure = r'cpu([0-9]+)'
        self.cpus = [int(re.match(cpure, x).group(1))
                     for x in os.listdir('/sys/devices/system/cpu')
                     if re.match(cpure, x)]
        import resource
        nfiles = len(self.cpus) * 1000
        resource.setrlimit(resource.RLIMIT_NOFILE, (nfiles, nfiles))
        events = []
        self.group_leaders = []
        for cpu in self.cpus:
            group = Group(cpu)
            for name in _fields:
                tracepoint = name
                filter = None
                m = re.match(r'(.*)\((.*)\)', name)
                if m:
                    tracepoint, sub = m.groups()
                    filter = '%s==%d\0' % (filters[tracepoint][0],
                                           filters[tracepoint][1][sub])
                event = group.add_event(name, event_set = 'kvm',
                                        tracepoint = tracepoint,
                                        filter = filter)
            self.group_leaders.append(group)
    def select(self, fields):
        for group in self.group_leaders:
            for event in group.events:
                if event.name in fields:
                    event.enable()
                else:
                    event.disable()
    def read(self):
        from collections import defaultdict
        ret = defaultdict(int)
        for group in self.group_leaders:
            for name, val in group.read().iteritems():
                ret[name] += val
        return ret

class Stats:
    def __init__(self, provider, fields = None):
        self.provider = provider
        self.fields_filter = fields
        self._update()
    def _update(self):
        def wanted(key):
            import re
            if not self.fields_filter:
                return True
            return re.match(self.fields_filter, key) is not None
        self.values = dict([(key, None)
                            for key in provider.fields()
                            if wanted(key)])
        self.provider.select(self.values.keys())
    def set_fields_filter(self, fields_filter):
        self.fields_filter = fields_filter
        self._update()
    def get(self):
        new = self.provider.read()
        for key in self.provider.fields():
            oldval = self.values.get(key, (0, 0))
            newval = new[key]
            newdelta = None
            if oldval is not None:
                newdelta = newval - oldval[0]
            self.values[key] = (newval, newdelta)
        return self.values

if not os.access('/sys/kernel/debug', os.F_OK):
    print 'Please enable CONFIG_DEBUG_FS in your kernel'
    sys.exit(1)
if not os.access('/sys/kernel/debug/kvm', os.F_OK):
    print "Please mount debugfs ('mount -t debugfs debugfs /sys/kernel/debug')"
    print "and ensure the kvm modules are loaded"
    sys.exit(1)

label_width = 40
number_width = 10

def tui(screen, stats):
    curses.use_default_colors()
    curses.noecho()
    drilldown = False
    fields_filter = stats.fields_filter
    def update_drilldown():
        if not fields_filter:
            if drilldown:
                stats.set_fields_filter(None)
            else:
                stats.set_fields_filter(r'^[^\(]*$')
    update_drilldown()
    def refresh(sleeptime):
        screen.erase()
        screen.addstr(0, 0, 'kvm statistics')
        row = 2
        s = stats.get()
        def sortkey(x):
            if s[x][1]:
                return (-s[x][1], -s[x][0])
            else:
                return (0, -s[x][0])
        for key in sorted(s.keys(), key = sortkey):
            if row >= screen.getmaxyx()[0]:
                break
            values = s[key]
            if not values[0] and not values[1]:
                break
            col = 1
            screen.addstr(row, col, key)
            col += label_width
            screen.addstr(row, col, '%10d' % (values[0],))
            col += number_width
            if values[1] is not None:
                screen.addstr(row, col, '%8d' % (values[1] / sleeptime,))
            row += 1
        screen.refresh()

    sleeptime = 0.25
    while True:
        refresh(sleeptime)
        curses.halfdelay(int(sleeptime * 10))
        sleeptime = 3
        try:
            c = screen.getkey()
            if c == 'x':
                drilldown = not drilldown
                update_drilldown()
            if c == 'q':
                break
        except KeyboardInterrupt:
            break
        except curses.error:
            continue

def batch(stats):
    s = stats.get()
    time.sleep(1)
    s = stats.get()
    for key in sorted(s.keys()):
        values = s[key]
        print '%-22s%10d%10d' % (key, values[0], values[1])

def log(stats):
    keys = sorted(stats.get().iterkeys())
    def banner():
        for k in keys:
            print '%10s' % k[0:9],
        print
    def statline():
        s = stats.get()
        for k in keys:
            print ' %9d' % s[k][1],
        print
    line = 0
    banner_repeat = 20
    while True:
        time.sleep(1)
        if line % banner_repeat == 0:
            banner()
        statline()
        line += 1

options = optparse.OptionParser()
options.add_option('-1', '--once', '--batch',
                   action = 'store_true',
                   default = False,
                   dest = 'once',
                   help = 'run in batch mode for one second',
                   )
options.add_option('-l', '--log',
                   action = 'store_true',
                   default = False,
                   dest = 'log',
                   help = 'run in logging mode (like vmstat)',
                   )
options.add_option('-f', '--fields',
                   action = 'store',
                   default = None,
                   dest = 'fields',
                   help = 'fields to display (regex)',
                   )
(options, args) = options.parse_args(sys.argv)

try:
    provider = TracepointProvider()
except:
    provider = DebugfsProvider()

stats = Stats(provider, fields = options.fields)

if options.log:
    log(stats)
elif not options.once:
    import curses.wrapper
    curses.wrapper(tui, stats)
else:
    batch(stats)
Commit	Line	Data
626c4276 JK	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	vendor_exit_reasons = {
145	'vmx': vmx_exit_reasons,
146	'svm': svm_exit_reasons,
147	}
148
149	exit_reasons = None
150
151	for line in file('/proc/cpuinfo').readlines():
152	if line.startswith('flags'):
153	for flag in line.split():
154	if flag in vendor_exit_reasons:
155	exit_reasons = vendor_exit_reasons[flag]
156
157	filters = {
158	'kvm_exit': ('exit_reason', exit_reasons)
159	}
160
161	def invert(d):
162	return dict((x[1], x[0]) for x in d.iteritems())
163
164	for f in filters:
165	filters[f] = (filters[f][0], invert(filters[f][1]))
166
167	import ctypes, struct, array
168
169	libc = ctypes.CDLL('libc.so.6')
170	syscall = libc.syscall
171	class perf_event_attr(ctypes.Structure):
172	_fields_ = [('type', ctypes.c_uint32),
173	('size', ctypes.c_uint32),
174	('config', ctypes.c_uint64),
175	('sample_freq', ctypes.c_uint64),
176	('sample_type', ctypes.c_uint64),
177	('read_format', ctypes.c_uint64),
178	('flags', ctypes.c_uint64),
179	('wakeup_events', ctypes.c_uint32),
180	('bp_type', ctypes.c_uint32),
181	('bp_addr', ctypes.c_uint64),
182	('bp_len', ctypes.c_uint64),
183	]
184	def _perf_event_open(attr, pid, cpu, group_fd, flags):
185	return syscall(298, ctypes.pointer(attr), ctypes.c_int(pid),
186	ctypes.c_int(cpu), ctypes.c_int(group_fd),
187	ctypes.c_long(flags))
188
189	PERF_TYPE_HARDWARE = 0
190	PERF_TYPE_SOFTWARE = 1
191	PERF_TYPE_TRACEPOINT = 2
192	PERF_TYPE_HW_CACHE = 3
193	PERF_TYPE_RAW = 4
194	PERF_TYPE_BREAKPOINT = 5
195
196	PERF_SAMPLE_IP = 1 << 0
197	PERF_SAMPLE_TID = 1 << 1
198	PERF_SAMPLE_TIME = 1 << 2
199	PERF_SAMPLE_ADDR = 1 << 3
200	PERF_SAMPLE_READ = 1 << 4
201	PERF_SAMPLE_CALLCHAIN = 1 << 5
202	PERF_SAMPLE_ID = 1 << 6
203	PERF_SAMPLE_CPU = 1 << 7
204	PERF_SAMPLE_PERIOD = 1 << 8
205	PERF_SAMPLE_STREAM_ID = 1 << 9
206	PERF_SAMPLE_RAW = 1 << 10
207
208	PERF_FORMAT_TOTAL_TIME_ENABLED = 1 << 0
209	PERF_FORMAT_TOTAL_TIME_RUNNING = 1 << 1
210	PERF_FORMAT_ID = 1 << 2
211	PERF_FORMAT_GROUP = 1 << 3
212
213	import re
214
215	sys_tracing = '/sys/kernel/debug/tracing'
216
217	class Group(object):
218	def __init__(self, cpu):
219	self.events = []
220	self.group_leader = None
221	self.cpu = cpu
222	def add_event(self, name, event_set, tracepoint, filter = None):
223	self.events.append(Event(group = self,
224	name = name, event_set = event_set,
225	tracepoint = tracepoint, filter = filter))
226	if len(self.events) == 1:
227	self.file = os.fdopen(self.events[0].fd)
228	def read(self):
229	bytes = 8 * (1 + len(self.events))
230	fmt = 'xxxxxxxx' + 'q' * len(self.events)
231	return dict(zip([event.name for event in self.events],
232	struct.unpack(fmt, self.file.read(bytes))))
233
234	class Event(object):
235	def __init__(self, group, name, event_set, tracepoint, filter = None):
236	self.name = name
237	attr = perf_event_attr()
238	attr.type = PERF_TYPE_TRACEPOINT
239	attr.size = ctypes.sizeof(attr)
240	id_path = os.path.join(sys_tracing, 'events', event_set,
241	tracepoint, 'id')
242	id = int(file(id_path).read())
243	attr.config = id
244	attr.sample_type = (PERF_SAMPLE_RAW
245	\| PERF_SAMPLE_TIME
246	\| PERF_SAMPLE_CPU)
247	attr.sample_period = 1
248	attr.read_format = PERF_FORMAT_GROUP
249	group_leader = -1
250	if group.events:
251	group_leader = group.events[0].fd
252	fd = _perf_event_open(attr, -1, group.cpu, group_leader, 0)
253	if fd == -1:
254	raise Exception('perf_event_open failed')
255	if filter:
256	import fcntl
257	fcntl.ioctl(fd, 0x40082406, filter)
258	self.fd = fd
259	def enable(self):
260	import fcntl
261	fcntl.ioctl(self.fd, 0x00002400, 0)
262	def disable(self):
263	import fcntl
264	fcntl.ioctl(self.fd, 0x00002401, 0)
265
266	class TracepointProvider(object):
267	def __init__(self):
268	path = os.path.join(sys_tracing, 'events', 'kvm')
269	fields = [f
270	for f in os.listdir(path)
271	if os.path.isdir(os.path.join(path, f))]
272	extra = []
273	for f in fields:
274	if f in filters:
275	subfield, values = filters[f]
276	for name, number in values.iteritems():
277	extra.append(f + '(' + name + ')')
278	fields += extra
279	self._setup(fields)
280	self.select(fields)
281	def fields(self):
282	return self._fields
283	def _setup(self, _fields):
284	self._fields = _fields
285	cpure = r'cpu([0-9]+)'
286	self.cpus = [int(re.match(cpure, x).group(1))
287	for x in os.listdir('/sys/devices/system/cpu')
288	if re.match(cpure, x)]
289	import resource
290	nfiles = len(self.cpus) * 1000
291	resource.setrlimit(resource.RLIMIT_NOFILE, (nfiles, nfiles))
292	events = []
293	self.group_leaders = []
294	for cpu in self.cpus:
295	group = Group(cpu)
296	for name in _fields:
297	tracepoint = name
298	filter = None
299	m = re.match(r'(.)\((.)\)', name)
300	if m:
301	tracepoint, sub = m.groups()
302	filter = '%s==%d\0' % (filters[tracepoint][0],
303	filters[tracepoint][1][sub])
304	event = group.add_event(name, event_set = 'kvm',
305	tracepoint = tracepoint,
306	filter = filter)
307	self.group_leaders.append(group)
308	def select(self, fields):
309	for group in self.group_leaders:
310	for event in group.events:
311	if event.name in fields:
312	event.enable()
313	else:
314	event.disable()
315	def read(self):
316	from collections import defaultdict
317	ret = defaultdict(int)
318	for group in self.group_leaders:
319	for name, val in group.read().iteritems():
320	ret[name] += val
321	return ret
322
323	class Stats:
324	def __init__(self, provider, fields = None):
325	self.provider = provider
326	self.fields_filter = fields
327	self._update()
328	def _update(self):
329	def wanted(key):
330	import re
331	if not self.fields_filter:
332	return True
333	return re.match(self.fields_filter, key) is not None
334	self.values = dict([(key, None)
335	for key in provider.fields()
336	if wanted(key)])
337	self.provider.select(self.values.keys())
338	def set_fields_filter(self, fields_filter):
339	self.fields_filter = fields_filter
340	self._update()
341	def get(self):
342	new = self.provider.read()
343	for key in self.provider.fields():
344	oldval = self.values.get(key, (0, 0))
345	newval = new[key]
346	newdelta = None
347	if oldval is not None:
348	newdelta = newval - oldval[0]
349	self.values[key] = (newval, newdelta)
350	return self.values
351
352	if not os.access('/sys/kernel/debug', os.F_OK):
353	print 'Please enable CONFIG_DEBUG_FS in your kernel'
354	sys.exit(1)
355	if not os.access('/sys/kernel/debug/kvm', os.F_OK):
356	print "Please mount debugfs ('mount -t debugfs debugfs /sys/kernel/debug')"
357	print "and ensure the kvm modules are loaded"
358	sys.exit(1)
359
360	label_width = 40
361	number_width = 10
362
363	def tui(screen, stats):
364	curses.use_default_colors()
365	curses.noecho()
366	drilldown = False
367	fields_filter = stats.fields_filter
368	def update_drilldown():
369	if not fields_filter:
370	if drilldown:
371	stats.set_fields_filter(None)
372	else:
373	stats.set_fields_filter(r'^[^\(]*$')
374	update_drilldown()
375	def refresh(sleeptime):
376	screen.erase()
377	screen.addstr(0, 0, 'kvm statistics')
378	row = 2
379	s = stats.get()
380	def sortkey(x):
381	if s[x][1]:
382	return (-s[x][1], -s[x][0])
383	else:
384	return (0, -s[x][0])
385	for key in sorted(s.keys(), key = sortkey):
386	if row >= screen.getmaxyx()[0]:
387	break
388	values = s[key]
389	if not values[0] and not values[1]:
390	break
391	col = 1
392	screen.addstr(row, col, key)
393	col += label_width
394	screen.addstr(row, col, '%10d' % (values[0],))
395	col += number_width
396	if values[1] is not None:
397	screen.addstr(row, col, '%8d' % (values[1] / sleeptime,))
398	row += 1
399	screen.refresh()
400
401	sleeptime = 0.25
402	while True:
403	refresh(sleeptime)
404	curses.halfdelay(int(sleeptime * 10))
405	sleeptime = 3
406	try:
407	c = screen.getkey()
408	if c == 'x':
409	drilldown = not drilldown
410	update_drilldown()
411	if c == 'q':
412	break
413	except KeyboardInterrupt:
414	break
415	except curses.error:
416	continue
417
418	def batch(stats):
419	s = stats.get()
420	time.sleep(1)
421	s = stats.get()
422	for key in sorted(s.keys()):
423	values = s[key]
424	print '%-22s%10d%10d' % (key, values[0], values[1])
425
426	def log(stats):
427	keys = sorted(stats.get().iterkeys())
428	def banner():
429	for k in keys:
430	print '%10s' % k[0:9],
431	print
432	def statline():
433	s = stats.get()
434	for k in keys:
435	print ' %9d' % s[k][1],
436	print
437	line = 0
438	banner_repeat = 20
439	while True:
440	time.sleep(1)
441	if line % banner_repeat == 0:
442	banner()
443	statline()
444	line += 1
445
446	options = optparse.OptionParser()
447	options.add_option('-1', '--once', '--batch',
448	action = 'store_true',
449	default = False,
450	dest = 'once',
451	help = 'run in batch mode for one second',
452	)
453	options.add_option('-l', '--log',
454	action = 'store_true',
455	default = False,
456	dest = 'log',
457	help = 'run in logging mode (like vmstat)',
458	)
459	options.add_option('-f', '--fields',
460	action = 'store',
461	default = None,
462	dest = 'fields',
463	help = 'fields to display (regex)',
464	)
465	(options, args) = options.parse_args(sys.argv)
466
467	try:
468	provider = TracepointProvider()
469	except:
470	provider = DebugfsProvider()
471
472	stats = Stats(provider, fields = options.fields)
473
474	if options.log:
475	log(stats)
476	elif not options.once:
477	import curses.wrapper
478	curses.wrapper(tui, stats)
479	else:
480	batch(stats)