tools/perf/scripts/python/arm-cs-trace-disasm.py

   1 # SPDX-License-Identifier: GPL-2.0
   2 # arm-cs-trace-disasm.py: ARM CoreSight Trace Dump With Disassember
   3 #
   4 # Author: Tor Jeremiassen <[email protected]>
   5 #         Mathieu Poirier <[email protected]>
   6 #         Leo Yan <[email protected]>
   7 #         Al Grant <[email protected]>
   8
   9 from __future__ import print_function
  10 import os
  11 from os import path
  12 import re
  13 from subprocess import *
  14 from optparse import OptionParser, make_option
  15
  16 from perf_trace_context import perf_set_itrace_options, \
  17         perf_sample_insn, perf_sample_srccode
  18
  19 # Below are some example commands for using this script.
  20 #
  21 # Output disassembly with objdump:
  22 #  perf script -s scripts/python/arm-cs-trace-disasm.py \
  23 #               -- -d objdump -k path/to/vmlinux
  24 # Output disassembly with llvm-objdump:
  25 #  perf script -s scripts/python/arm-cs-trace-disasm.py \
  26 #               -- -d llvm-objdump-11 -k path/to/vmlinux
  27 # Output only source line and symbols:
  28 #  perf script -s scripts/python/arm-cs-trace-disasm.py
  29
  30 # Command line parsing.
  31 option_list = [
  32         # formatting options for the bottom entry of the stack
  33         make_option("-k", "--vmlinux", dest="vmlinux_name",
  34                     help="Set path to vmlinux file"),
  35         make_option("-d", "--objdump", dest="objdump_name",
  36                     help="Set path to objdump executable file"),
  37         make_option("-v", "--verbose", dest="verbose",
  38                     action="store_true", default=False,
  39                     help="Enable debugging log")
  40 ]
  41
  42 parser = OptionParser(option_list=option_list)
  43 (options, args) = parser.parse_args()
  44
  45 # Initialize global dicts and regular expression
  46 disasm_cache = dict()
  47 cpu_data = dict()
  48 disasm_re = re.compile(r"^\s*([0-9a-fA-F]+):")
  49 disasm_func_re = re.compile(r"^\s*([0-9a-fA-F]+)\s.*:")
  50 cache_size = 64*1024
  51
  52 glb_source_file_name    = None
  53 glb_line_number         = None
  54 glb_dso                 = None
  55
  56 def get_optional(perf_dict, field):
  57        if field in perf_dict:
  58                return perf_dict[field]
  59        return "[unknown]"
  60
  61 def get_offset(perf_dict, field):
  62         if field in perf_dict:
  63                 return "+%#x" % perf_dict[field]
  64         return ""
  65
  66 def get_dso_file_path(dso_name, dso_build_id):
  67         if (dso_name == "[kernel.kallsyms]" or dso_name == "vmlinux"):
  68                 if (options.vmlinux_name):
  69                         return options.vmlinux_name;
  70                 else:
  71                         return dso_name
  72
  73         if (dso_name == "[vdso]") :
  74                 append = "/vdso"
  75         else:
  76                 append = "/elf"
  77
  78         dso_path = os.environ['PERF_BUILDID_DIR'] + "/" + dso_name + "/" + dso_build_id + append;
  79         # Replace duplicate slash chars to single slash char
  80         dso_path = dso_path.replace('//', '/', 1)
  81         return dso_path
  82
  83 def read_disam(dso_fname, dso_start, start_addr, stop_addr):
  84         addr_range = str(start_addr) + ":" + str(stop_addr) + ":" + dso_fname
  85
  86         # Don't let the cache get too big, clear it when it hits max size
  87         if (len(disasm_cache) > cache_size):
  88                 disasm_cache.clear();
  89
  90         if addr_range in disasm_cache:
  91                 disasm_output = disasm_cache[addr_range];
  92         else:
  93                 start_addr = start_addr - dso_start;
  94                 stop_addr = stop_addr - dso_start;
  95                 disasm = [ options.objdump_name, "-d", "-z",
  96                            "--start-address="+format(start_addr,"#x"),
  97                            "--stop-address="+format(stop_addr,"#x") ]
  98                 disasm += [ dso_fname ]
  99                 disasm_output = check_output(disasm).decode('utf-8').split('\n')
 100                 disasm_cache[addr_range] = disasm_output
 101
 102         return disasm_output
 103
 104 def print_disam(dso_fname, dso_start, start_addr, stop_addr):
 105         for line in read_disam(dso_fname, dso_start, start_addr, stop_addr):
 106                 m = disasm_func_re.search(line)
 107                 if m is None:
 108                         m = disasm_re.search(line)
 109                         if m is None:
 110                                 continue
 111                 print("\t" + line)
 112
 113 def print_sample(sample):
 114         print("Sample = { cpu: %04d addr: 0x%016x phys_addr: 0x%016x ip: 0x%016x " \
 115               "pid: %d tid: %d period: %d time: %d }" % \
 116               (sample['cpu'], sample['addr'], sample['phys_addr'], \
 117                sample['ip'], sample['pid'], sample['tid'], \
 118                sample['period'], sample['time']))
 119
 120 def trace_begin():
 121         print('ARM CoreSight Trace Data Assembler Dump')
 122
 123 def trace_end():
 124         print('End')
 125
 126 def trace_unhandled(event_name, context, event_fields_dict):
 127         print(' '.join(['%s=%s'%(k,str(v))for k,v in sorted(event_fields_dict.items())]))
 128
 129 def common_start_str(comm, sample):
 130         sec = int(sample["time"] / 1000000000)
 131         ns = sample["time"] % 1000000000
 132         cpu = sample["cpu"]
 133         pid = sample["pid"]
 134         tid = sample["tid"]
 135         return "%16s %5u/%-5u [%04u] %9u.%09u  " % (comm, pid, tid, cpu, sec, ns)
 136
 137 # This code is copied from intel-pt-events.py for printing source code
 138 # line and symbols.
 139 def print_srccode(comm, param_dict, sample, symbol, dso):
 140         ip = sample["ip"]
 141         if symbol == "[unknown]":
 142                 start_str = common_start_str(comm, sample) + ("%x" % ip).rjust(16).ljust(40)
 143         else:
 144                 offs = get_offset(param_dict, "symoff")
 145                 start_str = common_start_str(comm, sample) + (symbol + offs).ljust(40)
 146
 147         global glb_source_file_name
 148         global glb_line_number
 149         global glb_dso
 150
 151         source_file_name, line_number, source_line = perf_sample_srccode(perf_script_context)
 152         if source_file_name:
 153                 if glb_line_number == line_number and glb_source_file_name == source_file_name:
 154                         src_str = ""
 155                 else:
 156                         if len(source_file_name) > 40:
 157                                 src_file = ("..." + source_file_name[-37:]) + " "
 158                         else:
 159                                 src_file = source_file_name.ljust(41)
 160
 161                         if source_line is None:
 162                                 src_str = src_file + str(line_number).rjust(4) + " <source not found>"
 163                         else:
 164                                 src_str = src_file + str(line_number).rjust(4) + " " + source_line
 165                 glb_dso = None
 166         elif dso == glb_dso:
 167                 src_str = ""
 168         else:
 169                 src_str = dso
 170                 glb_dso = dso
 171
 172         glb_line_number = line_number
 173         glb_source_file_name = source_file_name
 174
 175         print(start_str, src_str)
 176
 177 def process_event(param_dict):
 178         global cache_size
 179         global options
 180
 181         sample = param_dict["sample"]
 182         comm = param_dict["comm"]
 183
 184         name = param_dict["ev_name"]
 185         dso = get_optional(param_dict, "dso")
 186         dso_bid = get_optional(param_dict, "dso_bid")
 187         dso_start = get_optional(param_dict, "dso_map_start")
 188         dso_end = get_optional(param_dict, "dso_map_end")
 189         symbol = get_optional(param_dict, "symbol")
 190
 191         cpu = sample["cpu"]
 192         ip = sample["ip"]
 193         addr = sample["addr"]
 194
 195         # Initialize CPU data if it's empty, and directly return back
 196         # if this is the first tracing event for this CPU.
 197         if (cpu_data.get(str(cpu) + 'addr') == None):
 198                 cpu_data[str(cpu) + 'addr'] = addr
 199                 return
 200
 201
 202         if (options.verbose == True):
 203                 print("Event type: %s" % name)
 204                 print_sample(sample)
 205
 206         # If cannot find dso so cannot dump assembler, bail out
 207         if (dso == '[unknown]'):
 208                 return
 209
 210         # Validate dso start and end addresses
 211         if ((dso_start == '[unknown]') or (dso_end == '[unknown]')):
 212                 print("Failed to find valid dso map for dso %s" % dso)
 213                 return
 214
 215         if (name[0:12] == "instructions"):
 216                 print_srccode(comm, param_dict, sample, symbol, dso)
 217                 return
 218
 219         # Don't proceed if this event is not a branch sample, .
 220         if (name[0:8] != "branches"):
 221                 return
 222
 223         # The format for packet is:
 224         #
 225         #                 +------------+------------+------------+
 226         #  sample_prev:   |    addr    |    ip      |    cpu     |
 227         #                 +------------+------------+------------+
 228         #  sample_next:   |    addr    |    ip      |    cpu     |
 229         #                 +------------+------------+------------+
 230         #
 231         # We need to combine the two continuous packets to get the instruction
 232         # range for sample_prev::cpu:
 233         #
 234         #     [ sample_prev::addr .. sample_next::ip ]
 235         #
 236         # For this purose, sample_prev::addr is stored into cpu_data structure
 237         # and read back for 'start_addr' when the new packet comes, and we need
 238         # to use sample_next::ip to calculate 'stop_addr', plusing extra 4 for
 239         # 'stop_addr' is for the sake of objdump so the final assembler dump can
 240         # include last instruction for sample_next::ip.
 241         start_addr = cpu_data[str(cpu) + 'addr']
 242         stop_addr  = ip + 4
 243
 244         # Record for previous sample packet
 245         cpu_data[str(cpu) + 'addr'] = addr
 246
 247         # Handle CS_ETM_TRACE_ON packet if start_addr=0 and stop_addr=4
 248         if (start_addr == 0 and stop_addr == 4):
 249                 print("CPU%d: CS_ETM_TRACE_ON packet is inserted" % cpu)
 250                 return
 251
 252         if (start_addr < int(dso_start) or start_addr > int(dso_end)):
 253                 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))
 254                 return
 255
 256         if (stop_addr < int(dso_start) or stop_addr > int(dso_end)):
 257                 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))
 258                 return
 259
 260         if (options.objdump_name != None):
 261                 # It doesn't need to decrease virtual memory offset for disassembly
 262                 # for kernel dso and executable file dso, so in this case we set
 263                 # vm_start to zero.
 264                 if (dso == "[kernel.kallsyms]" or dso_start == 0x400000):
 265                         dso_vm_start = 0
 266                 else:
 267                         dso_vm_start = int(dso_start)
 268
 269                 dso_fname = get_dso_file_path(dso, dso_bid)
 270                 if path.exists(dso_fname):
 271                         print_disam(dso_fname, dso_vm_start, start_addr, stop_addr)
 272                 else:
 273                         print("Failed to find dso %s for address range [ 0x%x .. 0x%x ]" % (dso, start_addr, stop_addr))
 274
 275         print_srccode(comm, param_dict, sample, symbol, dso)