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 356