perf intel-pt: Add decoder support for ptwrite and power event packets

Add decoder support for PTWRITE, MWAIT, PWRE, PWRX and EXSTOP packets. This
patch only affects the decoder, so the tools still do not select or consume
the new information. That is added in subsequent patches.

Signed-off-by: Adrian Hunter <adrian.hunter@intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Link: http://lkml.kernel.org/r/1495786658-18063-14-git-send-email-adrian.hunter@intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
index dacb9223e7438eca1861d9e8e3298823055ab28a..e42804d100012fae0fc17c1a3b25643b080005c7 100644 (file)
--- a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
@@ -158,8 +158,15 @@ struct intel_pt_decoder {
        bool continuous_period;
        bool overflow;
        bool set_fup_tx_flags;
+       bool set_fup_ptw;
+       bool set_fup_mwait;
+       bool set_fup_pwre;
+       bool set_fup_exstop;
        unsigned int fup_tx_flags;
        unsigned int tx_flags;
+       uint64_t fup_ptw_payload;
+       uint64_t fup_mwait_payload;
+       uint64_t fup_pwre_payload;
        uint64_t timestamp_insn_cnt;
        uint64_t sample_insn_cnt;
        uint64_t stuck_ip;
@@ -660,6 +667,8 @@ static int intel_pt_calc_cyc_cb(struct intel_pt_pkt_info *pkt_info)
        case INTEL_PT_PAD:
        case INTEL_PT_VMCS:
        case INTEL_PT_MNT:
+       case INTEL_PT_PTWRITE:
+       case INTEL_PT_PTWRITE_IP:
                return 0;
 
        case INTEL_PT_MTC:
@@ -758,6 +767,11 @@ static int intel_pt_calc_cyc_cb(struct intel_pt_pkt_info *pkt_info)
 
        case INTEL_PT_TIP_PGD:
        case INTEL_PT_TRACESTOP:
+       case INTEL_PT_EXSTOP:
+       case INTEL_PT_EXSTOP_IP:
+       case INTEL_PT_MWAIT:
+       case INTEL_PT_PWRE:
+       case INTEL_PT_PWRX:
        case INTEL_PT_OVF:
        case INTEL_PT_BAD: /* Does not happen */
        default:
@@ -1016,6 +1030,57 @@ out_no_progress:
        return err;
 }
 
