perf: Remove libpython support and legacy Python scripts

Remove embedded Python interpreter support (libpython) from perf, as
all Python scripts have been migrated to standalone scripts using the
perf Python extension module.

Changes include:
- Remove libpython detection and build flags from Makefile.config.
- Remove legacy Python script installation rules from Makefile.perf.
- Delete tools/perf/util/scripting-engines/trace-event-python.c and
  tools/perf/scripts/python/Perf-Trace-Util/Context.c.
- Remove Python scripting engine registration from
  trace-event-scripting.c.
- Remove libpython from the supported features list in builtin-check.c
  and Documentation/perf-check.txt.
- Delete the legacy Python scripts and bin wrappers in
  tools/perf/scripts/python/ and update shell tests.

Assisted-by: Antigravity:gemini-3.1-pro
Signed-off-by: Ian Rogers <irogers@google.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

1 files changed, 0 insertions, 494 deletions

diff --git a/tools/perf/scripts/python/intel-pt-events.py b/tools/perf/scripts/python/intel-pt-events.py
deleted file mode 100644
index 346c89bd16d6..000000000000
--- a/tools/perf/scripts/python/intel-pt-events.py
+++ /dev/null
@@ -1,494 +0,0 @@
-# SPDX-License-Identifier: GPL-2.0
-# intel-pt-events.py: Print Intel PT Events including Power Events and PTWRITE
-# Copyright (c) 2017-2021, Intel Corporation.
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms and conditions of the GNU General Public License,
-# version 2, as published by the Free Software Foundation.
-#
-# This program is distributed in the hope it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
-# more details.
-
-from __future__ import division, print_function
-
-import io
-import os
-import sys
-import struct
-import argparse
-import contextlib
-
-from libxed import LibXED
-from ctypes import create_string_buffer, addressof
-
-sys.path.append(os.environ['PERF_EXEC_PATH'] + \
-	'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
-
-from perf_trace_context import perf_set_itrace_options, \
-	perf_sample_insn, perf_sample_srccode
-
-try:
-	broken_pipe_exception = BrokenPipeError
-except:
-	broken_pipe_exception = IOError
-
-glb_switch_str		= {}
-glb_insn		= False
-glb_disassembler	= None
-glb_src			= False
-glb_source_file_name	= None
-glb_line_number		= None
-glb_dso			= None
-glb_stash_dict		= {}
-glb_output		= None
-glb_output_pos		= 0
-glb_cpu			= -1
-glb_time		= 0
-
-def get_optional_null(perf_dict, field):
-	if field in perf_dict:
-		return perf_dict[field]
-	return ""
-
-def get_optional_zero(perf_dict, field):
-	if field in perf_dict:
-		return perf_dict[field]
-	return 0
-
-def get_optional_bytes(perf_dict, field):
-	if field in perf_dict:
-		return perf_dict[field]
-	return bytes()
-
-def get_optional(perf_dict, field):
-	if field in perf_dict:
-		return perf_dict[field]
-	return "[unknown]"
-
-def get_offset(perf_dict, field):
-	if field in perf_dict:
-		return "+%#x" % perf_dict[field]
-	return ""
-
-def trace_begin():
-	ap = argparse.ArgumentParser(usage = "", add_help = False)
-	ap.add_argument("--insn-trace", action='store_true')
-	ap.add_argument("--src-trace", action='store_true')
-	ap.add_argument("--all-switch-events", action='store_true')
-	ap.add_argument("--interleave", type=int, nargs='?', const=4, default=0)
-	global glb_args
-	global glb_insn
-	global glb_src
-	glb_args = ap.parse_args()
-	if glb_args.insn_trace:
-		print("Intel PT Instruction Trace")
-		itrace = "i0nsepwxI"
-		glb_insn = True
-	elif glb_args.src_trace:
-		print("Intel PT Source Trace")
-		itrace = "i0nsepwxI"
-		glb_insn = True
-		glb_src = True
-	else:
-		print("Intel PT Branch Trace, Power Events, Event Trace and PTWRITE")
-		itrace = "bepwxI"
-	global glb_disassembler
-	try:
-		glb_disassembler = LibXED()
-	except:
-		glb_disassembler = None
-	perf_set_itrace_options(perf_script_context, itrace)
-
-def trace_end():
-	if glb_args.interleave:
-		flush_stashed_output()
-	print("End")
-
-def trace_unhandled(event_name, context, event_fields_dict):
-		print(' '.join(['%s=%s'%(k,str(v))for k,v in sorted(event_fields_dict.items())]))
-
-def stash_output():
-	global glb_stash_dict
-	global glb_output_pos
-	output_str = glb_output.getvalue()[glb_output_pos:]
-	n = len(output_str)
-	if n:
-		glb_output_pos += n
-		if glb_cpu not in glb_stash_dict:
-			glb_stash_dict[glb_cpu] = []
-		glb_stash_dict[glb_cpu].append(output_str)
-
-def flush_stashed_output():
-	global glb_stash_dict
-	while glb_stash_dict:
-		cpus = list(glb_stash_dict.keys())
-		# Output at most glb_args.interleave output strings per cpu
-		for cpu in cpus:
-			items = glb_stash_dict[cpu]
-			countdown = glb_args.interleave
-			while len(items) and countdown:
-				sys.stdout.write(items[0])
-				del items[0]
-				countdown -= 1
-			if not items:
-				del glb_stash_dict[cpu]
-
-def print_ptwrite(raw_buf):
-	data = struct.unpack_from("<IQ", raw_buf)
-	flags = data[0]
-	payload = data[1]
-	exact_ip = flags & 1
-	try:
-		s = payload.to_bytes(8, "little").decode("ascii").rstrip("\x00")
-		if not s.isprintable():
-			s = ""
-	except:
-		s = ""
-	print("IP: %u payload: %#x" % (exact_ip, payload), s, end=' ')
-
-def print_cbr(raw_buf):
-	data = struct.unpack_from("<BBBBII", raw_buf)
-	cbr = data[0]
-	f = (data[4] + 500) / 1000
-	p = ((cbr * 1000 / data[2]) + 5) / 10
-	print("%3u  freq: %4u MHz  (%3u%%)" % (cbr, f, p), end=' ')
-
-def print_mwait(raw_buf):
-	data = struct.unpack_from("<IQ", raw_buf)
-	payload = data[1]
-	hints = payload & 0xff
-	extensions = (payload >> 32) & 0x3
-	print("hints: %#x extensions: %#x" % (hints, extensions), end=' ')
-
-def print_pwre(raw_buf):
-	data = struct.unpack_from("<IQ", raw_buf)
-	payload = data[1]
-	hw = (payload >> 7) & 1
-	cstate = (payload >> 12) & 0xf
-	subcstate = (payload >> 8) & 0xf
-	print("hw: %u cstate: %u sub-cstate: %u" % (hw, cstate, subcstate),
-		end=' ')
-
-def print_exstop(raw_buf):
-	data = struct.unpack_from("<I", raw_buf)
-	flags = data[0]
-	exact_ip = flags & 1
-	print("IP: %u" % (exact_ip), end=' ')
-
-def print_pwrx(raw_buf):
-	data = struct.unpack_from("<IQ", raw_buf)
-	payload = data[1]
-	deepest_cstate = payload & 0xf
-	last_cstate = (payload >> 4) & 0xf
-	wake_reason = (payload >> 8) & 0xf
-	print("deepest cstate: %u last cstate: %u wake reason: %#x" %
-		(deepest_cstate, last_cstate, wake_reason), end=' ')
-
-def print_psb(raw_buf):
-	data = struct.unpack_from("<IQ", raw_buf)
-	offset = data[1]
-	print("offset: %#x" % (offset), end=' ')
-
-glb_cfe = ["", "INTR", "IRET", "SMI", "RSM", "SIPI", "INIT", "VMENTRY", "VMEXIT",
-		"VMEXIT_INTR", "SHUTDOWN", "", "UINT", "UIRET"] + [""] * 18
-glb_evd = ["", "PFA", "VMXQ", "VMXR"] + [""] * 60
-
-def print_evt(raw_buf):
-	data = struct.unpack_from("<BBH", raw_buf)
-	typ = data[0] & 0x1f
-	ip_flag = (data[0] & 0x80) >> 7
-	vector = data[1]
-	evd_cnt = data[2]
-	s = glb_cfe[typ]
-	if s:
-		print(" cfe: %s IP: %u vector: %u" % (s, ip_flag, vector), end=' ')
-	else:
-		print(" cfe: %u IP: %u vector: %u" % (typ, ip_flag, vector), end=' ')
-	pos = 4
-	for i in range(evd_cnt):
-		data = struct.unpack_from("<QQ", raw_buf)
-		et = data[0] & 0x3f
-		s = glb_evd[et]
-		if s:
-			print("%s: %#x" % (s, data[1]), end=' ')
-		else:
-			print("EVD_%u: %#x" % (et, data[1]), end=' ')
-
-def print_iflag(raw_buf):
-	data = struct.unpack_from("<IQ", raw_buf)
-	iflag = data[0] & 1
-	old_iflag = iflag ^ 1
-	via_branch = data[0] & 2
-	branch_ip = data[1]
-	if via_branch:
-		s = "via"
-	else:
-		s = "non"
-	print("IFLAG: %u->%u %s branch" % (old_iflag, iflag, s), end=' ')
-
-def common_start_str(comm, sample):
-	ts = sample["time"]
-	cpu = sample["cpu"]
-	pid = sample["pid"]
-	tid = sample["tid"]
-	if "machine_pid" in sample:
-		machine_pid = sample["machine_pid"]
-		vcpu = sample["vcpu"]
-		return "VM:%5d VCPU:%03d %16s %5u/%-5u [%03u] %9u.%09u  " % (machine_pid, vcpu, comm, pid, tid, cpu, ts / 1000000000, ts %1000000000)
-	else:
-		return "%16s %5u/%-5u [%03u] %9u.%09u  " % (comm, pid, tid, cpu, ts / 1000000000, ts %1000000000)
-
-def print_common_start(comm, sample, name):
-	flags_disp = get_optional_null(sample, "flags_disp")
-	# Unused fields:
-	# period      = sample["period"]
-	# phys_addr   = sample["phys_addr"]
-	# weight      = sample["weight"]
-	# transaction = sample["transaction"]
-	# cpumode     = get_optional_zero(sample, "cpumode")
-	print(common_start_str(comm, sample) + "%8s  %21s" % (name, flags_disp), end=' ')
-
-def print_instructions_start(comm, sample):
-	if "x" in get_optional_null(sample, "flags"):
-		print(common_start_str(comm, sample) + "x", end=' ')
-	else:
-		print(common_start_str(comm, sample), end='  ')
-
-def disassem(insn, ip):
-	inst = glb_disassembler.Instruction()
-	glb_disassembler.SetMode(inst, 0) # Assume 64-bit
-	buf = create_string_buffer(64)
-	buf.value = insn
-	return glb_disassembler.DisassembleOne(inst, addressof(buf), len(insn), ip)
-
-def print_common_ip(param_dict, sample, symbol, dso):
-	ip   = sample["ip"]
-	offs = get_offset(param_dict, "symoff")
-	if "cyc_cnt" in sample:
-		cyc_cnt = sample["cyc_cnt"]
-		insn_cnt = get_optional_zero(sample, "insn_cnt")
-		ipc_str = "  IPC: %#.2f (%u/%u)" % (insn_cnt / cyc_cnt, insn_cnt, cyc_cnt)
-	else:
-		ipc_str = ""
-	if glb_insn and glb_disassembler is not None:
-		insn = perf_sample_insn(perf_script_context)
-		if insn and len(insn):
-			cnt, text = disassem(insn, ip)
-			byte_str = ("%x" % ip).rjust(16)
-			if sys.version_info.major >= 3:
-				for k in range(cnt):
-					byte_str += " %02x" % insn[k]
-			else:
-				for k in xrange(cnt):
-					byte_str += " %02x" % ord(insn[k])
-			print("%-40s  %-30s" % (byte_str, text), end=' ')
-		print("%s%s (%s)" % (symbol, offs, dso), end=' ')
-	else:
-		print("%16x %s%s (%s)" % (ip, symbol, offs, dso), end=' ')
-	if "addr_correlates_sym" in sample:
-		addr   = sample["addr"]
-		dso    = get_optional(sample, "addr_dso")
-		symbol = get_optional(sample, "addr_symbol")
-		offs   = get_offset(sample, "addr_symoff")
-		print("=> %x %s%s (%s)%s" % (addr, symbol, offs, dso, ipc_str))
-	else:
-		print(ipc_str)
-
-def print_srccode(comm, param_dict, sample, symbol, dso, with_insn):
-	ip = sample["ip"]
-	if symbol == "[unknown]":
-		start_str = common_start_str(comm, sample) + ("%x" % ip).rjust(16).ljust(40)
-	else:
-		offs = get_offset(param_dict, "symoff")
-		start_str = common_start_str(comm, sample) + (symbol + offs).ljust(40)
-
-	if with_insn and glb_insn and glb_disassembler is not None:
-		insn = perf_sample_insn(perf_script_context)
-		if insn and len(insn):
-			cnt, text = disassem(insn, ip)
-		start_str += text.ljust(30)
-
-	global glb_source_file_name
-	global glb_line_number
-	global glb_dso
-
-	source_file_name, line_number, source_line = perf_sample_srccode(perf_script_context)
-	if source_file_name:
-		if glb_line_number == line_number and glb_source_file_name == source_file_name:
-			src_str = ""
-		else:
-			if len(source_file_name) > 40:
-				src_file = ("..." + source_file_name[-37:]) + " "
-			else:
-				src_file = source_file_name.ljust(41)
-			if source_line is None:
-				src_str = src_file + str(line_number).rjust(4) + " <source not found>"
-			else:
-				src_str = src_file + str(line_number).rjust(4) + " " + source_line
-		glb_dso = None
-	elif dso == glb_dso:
-		src_str = ""
-	else:
-		src_str = dso
-		glb_dso = dso
-
-	glb_line_number = line_number
-	glb_source_file_name = source_file_name
-
-	print(start_str, src_str)
-
-def do_process_event(param_dict):
-	sample	   = param_dict["sample"]
-	raw_buf	   = param_dict["raw_buf"]
-	comm	   = param_dict["comm"]
-	name	   = param_dict["ev_name"]
-	# Unused fields:
-	# callchain  = param_dict["callchain"]
-	# brstack    = param_dict["brstack"]
-	# brstacksym = param_dict["brstacksym"]
-	# event_attr = param_dict["attr"]
-
-	# Symbol and dso info are not always resolved
-	dso    = get_optional(param_dict, "dso")
-	symbol = get_optional(param_dict, "symbol")
-
-	cpu = sample["cpu"]
-	if cpu in glb_switch_str:
-		print(glb_switch_str[cpu])
-		del glb_switch_str[cpu]
-
-	if name.startswith("instructions"):
-		if glb_src:
-			print_srccode(comm, param_dict, sample, symbol, dso, True)
-		else:
-			print_instructions_start(comm, sample)
-			print_common_ip(param_dict, sample, symbol, dso)
-	elif name.startswith("branches"):
-		if glb_src:
-			print_srccode(comm, param_dict, sample, symbol, dso, False)
-		else:
-			print_common_start(comm, sample, name)
-			print_common_ip(param_dict, sample, symbol, dso)
-	elif name == "ptwrite":
-		print_common_start(comm, sample, name)
-		print_ptwrite(raw_buf)
-		print_common_ip(param_dict, sample, symbol, dso)
-	elif name == "cbr":
-		print_common_start(comm, sample, name)
-		print_cbr(raw_buf)
-		print_common_ip(param_dict, sample, symbol, dso)
-	elif name == "mwait":
-		print_common_start(comm, sample, name)
-		print_mwait(raw_buf)
-		print_common_ip(param_dict, sample, symbol, dso)
-	elif name == "pwre":
-		print_common_start(comm, sample, name)
-		print_pwre(raw_buf)
-		print_common_ip(param_dict, sample, symbol, dso)
-	elif name == "exstop":
-		print_common_start(comm, sample, name)
-		print_exstop(raw_buf)
-		print_common_ip(param_dict, sample, symbol, dso)
-	elif name == "pwrx":
-		print_common_start(comm, sample, name)
-		print_pwrx(raw_buf)
-		print_common_ip(param_dict, sample, symbol, dso)
-	elif name == "psb":
-		print_common_start(comm, sample, name)
-		print_psb(raw_buf)
-		print_common_ip(param_dict, sample, symbol, dso)
-	elif name == "evt":
-		print_common_start(comm, sample, name)
-		print_evt(raw_buf)
-		print_common_ip(param_dict, sample, symbol, dso)
-	elif name == "iflag":
-		print_common_start(comm, sample, name)
-		print_iflag(raw_buf)
-		print_common_ip(param_dict, sample, symbol, dso)
-	else:
-		print_common_start(comm, sample, name)
-		print_common_ip(param_dict, sample, symbol, dso)
-
-def interleave_events(param_dict):
-	global glb_cpu
-	global glb_time
-	global glb_output
-	global glb_output_pos
-
-	sample  = param_dict["sample"]
-	glb_cpu = sample["cpu"]
-	ts      = sample["time"]
-
-	if glb_time != ts:
-		glb_time = ts
-		flush_stashed_output()
-
-	glb_output_pos = 0
-	with contextlib.redirect_stdout(io.StringIO()) as glb_output:
-		do_process_event(param_dict)
-
-	stash_output()
-
-def process_event(param_dict):
-	try:
-		if glb_args.interleave:
-			interleave_events(param_dict)
-		else:
-			do_process_event(param_dict)
-	except broken_pipe_exception:
-		# Stop python printing broken pipe errors and traceback
-		sys.stdout = open(os.devnull, 'w')
-		sys.exit(1)
-
-def auxtrace_error(typ, code, cpu, pid, tid, ip, ts, msg, cpumode, *x):
-	if glb_args.interleave:
-		flush_stashed_output()
-	if len(x) >= 2 and x[0]:
-		machine_pid = x[0]
-		vcpu = x[1]
-	else:
-		machine_pid = 0
-		vcpu = -1
-	try:
-		if machine_pid:
-			print("VM:%5d VCPU:%03d %16s %5u/%-5u [%03u] %9u.%09u  error type %u code %u: %s ip 0x%16x" %
-				(machine_pid, vcpu, "Trace error", pid, tid, cpu, ts / 1000000000, ts %1000000000, typ, code, msg, ip))
-		else:
-			print("%16s %5u/%-5u [%03u] %9u.%09u  error type %u code %u: %s ip 0x%16x" %
-				("Trace error", pid, tid, cpu, ts / 1000000000, ts %1000000000, typ, code, msg, ip))
-	except broken_pipe_exception:
-		# Stop python printing broken pipe errors and traceback
-		sys.stdout = open(os.devnull, 'w')
-		sys.exit(1)
-
-def context_switch(ts, cpu, pid, tid, np_pid, np_tid, machine_pid, out, out_preempt, *x):
-	if glb_args.interleave:
-		flush_stashed_output()
-	if out:
-		out_str = "Switch out "
-	else:
-		out_str = "Switch In  "
-	if out_preempt:
-		preempt_str = "preempt"
-	else:
-		preempt_str = ""
-	if len(x) >= 2 and x[0]:
-		machine_pid = x[0]
-		vcpu = x[1]
-	else:
-		vcpu = None;
-	if machine_pid == -1:
-		machine_str = ""
-	elif vcpu is None:
-		machine_str = "machine PID %d" % machine_pid
-	else:
-		machine_str = "machine PID %d VCPU %d" % (machine_pid, vcpu)
-	switch_str = "%16s %5d/%-5d [%03u] %9u.%09u %5d/%-5d %s %s" % \
-		(out_str, pid, tid, cpu, ts / 1000000000, ts %1000000000, np_pid, np_tid, machine_str, preempt_str)
-	if glb_args.all_switch_events:
-		print(switch_str)
-	else:
-		global glb_switch_str
-		glb_switch_str[cpu] = switch_str