Files
Ian Rogers ac6e4e290b perf python sctop: Fix offline interval printing and test flakiness
In sctop.py:
- If an earlier interval elapsed and printed an empty table before the
  target comm ('sleep') executed any syscalls, analyzer.printed became
  True and the final partial interval containing the target comm's
  syscalls was never flushed at EOF. Flush print_current_totals() in
  finally when analyzer.syscalls is non-empty as well as when nothing
  has been printed yet.
- Initialize analyzer.e_machine after creating perf.session rather than
  when session is still None.

In test_sctop_python.sh:
- Use a private temporary directory via 'mktemp -d'.
- Drop '-a' and pass '-B -N --no-bpf-event' to 'perf record', and sleep
  briefly in the subshell ('sh -c "sleep 0.1; sleep 0.05"') with a
  bounded retry loop so 'sleep's PERF_RECORD_COMM and sys_enter events
  are reliably captured under heavy load.

Fixes: b83f0bacf5 ("perf python: Port sctop to perf module")
Assisted-by: Antigravity:gemini-3.1-pro
Signed-off-by: Ian Rogers <[email protected]>
Signed-off-by: Arnaldo Carvalho de Melo <[email protected]>
2026-09-29 20:51:06 +02:00

254 lines
9.6 KiB
Python
Executable File