+static bool intel_pt_fup_event(struct intel_pt_decoder *decoder)
+{
+       bool ret = false;
+
+       if (decoder->set_fup_tx_flags) {
+               decoder->set_fup_tx_flags = false;
+               decoder->tx_flags = decoder->fup_tx_flags;
+               decoder->state.type = INTEL_PT_TRANSACTION;
+               decoder->state.from_ip = decoder->ip;
+               decoder->state.to_ip = 0;
+               decoder->state.flags = decoder->fup_tx_flags;
+               return true;
+       }
+       if (decoder->set_fup_ptw) {
+               decoder->set_fup_ptw = false;
+               decoder->state.type = INTEL_PT_PTW;
+               decoder->state.flags |= INTEL_PT_FUP_IP;
+               decoder->state.from_ip = decoder->ip;
+               decoder->state.to_ip = 0;
+               decoder->state.ptw_payload = decoder->fup_ptw_payload;
+               return true;
+       }
+       if (decoder->set_fup_mwait) {
+               decoder->set_fup_mwait = false;
+               decoder->state.type = INTEL_PT_MWAIT_OP;
+               decoder->state.from_ip = decoder->ip;
+               decoder->state.to_ip = 0;
+               decoder->state.mwait_payload = decoder->fup_mwait_payload;
+               ret = true;
+       }
+       if (decoder->set_fup_pwre) {
+               decoder->set_fup_pwre = false;
+               decoder->state.type |= INTEL_PT_PWR_ENTRY;
+               decoder->state.type &= ~INTEL_PT_BRANCH;
+               decoder->state.from_ip = decoder->ip;
+               decoder->state.to_ip = 0;
+               decoder->state.pwre_payload = decoder->fup_pwre_payload;
+               ret = true;
+       }
+       if (decoder->set_fup_exstop) {
+               decoder->set_fup_exstop = false;
+               decoder->state.type |= INTEL_PT_EX_STOP;
+               decoder->state.type &= ~INTEL_PT_BRANCH;
+               decoder->state.flags |= INTEL_PT_FUP_IP;
+               decoder->state.from_ip = decoder->ip;
+               decoder->state.to_ip = 0;
+               ret = true;
+       }
+       return ret;
+}
+
 static int intel_pt_walk_fup(struct intel_pt_decoder *decoder)
 {
        struct intel_pt_insn intel_pt_insn;
@@ -1029,15 +1094,8 @@ static int intel_pt_walk_fup(struct intel_pt_decoder *decoder)
                if (err == INTEL_PT_RETURN)
                        return 0;
                if (err == -EAGAIN) {
-                       if (decoder->set_fup_tx_flags) {
-                               decoder->set_fup_tx_flags = false;
-                               decoder->tx_flags = decoder->fup_tx_flags;
-                               decoder->state.type = INTEL_PT_TRANSACTION;
-                               decoder->state.from_ip = decoder->ip;
-                               decoder->state.to_ip = 0;
-                               decoder->state.flags = decoder->fup_tx_flags;
+                       if (intel_pt_fup_event(decoder))
                                return 0;
-                       }
                        return err;
                }
                decoder->set_fup_tx_flags = false;
@@ -1443,6 +1501,13 @@ static int intel_pt_walk_psbend(struct intel_pt_decoder *decoder)
                case INTEL_PT_TRACESTOP:
                case INTEL_PT_BAD:
                case INTEL_PT_PSB:
+               case INTEL_PT_PTWRITE:
+               case INTEL_PT_PTWRITE_IP:
+               case INTEL_PT_EXSTOP:
+               case INTEL_PT_EXSTOP_IP:
+               case INTEL_PT_MWAIT:
+               case INTEL_PT_PWRE:
+               case INTEL_PT_PWRX:
                        decoder->have_tma = false;
                        intel_pt_log("ERROR: Unexpected packet\n");
                        return -EAGAIN;
@@ -1524,6 +1589,13 @@ static int intel_pt_walk_fup_tip(struct intel_pt_decoder *decoder)
                case INTEL_PT_MODE_TSX:
                case INTEL_PT_BAD:
                case INTEL_PT_PSBEND:
+               case INTEL_PT_PTWRITE:
+               case INTEL_PT_PTWRITE_IP:
+               case INTEL_PT_EXSTOP:
+               case INTEL_PT_EXSTOP_IP:
+               case INTEL_PT_MWAIT:
+               case INTEL_PT_PWRE:
+               case INTEL_PT_PWRX:
                        intel_pt_log("ERROR: Missing TIP after FUP\n");
                        decoder->pkt_state = INTEL_PT_STATE_ERR3;
                        return -ENOENT;
@@ -1654,8 +1726,13 @@ next:
                        intel_pt_set_last_ip(decoder);
                        if (!decoder->branch_enable) {
                                decoder->ip = decoder->last_ip;
+                               if (intel_pt_fup_event(decoder))
+                                       return 0;
+                               no_tip = false;
                                break;
                        }
+                       if (decoder->set_fup_mwait)
+                               no_tip = true;
                        err = intel_pt_walk_fup(decoder);
                        if (err != -EAGAIN) {
                                if (err)
@@ -1755,6 +1832,71 @@ next:
                case INTEL_PT_PAD:
                        break;
 
+               case INTEL_PT_PTWRITE_IP:
+                       decoder->fup_ptw_payload = decoder->packet.payload;
+                       err = intel_pt_get_next_packet(decoder);
+                       if (err)
+                               return err;
+                       if (decoder->packet.type == INTEL_PT_FUP) {
+                               decoder->set_fup_ptw = true;
+                               no_tip = true;
+                       } else {
+                               intel_pt_log_at("ERROR: Missing FUP after PTWRITE",
+                                               decoder->pos);
+                       }
+                       goto next;
+
+               case INTEL_PT_PTWRITE:
+                       decoder->state.type = INTEL_PT_PTW;
+                       decoder->state.from_ip = decoder->ip;
+                       decoder->state.to_ip = 0;
+                       decoder->state.ptw_payload = decoder->packet.payload;
+                       return 0;
+
+               case INTEL_PT_MWAIT:
+                       decoder->fup_mwait_payload = decoder->packet.payload;
+                       decoder->set_fup_mwait = true;
+                       break;
+
+               case INTEL_PT_PWRE:
+                       if (decoder->set_fup_mwait) {
+                               decoder->fup_pwre_payload =
+                                                       decoder->packet.payload;
+                               decoder->set_fup_pwre = true;
+                               break;
+                       }
+                       decoder->state.type = INTEL_PT_PWR_ENTRY;
+                       decoder->state.from_ip = decoder->ip;
+                       decoder->state.to_ip = 0;
+                       decoder->state.pwrx_payload = decoder->packet.payload;
+                       return 0;
+
+               case INTEL_PT_EXSTOP_IP:
+                       err = intel_pt_get_next_packet(decoder);
+                       if (err)
+                               return err;
+                       if (decoder->packet.type == INTEL_PT_FUP) {
+                               decoder->set_fup_exstop = true;
+                               no_tip = true;
+                       } else {
+                               intel_pt_log_at("ERROR: Missing FUP after EXSTOP",
+                                               decoder->pos);
+                       }
+                       goto next;
+
+               case INTEL_PT_EXSTOP:
+                       decoder->state.type = INTEL_PT_EX_STOP;
+                       decoder->state.from_ip = decoder->ip;
+                       decoder->state.to_ip = 0;
+                       return 0;
+
+               case INTEL_PT_PWRX:
+                       decoder->state.type = INTEL_PT_PWR_EXIT;
+                       decoder->state.from_ip = decoder->ip;
+                       decoder->state.to_ip = 0;
+                       decoder->state.pwrx_payload = decoder->packet.payload;
+                       return 0;
+
                default:
                        return intel_pt_bug(decoder);
                }
@@ -1784,6 +1926,13 @@ static int intel_pt_walk_psb(struct intel_pt_decoder *decoder)
                        __fallthrough;
                case INTEL_PT_TIP_PGE:
                case INTEL_PT_TIP:
+               case INTEL_PT_PTWRITE:
+               case INTEL_PT_PTWRITE_IP:
+               case INTEL_PT_EXSTOP:
+               case INTEL_PT_EXSTOP_IP:
+               case INTEL_PT_MWAIT:
+               case INTEL_PT_PWRE:
+               case INTEL_PT_PWRX:
                        intel_pt_log("ERROR: Unexpected packet\n");
                        return -ENOENT;
 
@@ -1958,6 +2107,13 @@ static int intel_pt_walk_to_ip(struct intel_pt_decoder *decoder)
                case INTEL_PT_VMCS:
                case INTEL_PT_MNT:
                case INTEL_PT_PAD:
+               case INTEL_PT_PTWRITE:
+               case INTEL_PT_PTWRITE_IP:
+               case INTEL_PT_EXSTOP:
+               case INTEL_PT_EXSTOP_IP:
+               case INTEL_PT_MWAIT:
+               case INTEL_PT_PWRE:
+               case INTEL_PT_PWRX:
                default:
                        break;
                }
