Loading...
Note: File does not exist in v5.4.
1# SPDX-License-Identifier: GPL-2.0
2# arm-cs-trace-disasm.py: ARM CoreSight Trace Dump With Disassember
3#
4# Author: Tor Jeremiassen <tor@ti.com>
5# Mathieu Poirier <mathieu.poirier@linaro.org>
6# Leo Yan <leo.yan@linaro.org>
7# Al Grant <Al.Grant@arm.com>
8
9from __future__ import print_function
10import os
11from os import path
12import re
13from subprocess import *
14import argparse
15import platform
16
17from perf_trace_context import perf_sample_srccode, perf_config_get
18
19# Below are some example commands for using this script.
20# Note a --kcore recording is required for accurate decode
21# due to the alternatives patching mechanism. However this
22# script only supports reading vmlinux for disassembly dump,
23# meaning that any patched instructions will appear
24# as unpatched, but the instruction ranges themselves will
25# be correct. In addition to this, source line info comes
26# from Perf, and when using kcore there is no debug info. The
27# following lists the supported features in each mode:
28#
29# +-----------+-----------------+------------------+------------------+
30# | Recording | Accurate decode | Source line dump | Disassembly dump |
31# +-----------+-----------------+------------------+------------------+
32# | --kcore | yes | no | yes |
33# | normal | no | yes | yes |
34# +-----------+-----------------+------------------+------------------+
35#
36# Output disassembly with objdump and auto detect vmlinux
37# (when running on same machine.)
38# perf script -s scripts/python/arm-cs-trace-disasm.py -d
39#
40# Output disassembly with llvm-objdump:
41# perf script -s scripts/python/arm-cs-trace-disasm.py \
42# -- -d llvm-objdump-11 -k path/to/vmlinux
43#
44# Output only source line and symbols:
45# perf script -s scripts/python/arm-cs-trace-disasm.py
46
47def default_objdump():
48 config = perf_config_get("annotate.objdump")
49 return config if config else "objdump"
50
51# Command line parsing.
52def int_arg(v):
53 v = int(v)
54 if v < 0:
55 raise argparse.ArgumentTypeError("Argument must be a positive integer")
56 return v
57
58args = argparse.ArgumentParser()
59args.add_argument("-k", "--vmlinux",
60 help="Set path to vmlinux file. Omit to autodetect if running on same machine")
61args.add_argument("-d", "--objdump", nargs="?", const=default_objdump(),
62 help="Show disassembly. Can also be used to change the objdump path"),
63args.add_argument("-v", "--verbose", action="store_true", help="Enable debugging log")
64args.add_argument("--start-time", type=int_arg, help="Monotonic clock time of sample to start from. "
65 "See 'time' field on samples in -v mode.")
66args.add_argument("--stop-time", type=int_arg, help="Monotonic clock time of sample to stop at. "
67 "See 'time' field on samples in -v mode.")
68args.add_argument("--start-sample", type=int_arg, help="Index of sample to start from. "
69 "See 'index' field on samples in -v mode.")
70args.add_argument("--stop-sample", type=int_arg, help="Index of sample to stop at. "
71 "See 'index' field on samples in -v mode.")
72
73options = args.parse_args()
74if (options.start_time and options.stop_time and
75 options.start_time >= options.stop_time):
76 print("--start-time must less than --stop-time")
77 exit(2)
78if (options.start_sample and options.stop_sample and
79 options.start_sample >= options.stop_sample):
80 print("--start-sample must less than --stop-sample")
81 exit(2)
82
83# Initialize global dicts and regular expression
84disasm_cache = dict()
85cpu_data = dict()
86disasm_re = re.compile(r"^\s*([0-9a-fA-F]+):")
87disasm_func_re = re.compile(r"^\s*([0-9a-fA-F]+)\s.*:")
88cache_size = 64*1024
89sample_idx = -1
90
91glb_source_file_name = None
92glb_line_number = None
93glb_dso = None
94
95kver = platform.release()
96vmlinux_paths = [
97 f"/usr/lib/debug/boot/vmlinux-{kver}.debug",
98 f"/usr/lib/debug/lib/modules/{kver}/vmlinux",
99 f"/lib/modules/{kver}/build/vmlinux",
100 f"/usr/lib/debug/boot/vmlinux-{kver}",
101 f"/boot/vmlinux-{kver}",
102 f"/boot/vmlinux",
103 f"vmlinux"
104]
105
106def get_optional(perf_dict, field):
107 if field in perf_dict:
108 return perf_dict[field]
109 return "[unknown]"
110
111def get_offset(perf_dict, field):
112 if field in perf_dict:
113 return "+%#x" % perf_dict[field]
114 return ""
115
116def find_vmlinux():
117 if hasattr(find_vmlinux, "path"):
118 return find_vmlinux.path
119
120 for v in vmlinux_paths:
121 if os.access(v, os.R_OK):
122 find_vmlinux.path = v
123 break
124 else:
125 find_vmlinux.path = None
126
127 return find_vmlinux.path
128
129def get_dso_file_path(dso_name, dso_build_id):
130 if (dso_name == "[kernel.kallsyms]" or dso_name == "vmlinux"):
131 if (options.vmlinux):
132 return options.vmlinux;
133 else:
134 return find_vmlinux() if find_vmlinux() else dso_name
135
136 if (dso_name == "[vdso]") :
137 append = "/vdso"
138 else:
139 append = "/elf"
140
141 dso_path = os.environ['PERF_BUILDID_DIR'] + "/" + dso_name + "/" + dso_build_id + append;
142 # Replace duplicate slash chars to single slash char
143 dso_path = dso_path.replace('//', '/', 1)
144 return dso_path
145
146def read_disam(dso_fname, dso_start, start_addr, stop_addr):
147 addr_range = str(start_addr) + ":" + str(stop_addr) + ":" + dso_fname
148
149 # Don't let the cache get too big, clear it when it hits max size
150 if (len(disasm_cache) > cache_size):
151 disasm_cache.clear();
152
153 if addr_range in disasm_cache:
154 disasm_output = disasm_cache[addr_range];
155 else:
156 start_addr = start_addr - dso_start;
157 stop_addr = stop_addr - dso_start;
158 disasm = [ options.objdump, "-d", "-z",
159 "--start-address="+format(start_addr,"#x"),
160 "--stop-address="+format(stop_addr,"#x") ]
161 disasm += [ dso_fname ]
162 disasm_output = check_output(disasm).decode('utf-8').split('\n')
163 disasm_cache[addr_range] = disasm_output
164
165 return disasm_output
166
167def print_disam(dso_fname, dso_start, start_addr, stop_addr):
168 for line in read_disam(dso_fname, dso_start, start_addr, stop_addr):
169 m = disasm_func_re.search(line)
170 if m is None:
171 m = disasm_re.search(line)
172 if m is None:
173 continue
174 print("\t" + line)
175
176def print_sample(sample):
177 print("Sample = { cpu: %04d addr: 0x%016x phys_addr: 0x%016x ip: 0x%016x " \
178 "pid: %d tid: %d period: %d time: %d index: %d}" % \
179 (sample['cpu'], sample['addr'], sample['phys_addr'], \
180 sample['ip'], sample['pid'], sample['tid'], \
181 sample['period'], sample['time'], sample_idx))
182
183def trace_begin():
184 print('ARM CoreSight Trace Data Assembler Dump')
185
186def trace_end():
187 print('End')
188
189def trace_unhandled(event_name, context, event_fields_dict):
190 print(' '.join(['%s=%s'%(k,str(v))for k,v in sorted(event_fields_dict.items())]))
191
192def common_start_str(comm, sample):
193 sec = int(sample["time"] / 1000000000)
194 ns = sample["time"] % 1000000000
195 cpu = sample["cpu"]
196 pid = sample["pid"]
197 tid = sample["tid"]
198 return "%16s %5u/%-5u [%04u] %9u.%09u " % (comm, pid, tid, cpu, sec, ns)
199
200# This code is copied from intel-pt-events.py for printing source code
201# line and symbols.
202def print_srccode(comm, param_dict, sample, symbol, dso):
203 ip = sample["ip"]
204 if symbol == "[unknown]":
205 start_str = common_start_str(comm, sample) + ("%x" % ip).rjust(16).ljust(40)
206 else:
207 offs = get_offset(param_dict, "symoff")
208 start_str = common_start_str(comm, sample) + (symbol + offs).ljust(40)
209
210 global glb_source_file_name
211 global glb_line_number
212 global glb_dso
213
214 source_file_name, line_number, source_line = perf_sample_srccode(perf_script_context)
215 if source_file_name:
216 if glb_line_number == line_number and glb_source_file_name == source_file_name:
217 src_str = ""
218 else:
219 if len(source_file_name) > 40:
220 src_file = ("..." + source_file_name[-37:]) + " "
221 else:
222 src_file = source_file_name.ljust(41)
223
224 if source_line is None:
225 src_str = src_file + str(line_number).rjust(4) + " <source not found>"
226 else:
227 src_str = src_file + str(line_number).rjust(4) + " " + source_line
228 glb_dso = None
229 elif dso == glb_dso:
230 src_str = ""
231 else:
232 src_str = dso
233 glb_dso = dso
234
235 glb_line_number = line_number
236 glb_source_file_name = source_file_name
237
238 print(start_str, src_str)
239
240def process_event(param_dict):
241 global cache_size
242 global options
243 global sample_idx
244
245 sample = param_dict["sample"]
246 comm = param_dict["comm"]
247
248 name = param_dict["ev_name"]
249 dso = get_optional(param_dict, "dso")
250 dso_bid = get_optional(param_dict, "dso_bid")
251 dso_start = get_optional(param_dict, "dso_map_start")
252 dso_end = get_optional(param_dict, "dso_map_end")
253 symbol = get_optional(param_dict, "symbol")
254 map_pgoff = get_optional(param_dict, "map_pgoff")
255 # check for valid map offset
256 if (str(map_pgoff) == '[unknown]'):
257 map_pgoff = 0
258
259 cpu = sample["cpu"]
260 ip = sample["ip"]
261 addr = sample["addr"]
262
263 sample_idx += 1
264
265 if (options.start_time and sample["time"] < options.start_time):
266 return
267 if (options.stop_time and sample["time"] > options.stop_time):
268 exit(0)
269 if (options.start_sample and sample_idx < options.start_sample):
270 return
271 if (options.stop_sample and sample_idx > options.stop_sample):
272 exit(0)
273
274 if (options.verbose == True):
275 print("Event type: %s" % name)
276 print_sample(sample)
277
278 # Initialize CPU data if it's empty, and directly return back
279 # if this is the first tracing event for this CPU.
280 if (cpu_data.get(str(cpu) + 'addr') == None):
281 cpu_data[str(cpu) + 'addr'] = addr
282 return
283
284 # If cannot find dso so cannot dump assembler, bail out
285 if (dso == '[unknown]'):
286 return
287
288 # Validate dso start and end addresses
289 if ((dso_start == '[unknown]') or (dso_end == '[unknown]')):
290 print("Failed to find valid dso map for dso %s" % dso)
291 return
292
293 if (name[0:12] == "instructions"):
294 print_srccode(comm, param_dict, sample, symbol, dso)
295 return
296
297 # Don't proceed if this event is not a branch sample, .
298 if (name[0:8] != "branches"):
299 return
300
301 # The format for packet is:
302 #
303 # +------------+------------+------------+
304 # sample_prev: | addr | ip | cpu |
305 # +------------+------------+------------+
306 # sample_next: | addr | ip | cpu |
307 # +------------+------------+------------+
308 #
309 # We need to combine the two continuous packets to get the instruction
310 # range for sample_prev::cpu:
311 #
312 # [ sample_prev::addr .. sample_next::ip ]
313 #
314 # For this purose, sample_prev::addr is stored into cpu_data structure
315 # and read back for 'start_addr' when the new packet comes, and we need
316 # to use sample_next::ip to calculate 'stop_addr', plusing extra 4 for
317 # 'stop_addr' is for the sake of objdump so the final assembler dump can
318 # include last instruction for sample_next::ip.
319 start_addr = cpu_data[str(cpu) + 'addr']
320 stop_addr = ip + 4
321
322 # Record for previous sample packet
323 cpu_data[str(cpu) + 'addr'] = addr
324
325 # Filter out zero start_address. Optionally identify CS_ETM_TRACE_ON packet
326 if (start_addr == 0):
327 if ((stop_addr == 4) and (options.verbose == True)):
328 print("CPU%d: CS_ETM_TRACE_ON packet is inserted" % cpu)
329 return
330
331 if (start_addr < int(dso_start) or start_addr > int(dso_end)):
332 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))
333 return
334
335 if (stop_addr < int(dso_start) or stop_addr > int(dso_end)):
336 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))
337 return
338
339 if (options.objdump != None):
340 # It doesn't need to decrease virtual memory offset for disassembly
341 # for kernel dso and executable file dso, so in this case we set
342 # vm_start to zero.
343 if (dso == "[kernel.kallsyms]" or dso_start == 0x400000):
344 dso_vm_start = 0
345 map_pgoff = 0
346 else:
347 dso_vm_start = int(dso_start)
348
349 dso_fname = get_dso_file_path(dso, dso_bid)
350 if path.exists(dso_fname):
351 print_disam(dso_fname, dso_vm_start, start_addr + map_pgoff, stop_addr + map_pgoff)
352 else:
353 print("Failed to find dso %s for address range [ 0x%x .. 0x%x ]" % (dso, start_addr + map_pgoff, stop_addr + map_pgoff))
354
355 print_srccode(comm, param_dict, sample, symbol, dso)