#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0
"""
System call top
Periodically displays system-wide system call totals, broken down by
syscall. If a [comm] arg is specified, only syscalls called by
[comm] are displayed. If an [interval] arg is specified, the display
will be refreshed every [interval] seconds. The default interval is
3 seconds.
Ported from tools/perf/scripts/python/sctop.py
"""
from __future__ import annotations
import argparse
from collections import defaultdict
import os
import sys
import threading
from typing import Optional
import perf
from perf_live import LiveSession
class SCTopAnalyzer:
"""Periodically displays system-wide system call totals."""
def __init__(self, for_comm: Optional[str], interval: int, offline: bool = False):
self.for_comm = for_comm
self.interval = interval
self.syscalls: dict[int, int] = defaultdict(int)
self.comm_cache: dict[int, str] = {}
self.lock = threading.Lock()
self.stop_event = threading.Event()
self.thread = threading.Thread(target=self.print_syscall_totals)
self.offline = offline
self.own_pid = os.getpid()
self.last_print_time: Optional[int] = None
self.printed = False
self.session: Optional[perf.session] = None
self.e_machine: Optional[int] = None
def syscall_name(self, syscall_id: int) -> str:
"""Lookup syscall name by ID."""
# Mask out the x86_64 x32 ABI bit (__X32_SYSCALL_BIT = 0x40000000) before
# resolving the syscall number in the architecture's syscall table.
raw_sc_id = syscall_id & ~0x40000000
try:
e_machine = getattr(self.session, "e_machine", self.e_machine)
if e_machine is not None:
name = perf.syscall_name(raw_sc_id, e_machine)
else:
name = perf.syscall_name(raw_sc_id)
if name is not None:
return name
except (TypeError, OverflowError):
pass
return str(syscall_id)
def process_event(self, sample: perf.sample_event) -> None:
"""Collect syscall events."""
if not self.offline and sample.sample_pid == self.own_pid:
return
name = str(sample.evsel)
# Per-syscall syscalls:sys_enter_* tracepoints expose '__syscall_nr' (or 'nr')
# and may have an unrelated syscall argument named 'id', whereas
# raw_syscalls:sys_enter (and legacy pre-2.6.35 syscalls:sys_enter) expose 'id'.
if name.startswith("evsel(syscalls:sys_enter_"):
syscall_id = getattr(sample, "__syscall_nr", -1)
if not (0 <= (syscall_id & ~0x40000000) <= 0xffff):
syscall_id = getattr(sample, "nr", -1)
elif name.startswith(("evsel(raw_syscalls:sys_enter", "evsel(syscalls:sys_enter")):
syscall_id = getattr(sample, "id", -1)
if not (0 <= (syscall_id & ~0x40000000) <= 0xffff):
syscall_id = getattr(sample, "__syscall_nr", -1)
if not (0 <= (syscall_id & ~0x40000000) <= 0xffff):
syscall_id = getattr(sample, "nr", -1)
else:
syscall_id = -1
skip = False
with self.lock:
if self.for_comm is not None:
is_execve = (0 <= (syscall_id & ~0x40000000) <= 0xffff and
self.syscall_name(syscall_id) in ("execve", "execveat"))
if is_execve:
self.comm_cache.pop(sample.sample_pid, None)
comm = "Unknown"
if hasattr(self, 'session') and self.session:
# In offline perf.data mode, query session.find_thread() directly
# so PERF_RECORD_COMM updates after execve (e.g. perf -> sleep)
# are reflected immediately rather than returning a stale cached comm.
try:
proc = self.session.find_thread(sample.sample_pid, sample.sample_tid)
if proc:
comm = proc.comm() or "Unknown"
except TypeError:
pass
if comm != "Unknown" and not is_execve:
self.comm_cache[sample.sample_pid] = comm
elif sample.sample_pid in self.comm_cache:
comm = self.comm_cache[sample.sample_pid]
elif sample.sample_pid in self.comm_cache:
comm = self.comm_cache[sample.sample_pid]
else:
try:
with open(f"/proc/{sample.sample_pid}/comm", "r",
encoding="utf-8", errors="replace") as f:
comm = f.read().strip()
except OSError:
comm = "Unknown"
# Cache both matching and non-matching comms (including "Unknown"
# when a PID has exited or is inaccessible) so live system-wide
# tracing does not re-open /proc/<pid>/comm on every syscall.
# Do not cache during sys_enter(execve/execveat) since /proc/<pid>/comm
# still holds the pre-exec command name until the syscall completes.
if not is_execve:
self.comm_cache[sample.sample_pid] = comm
if comm != self.for_comm:
skip = True
is_enter = (name.startswith("evsel(raw_syscalls:sys_enter") or
name.startswith("evsel(syscalls:sys_enter"))
if not skip and is_enter and 0 <= (syscall_id & ~0x40000000) <= 0xffff:
self.syscalls[syscall_id] += 1
if self.offline and hasattr(sample, "sample_time"):
interval_ns = self.interval * (10 ** 9)
if self.last_print_time is None:
self.last_print_time = sample.sample_time
elif sample.sample_time - self.last_print_time >= interval_ns:
self.print_current_totals()
self.last_print_time = sample.sample_time
def print_current_totals(self):
"""Print current syscall totals."""
self.printed = True
# Clear terminal
if not self.offline:
print("\x1b[2J\x1b[H", end="")
else:
print()
with self.lock:
for_comm = self.for_comm
if for_comm is not None:
print(f"\nsyscall events for {for_comm}:\n")
else:
print("\nsyscall events:\n")
print(f"{'event':40s} {'count':10s}")
print(f"{'-' * 40:40s} {'-' * 10:10s}")
with self.lock:
current_syscalls = list(self.syscalls.items())
self.syscalls.clear()
self.comm_cache.clear()
current_syscalls.sort(key=lambda kv: (-kv[1], kv[0]))
for syscall_id, val in current_syscalls:
print(f"{self.syscall_name(syscall_id):<40s} {val:10d}")
def print_syscall_totals(self):
"""Periodically print syscall totals."""
while not self.stop_event.is_set():
self.print_current_totals()
self.stop_event.wait(self.interval)
# Print final batch
self.print_current_totals()
def start(self):
"""Start the background thread."""
self.thread.start()
def stop(self):
"""Stop the background thread."""
self.stop_event.set()
self.thread.join()
def main():
"""Main function."""
ap = argparse.ArgumentParser(description="System call top")
ap.add_argument("args", nargs="*", help="[comm] [interval] or [interval]")
ap.add_argument("-i", "--input", help="Input file name")
args = ap.parse_args()
for_comm = None
default_interval = 3
interval = default_interval
if len(args.args) > 2:
print("Usage: python sctop.py [comm] [interval]")
sys.exit(1)
if len(args.args) > 1:
for_comm = args.args[0]
try:
interval = int(args.args[1])
except ValueError:
print(f"Invalid interval: {args.args[1]}")
sys.exit(1)
elif len(args.args) > 0:
try:
interval = int(args.args[0])
except ValueError:
for_comm = args.args[0]
interval = default_interval
analyzer = SCTopAnalyzer(for_comm, interval, offline=bool(args.input))
session = None
try:
if args.input:
session = perf.session(perf.data(args.input), sample=analyzer.process_event)
analyzer.session = session
analyzer.e_machine = getattr(session, "e_machine", None)
session.process_events()
else:
try:
live_session = LiveSession(
"raw_syscalls:sys_enter", sample_callback=analyzer.process_event
)
except OSError:
live_session = LiveSession(
"syscalls:sys_enter_*", sample_callback=analyzer.process_event
)
analyzer.start()
live_session.run()
except KeyboardInterrupt:
pass
except (OSError, IOError) as e:
print(f"Error: {e}", file=sys.stderr)
sys.exit(1)
finally:
if args.input:
if not analyzer.printed or analyzer.syscalls:
analyzer.print_current_totals()
# Break the reference cycle between perf.session and analyzer.process_event
# because perf.session lacks cyclic GC support (tp_traverse).
analyzer.session = None
session = None
elif analyzer.thread.is_alive():
analyzer.stop()
if __name__ == "__main__":
main()