| #!/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. |
| """The kvm_stat module outputs statistics about running KVM VMs |
| |
| Three different ways of output formatting are available: |
| - as a top-like text ui |
| - in a key -> value format |
| - in an all keys, all values format |
| |
| The data is sampled from the KVM's debugfs entries and its perf events. |
| """ |
| |
| import curses |
| import sys |
| import os |
| import time |
| import optparse |
| import ctypes |
| import fcntl |
| import resource |
| import struct |
| import re |
| from collections import defaultdict |
| from time import sleep |
| |
| VMX_EXIT_REASONS = { |
| 'EXCEPTION_NMI': 0, |
| 'EXTERNAL_INTERRUPT': 1, |
| 'TRIPLE_FAULT': 2, |
| 'PENDING_INTERRUPT': 7, |
| 'NMI_WINDOW': 8, |
| 'TASK_SWITCH': 9, |
| 'CPUID': 10, |
| 'HLT': 12, |
| 'INVLPG': 14, |
| 'RDPMC': 15, |
| 'RDTSC': 16, |
| 'VMCALL': 18, |
| 'VMCLEAR': 19, |
| 'VMLAUNCH': 20, |
| 'VMPTRLD': 21, |
| 'VMPTRST': 22, |
| 'VMREAD': 23, |
| 'VMRESUME': 24, |
| 'VMWRITE': 25, |
| 'VMOFF': 26, |
| 'VMON': 27, |
| 'CR_ACCESS': 28, |
| 'DR_ACCESS': 29, |
| 'IO_INSTRUCTION': 30, |
| 'MSR_READ': 31, |
| 'MSR_WRITE': 32, |
| 'INVALID_STATE': 33, |
| 'MWAIT_INSTRUCTION': 36, |
| 'MONITOR_INSTRUCTION': 39, |
| 'PAUSE_INSTRUCTION': 40, |
| 'MCE_DURING_VMENTRY': 41, |
| 'TPR_BELOW_THRESHOLD': 43, |
| 'APIC_ACCESS': 44, |
| 'EPT_VIOLATION': 48, |
| 'EPT_MISCONFIG': 49, |
| 'WBINVD': 54, |
| 'XSETBV': 55, |
| 'APIC_WRITE': 56, |
| 'INVPCID': 58, |
| } |
| |
| SVM_EXIT_REASONS = { |
| 'READ_CR0': 0x000, |
| 'READ_CR3': 0x003, |
| 'READ_CR4': 0x004, |
| 'READ_CR8': 0x008, |
| 'WRITE_CR0': 0x010, |
| 'WRITE_CR3': 0x013, |
| 'WRITE_CR4': 0x014, |
| 'WRITE_CR8': 0x018, |
| 'READ_DR0': 0x020, |
| 'READ_DR1': 0x021, |
| 'READ_DR2': 0x022, |
| 'READ_DR3': 0x023, |
| 'READ_DR4': 0x024, |
| 'READ_DR5': 0x025, |
| 'READ_DR6': 0x026, |
| 'READ_DR7': 0x027, |
| 'WRITE_DR0': 0x030, |
| 'WRITE_DR1': 0x031, |
| 'WRITE_DR2': 0x032, |
| 'WRITE_DR3': 0x033, |
| 'WRITE_DR4': 0x034, |
| 'WRITE_DR5': 0x035, |
| 'WRITE_DR6': 0x036, |
| 'WRITE_DR7': 0x037, |
| 'EXCP_BASE': 0x040, |
| 'INTR': 0x060, |
| 'NMI': 0x061, |
| 'SMI': 0x062, |
| 'INIT': 0x063, |
| 'VINTR': 0x064, |
| 'CR0_SEL_WRITE': 0x065, |
| 'IDTR_READ': 0x066, |
| 'GDTR_READ': 0x067, |
| 'LDTR_READ': 0x068, |
| 'TR_READ': 0x069, |
| 'IDTR_WRITE': 0x06a, |
| 'GDTR_WRITE': 0x06b, |
| 'LDTR_WRITE': 0x06c, |
| 'TR_WRITE': 0x06d, |
| 'RDTSC': 0x06e, |
| 'RDPMC': 0x06f, |
| 'PUSHF': 0x070, |
| 'POPF': 0x071, |
| 'CPUID': 0x072, |
| 'RSM': 0x073, |
| 'IRET': 0x074, |
| 'SWINT': 0x075, |
| 'INVD': 0x076, |
| 'PAUSE': 0x077, |
| 'HLT': 0x078, |
| 'INVLPG': 0x079, |
| 'INVLPGA': 0x07a, |
| 'IOIO': 0x07b, |
| 'MSR': 0x07c, |
| 'TASK_SWITCH': 0x07d, |
| 'FERR_FREEZE': 0x07e, |
| 'SHUTDOWN': 0x07f, |
| 'VMRUN': 0x080, |
| 'VMMCALL': 0x081, |
| 'VMLOAD': 0x082, |
| 'VMSAVE': 0x083, |
| 'STGI': 0x084, |
| 'CLGI': 0x085, |
| 'SKINIT': 0x086, |
| 'RDTSCP': 0x087, |
| 'ICEBP': 0x088, |
| 'WBINVD': 0x089, |
| 'MONITOR': 0x08a, |
| 'MWAIT': 0x08b, |
| 'MWAIT_COND': 0x08c, |
| 'XSETBV': 0x08d, |
| 'NPF': 0x400, |
| } |
| |
| # EC definition of HSR (from arch/arm64/include/asm/kvm_arm.h) |
| AARCH64_EXIT_REASONS = { |
| 'UNKNOWN': 0x00, |
| 'WFI': 0x01, |
| 'CP15_32': 0x03, |
| 'CP15_64': 0x04, |
| 'CP14_MR': 0x05, |
| 'CP14_LS': 0x06, |
| 'FP_ASIMD': 0x07, |
| 'CP10_ID': 0x08, |
| 'CP14_64': 0x0C, |
| 'ILL_ISS': 0x0E, |
| 'SVC32': 0x11, |
| 'HVC32': 0x12, |
| 'SMC32': 0x13, |
| 'SVC64': 0x15, |
| 'HVC64': 0x16, |
| 'SMC64': 0x17, |
| 'SYS64': 0x18, |
| 'IABT': 0x20, |
| 'IABT_HYP': 0x21, |
| 'PC_ALIGN': 0x22, |
| 'DABT': 0x24, |
| 'DABT_HYP': 0x25, |
| 'SP_ALIGN': 0x26, |
| 'FP_EXC32': 0x28, |
| 'FP_EXC64': 0x2C, |
| 'SERROR': 0x2F, |
| 'BREAKPT': 0x30, |
| 'BREAKPT_HYP': 0x31, |
| 'SOFTSTP': 0x32, |
| 'SOFTSTP_HYP': 0x33, |
| 'WATCHPT': 0x34, |
| 'WATCHPT_HYP': 0x35, |
| 'BKPT32': 0x38, |
| 'VECTOR32': 0x3A, |
| 'BRK64': 0x3C, |
| } |
| |
| # From include/uapi/linux/kvm.h, KVM_EXIT_xxx |
| USERSPACE_EXIT_REASONS = { |
| 'UNKNOWN': 0, |
| 'EXCEPTION': 1, |
| 'IO': 2, |
| 'HYPERCALL': 3, |
| 'DEBUG': 4, |
| 'HLT': 5, |
| 'MMIO': 6, |
| 'IRQ_WINDOW_OPEN': 7, |
| 'SHUTDOWN': 8, |
| 'FAIL_ENTRY': 9, |
| 'INTR': 10, |
| 'SET_TPR': 11, |
| 'TPR_ACCESS': 12, |
| 'S390_SIEIC': 13, |
| 'S390_RESET': 14, |
| 'DCR': 15, |
| 'NMI': 16, |
| 'INTERNAL_ERROR': 17, |
| 'OSI': 18, |
| 'PAPR_HCALL': 19, |
| 'S390_UCONTROL': 20, |
| 'WATCHDOG': 21, |
| 'S390_TSCH': 22, |
| 'EPR': 23, |
| 'SYSTEM_EVENT': 24, |
| } |
| |
| IOCTL_NUMBERS = { |
| 'SET_FILTER': 0x40082406, |
| 'ENABLE': 0x00002400, |
| 'DISABLE': 0x00002401, |
| 'RESET': 0x00002403, |
| } |
| |
| class Arch(object): |
| """Encapsulates global architecture specific data. |
| |
| Contains the performance event open syscall and ioctl numbers, as |
| well as the VM exit reasons for the architecture it runs on. |
| |
| """ |
| @staticmethod |
| def get_arch(): |
| machine = os.uname()[4] |
| |
| if machine.startswith('ppc'): |
| return ArchPPC() |
| elif machine.startswith('aarch64'): |
| return ArchA64() |
| elif machine.startswith('s390'): |
| return ArchS390() |
| else: |
| # X86_64 |
| for line in open('/proc/cpuinfo'): |
| if not line.startswith('flags'): |
| continue |
| |
| flags = line.split() |
| if 'vmx' in flags: |
| return ArchX86(VMX_EXIT_REASONS) |
| if 'svm' in flags: |
| return ArchX86(SVM_EXIT_REASONS) |
| return |
| |
| class ArchX86(Arch): |
| def __init__(self, exit_reasons): |
| self.sc_perf_evt_open = 298 |
| self.ioctl_numbers = IOCTL_NUMBERS |
| self.exit_reasons = exit_reasons |
| |
| class ArchPPC(Arch): |
| def __init__(self): |
| self.sc_perf_evt_open = 319 |
| self.ioctl_numbers = IOCTL_NUMBERS |
| self.ioctl_numbers['ENABLE'] = 0x20002400 |
| self.ioctl_numbers['DISABLE'] = 0x20002401 |
| self.ioctl_numbers['RESET'] = 0x20002403 |
| |
| # PPC comes in 32 and 64 bit and some generated ioctl |
| # numbers depend on the wordsize. |
| char_ptr_size = ctypes.sizeof(ctypes.c_char_p) |
| self.ioctl_numbers['SET_FILTER'] = 0x80002406 | char_ptr_size << 16 |
| self.exit_reasons = {} |
| |
| class ArchA64(Arch): |
| def __init__(self): |
| self.sc_perf_evt_open = 241 |
| self.ioctl_numbers = IOCTL_NUMBERS |
| self.exit_reasons = AARCH64_EXIT_REASONS |
| |
| class ArchS390(Arch): |
| def __init__(self): |
| self.sc_perf_evt_open = 331 |
| self.ioctl_numbers = IOCTL_NUMBERS |
| self.exit_reasons = None |
| |
| ARCH = Arch.get_arch() |
| |
| |
| def walkdir(path): |
| """Returns os.walk() data for specified directory. |
| |
| As it is only a wrapper it returns the same 3-tuple of (dirpath, |
| dirnames, filenames). |
| """ |
| return next(os.walk(path)) |
| |
| |
| def parse_int_list(list_string): |
| """Returns an int list from a string of comma separated integers and |
| integer ranges.""" |
| integers = [] |
| members = list_string.split(',') |
| |
| for member in members: |
| if '-' not in member: |
| integers.append(int(member)) |
| else: |
| int_range = member.split('-') |
| integers.extend(range(int(int_range[0]), |
| int(int_range[1]) + 1)) |
| |
| return integers |
| |
| |
| def get_online_cpus(): |
| """Returns a list of cpu id integers.""" |
| with open('/sys/devices/system/cpu/online') as cpu_list: |
| cpu_string = cpu_list.readline() |
| return parse_int_list(cpu_string) |
| |
| |
| def get_filters(): |
| """Returns a dict of trace events, their filter ids and |
| the values that can be filtered. |
| |
| Trace events can be filtered for special values by setting a |
| filter string via an ioctl. The string normally has the format |
| identifier==value. For each filter a new event will be created, to |
| be able to distinguish the events. |
| |
| """ |
| filters = {} |
| filters['kvm_userspace_exit'] = ('reason', USERSPACE_EXIT_REASONS) |
| if ARCH.exit_reasons: |
| filters['kvm_exit'] = ('exit_reason', ARCH.exit_reasons) |
| return filters |
| |
| libc = ctypes.CDLL('libc.so.6', use_errno=True) |
| syscall = libc.syscall |
| |
| class perf_event_attr(ctypes.Structure): |
| """Struct that holds the necessary data to set up a trace event. |
| |
| For an extensive explanation see perf_event_open(2) and |
| include/uapi/linux/perf_event.h, struct perf_event_attr |
| |
| All fields that are not initialized in the constructor are 0. |
| |
| """ |
| _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 __init__(self): |
| super(self.__class__, self).__init__() |
| self.type = PERF_TYPE_TRACEPOINT |
| self.size = ctypes.sizeof(self) |
| self.read_format = PERF_FORMAT_GROUP |
| |
| def perf_event_open(attr, pid, cpu, group_fd, flags): |
| """Wrapper for the sys_perf_evt_open() syscall. |
| |
| Used to set up performance events, returns a file descriptor or -1 |
| on error. |
| |
| Attributes are: |
| - syscall number |
| - struct perf_event_attr * |
| - pid or -1 to monitor all pids |
| - cpu number or -1 to monitor all cpus |
| - The file descriptor of the group leader or -1 to create a group. |
| - flags |
| |
| """ |
| return syscall(ARCH.sc_perf_evt_open, ctypes.pointer(attr), |
| ctypes.c_int(pid), ctypes.c_int(cpu), |
| ctypes.c_int(group_fd), ctypes.c_long(flags)) |
| |
| PERF_TYPE_TRACEPOINT = 2 |
| PERF_FORMAT_GROUP = 1 << 3 |
| |
| PATH_DEBUGFS_TRACING = '/sys/kernel/debug/tracing' |
| PATH_DEBUGFS_KVM = '/sys/kernel/debug/kvm' |
| |
| class Group(object): |
| """Represents a perf event group.""" |
| |
| def __init__(self): |
| self.events = [] |
| |
| def add_event(self, event): |
| self.events.append(event) |
| |
| def read(self): |
| """Returns a dict with 'event name: value' for all events in the |
| group. |
| |
| Values are read by reading from the file descriptor of the |
| event that is the group leader. See perf_event_open(2) for |
| details. |
| |
| Read format for the used event configuration is: |
| struct read_format { |
| u64 nr; /* The number of events */ |
| struct { |
| u64 value; /* The value of the event */ |
| } values[nr]; |
| }; |
| |
| """ |
| length = 8 * (1 + len(self.events)) |
| read_format = 'xxxxxxxx' + 'Q' * len(self.events) |
| return dict(zip([event.name for event in self.events], |
| struct.unpack(read_format, |
| os.read(self.events[0].fd, length)))) |
| |
| class Event(object): |
| """Represents a performance event and manages its life cycle.""" |
| def __init__(self, name, group, trace_cpu, trace_pid, trace_point, |
| trace_filter, trace_set='kvm'): |
| self.name = name |
| self.fd = None |
| self.setup_event(group, trace_cpu, trace_pid, trace_point, |
| trace_filter, trace_set) |
| |
| def __del__(self): |
| """Closes the event's file descriptor. |
| |
| As no python file object was created for the file descriptor, |
| python will not reference count the descriptor and will not |
| close it itself automatically, so we do it. |
| |
| """ |
| if self.fd: |
| os.close(self.fd) |
| |
| def setup_event_attribute(self, trace_set, trace_point): |
| """Returns an initialized ctype perf_event_attr struct.""" |
| |
| id_path = os.path.join(PATH_DEBUGFS_TRACING, 'events', trace_set, |
| trace_point, 'id') |
| |
| event_attr = perf_event_attr() |
| event_attr.config = int(open(id_path).read()) |
| return event_attr |
| |
| def setup_event(self, group, trace_cpu, trace_pid, trace_point, |
| trace_filter, trace_set): |
| """Sets up the perf event in Linux. |
| |
| Issues the syscall to register the event in the kernel and |
| then sets the optional filter. |
| |
| """ |
| |
| event_attr = self.setup_event_attribute(trace_set, trace_point) |
| |
| # First event will be group leader. |
| group_leader = -1 |
| |
| # All others have to pass the leader's descriptor instead. |
| if group.events: |
| group_leader = group.events[0].fd |
| |
| fd = perf_event_open(event_attr, trace_pid, |
| trace_cpu, group_leader, 0) |
| if fd == -1: |
| err = ctypes.get_errno() |
| raise OSError(err, os.strerror(err), |
| 'while calling sys_perf_event_open().') |
| |
| if trace_filter: |
| fcntl.ioctl(fd, ARCH.ioctl_numbers['SET_FILTER'], |
| trace_filter) |
| |
| self.fd = fd |
| |
| def enable(self): |
| """Enables the trace event in the kernel. |
| |
| Enabling the group leader makes reading counters from it and the |
| events under it possible. |
| |
| """ |
| fcntl.ioctl(self.fd, ARCH.ioctl_numbers['ENABLE'], 0) |
| |
| def disable(self): |
| """Disables the trace event in the kernel. |
| |
| Disabling the group leader makes reading all counters under it |
| impossible. |
| |
| """ |
| fcntl.ioctl(self.fd, ARCH.ioctl_numbers['DISABLE'], 0) |
| |
| def reset(self): |
| """Resets the count of the trace event in the kernel.""" |
| fcntl.ioctl(self.fd, ARCH.ioctl_numbers['RESET'], 0) |
| |
| class TracepointProvider(object): |
| """Data provider for the stats class. |
| |
| Manages the events/groups from which it acquires its data. |
| |
| """ |
| def __init__(self): |
| self.group_leaders = [] |
| self.filters = get_filters() |
| self._fields = self.get_available_fields() |
| self._pid = 0 |
| |
| def get_available_fields(self): |
| """Returns a list of available event's of format 'event name(filter |
| name)'. |
| |
| All available events have directories under |
| /sys/kernel/debug/tracing/events/ which export information |
| about the specific event. Therefore, listing the dirs gives us |
| a list of all available events. |
| |
| Some events like the vm exit reasons can be filtered for |
| specific values. To take account for that, the routine below |
| creates special fields with the following format: |
| event name(filter name) |
| |
| """ |
| path = os.path.join(PATH_DEBUGFS_TRACING, 'events', 'kvm') |
| fields = walkdir(path)[1] |
| extra = [] |
| for field in fields: |
| if field in self.filters: |
| filter_name_, filter_dicts = self.filters[field] |
| for name in filter_dicts: |
| extra.append(field + '(' + name + ')') |
| fields += extra |
| return fields |
| |
| def setup_traces(self): |
| """Creates all event and group objects needed to be able to retrieve |
| data.""" |
| if self._pid > 0: |
| # Fetch list of all threads of the monitored pid, as qemu |
| # starts a thread for each vcpu. |
| path = os.path.join('/proc', str(self._pid), 'task') |
| groupids = walkdir(path)[1] |
| else: |
| groupids = get_online_cpus() |
| |
| # The constant is needed as a buffer for python libs, std |
| # streams and other files that the script opens. |
| newlim = len(groupids) * len(self._fields) + 50 |
| try: |
| softlim_, hardlim = resource.getrlimit(resource.RLIMIT_NOFILE) |
| |
| if hardlim < newlim: |
| # Now we need CAP_SYS_RESOURCE, to increase the hard limit. |
| resource.setrlimit(resource.RLIMIT_NOFILE, (newlim, newlim)) |
| else: |
| # Raising the soft limit is sufficient. |
| resource.setrlimit(resource.RLIMIT_NOFILE, (newlim, hardlim)) |
| |
| except ValueError: |
| sys.exit("NOFILE rlimit could not be raised to {0}".format(newlim)) |
| |
| for groupid in groupids: |
| group = Group() |
| for name in self._fields: |
| tracepoint = name |
| tracefilter = None |
| match = re.match(r'(.*)\((.*)\)', name) |
| if match: |
| tracepoint, sub = match.groups() |
| tracefilter = ('%s==%d\0' % |
| (self.filters[tracepoint][0], |
| self.filters[tracepoint][1][sub])) |
| |
| # From perf_event_open(2): |
| # pid > 0 and cpu == -1 |
| # This measures the specified process/thread on any CPU. |
| # |
| # pid == -1 and cpu >= 0 |
| # This measures all processes/threads on the specified CPU. |
| trace_cpu = groupid if self._pid == 0 else -1 |
| trace_pid = int(groupid) if self._pid != 0 else -1 |
| |
| group.add_event(Event(name=name, |
| group=group, |
| trace_cpu=trace_cpu, |
| trace_pid=trace_pid, |
| trace_point=tracepoint, |
| trace_filter=tracefilter)) |
| |
| self.group_leaders.append(group) |
| |
| def available_fields(self): |
| return self.get_available_fields() |
| |
| @property |
| def fields(self): |
| return self._fields |
| |
| @fields.setter |
| def fields(self, fields): |
| """Enables/disables the (un)wanted events""" |
| self._fields = fields |
| for group in self.group_leaders: |
| for index, event in enumerate(group.events): |
| if event.name in fields: |
| event.reset() |
| event.enable() |
| else: |
| # Do not disable the group leader. |
| # It would disable all of its events. |
| if index != 0: |
| event.disable() |
| |
| @property |
| def pid(self): |
| return self._pid |
| |
| @pid.setter |
| def pid(self, pid): |
| """Changes the monitored pid by setting new traces.""" |
| self._pid = pid |
| # The garbage collector will get rid of all Event/Group |
| # objects and open files after removing the references. |
| self.group_leaders = [] |
| self.setup_traces() |
| self.fields = self._fields |
| |
| def read(self): |
| """Returns 'event name: current value' for all enabled events.""" |
| ret = defaultdict(int) |
| for group in self.group_leaders: |
| for name, val in group.read().iteritems(): |
| if name in self._fields: |
| ret[name] += val |
| return ret |
| |
| class DebugfsProvider(object): |
| """Provides data from the files that KVM creates in the kvm debugfs |
| folder.""" |
| def __init__(self): |
| self._fields = self.get_available_fields() |
| self._pid = 0 |
| self.do_read = True |
| |
| def get_available_fields(self): |
| """"Returns a list of available fields. |
| |
| The fields are all available KVM debugfs files |
| |
| """ |
| return walkdir(PATH_DEBUGFS_KVM)[2] |
| |
| @property |
| def fields(self): |
| return self._fields |
| |
| @fields.setter |
| def fields(self, fields): |
| self._fields = fields |
| |
| @property |
| def pid(self): |
| return self._pid |
| |
| @pid.setter |
| def pid(self, pid): |
| if pid != 0: |
| self._pid = pid |
| |
| vms = walkdir(PATH_DEBUGFS_KVM)[1] |
| if len(vms) == 0: |
| self.do_read = False |
| |
| self.paths = filter(lambda x: "{}-".format(pid) in x, vms) |
| |
| else: |
| self.paths = [''] |
| self.do_read = True |
| |
| def read(self): |
| """Returns a dict with format:'file name / field -> current value'.""" |
| results = {} |
| |
| # If no debugfs filtering support is available, then don't read. |
| if not self.do_read: |
| return results |
| |
| for path in self.paths: |
| for field in self._fields: |
| results[field] = results.get(field, 0) \ |
| + self.read_field(field, path) |
| |
| return results |
| |
| def read_field(self, field, path): |
| """Returns the value of a single field from a specific VM.""" |
| try: |
| return int(open(os.path.join(PATH_DEBUGFS_KVM, |
| path, |
| field)) |
| .read()) |
| except IOError: |
| return 0 |
| |
| class Stats(object): |
| """Manages the data providers and the data they provide. |
| |
| It is used to set filters on the provider's data and collect all |
| provider data. |
| |
| """ |
| def __init__(self, providers, pid, fields=None): |
| self.providers = providers |
| self._pid_filter = pid |
| self._fields_filter = fields |
| self.values = {} |
| self.update_provider_pid() |
| self.update_provider_filters() |
| |
| def update_provider_filters(self): |
| """Propagates fields filters to providers.""" |
| def wanted(key): |
| if not self._fields_filter: |
| return True |
| return re.match(self._fields_filter, key) is not None |
| |
| # As we reset the counters when updating the fields we can |
| # also clear the cache of old values. |
| self.values = {} |
| for provider in self.providers: |
| provider_fields = [key for key in provider.get_available_fields() |
| if wanted(key)] |
| provider.fields = provider_fields |
| |
| def update_provider_pid(self): |
| """Propagates pid filters to providers.""" |
| for provider in self.providers: |
| provider.pid = self._pid_filter |
| |
| @property |
| def fields_filter(self): |
| return self._fields_filter |
| |
| @fields_filter.setter |
| def fields_filter(self, fields_filter): |
| self._fields_filter = fields_filter |
| self.update_provider_filters() |
| |
| @property |
| def pid_filter(self): |
| return self._pid_filter |
| |
| @pid_filter.setter |
| def pid_filter(self, pid): |
| self._pid_filter = pid |
| self.values = {} |
| self.update_provider_pid() |
| |
| def get(self): |
| """Returns a dict with field -> (value, delta to last value) of all |
| provider data.""" |
| for provider in self.providers: |
| new = provider.read() |
| for key in provider.fields: |
| oldval = self.values.get(key, (0, 0)) |
| newval = new.get(key, 0) |
| newdelta = None |
| if oldval is not None: |
| newdelta = newval - oldval[0] |
| self.values[key] = (newval, newdelta) |
| return self.values |
| |
| LABEL_WIDTH = 40 |
| NUMBER_WIDTH = 10 |
| |
| class Tui(object): |
| """Instruments curses to draw a nice text ui.""" |
| def __init__(self, stats): |
| self.stats = stats |
| self.screen = None |
| self.drilldown = False |
| self.update_drilldown() |
| |
| def __enter__(self): |
| """Initialises curses for later use. Based on curses.wrapper |
| implementation from the Python standard library.""" |
| self.screen = curses.initscr() |
| curses.noecho() |
| curses.cbreak() |
| |
| # The try/catch works around a minor bit of |
| # over-conscientiousness in the curses module, the error |
| # return from C start_color() is ignorable. |
| try: |
| curses.start_color() |
| except: |
| pass |
| |
| curses.use_default_colors() |
| return self |
| |
| def __exit__(self, *exception): |
| """Resets the terminal to its normal state. Based on curses.wrappre |
| implementation from the Python standard library.""" |
| if self.screen: |
| self.screen.keypad(0) |
| curses.echo() |
| curses.nocbreak() |
| curses.endwin() |
| |
| def update_drilldown(self): |
| """Sets or removes a filter that only allows fields without braces.""" |
| if not self.stats.fields_filter: |
| self.stats.fields_filter = r'^[^\(]*$' |
| |
| elif self.stats.fields_filter == r'^[^\(]*$': |
| self.stats.fields_filter = None |
| |
| def update_pid(self, pid): |
| """Propagates pid selection to stats object.""" |
| self.stats.pid_filter = pid |
| |
| def refresh(self, sleeptime): |
| """Refreshes on-screen data.""" |
| self.screen.erase() |
| if self.stats.pid_filter > 0: |
| self.screen.addstr(0, 0, 'kvm statistics - pid {0}' |
| .format(self.stats.pid_filter), |
| curses.A_BOLD) |
| else: |
| self.screen.addstr(0, 0, 'kvm statistics - summary', curses.A_BOLD) |
| self.screen.addstr(2, 1, 'Event') |
| self.screen.addstr(2, 1 + LABEL_WIDTH + NUMBER_WIDTH - |
| len('Total'), 'Total') |
| self.screen.addstr(2, 1 + LABEL_WIDTH + NUMBER_WIDTH + 8 - |
| len('Current'), 'Current') |
| row = 3 |
| stats = self.stats.get() |
| def sortkey(x): |
| if stats[x][1]: |
| return (-stats[x][1], -stats[x][0]) |
| else: |
| return (0, -stats[x][0]) |
| for key in sorted(stats.keys(), key=sortkey): |
| |
| if row >= self.screen.getmaxyx()[0]: |
| break |
| values = stats[key] |
| if not values[0] and not values[1]: |
| break |
| col = 1 |
| self.screen.addstr(row, col, key) |
| col += LABEL_WIDTH |
| self.screen.addstr(row, col, '%10d' % (values[0],)) |
| col += NUMBER_WIDTH |
| if values[1] is not None: |
| self.screen.addstr(row, col, '%8d' % (values[1] / sleeptime,)) |
| row += 1 |
| self.screen.refresh() |
| |
| def show_filter_selection(self): |
| """Draws filter selection mask. |
| |
| Asks for a valid regex and sets the fields filter accordingly. |
| |
| """ |
| while True: |
| self.screen.erase() |
| self.screen.addstr(0, 0, |
| "Show statistics for events matching a regex.", |
| curses.A_BOLD) |
| self.screen.addstr(2, 0, |
| "Current regex: {0}" |
| .format(self.stats.fields_filter)) |
| self.screen.addstr(3, 0, "New regex: ") |
| curses.echo() |
| regex = self.screen.getstr() |
| curses.noecho() |
| if len(regex) == 0: |
| return |
| try: |
| re.compile(regex) |
| self.stats.fields_filter = regex |
| return |
| except re.error: |
| continue |
| |
| def show_vm_selection(self): |
| """Draws PID selection mask. |
| |
| Asks for a pid until a valid pid or 0 has been entered. |
| |
| """ |
| while True: |
| self.screen.erase() |
| self.screen.addstr(0, 0, |
| 'Show statistics for specific pid.', |
| curses.A_BOLD) |
| self.screen.addstr(1, 0, |
| 'This might limit the shown data to the trace ' |
| 'statistics.') |
| |
| curses.echo() |
| self.screen.addstr(3, 0, "Pid [0 or pid]: ") |
| pid = self.screen.getstr() |
| curses.noecho() |
| |
| try: |
| pid = int(pid) |
| |
| if pid == 0: |
| self.update_pid(pid) |
| break |
| else: |
| if not os.path.isdir(os.path.join('/proc/', str(pid))): |
| continue |
| else: |
| self.update_pid(pid) |
| break |
| |
| except ValueError: |
| continue |
| |
| def show_stats(self): |
| """Refreshes the screen and processes user input.""" |
| sleeptime = 0.25 |
| while True: |
| self.refresh(sleeptime) |
| curses.halfdelay(int(sleeptime * 10)) |
| sleeptime = 3 |
| try: |
| char = self.screen.getkey() |
| if char == 'x': |
| self.drilldown = not self.drilldown |
| self.update_drilldown() |
| if char == 'q': |
| break |
| if char == 'f': |
| self.show_filter_selection() |
| if char == 'p': |
| self.show_vm_selection() |
| except KeyboardInterrupt: |
| break |
| except curses.error: |
| continue |
| |
| def batch(stats): |
| """Prints statistics in a key, value format.""" |
| s = stats.get() |
| time.sleep(1) |
| s = stats.get() |
| for key in sorted(s.keys()): |
| values = s[key] |
| print '%-42s%10d%10d' % (key, values[0], values[1]) |
| |
| def log(stats): |
| """Prints statistics as reiterating key block, multiple value blocks.""" |
| keys = sorted(stats.get().iterkeys()) |
| def banner(): |
| for k in keys: |
| print '%s' % k, |
| 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 |
| |
| def get_options(): |
| """Returns processed program arguments.""" |
| description_text = """ |
| This script displays various statistics about VMs running under KVM. |
| The statistics are gathered from the KVM debugfs entries and / or the |
| currently available perf traces. |
| |
| The monitoring takes additional cpu cycles and might affect the VM's |
| performance. |
| |
| Requirements: |
| - Access to: |
| /sys/kernel/debug/kvm |
| /sys/kernel/debug/trace/events/* |
| /proc/pid/task |
| - /proc/sys/kernel/perf_event_paranoid < 1 if user has no |
| CAP_SYS_ADMIN and perf events are used. |
| - CAP_SYS_RESOURCE if the hard limit is not high enough to allow |
| the large number of files that are possibly opened. |
| """ |
| |
| class PlainHelpFormatter(optparse.IndentedHelpFormatter): |
| def format_description(self, description): |
| if description: |
| return description + "\n" |
| else: |
| return "" |
| |
| optparser = optparse.OptionParser(description=description_text, |
| formatter=PlainHelpFormatter()) |
| optparser.add_option('-1', '--once', '--batch', |
| action='store_true', |
| default=False, |
| dest='once', |
| help='run in batch mode for one second', |
| ) |
| optparser.add_option('-l', '--log', |
| action='store_true', |
| default=False, |
| dest='log', |
| help='run in logging mode (like vmstat)', |
| ) |
| optparser.add_option('-t', '--tracepoints', |
| action='store_true', |
| default=False, |
| dest='tracepoints', |
| help='retrieve statistics from tracepoints', |
| ) |
| optparser.add_option('-d', '--debugfs', |
| action='store_true', |
| default=False, |
| dest='debugfs', |
| help='retrieve statistics from debugfs', |
| ) |
| optparser.add_option('-f', '--fields', |
| action='store', |
| default=None, |
| dest='fields', |
| help='fields to display (regex)', |
| ) |
| optparser.add_option('-p', '--pid', |
| action='store', |
| default=0, |
| type=int, |
| dest='pid', |
| help='restrict statistics to pid', |
| ) |
| (options, _) = optparser.parse_args(sys.argv) |
| return options |
| |
| def get_providers(options): |
| """Returns a list of data providers depending on the passed options.""" |
| providers = [] |
| |
| if options.tracepoints: |
| providers.append(TracepointProvider()) |
| if options.debugfs: |
| providers.append(DebugfsProvider()) |
| if len(providers) == 0: |
| providers.append(TracepointProvider()) |
| |
| return providers |
| |
| def check_access(options): |
| """Exits if the current user can't access all needed directories.""" |
| if not os.path.exists('/sys/kernel/debug'): |
| sys.stderr.write('Please enable CONFIG_DEBUG_FS in your kernel.') |
| sys.exit(1) |
| |
| if not os.path.exists(PATH_DEBUGFS_KVM): |
| sys.stderr.write("Please make sure, that debugfs is mounted and " |
| "readable by the current user:\n" |
| "('mount -t debugfs debugfs /sys/kernel/debug')\n" |
| "Also ensure, that the kvm modules are loaded.\n") |
| sys.exit(1) |
| |
| if not os.path.exists(PATH_DEBUGFS_TRACING) and (options.tracepoints |
| or not options.debugfs): |
| sys.stderr.write("Please enable CONFIG_TRACING in your kernel " |
| "when using the option -t (default).\n" |
| "If it is enabled, make {0} readable by the " |
| "current user.\n" |
| .format(PATH_DEBUGFS_TRACING)) |
| if options.tracepoints: |
| sys.exit(1) |
| |
| sys.stderr.write("Falling back to debugfs statistics!\n") |
| options.debugfs = True |
| sleep(5) |
| |
| return options |
| |
| def main(): |
| options = get_options() |
| options = check_access(options) |
| |
| if (options.pid > 0 and |
| not os.path.isdir(os.path.join('/proc/', |
| str(options.pid)))): |
| sys.stderr.write('Did you use a (unsupported) tid instead of a pid?\n') |
| sys.exit('Specified pid does not exist.') |
| |
| providers = get_providers(options) |
| stats = Stats(providers, options.pid, fields=options.fields) |
| |
| if options.log: |
| log(stats) |
| elif not options.once: |
| with Tui(stats) as tui: |
| tui.show_stats() |
| else: |
| batch(stats) |
| |
| if __name__ == "__main__": |
| main() |