Lines Matching refs:self
268 def tracepoint_is_child(self, field): argument
275 def __init__(self, exit_reasons): argument
276 self.sc_perf_evt_open = 298
277 self.ioctl_numbers = IOCTL_NUMBERS
278 self.exit_reason_field = 'exit_reason'
279 self.exit_reasons = exit_reasons
281 def debugfs_is_child(self, field): argument
287 def __init__(self): argument
288 self.sc_perf_evt_open = 319
289 self.ioctl_numbers = IOCTL_NUMBERS
290 self.ioctl_numbers['ENABLE'] = 0x20002400
291 self.ioctl_numbers['DISABLE'] = 0x20002401
292 self.ioctl_numbers['RESET'] = 0x20002403
297 self.ioctl_numbers['SET_FILTER'] = 0x80002406 | char_ptr_size << 16
298 self.exit_reason_field = 'exit_nr'
299 self.exit_reasons = {}
301 def debugfs_is_child(self, field): argument
307 def __init__(self): argument
308 self.sc_perf_evt_open = 241
309 self.ioctl_numbers = IOCTL_NUMBERS
310 self.exit_reason_field = 'esr_ec'
311 self.exit_reasons = AARCH64_EXIT_REASONS
313 def debugfs_is_child(self, field): argument
319 def __init__(self): argument
320 self.sc_perf_evt_open = 331
321 self.ioctl_numbers = IOCTL_NUMBERS
322 self.exit_reason_field = None
323 self.exit_reasons = None
325 def debugfs_is_child(self, field): argument
356 def __init__(self): argument
357 super(self.__class__, self).__init__()
358 self.type = PERF_TYPE_TRACEPOINT
359 self.size = ctypes.sizeof(self)
360 self.read_format = PERF_FORMAT_GROUP
370 def __init__(self): argument
371 self.events = []
373 def add_event(self, event): argument
374 self.events.append(event)
376 def read(self): argument
393 length = 8 * (1 + len(self.events))
394 read_format = 'xxxxxxxx' + 'Q' * len(self.events)
395 return dict(zip([event.name for event in self.events],
397 os.read(self.events[0].fd, length))))
402 def __init__(self, name, group, trace_cpu, trace_pid, trace_point, argument
404 self.libc = ctypes.CDLL('libc.so.6', use_errno=True)
405 self.syscall = self.libc.syscall
406 self.name = name
407 self.fd = None
408 self._setup_event(group, trace_cpu, trace_pid, trace_point,
411 def __del__(self): argument
419 if self.fd:
420 os.close(self.fd)
422 def _perf_event_open(self, attr, pid, cpu, group_fd, flags): argument
437 return self.syscall(ARCH.sc_perf_evt_open, ctypes.pointer(attr),
441 def _setup_event_attribute(self, trace_set, trace_point): argument
451 def _setup_event(self, group, trace_cpu, trace_pid, trace_point, argument
460 event_attr = self._setup_event_attribute(trace_set, trace_point)
469 fd = self._perf_event_open(event_attr, trace_pid,
480 self.fd = fd
482 def enable(self): argument
489 fcntl.ioctl(self.fd, ARCH.ioctl_numbers['ENABLE'], 0)
491 def disable(self): argument
498 fcntl.ioctl(self.fd, ARCH.ioctl_numbers['DISABLE'], 0)
500 def reset(self): argument
502 fcntl.ioctl(self.fd, ARCH.ioctl_numbers['RESET'], 0)
507 def __init__(self, pid): argument
508 self.child_events = False
509 self.pid = pid
534 def __init__(self, pid, fields_filter): argument
535 self.group_leaders = []
536 self.filters = self._get_filters()
537 self.update_fields(fields_filter)
538 super(TracepointProvider, self).__init__(pid)
557 def _get_available_fields(self): argument
573 fields = self.walkdir(path)[1]
576 if field in self.filters:
577 filter_name_, filter_dicts = self.filters[field]
583 def update_fields(self, fields_filter): argument
585 self.fields = [field for field in self._get_available_fields()
586 if self.is_field_wanted(fields_filter, field)]
588 for field in self._fields:
590 if (parent and parent not in self._fields):
591 self.fields.append(parent)
616 def _setup_traces(self): argument
619 fields = self._get_available_fields()
620 if self._pid > 0:
623 path = os.path.join('/proc', str(self._pid), 'task')
624 groupids = self.walkdir(path)[1]
626 groupids = self._get_online_cpus()
653 (self.filters[tracepoint][0],
654 self.filters[tracepoint][1][sub]))
662 trace_cpu = groupid if self._pid == 0 else -1
663 trace_pid = int(groupid) if self._pid != 0 else -1
672 self.group_leaders.append(group)
675 def fields(self): argument
676 return self._fields
679 def fields(self, fields): argument
681 self._fields = fields
682 for group in self.group_leaders:
694 def pid(self): argument
695 return self._pid
698 def pid(self, pid): argument
700 self._pid = pid
703 self.group_leaders = []
704 self._setup_traces()
705 self.fields = self._fields
707 def read(self, by_guest=0): argument
710 for group in self.group_leaders:
712 if name not in self._fields:
720 def reset(self): argument
722 for group in self.group_leaders:
730 def __init__(self, pid, fields_filter, include_past): argument
731 self.update_fields(fields_filter)
732 self._baseline = {}
733 self.do_read = True
734 self.paths = []
735 super(DebugfsProvider, self).__init__(pid)
737 self._restore()
739 def _get_available_fields(self): argument
746 fields = [field for field in self.walkdir(PATH_DEBUGFS_KVM)[2]
751 def update_fields(self, fields_filter): argument
753 self._fields = [field for field in self._get_available_fields()
754 if self.is_field_wanted(fields_filter, field)]
756 for field in self._fields:
758 if (parent and parent not in self._fields):
759 self.fields.append(parent)
762 def fields(self): argument
763 return self._fields
766 def fields(self, fields): argument
767 self._fields = fields
768 self.reset()
771 def pid(self): argument
772 return self._pid
775 def pid(self, pid): argument
776 self._pid = pid
778 vms = self.walkdir(PATH_DEBUGFS_KVM)[1]
780 self.do_read = False
782 self.paths = list(filter(lambda x: "{}-".format(pid) in x, vms))
785 self.paths = []
786 self.do_read = True
788 def _verify_paths(self): argument
790 for path in self.paths:
792 self.paths.remove(path)
795 def read(self, reset=0, by_guest=0): argument
807 if not self.do_read:
809 self._verify_paths()
811 paths = self.paths
812 if self._pid == 0:
818 for field in self._fields:
819 value = self._read_field(field, path)
822 self._baseline[key] = value
824 self._baseline[key] = 0
825 if self._baseline.get(key, -1) == -1:
826 self._baseline[key] = value
833 increment = value - self._baseline.get(key, 0)
841 def _read_field(self, field, path): argument
851 def reset(self): argument
853 self._baseline = {}
854 self.read(1)
856 def _restore(self): argument
858 self._baseline = {}
859 self.read(2)
872 def __init__(self, options): argument
873 self.providers = self._get_providers(options)
874 self._pid_filter = options.pid
875 self._fields_filter = options.fields
876 self.values = {}
877 self._child_events = False
879 def _get_providers(self, options): argument
891 def _update_provider_filters(self): argument
895 self.values = {}
896 for provider in self.providers:
897 provider.update_fields(self._fields_filter)
899 def reset(self): argument
900 self.values = {}
901 for provider in self.providers:
905 def fields_filter(self): argument
906 return self._fields_filter
909 def fields_filter(self, fields_filter): argument
910 if fields_filter != self._fields_filter:
911 self._fields_filter = fields_filter
912 self._update_provider_filters()
915 def pid_filter(self): argument
916 return self._pid_filter
919 def pid_filter(self, pid): argument
920 if pid != self._pid_filter:
921 self._pid_filter = pid
922 self.values = {}
923 for provider in self.providers:
924 provider.pid = self._pid_filter
927 def child_events(self): argument
928 return self._child_events
931 def child_events(self, val): argument
932 self._child_events = val
933 for provider in self.providers:
936 def get(self, by_guest=0): argument
946 for provider in self.providers:
949 oldval = self.values.get(key, EventStat(0, 0)).value
952 self.values[key] = EventStat(newval, newdelta)
953 return self.values
955 def toggle_display_guests(self, to_pid): argument
964 if any(isinstance(ins, TracepointProvider) for ins in self.providers):
967 for provider in self.providers:
970 if key in self.values.keys():
971 del self.values[key]
973 oldvals = self.values.copy()
976 del self.values[key]
978 self.get(to_pid)
992 def __init__(self, stats, opts): argument
993 self.stats = stats
994 self.screen = None
995 self._delay_initial = 0.25
996 self._delay_regular = opts.set_delay
997 self._sorting = SORT_DEFAULT
998 self._display_guests = 0
1000 def __enter__(self): argument
1003 self.screen = curses.initscr()
1023 return self
1025 def __exit__(self, *exception): argument
1028 if self.screen:
1029 self.screen.keypad(0)
1053 def _print_all_gnames(self, row): argument
1055 self.screen.addstr(row, 2, '%8s %-60s' %
1061 for line in self.get_all_gnames():
1062 self.screen.addstr(row, 2, '%8s %-60s' % (line[0], line[1]))
1064 if row >= self.screen.getmaxyx()[0]:
1067 self.screen.addstr(row + 1, 2, 'Not available')
1116 def _update_pid(self, pid): argument
1118 self.screen.addstr(4, 1, 'Updating pid filter...')
1119 self.screen.refresh()
1120 self.stats.pid_filter = pid
1122 def _refresh_header(self, pid=None): argument
1125 pid = self.stats.pid_filter
1126 self.screen.erase()
1127 gname = self.get_gname_from_pid(pid)
1128 self._gname = gname
1134 self._headline = 'kvm statistics - pid {0} {1}'.format(pid, gname)
1136 self._headline = 'kvm statistics - summary'
1137 self.screen.addstr(0, 0, self._headline, curses.A_BOLD)
1138 if self.stats.fields_filter:
1139 regex = self.stats.fields_filter
1142 self.screen.addstr(1, 17, 'regex filter: {0}'.format(regex))
1143 if self._display_guests:
1147 self.screen.addstr(2, 1, '%-40s %10s%7s %8s' %
1150 self.screen.addstr(4, 1, 'Collecting data...')
1151 self.screen.refresh()
1153 def _refresh_body(self, sleeptime): argument
1161 def get_sorted_events(self, stats): argument
1163 if self._sorting == SORT_DEFAULT:
1183 if not self.stats.child_events:
1188 if self.stats.child_events:
1195 if not self._is_running_guest(self.stats.pid_filter):
1196 if self._gname:
1198 pids = self.get_pid_from_gname(self._gname)
1200 self._refresh_header(pids[0])
1201 self._update_pid(pids[0])
1205 self._display_guest_dead()
1209 self.screen.move(row, 0)
1210 self.screen.clrtobot()
1211 stats = self.stats.get(self._display_guests)
1215 if self._display_guests:
1216 if self.get_gname_from_pid(key):
1231 for key, values in get_sorted_events(self, stats):
1232 if row >= self.screen.getmaxyx()[0] - 1 or values == (0, 0):
1234 if self._display_guests:
1235 key = self.get_gname_from_pid(key)
1249 self.screen.addstr(row, 1, '%-40s %10d%7.1f %8s' % (key,
1255 self.screen.addstr(4, 1, 'Guest removed, updating...')
1257 self.screen.addstr(4, 1, 'No matching events reported yet')
1260 self.screen.addstr(row, 1, '%-40s %10d %8s' %
1262 self.screen.refresh()
1264 def _display_guest_dead(self): argument
1266 y = min(len(self._headline), 80 - len(marker))
1267 self.screen.addstr(0, y, marker, curses.A_BLINK | curses.A_STANDOUT)
1269 def _show_msg(self, text): argument
1273 self.screen.erase()
1274 (x, term_width) = self.screen.getmaxyx()
1278 self.screen.addstr(row, start, line)
1280 self.screen.addstr(row + 1, (term_width - len(hint)) // 2, hint,
1282 self.screen.getkey()
1284 def _show_help_interactive(self): argument
1302 self.screen.erase()
1303 self.screen.addstr(0, 0, "Interactive commands reference",
1305 self.screen.addstr(2, 0, "Press any key to exit", curses.A_STANDOUT)
1308 self.screen.addstr(row, 0, line)
1310 self.screen.getkey()
1311 self._refresh_header()
1313 def _show_filter_selection(self): argument
1321 self.screen.erase()
1322 self.screen.addstr(0, 0,
1325 self.screen.addstr(2, 0,
1327 .format(self.stats.fields_filter))
1328 self.screen.addstr(5, 0, msg)
1329 self.screen.addstr(3, 0, "New regex: ")
1331 regex = self.screen.getstr().decode(ENCODING)
1334 self.stats.fields_filter = ''
1335 self._refresh_header()
1339 self.stats.fields_filter = regex
1340 self._refresh_header()
1346 def _show_set_update_interval(self): argument
1350 self.screen.erase()
1351 self.screen.addstr(0, 0, 'Set update interval (defaults to %.1fs).'
1353 self.screen.addstr(4, 0, msg)
1354 self.screen.addstr(2, 0, 'Change delay from %.1fs to ' %
1355 self._delay_regular)
1357 val = self.screen.getstr().decode(ENCODING)
1369 self._delay_regular = delay
1374 self._refresh_header()
1376 def _is_running_guest(self, pid): argument
1382 def _show_vm_selection_by_guest(self): argument
1390 self.screen.erase()
1391 self.screen.addstr(0, 0,
1394 self.screen.addstr(1, 0,
1397 self.screen.addstr(5, 0, msg)
1398 self._print_all_gnames(7)
1401 self.screen.addstr(3, 0, "Guest or pid [ENTER exits]: ")
1402 guest = self.screen.getstr().decode(ENCODING)
1409 if not self._is_running_guest(guest):
1416 pids = self.get_pid_from_gname(guest)
1431 self._refresh_header(pid)
1432 self._update_pid(pid)
1434 def show_stats(self): argument
1436 sleeptime = self._delay_initial
1437 self._refresh_header()
1440 self._refresh_body(time.time() - start)
1443 sleeptime = self._delay_regular
1445 char = self.screen.getkey()
1447 self._display_guests = not self._display_guests
1448 if self.stats.toggle_display_guests(self._display_guests):
1449 self._show_msg(['Command not available with '
1453 self._display_guests = not self._display_guests
1454 self._refresh_header()
1456 self.stats.fields_filter = ''
1457 self._refresh_header(0)
1458 self._update_pid(0)
1461 self._show_filter_selection()
1463 sleeptime = self._delay_initial
1465 self._show_vm_selection_by_guest()
1466 sleeptime = self._delay_initial
1468 self._show_help_interactive()
1470 self._sorting = not self._sorting
1474 self.stats.reset()
1477 self._show_set_update_interval()
1479 sleeptime = self._delay_initial
1481 self.stats.child_events = not self.stats.child_events
1502 def __init__(self, keys): argument
1503 self._banner = ''
1505 self._banner += key.split(' ')[0] + ' '
1507 def get_banner(self): argument
1508 return self._banner
1510 def get_statline(self, keys, s): argument
1518 def __init__(self, keys): argument
1519 self._banner = 'timestamp'
1520 self._banner += reduce(lambda res, key: "{},{!s}".format(res,
1523 def get_banner(self): argument
1524 return self._banner
1526 def get_statline(self, keys, s): argument
1638 def __call__(self, parser, namespace, values, option_string=None): argument