tools/perf/scripts/python/intel-pt-events.py

   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
  14 from __future__ import print_function
  15
  16 import os
  17 import sys
  18 import struct
  19 import argparse
  20
  21 from libxed import LibXED
  22 from ctypes import create_string_buffer, addressof
  23
  24 sys.path.append(os.environ['PERF_EXEC_PATH'] + \
  25         '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
  26
  27 from perf_trace_context import perf_set_itrace_options, \
  28         perf_sample_insn, perf_sample_srccode
  29
  30 try:
  31         broken_pipe_exception = BrokenPipeError
  32 except:
  33         broken_pipe_exception = IOError
  34
  35 glb_switch_str          = {}
  36 glb_insn                = False
  37 glb_disassembler        = None
  38 glb_src                 = False
  39 glb_source_file_name    = None
  40 glb_line_number         = None
  41 glb_dso                 = None
  42
  43 def get_optional_null(perf_dict, field):
  44         if field in perf_dict:
  45                 return perf_dict[field]
  46         return ""
  47
  48 def get_optional_zero(perf_dict, field):
  49         if field in perf_dict:
  50                 return perf_dict[field]
  51         return 0
  52
  53 def get_optional_bytes(perf_dict, field):
  54         if field in perf_dict:
  55                 return perf_dict[field]
  56         return bytes()
  57
  58 def get_optional(perf_dict, field):
  59         if field in perf_dict:
  60                 return perf_dict[field]
  61         return "[unknown]"
  62
  63 def get_offset(perf_dict, field):
  64         if field in perf_dict:
  65                 return "+%#x" % perf_dict[field]
  66         return ""
  67
  68 def trace_begin():
  69         ap = argparse.ArgumentParser(usage = "", add_help = False)
  70         ap.add_argument("--insn-trace", action='store_true')
  71         ap.add_argument("--src-trace", action='store_true')
  72         ap.add_argument("--all-switch-events", 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 = "i0nsepwxI"
  80                 glb_insn = True
  81         elif glb_args.src_trace:
  82                 print("Intel PT Source Trace")
  83                 itrace = "i0nsepwxI"
  84                 glb_insn = True
  85                 glb_src = True
  86         else:
  87                 print("Intel PT Branch Trace, Power Events, Event Trace and PTWRITE")
  88                 itrace = "bepwxI"
  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
  96 def trace_end():
  97         print("End")
  98
  99 def 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
 102 def 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         try:
 108                 s = payload.to_bytes(8, "little").decode("ascii").rstrip("\x00")
 109                 if not s.isprintable():
 110                         s = ""
 111         except:
 112                 s = ""
 113         print("IP: %u payload: %#x" % (exact_ip, payload), s, end=' ')
 114
 115 def print_cbr(raw_buf):
 116         data = struct.unpack_from("<BBBBII", raw_buf)
 117         cbr = data[0]
 118         f = (data[4] + 500) / 1000
 119         p = ((cbr * 1000 / data[2]) + 5) / 10
 120         print("%3u  freq: %4u MHz  (%3u%%)" % (cbr, f, p), end=' ')
 121
 122 def print_mwait(raw_buf):
 123         data = struct.unpack_from("<IQ", raw_buf)
 124         payload = data[1]
 125         hints = payload & 0xff
 126         extensions = (payload >> 32) & 0x3
 127         print("hints: %#x extensions: %#x" % (hints, extensions), end=' ')
 128
 129 def print_pwre(raw_buf):
 130         data = struct.unpack_from("<IQ", raw_buf)
 131         payload = data[1]
 132         hw = (payload >> 7) & 1
 133         cstate = (payload >> 12) & 0xf
 134         subcstate = (payload >> 8) & 0xf
 135         print("hw: %u cstate: %u sub-cstate: %u" % (hw, cstate, subcstate),
 136                 end=' ')
 137
 138 def print_exstop(raw_buf):
 139         data = struct.unpack_from("<I", raw_buf)
 140         flags = data[0]
 141         exact_ip = flags & 1
 142         print("IP: %u" % (exact_ip), end=' ')
 143
 144 def print_pwrx(raw_buf):
 145         data = struct.unpack_from("<IQ", raw_buf)
 146         payload = data[1]
 147         deepest_cstate = payload & 0xf
 148         last_cstate = (payload >> 4) & 0xf
 149         wake_reason = (payload >> 8) & 0xf
 150         print("deepest cstate: %u last cstate: %u wake reason: %#x" %
 151                 (deepest_cstate, last_cstate, wake_reason), end=' ')
 152
 153 def print_psb(raw_buf):
 154         data = struct.unpack_from("<IQ", raw_buf)
 155         offset = data[1]
 156         print("offset: %#x" % (offset), end=' ')
 157
 158 glb_cfe = ["", "INTR", "IRET", "SMI", "RSM", "SIPI", "INIT", "VMENTRY", "VMEXIT",
 159                 "VMEXIT_INTR", "SHUTDOWN", "", "UINT", "UIRET"] + [""] * 18
 160 glb_evd = ["", "PFA", "VMXQ", "VMXR"] + [""] * 60
 161
 162 def print_evt(raw_buf):
 163         data = struct.unpack_from("<BBH", raw_buf)
 164         typ = data[0] & 0x1f
 165         ip_flag = (data[0] & 0x80) >> 7
 166         vector = data[1]
 167         evd_cnt = data[2]
 168         s = glb_cfe[typ]
 169         if s:
 170                 print(" cfe: %s IP: %u vector: %u" % (s, ip_flag, vector), end=' ')
 171         else:
 172                 print(" cfe: %u IP: %u vector: %u" % (typ, ip_flag, vector), end=' ')
 173         pos = 4
 174         for i in range(evd_cnt):
 175                 data = struct.unpack_from("<QQ", raw_buf)
 176                 et = data[0] & 0x3f
 177                 s = glb_evd[et]
 178                 if s:
 179                         print("%s: %#x" % (s, data[1]), end=' ')
 180                 else:
 181                         print("EVD_%u: %#x" % (et, data[1]), end=' ')
 182
 183 def print_iflag(raw_buf):
 184         data = struct.unpack_from("<IQ", raw_buf)
 185         iflag = data[0] & 1
 186         old_iflag = iflag ^ 1
 187         via_branch = data[0] & 2
 188         branch_ip = data[1]
 189         if via_branch:
 190                 s = "via"
 191         else:
 192                 s = "non"
 193         print("IFLAG: %u->%u %s branch" % (old_iflag, iflag, s), end=' ')
 194
 195 def common_start_str(comm, sample):
 196         ts = sample["time"]
 197         cpu = sample["cpu"]
 198         pid = sample["pid"]
 199         tid = sample["tid"]
 200         if "machine_pid" in sample:
 201                 machine_pid = sample["machine_pid"]
 202                 vcpu = sample["vcpu"]
 203                 return "VM:%5d VCPU:%03d %16s %5u/%-5u [%03u] %9u.%09u  " % (machine_pid, vcpu, comm, pid, tid, cpu, ts / 1000000000, ts %1000000000)
 204         else:
 205                 return "%16s %5u/%-5u [%03u] %9u.%09u  " % (comm, pid, tid, cpu, ts / 1000000000, ts %1000000000)
 206
 207 def print_common_start(comm, sample, name):
 208         flags_disp = get_optional_null(sample, "flags_disp")
 209         # Unused fields:
 210         # period      = sample["period"]
 211         # phys_addr   = sample["phys_addr"]
 212         # weight      = sample["weight"]
 213         # transaction = sample["transaction"]
 214         # cpumode     = get_optional_zero(sample, "cpumode")
 215         print(common_start_str(comm, sample) + "%8s  %21s" % (name, flags_disp), end=' ')
 216
 217 def print_instructions_start(comm, sample):
 218         if "x" in get_optional_null(sample, "flags"):
 219                 print(common_start_str(comm, sample) + "x", end=' ')
 220         else:
 221                 print(common_start_str(comm, sample), end='  ')
 222
 223 def disassem(insn, ip):
 224         inst = glb_disassembler.Instruction()
 225         glb_disassembler.SetMode(inst, 0) # Assume 64-bit
 226         buf = create_string_buffer(64)
 227         buf.value = insn
 228         return glb_disassembler.DisassembleOne(inst, addressof(buf), len(insn), ip)
 229
 230 def print_common_ip(param_dict, sample, symbol, dso):
 231         ip   = sample["ip"]
 232         offs = get_offset(param_dict, "symoff")
 233         if "cyc_cnt" in sample:
 234                 cyc_cnt = sample["cyc_cnt"]
 235                 insn_cnt = get_optional_zero(sample, "insn_cnt")
 236                 ipc_str = "  IPC: %#.2f (%u/%u)" % (insn_cnt / cyc_cnt, insn_cnt, cyc_cnt)
 237         else:
 238                 ipc_str = ""
 239         if glb_insn and glb_disassembler is not None:
 240                 insn = perf_sample_insn(perf_script_context)
 241                 if insn and len(insn):
 242                         cnt, text = disassem(insn, ip)
 243                         byte_str = ("%x" % ip).rjust(16)
 244                         if sys.version_info.major >= 3:
 245                                 for k in range(cnt):
 246                                         byte_str += " %02x" % insn[k]
 247                         else:
 248                                 for k in xrange(cnt):
 249                                         byte_str += " %02x" % ord(insn[k])
 250                         print("%-40s  %-30s" % (byte_str, text), end=' ')
 251                 print("%s%s (%s)" % (symbol, offs, dso), end=' ')
 252         else:
 253                 print("%16x %s%s (%s)" % (ip, symbol, offs, dso), end=' ')
 254         if "addr_correlates_sym" in sample:
 255                 addr   = sample["addr"]
 256                 dso    = get_optional(sample, "addr_dso")
 257                 symbol = get_optional(sample, "addr_symbol")
 258                 offs   = get_offset(sample, "addr_symoff")
 259                 print("=> %x %s%s (%s)%s" % (addr, symbol, offs, dso, ipc_str))
 260         else:
 261                 print(ipc_str)
 262
 263 def print_srccode(comm, param_dict, sample, symbol, dso, with_insn):
 264         ip = sample["ip"]
 265         if symbol == "[unknown]":
 266                 start_str = common_start_str(comm, sample) + ("%x" % ip).rjust(16).ljust(40)
 267         else:
 268                 offs = get_offset(param_dict, "symoff")
 269                 start_str = common_start_str(comm, sample) + (symbol + offs).ljust(40)
 270
 271         if with_insn and glb_insn and glb_disassembler is not None:
 272                 insn = perf_sample_insn(perf_script_context)
 273                 if insn and len(insn):
 274                         cnt, text = disassem(insn, ip)
 275                 start_str += text.ljust(30)
 276
 277         global glb_source_file_name
 278         global glb_line_number
 279         global glb_dso
 280
 281         source_file_name, line_number, source_line = perf_sample_srccode(perf_script_context)
 282         if source_file_name:
 283                 if glb_line_number == line_number and glb_source_file_name == source_file_name:
 284                         src_str = ""
 285                 else:
 286                         if len(source_file_name) > 40:
 287                                 src_file = ("..." + source_file_name[-37:]) + " "
 288                         else:
 289                                 src_file = source_file_name.ljust(41)
 290                         if source_line is None:
 291                                 src_str = src_file + str(line_number).rjust(4) + " <source not found>"
 292                         else:
 293                                 src_str = src_file + str(line_number).rjust(4) + " " + source_line
 294                 glb_dso = None
 295         elif dso == glb_dso:
 296                 src_str = ""
 297         else:
 298                 src_str = dso
 299                 glb_dso = dso
 300
 301         glb_line_number = line_number
 302         glb_source_file_name = source_file_name
 303
 304         print(start_str, src_str)
 305
 306 def do_process_event(param_dict):
 307         event_attr = param_dict["attr"]
 308         sample     = param_dict["sample"]
 309         raw_buf    = param_dict["raw_buf"]
 310         comm       = param_dict["comm"]
 311         name       = param_dict["ev_name"]
 312         # Unused fields:
 313         # callchain  = param_dict["callchain"]
 314         # brstack    = param_dict["brstack"]
 315         # brstacksym = param_dict["brstacksym"]
 316
 317         # Symbol and dso info are not always resolved
 318         dso    = get_optional(param_dict, "dso")
 319         symbol = get_optional(param_dict, "symbol")
 320
 321         cpu = sample["cpu"]
 322         if cpu in glb_switch_str:
 323                 print(glb_switch_str[cpu])
 324                 del glb_switch_str[cpu]
 325
 326         if name[0:12] == "instructions":
 327                 if glb_src:
 328                         print_srccode(comm, param_dict, sample, symbol, dso, True)
 329                 else:
 330                         print_instructions_start(comm, sample)
 331                         print_common_ip(param_dict, sample, symbol, dso)
 332         elif name[0:8] == "branches":
 333                 if glb_src:
 334                         print_srccode(comm, param_dict, sample, symbol, dso, False)
 335                 else:
 336                         print_common_start(comm, sample, name)
 337                         print_common_ip(param_dict, sample, symbol, dso)
 338         elif name == "ptwrite":
 339                 print_common_start(comm, sample, name)
 340                 print_ptwrite(raw_buf)
 341                 print_common_ip(param_dict, sample, symbol, dso)
 342         elif name == "cbr":
 343                 print_common_start(comm, sample, name)
 344                 print_cbr(raw_buf)
 345                 print_common_ip(param_dict, sample, symbol, dso)
 346         elif name == "mwait":
 347                 print_common_start(comm, sample, name)
 348                 print_mwait(raw_buf)
 349                 print_common_ip(param_dict, sample, symbol, dso)
 350         elif name == "pwre":
 351                 print_common_start(comm, sample, name)
 352                 print_pwre(raw_buf)
 353                 print_common_ip(param_dict, sample, symbol, dso)
 354         elif name == "exstop":
 355                 print_common_start(comm, sample, name)
 356                 print_exstop(raw_buf)
 357                 print_common_ip(param_dict, sample, symbol, dso)
 358         elif name == "pwrx":
 359                 print_common_start(comm, sample, name)
 360                 print_pwrx(raw_buf)
 361                 print_common_ip(param_dict, sample, symbol, dso)
 362         elif name == "psb":
 363                 print_common_start(comm, sample, name)
 364                 print_psb(raw_buf)
 365                 print_common_ip(param_dict, sample, symbol, dso)
 366         elif name == "evt":
 367                 print_common_start(comm, sample, name)
 368                 print_evt(raw_buf)
 369                 print_common_ip(param_dict, sample, symbol, dso)
 370         elif name == "iflag":
 371                 print_common_start(comm, sample, name)
 372                 print_iflag(raw_buf)
 373                 print_common_ip(param_dict, sample, symbol, dso)
 374         else:
 375                 print_common_start(comm, sample, name)
 376                 print_common_ip(param_dict, sample, symbol, dso)
 377
 378 def process_event(param_dict):
 379         try:
 380                 do_process_event(param_dict)
 381         except broken_pipe_exception:
 382                 # Stop python printing broken pipe errors and traceback
 383                 sys.stdout = open(os.devnull, 'w')
 384                 sys.exit(1)
 385
 386 def auxtrace_error(typ, code, cpu, pid, tid, ip, ts, msg, cpumode, *x):
 387         if len(x) >= 2 and x[0]:
 388                 machine_pid = x[0]
 389                 vcpu = x[1]
 390         else:
 391                 machine_pid = 0
 392                 vcpu = -1
 393         try:
 394                 if machine_pid:
 395                         print("VM:%5d VCPU:%03d %16s %5u/%-5u [%03u] %9u.%09u  error type %u code %u: %s ip 0x%16x" %
 396                                 (machine_pid, vcpu, "Trace error", pid, tid, cpu, ts / 1000000000, ts %1000000000, typ, code, msg, ip))
 397                 else:
 398                         print("%16s %5u/%-5u [%03u] %9u.%09u  error type %u code %u: %s ip 0x%16x" %
 399                                 ("Trace error", pid, tid, cpu, ts / 1000000000, ts %1000000000, typ, code, msg, ip))
 400         except broken_pipe_exception:
 401                 # Stop python printing broken pipe errors and traceback
 402                 sys.stdout = open(os.devnull, 'w')
 403                 sys.exit(1)
 404
 405 def context_switch(ts, cpu, pid, tid, np_pid, np_tid, machine_pid, out, out_preempt, *x):
 406         if out:
 407                 out_str = "Switch out "
 408         else:
 409                 out_str = "Switch In  "
 410         if out_preempt:
 411                 preempt_str = "preempt"
 412         else:
 413                 preempt_str = ""
 414         if len(x) >= 2 and x[0]:
 415                 machine_pid = x[0]
 416                 vcpu = x[1]
 417         else:
 418                 vcpu = None;
 419         if machine_pid == -1:
 420                 machine_str = ""
 421         elif vcpu is None:
 422                 machine_str = "machine PID %d" % machine_pid
 423         else:
 424                 machine_str = "machine PID %d VCPU %d" % (machine_pid, vcpu)
 425         switch_str = "%16s %5d/%-5d [%03u] %9u.%09u %5d/%-5d %s %s" % \
 426                 (out_str, pid, tid, cpu, ts / 1000000000, ts %1000000000, np_pid, np_tid, machine_str, preempt_str)
 427         if glb_args.all_switch_events:
 428                 print(switch_str)
 429         else:
 430                 global glb_switch_str
 431                 glb_switch_str[cpu] = switch_str