Loading...
1# intel-pt-events.py: Print Intel PT Power Events and PTWRITE
2# Copyright (c) 2017, Intel Corporation.
3#
4# This program is free software; you can redistribute it and/or modify it
5# under the terms and conditions of the GNU General Public License,
6# version 2, as published by the Free Software Foundation.
7#
8# This program is distributed in the hope it will be useful, but WITHOUT
9# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11# more details.
12
13from __future__ import print_function
14
15import os
16import sys
17import struct
18
19sys.path.append(os.environ['PERF_EXEC_PATH'] + \
20 '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
21
22# These perf imports are not used at present
23#from perf_trace_context import *
24#from Core import *
25
26def trace_begin():
27 print("Intel PT Power Events and PTWRITE")
28
29def trace_end():
30 print("End")
31
32def trace_unhandled(event_name, context, event_fields_dict):
33 print(' '.join(['%s=%s'%(k,str(v))for k,v in sorted(event_fields_dict.items())]))
34
35def print_ptwrite(raw_buf):
36 data = struct.unpack_from("<IQ", raw_buf)
37 flags = data[0]
38 payload = data[1]
39 exact_ip = flags & 1
40 print("IP: %u payload: %#x" % (exact_ip, payload), end=' ')
41
42def print_cbr(raw_buf):
43 data = struct.unpack_from("<BBBBII", raw_buf)
44 cbr = data[0]
45 f = (data[4] + 500) / 1000
46 p = ((cbr * 1000 / data[2]) + 5) / 10
47 print("%3u freq: %4u MHz (%3u%%)" % (cbr, f, p), end=' ')
48
49def print_mwait(raw_buf):
50 data = struct.unpack_from("<IQ", raw_buf)
51 payload = data[1]
52 hints = payload & 0xff
53 extensions = (payload >> 32) & 0x3
54 print("hints: %#x extensions: %#x" % (hints, extensions), end=' ')
55
56def print_pwre(raw_buf):
57 data = struct.unpack_from("<IQ", raw_buf)
58 payload = data[1]
59 hw = (payload >> 7) & 1
60 cstate = (payload >> 12) & 0xf
61 subcstate = (payload >> 8) & 0xf
62 print("hw: %u cstate: %u sub-cstate: %u" % (hw, cstate, subcstate),
63 end=' ')
64
65def print_exstop(raw_buf):
66 data = struct.unpack_from("<I", raw_buf)
67 flags = data[0]
68 exact_ip = flags & 1
69 print("IP: %u" % (exact_ip), end=' ')
70
71def print_pwrx(raw_buf):
72 data = struct.unpack_from("<IQ", raw_buf)
73 payload = data[1]
74 deepest_cstate = payload & 0xf
75 last_cstate = (payload >> 4) & 0xf
76 wake_reason = (payload >> 8) & 0xf
77 print("deepest cstate: %u last cstate: %u wake reason: %#x" %
78 (deepest_cstate, last_cstate, wake_reason), end=' ')
79
80def print_common_start(comm, sample, name):
81 ts = sample["time"]
82 cpu = sample["cpu"]
83 pid = sample["pid"]
84 tid = sample["tid"]
85 print("%16s %5u/%-5u [%03u] %9u.%09u %7s:" %
86 (comm, pid, tid, cpu, ts / 1000000000, ts %1000000000, name),
87 end=' ')
88
89def print_common_ip(sample, symbol, dso):
90 ip = sample["ip"]
91 print("%16x %s (%s)" % (ip, symbol, dso))
92
93def process_event(param_dict):
94 event_attr = param_dict["attr"]
95 sample = param_dict["sample"]
96 raw_buf = param_dict["raw_buf"]
97 comm = param_dict["comm"]
98 name = param_dict["ev_name"]
99
100 # Symbol and dso info are not always resolved
101 if "dso" in param_dict:
102 dso = param_dict["dso"]
103 else:
104 dso = "[unknown]"
105
106 if "symbol" in param_dict:
107 symbol = param_dict["symbol"]
108 else:
109 symbol = "[unknown]"
110
111 if name == "ptwrite":
112 print_common_start(comm, sample, name)
113 print_ptwrite(raw_buf)
114 print_common_ip(sample, symbol, dso)
115 elif name == "cbr":
116 print_common_start(comm, sample, name)
117 print_cbr(raw_buf)
118 print_common_ip(sample, symbol, dso)
119 elif name == "mwait":
120 print_common_start(comm, sample, name)
121 print_mwait(raw_buf)
122 print_common_ip(sample, symbol, dso)
123 elif name == "pwre":
124 print_common_start(comm, sample, name)
125 print_pwre(raw_buf)
126 print_common_ip(sample, symbol, dso)
127 elif name == "exstop":
128 print_common_start(comm, sample, name)
129 print_exstop(raw_buf)
130 print_common_ip(sample, symbol, dso)
131 elif name == "pwrx":
132 print_common_start(comm, sample, name)
133 print_pwrx(raw_buf)
134 print_common_ip(sample, symbol, dso)
1# SPDX-License-Identifier: GPL-2.0
2# intel-pt-events.py: Print Intel PT Events including Power Events and PTWRITE
3# Copyright (c) 2017-2021, Intel Corporation.
4#
5# This program is free software; you can redistribute it and/or modify it
6# under the terms and conditions of the GNU General Public License,
7# version 2, as published by the Free Software Foundation.
8#
9# This program is distributed in the hope it will be useful, but WITHOUT
10# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12# more details.
13
14from __future__ import print_function
15
16import os
17import sys
18import struct
19import argparse
20
21from libxed import LibXED
22from ctypes import create_string_buffer, addressof
23
24sys.path.append(os.environ['PERF_EXEC_PATH'] + \
25 '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
26
27from perf_trace_context import perf_set_itrace_options, \
28 perf_sample_insn, perf_sample_srccode
29
30try:
31 broken_pipe_exception = BrokenPipeError
32except:
33 broken_pipe_exception = IOError
34
35glb_switch_str = None
36glb_switch_printed = True
37glb_insn = False
38glb_disassembler = None
39glb_src = False
40glb_source_file_name = None
41glb_line_number = None
42glb_dso = None
43
44def get_optional_null(perf_dict, field):
45 if field in perf_dict:
46 return perf_dict[field]
47 return ""
48
49def get_optional_zero(perf_dict, field):
50 if field in perf_dict:
51 return perf_dict[field]
52 return 0
53
54def get_optional_bytes(perf_dict, field):
55 if field in perf_dict:
56 return perf_dict[field]
57 return bytes()
58
59def get_optional(perf_dict, field):
60 if field in perf_dict:
61 return perf_dict[field]
62 return "[unknown]"
63
64def get_offset(perf_dict, field):
65 if field in perf_dict:
66 return "+%#x" % perf_dict[field]
67 return ""
68
69def trace_begin():
70 ap = argparse.ArgumentParser(usage = "", add_help = False)
71 ap.add_argument("--insn-trace", action='store_true')
72 ap.add_argument("--src-trace", action='store_true')
73 global glb_args
74 global glb_insn
75 global glb_src
76 glb_args = ap.parse_args()
77 if glb_args.insn_trace:
78 print("Intel PT Instruction Trace")
79 itrace = "i0nsepwx"
80 glb_insn = True
81 elif glb_args.src_trace:
82 print("Intel PT Source Trace")
83 itrace = "i0nsepwx"
84 glb_insn = True
85 glb_src = True
86 else:
87 print("Intel PT Branch Trace, Power Events and PTWRITE")
88 itrace = "bepwx"
89 global glb_disassembler
90 try:
91 glb_disassembler = LibXED()
92 except:
93 glb_disassembler = None
94 perf_set_itrace_options(perf_script_context, itrace)
95
96def trace_end():
97 print("End")
98
99def trace_unhandled(event_name, context, event_fields_dict):
100 print(' '.join(['%s=%s'%(k,str(v))for k,v in sorted(event_fields_dict.items())]))
101
102def print_ptwrite(raw_buf):
103 data = struct.unpack_from("<IQ", raw_buf)
104 flags = data[0]
105 payload = data[1]
106 exact_ip = flags & 1
107 print("IP: %u payload: %#x" % (exact_ip, payload), end=' ')
108
109def print_cbr(raw_buf):
110 data = struct.unpack_from("<BBBBII", raw_buf)
111 cbr = data[0]
112 f = (data[4] + 500) / 1000
113 p = ((cbr * 1000 / data[2]) + 5) / 10
114 print("%3u freq: %4u MHz (%3u%%)" % (cbr, f, p), end=' ')
115
116def print_mwait(raw_buf):
117 data = struct.unpack_from("<IQ", raw_buf)
118 payload = data[1]
119 hints = payload & 0xff
120 extensions = (payload >> 32) & 0x3
121 print("hints: %#x extensions: %#x" % (hints, extensions), end=' ')
122
123def print_pwre(raw_buf):
124 data = struct.unpack_from("<IQ", raw_buf)
125 payload = data[1]
126 hw = (payload >> 7) & 1
127 cstate = (payload >> 12) & 0xf
128 subcstate = (payload >> 8) & 0xf
129 print("hw: %u cstate: %u sub-cstate: %u" % (hw, cstate, subcstate),
130 end=' ')
131
132def print_exstop(raw_buf):
133 data = struct.unpack_from("<I", raw_buf)
134 flags = data[0]
135 exact_ip = flags & 1
136 print("IP: %u" % (exact_ip), end=' ')
137
138def print_pwrx(raw_buf):
139 data = struct.unpack_from("<IQ", raw_buf)
140 payload = data[1]
141 deepest_cstate = payload & 0xf
142 last_cstate = (payload >> 4) & 0xf
143 wake_reason = (payload >> 8) & 0xf
144 print("deepest cstate: %u last cstate: %u wake reason: %#x" %
145 (deepest_cstate, last_cstate, wake_reason), end=' ')
146
147def print_psb(raw_buf):
148 data = struct.unpack_from("<IQ", raw_buf)
149 offset = data[1]
150 print("offset: %#x" % (offset), end=' ')
151
152def common_start_str(comm, sample):
153 ts = sample["time"]
154 cpu = sample["cpu"]
155 pid = sample["pid"]
156 tid = sample["tid"]
157 return "%16s %5u/%-5u [%03u] %9u.%09u " % (comm, pid, tid, cpu, ts / 1000000000, ts %1000000000)
158
159def print_common_start(comm, sample, name):
160 flags_disp = get_optional_null(sample, "flags_disp")
161 # Unused fields:
162 # period = sample["period"]
163 # phys_addr = sample["phys_addr"]
164 # weight = sample["weight"]
165 # transaction = sample["transaction"]
166 # cpumode = get_optional_zero(sample, "cpumode")
167 print(common_start_str(comm, sample) + "%7s %19s" % (name, flags_disp), end=' ')
168
169def print_instructions_start(comm, sample):
170 if "x" in get_optional_null(sample, "flags"):
171 print(common_start_str(comm, sample) + "x", end=' ')
172 else:
173 print(common_start_str(comm, sample), end=' ')
174
175def disassem(insn, ip):
176 inst = glb_disassembler.Instruction()
177 glb_disassembler.SetMode(inst, 0) # Assume 64-bit
178 buf = create_string_buffer(64)
179 buf.value = insn
180 return glb_disassembler.DisassembleOne(inst, addressof(buf), len(insn), ip)
181
182def print_common_ip(param_dict, sample, symbol, dso):
183 ip = sample["ip"]
184 offs = get_offset(param_dict, "symoff")
185 if "cyc_cnt" in sample:
186 cyc_cnt = sample["cyc_cnt"]
187 insn_cnt = get_optional_zero(sample, "insn_cnt")
188 ipc_str = " IPC: %#.2f (%u/%u)" % (insn_cnt / cyc_cnt, insn_cnt, cyc_cnt)
189 else:
190 ipc_str = ""
191 if glb_insn and glb_disassembler is not None:
192 insn = perf_sample_insn(perf_script_context)
193 if insn and len(insn):
194 cnt, text = disassem(insn, ip)
195 byte_str = ("%x" % ip).rjust(16)
196 if sys.version_info.major >= 3:
197 for k in range(cnt):
198 byte_str += " %02x" % insn[k]
199 else:
200 for k in xrange(cnt):
201 byte_str += " %02x" % ord(insn[k])
202 print("%-40s %-30s" % (byte_str, text), end=' ')
203 print("%s%s (%s)" % (symbol, offs, dso), end=' ')
204 else:
205 print("%16x %s%s (%s)" % (ip, symbol, offs, dso), end=' ')
206 if "addr_correlates_sym" in sample:
207 addr = sample["addr"]
208 dso = get_optional(sample, "addr_dso")
209 symbol = get_optional(sample, "addr_symbol")
210 offs = get_offset(sample, "addr_symoff")
211 print("=> %x %s%s (%s)%s" % (addr, symbol, offs, dso, ipc_str))
212 else:
213 print(ipc_str)
214
215def print_srccode(comm, param_dict, sample, symbol, dso, with_insn):
216 ip = sample["ip"]
217 if symbol == "[unknown]":
218 start_str = common_start_str(comm, sample) + ("%x" % ip).rjust(16).ljust(40)
219 else:
220 offs = get_offset(param_dict, "symoff")
221 start_str = common_start_str(comm, sample) + (symbol + offs).ljust(40)
222
223 if with_insn and glb_insn and glb_disassembler is not None:
224 insn = perf_sample_insn(perf_script_context)
225 if insn and len(insn):
226 cnt, text = disassem(insn, ip)
227 start_str += text.ljust(30)
228
229 global glb_source_file_name
230 global glb_line_number
231 global glb_dso
232
233 source_file_name, line_number, source_line = perf_sample_srccode(perf_script_context)
234 if source_file_name:
235 if glb_line_number == line_number and glb_source_file_name == source_file_name:
236 src_str = ""
237 else:
238 if len(source_file_name) > 40:
239 src_file = ("..." + source_file_name[-37:]) + " "
240 else:
241 src_file = source_file_name.ljust(41)
242 if source_line is None:
243 src_str = src_file + str(line_number).rjust(4) + " <source not found>"
244 else:
245 src_str = src_file + str(line_number).rjust(4) + " " + source_line
246 glb_dso = None
247 elif dso == glb_dso:
248 src_str = ""
249 else:
250 src_str = dso
251 glb_dso = dso
252
253 glb_line_number = line_number
254 glb_source_file_name = source_file_name
255
256 print(start_str, src_str)
257
258def do_process_event(param_dict):
259 global glb_switch_printed
260 if not glb_switch_printed:
261 print(glb_switch_str)
262 glb_switch_printed = True
263 event_attr = param_dict["attr"]
264 sample = param_dict["sample"]
265 raw_buf = param_dict["raw_buf"]
266 comm = param_dict["comm"]
267 name = param_dict["ev_name"]
268 # Unused fields:
269 # callchain = param_dict["callchain"]
270 # brstack = param_dict["brstack"]
271 # brstacksym = param_dict["brstacksym"]
272
273 # Symbol and dso info are not always resolved
274 dso = get_optional(param_dict, "dso")
275 symbol = get_optional(param_dict, "symbol")
276
277 if name[0:12] == "instructions":
278 if glb_src:
279 print_srccode(comm, param_dict, sample, symbol, dso, True)
280 else:
281 print_instructions_start(comm, sample)
282 print_common_ip(param_dict, sample, symbol, dso)
283 elif name[0:8] == "branches":
284 if glb_src:
285 print_srccode(comm, param_dict, sample, symbol, dso, False)
286 else:
287 print_common_start(comm, sample, name)
288 print_common_ip(param_dict, sample, symbol, dso)
289 elif name == "ptwrite":
290 print_common_start(comm, sample, name)
291 print_ptwrite(raw_buf)
292 print_common_ip(param_dict, sample, symbol, dso)
293 elif name == "cbr":
294 print_common_start(comm, sample, name)
295 print_cbr(raw_buf)
296 print_common_ip(param_dict, sample, symbol, dso)
297 elif name == "mwait":
298 print_common_start(comm, sample, name)
299 print_mwait(raw_buf)
300 print_common_ip(param_dict, sample, symbol, dso)
301 elif name == "pwre":
302 print_common_start(comm, sample, name)
303 print_pwre(raw_buf)
304 print_common_ip(param_dict, sample, symbol, dso)
305 elif name == "exstop":
306 print_common_start(comm, sample, name)
307 print_exstop(raw_buf)
308 print_common_ip(param_dict, sample, symbol, dso)
309 elif name == "pwrx":
310 print_common_start(comm, sample, name)
311 print_pwrx(raw_buf)
312 print_common_ip(param_dict, sample, symbol, dso)
313 elif name == "psb":
314 print_common_start(comm, sample, name)
315 print_psb(raw_buf)
316 print_common_ip(param_dict, sample, symbol, dso)
317 else:
318 print_common_start(comm, sample, name)
319 print_common_ip(param_dict, sample, symbol, dso)
320
321def process_event(param_dict):
322 try:
323 do_process_event(param_dict)
324 except broken_pipe_exception:
325 # Stop python printing broken pipe errors and traceback
326 sys.stdout = open(os.devnull, 'w')
327 sys.exit(1)
328
329def auxtrace_error(typ, code, cpu, pid, tid, ip, ts, msg, cpumode, *x):
330 try:
331 print("%16s %5u/%-5u [%03u] %9u.%09u error type %u code %u: %s ip 0x%16x" %
332 ("Trace error", pid, tid, cpu, ts / 1000000000, ts %1000000000, typ, code, msg, ip))
333 except broken_pipe_exception:
334 # Stop python printing broken pipe errors and traceback
335 sys.stdout = open(os.devnull, 'w')
336 sys.exit(1)
337
338def context_switch(ts, cpu, pid, tid, np_pid, np_tid, machine_pid, out, out_preempt, *x):
339 global glb_switch_printed
340 global glb_switch_str
341 if out:
342 out_str = "Switch out "
343 else:
344 out_str = "Switch In "
345 if out_preempt:
346 preempt_str = "preempt"
347 else:
348 preempt_str = ""
349 if machine_pid == -1:
350 machine_str = ""
351 else:
352 machine_str = "machine PID %d" % machine_pid
353 glb_switch_str = "%16s %5d/%-5d [%03u] %9u.%09u %5d/%-5d %s %s" % \
354 (out_str, pid, tid, cpu, ts / 1000000000, ts %1000000000, np_pid, np_tid, machine_str, preempt_str)
355 glb_switch_printed = False