@@ -1969,6 +2125,10 @@ static int intel_pt_sync_ip(struct intel_pt_decoder *decoder)
        int err;
 
        decoder->set_fup_tx_flags = false;
+       decoder->set_fup_ptw = false;
+       decoder->set_fup_mwait = false;
+       decoder->set_fup_pwre = false;
+       decoder->set_fup_exstop = false;
 
        if (!decoder->branch_enable) {
                decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;

diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
index add3bed58349080b1756e321334a747eec3aea25..414c88e9e0da01e6b6875b700fa46754f9d8a1c8 100644 (file)
--- a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
@@ -25,11 +25,17 @@
 #define INTEL_PT_IN_TX         (1 << 0)
 #define INTEL_PT_ABORT_TX      (1 << 1)
 #define INTEL_PT_ASYNC         (1 << 2)
+#define INTEL_PT_FUP_IP                (1 << 3)
 
 enum intel_pt_sample_type {
        INTEL_PT_BRANCH         = 1 << 0,
        INTEL_PT_INSTRUCTION    = 1 << 1,
        INTEL_PT_TRANSACTION    = 1 << 2,
+       INTEL_PT_PTW            = 1 << 3,
+       INTEL_PT_MWAIT_OP       = 1 << 4,
+       INTEL_PT_PWR_ENTRY      = 1 << 5,
+       INTEL_PT_EX_STOP        = 1 << 6,
+       INTEL_PT_PWR_EXIT       = 1 << 7,
 };
 
 enum intel_pt_period_type {
@@ -63,6 +69,10 @@ struct intel_pt_state {
        uint64_t timestamp;
        uint64_t est_timestamp;
        uint64_t trace_nr;
+       uint64_t ptw_payload;
+       uint64_t mwait_payload;
+       uint64_t pwre_payload;
+       uint64_t pwrx_payload;
        uint32_t flags;
        enum intel_pt_insn_op insn_op;
        int insn_len;

diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c b/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c
index 7528ae4f7e28e1d419c699759125c979e8dc1397..accdb646a03d9bb44de2bcc317037c2d4a0717e5 100644 (file)
--- a/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c
@@ -64,6 +64,13 @@ static const char * const packet_name[] = {
        [INTEL_PT_PIP]          = "PIP",
        [INTEL_PT_OVF]          = "OVF",
        [INTEL_PT_MNT]          = "MNT",
+       [INTEL_PT_PTWRITE]      = "PTWRITE",
+       [INTEL_PT_PTWRITE_IP]   = "PTWRITE",
+       [INTEL_PT_EXSTOP]       = "EXSTOP",
+       [INTEL_PT_EXSTOP_IP]    = "EXSTOP",
+       [INTEL_PT_MWAIT]        = "MWAIT",
+       [INTEL_PT_PWRE]         = "PWRE",
+       [INTEL_PT_PWRX]         = "PWRX",
 };
 
 const char *intel_pt_pkt_name(enum intel_pt_pkt_type type)
@@ -217,12 +224,80 @@ static int intel_pt_get_3byte(const unsigned char *buf, size_t len,
        }
 }
 
+static int intel_pt_get_ptwrite(const unsigned char *buf, size_t len,
+                               struct intel_pt_pkt *packet)
+{
+       packet->count = (buf[1] >> 5) & 0x3;
+       packet->type = buf[1] & BIT(7) ? INTEL_PT_PTWRITE_IP :
+                                        INTEL_PT_PTWRITE;
+
+       switch (packet->count) {
+       case 0:
+               if (len < 6)
+                       return INTEL_PT_NEED_MORE_BYTES;
+               packet->payload = le32_to_cpu(*(uint32_t *)(buf + 2));
+               return 6;
+       case 1:
+               if (len < 10)
+                       return INTEL_PT_NEED_MORE_BYTES;
+               packet->payload = le64_to_cpu(*(uint64_t *)(buf + 2));
+               return 10;
+       default:
+               return INTEL_PT_BAD_PACKET;
+       }
+}
+
+static int intel_pt_get_exstop(struct intel_pt_pkt *packet)
+{
+       packet->type = INTEL_PT_EXSTOP;
+       return 2;
+}
+
+static int intel_pt_get_exstop_ip(struct intel_pt_pkt *packet)
+{
+       packet->type = INTEL_PT_EXSTOP_IP;
+       return 2;
+}
+
+static int intel_pt_get_mwait(const unsigned char *buf, size_t len,
+                             struct intel_pt_pkt *packet)
+{
+       if (len < 10)
+               return INTEL_PT_NEED_MORE_BYTES;
+       packet->type = INTEL_PT_MWAIT;
+       packet->payload = le64_to_cpu(*(uint64_t *)(buf + 2));
+       return 10;
+}
+
+static int intel_pt_get_pwre(const unsigned char *buf, size_t len,
+                            struct intel_pt_pkt *packet)
+{
+       if (len < 4)
+               return INTEL_PT_NEED_MORE_BYTES;
+       packet->type = INTEL_PT_PWRE;
+       memcpy_le64(&packet->payload, buf + 2, 2);
+       return 4;
+}
+
+static int intel_pt_get_pwrx(const unsigned char *buf, size_t len,
+                            struct intel_pt_pkt *packet)
+{
+       if (len < 7)
+               return INTEL_PT_NEED_MORE_BYTES;
+       packet->type = INTEL_PT_PWRX;
+       memcpy_le64(&packet->payload, buf + 2, 5);
+       return 7;
+}
+
 static int intel_pt_get_ext(const unsigned char *buf, size_t len,
                            struct intel_pt_pkt *packet)
 {
        if (len < 2)
                return INTEL_PT_NEED_MORE_BYTES;
 
+       if ((buf[1] & 0x1f) == 0x12)
+               return intel_pt_get_ptwrite(buf, len, packet);
+
        switch (buf[1]) {
        case 0xa3: /* Long TNT */
                return intel_pt_get_long_tnt(buf, len, packet);
@@ -244,6 +319,16 @@ static int intel_pt_get_ext(const unsigned char *buf, size_t len,
                return intel_pt_get_tma(buf, len, packet);
        case 0xC3: /* 3-byte header */
                return intel_pt_get_3byte(buf, len, packet);
+       case 0x62: /* EXSTOP no IP */
+               return intel_pt_get_exstop(packet);
+       case 0xE2: /* EXSTOP with IP */
+               return intel_pt_get_exstop_ip(packet);
+       case 0xC2: /* MWAIT */
+               return intel_pt_get_mwait(buf, len, packet);
+       case 0x22: /* PWRE */
+               return intel_pt_get_pwre(buf, len, packet);
+       case 0xA2: /* PWRX */
+               return intel_pt_get_pwrx(buf, len, packet);
        default:
                return INTEL_PT_BAD_PACKET;
        }
@@ -522,6 +607,29 @@ int intel_pt_pkt_desc(const struct intel_pt_pkt *packet, char *buf,
                ret = snprintf(buf, buf_len, "%s 0x%llx (NR=%d)",
                               name, payload, nr);
                return ret;
+       case INTEL_PT_PTWRITE:
+               return snprintf(buf, buf_len, "%s 0x%llx IP:0", name, payload);
+       case INTEL_PT_PTWRITE_IP:
+               return snprintf(buf, buf_len, "%s 0x%llx IP:1", name, payload);
+       case INTEL_PT_EXSTOP:
+               return snprintf(buf, buf_len, "%s IP:0", name);
+       case INTEL_PT_EXSTOP_IP:
+               return snprintf(buf, buf_len, "%s IP:1", name);
+       case INTEL_PT_MWAIT:
+               return snprintf(buf, buf_len, "%s 0x%llx Hints 0x%x Extensions 0x%x",
+                               name, payload, (unsigned int)(payload & 0xff),
+                               (unsigned int)((payload >> 32) & 0x3));
+       case INTEL_PT_PWRE:
+               return snprintf(buf, buf_len, "%s 0x%llx HW:%u CState:%u Sub-CState:%u",
+                               name, payload, !!(payload & 0x80),
+                               (unsigned int)((payload >> 12) & 0xf),
+                               (unsigned int)((payload >> 8) & 0xf));
+       case INTEL_PT_PWRX:
+               return snprintf(buf, buf_len, "%s 0x%llx Last CState:%u Deepest CState:%u Wake Reason 0x%x",
+                               name, payload,
+                               (unsigned int)((payload >> 4) & 0xf),
+                               (unsigned int)(payload & 0xf),
+                               (unsigned int)((payload >> 8) & 0xf));
        default:
                break;
        }

diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.h b/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.h
index 781bb79883bd612bb803318daff7248710f6c107..73ddc3a88d0749eddc31b4a7a98982921c4edc78 100644 (file)
--- a/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.h
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.h
@@ -52,6 +52,13 @@ enum intel_pt_pkt_type {
        INTEL_PT_PIP,
        INTEL_PT_OVF,
        INTEL_PT_MNT,
+       INTEL_PT_PTWRITE,
+       INTEL_PT_PTWRITE_IP,
+       INTEL_PT_EXSTOP,
+       INTEL_PT_EXSTOP_IP,
+       INTEL_PT_MWAIT,
+       INTEL_PT_PWRE,
+       INTEL_PT_PWRX,
 };
 
 struct intel_pt_pkt {