Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356# SPDX-License-Identifier: GPL-2.0# arm-cs-trace-disasm.py: ARM CoreSight Trace Dump With Disassember## Author: Tor Jeremiassen <tor@ti.com># Mathieu Poirier <mathieu.poirier@linaro.org># Leo Yan <leo.yan@linaro.org># Al Grant <Al.Grant@arm.com>
from __future__ import print_functionimport osfrom os import pathimport refrom subprocess import *import argparseimport platform
from perf_trace_context import perf_sample_srccode, perf_config_get
# Below are some example commands for using this script.# Note a --kcore recording is required for accurate decode# due to the alternatives patching mechanism. In addition to this,# source line info comes from Perf, and when using kcore there is# no debug info. The following lists the supported features in each mode:## +-----------+-----------------+------------------+------------------+# | Recording | Accurate decode | Source line dump | Disassembly dump |# +-----------+-----------------+------------------+------------------+# | --kcore | yes | no | yes |# | normal | no | yes (inaccurate) | yes (inaccurate) |# +-----------+-----------------+------------------+------------------+## Output disassembly with objdump and auto detect vmlinux# (when running on same machine.):# perf script -s scripts/python/arm-cs-trace-disasm.py -d## Output disassembly with llvm-objdump:# perf script -s scripts/python/arm-cs-trace-disasm.py \# -- -d llvm-objdump-11 -k path/to/vmlinux## Output accurate disassembly by passing kcore to script:# perf script -s scripts/python/arm-cs-trace-disasm.py \# -- -d -k perf.data/kcore_dir/kcore## Output only source line and symbols:# perf script -s scripts/python/arm-cs-trace-disasm.py
def default_objdump(): config = perf_config_get("annotate.objdump") return config if config else "objdump"
# Command line parsing.def int_arg(v): v = int(v) if v < 0: raise argparse.ArgumentTypeError("Argument must be a positive integer") return v
args = argparse.ArgumentParser()args.add_argument("-k", "--vmlinux", help="Set path to vmlinux or kcore file. Omit to autodetect if running on same machine")args.add_argument("-d", "--objdump", nargs="?", const=default_objdump(), help="Show disassembly. Can also be used to change the objdump path"),args.add_argument("-v", "--verbose", action="store_true", help="Enable debugging log")args.add_argument("--start-time", type=int_arg, help="Monotonic clock time of sample to start from. " "See 'time' field on samples in -v mode.")args.add_argument("--stop-time", type=int_arg, help="Monotonic clock time of sample to stop at. " "See 'time' field on samples in -v mode.")args.add_argument("--start-sample", type=int_arg, help="Index of sample to start from. " "See 'index' field on samples in -v mode.")args.add_argument("--stop-sample", type=int_arg, help="Index of sample to stop at. " "See 'index' field on samples in -v mode.")
options = args.parse_args()if (options.start_time and options.stop_time and options.start_time >= options.stop_time): print("--start-time must less than --stop-time") exit(2)if (options.start_sample and options.stop_sample and options.start_sample >= options.stop_sample): print("--start-sample must less than --stop-sample") exit(2)
# Initialize global dicts and regular expressiondisasm_cache = dict()cpu_data = dict()disasm_re = re.compile(r"^\s*([0-9a-fA-F]+):")disasm_func_re = re.compile(r"^\s*([0-9a-fA-F]+)\s.*:")cache_size = 64*1024sample_idx = -1
glb_source_file_name = Noneglb_line_number = Noneglb_dso = None
kver = platform.release()vmlinux_paths = [ f"/usr/lib/debug/boot/vmlinux-{kver}.debug", f"/usr/lib/debug/lib/modules/{kver}/vmlinux", f"/lib/modules/{kver}/build/vmlinux", f"/usr/lib/debug/boot/vmlinux-{kver}", f"/boot/vmlinux-{kver}", f"/boot/vmlinux", f"vmlinux"]
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 find_vmlinux(): if hasattr(find_vmlinux, "path"): return find_vmlinux.path
for v in vmlinux_paths: if os.access(v, os.R_OK): find_vmlinux.path = v break else: find_vmlinux.path = None
return find_vmlinux.path
def get_dso_file_path(dso_name, dso_build_id): if (dso_name == "[kernel.kallsyms]" or dso_name == "vmlinux"): if (options.vmlinux): return options.vmlinux; else: return find_vmlinux() if find_vmlinux() else dso_name
if (dso_name == "[vdso]") : append = "/vdso" else: append = "/elf"
dso_path = os.environ['PERF_BUILDID_DIR'] + "/" + dso_name + "/" + dso_build_id + append; # Replace duplicate slash chars to single slash char dso_path = dso_path.replace('//', '/', 1) return dso_path
def read_disam(dso_fname, dso_start, start_addr, stop_addr): addr_range = str(start_addr) + ":" + str(stop_addr) + ":" + dso_fname
# Don't let the cache get too big, clear it when it hits max size if (len(disasm_cache) > cache_size): disasm_cache.clear();
if addr_range in disasm_cache: disasm_output = disasm_cache[addr_range]; else: start_addr = start_addr - dso_start; stop_addr = stop_addr - dso_start; disasm = [ options.objdump, "-d", "-z", "--start-address="+format(start_addr,"#x"), "--stop-address="+format(stop_addr,"#x") ] disasm += [ dso_fname ] disasm_output = check_output(disasm).decode('utf-8').split('\n') disasm_cache[addr_range] = disasm_output
return disasm_output
def print_disam(dso_fname, dso_start, start_addr, stop_addr): for line in read_disam(dso_fname, dso_start, start_addr, stop_addr): m = disasm_func_re.search(line) if m is None: m = disasm_re.search(line) if m is None: continue print("\t" + line)
def print_sample(sample): print("Sample = { cpu: %04d addr: 0x%016x phys_addr: 0x%016x ip: 0x%016x " \ "pid: %d tid: %d period: %d time: %d index: %d}" % \ (sample['cpu'], sample['addr'], sample['phys_addr'], \ sample['ip'], sample['pid'], sample['tid'], \ sample['period'], sample['time'], sample_idx))
def trace_begin(): print('ARM CoreSight Trace Data Assembler Dump')
def trace_end(): 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 common_start_str(comm, sample): sec = int(sample["time"] / 1000000000) ns = sample["time"] % 1000000000 cpu = sample["cpu"] pid = sample["pid"] tid = sample["tid"] return "%16s %5u/%-5u [%04u] %9u.%09u " % (comm, pid, tid, cpu, sec, ns)
# This code is copied from intel-pt-events.py for printing source code# line and symbols.def print_srccode(comm, param_dict, sample, symbol, dso): 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)
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 process_event(param_dict): global cache_size global options global sample_idx
sample = param_dict["sample"] comm = param_dict["comm"]
name = param_dict["ev_name"] dso = get_optional(param_dict, "dso") dso_bid = get_optional(param_dict, "dso_bid") dso_start = get_optional(param_dict, "dso_map_start") dso_end = get_optional(param_dict, "dso_map_end") symbol = get_optional(param_dict, "symbol") map_pgoff = get_optional(param_dict, "map_pgoff") # check for valid map offset if (str(map_pgoff) == '[unknown]'): map_pgoff = 0
cpu = sample["cpu"] ip = sample["ip"] addr = sample["addr"]
sample_idx += 1
if (options.start_time and sample["time"] < options.start_time): return if (options.stop_time and sample["time"] > options.stop_time): exit(0) if (options.start_sample and sample_idx < options.start_sample): return if (options.stop_sample and sample_idx > options.stop_sample): exit(0)
if (options.verbose == True): print("Event type: %s" % name) print_sample(sample)
# Initialize CPU data if it's empty, and directly return back # if this is the first tracing event for this CPU. if (cpu_data.get(str(cpu) + 'addr') == None): cpu_data[str(cpu) + 'addr'] = addr return
# If cannot find dso so cannot dump assembler, bail out if (dso == '[unknown]'): return
# Validate dso start and end addresses if ((dso_start == '[unknown]') or (dso_end == '[unknown]')): print("Failed to find valid dso map for dso %s" % dso) return
if (name[0:12] == "instructions"): print_srccode(comm, param_dict, sample, symbol, dso) return
# Don't proceed if this event is not a branch sample, . if (name[0:8] != "branches"): return
# The format for packet is: # # +------------+------------+------------+ # sample_prev: | addr | ip | cpu | # +------------+------------+------------+ # sample_next: | addr | ip | cpu | # +------------+------------+------------+ # # We need to combine the two continuous packets to get the instruction # range for sample_prev::cpu: # # [ sample_prev::addr .. sample_next::ip ] # # For this purose, sample_prev::addr is stored into cpu_data structure # and read back for 'start_addr' when the new packet comes, and we need # to use sample_next::ip to calculate 'stop_addr', plusing extra 4 for # 'stop_addr' is for the sake of objdump so the final assembler dump can # include last instruction for sample_next::ip. start_addr = cpu_data[str(cpu) + 'addr'] stop_addr = ip + 4
# Record for previous sample packet cpu_data[str(cpu) + 'addr'] = addr
# Filter out zero start_address. Optionally identify CS_ETM_TRACE_ON packet if (start_addr == 0): if ((stop_addr == 4) and (options.verbose == True)): print("CPU%d: CS_ETM_TRACE_ON packet is inserted" % cpu) return
if (start_addr < int(dso_start) or start_addr > int(dso_end)): print("Start address 0x%x is out of range [ 0x%x .. 0x%x ] for dso %s" % (start_addr, int(dso_start), int(dso_end), dso)) return
if (stop_addr < int(dso_start) or stop_addr > int(dso_end)): print("Stop address 0x%x is out of range [ 0x%x .. 0x%x ] for dso %s" % (stop_addr, int(dso_start), int(dso_end), dso)) return
if (options.objdump != None): # It doesn't need to decrease virtual memory offset for disassembly # for kernel dso and executable file dso, so in this case we set # vm_start to zero. if (dso == "[kernel.kallsyms]" or dso_start == 0x400000): dso_vm_start = 0 map_pgoff = 0 else: dso_vm_start = int(dso_start)
dso_fname = get_dso_file_path(dso, dso_bid) if path.exists(dso_fname): print_disam(dso_fname, dso_vm_start, start_addr + map_pgoff, stop_addr + map_pgoff) else: print("Failed to find dso %s for address range [ 0x%x .. 0x%x ]" % (dso, start_addr + map_pgoff, stop_addr + map_pgoff))
print_srccode(comm, param_dict, sample, symbol, dso)