Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0+ */
0002 /*
0003  * Trace points for SSAM/SSH.
0004  *
0005  * Copyright (C) 2020-2022 Maximilian Luz <luzmaximilian@gmail.com>
0006  */
0007 
0008 #undef TRACE_SYSTEM
0009 #define TRACE_SYSTEM surface_aggregator
0010 
0011 #if !defined(_SURFACE_AGGREGATOR_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
0012 #define _SURFACE_AGGREGATOR_TRACE_H
0013 
0014 #include <linux/surface_aggregator/serial_hub.h>
0015 
0016 #include <asm/unaligned.h>
0017 #include <linux/tracepoint.h>
0018 
0019 TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_DATA_SEQ);
0020 TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_DATA_NSQ);
0021 TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_ACK);
0022 TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_NAK);
0023 
0024 TRACE_DEFINE_ENUM(SSH_PACKET_SF_LOCKED_BIT);
0025 TRACE_DEFINE_ENUM(SSH_PACKET_SF_QUEUED_BIT);
0026 TRACE_DEFINE_ENUM(SSH_PACKET_SF_PENDING_BIT);
0027 TRACE_DEFINE_ENUM(SSH_PACKET_SF_TRANSMITTING_BIT);
0028 TRACE_DEFINE_ENUM(SSH_PACKET_SF_TRANSMITTED_BIT);
0029 TRACE_DEFINE_ENUM(SSH_PACKET_SF_ACKED_BIT);
0030 TRACE_DEFINE_ENUM(SSH_PACKET_SF_CANCELED_BIT);
0031 TRACE_DEFINE_ENUM(SSH_PACKET_SF_COMPLETED_BIT);
0032 
0033 TRACE_DEFINE_ENUM(SSH_PACKET_TY_FLUSH_BIT);
0034 TRACE_DEFINE_ENUM(SSH_PACKET_TY_SEQUENCED_BIT);
0035 TRACE_DEFINE_ENUM(SSH_PACKET_TY_BLOCKING_BIT);
0036 
0037 TRACE_DEFINE_ENUM(SSH_PACKET_FLAGS_SF_MASK);
0038 TRACE_DEFINE_ENUM(SSH_PACKET_FLAGS_TY_MASK);
0039 
0040 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_LOCKED_BIT);
0041 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_QUEUED_BIT);
0042 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_PENDING_BIT);
0043 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_TRANSMITTING_BIT);
0044 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_TRANSMITTED_BIT);
0045 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_RSPRCVD_BIT);
0046 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_CANCELED_BIT);
0047 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_COMPLETED_BIT);
0048 
0049 TRACE_DEFINE_ENUM(SSH_REQUEST_TY_FLUSH_BIT);
0050 TRACE_DEFINE_ENUM(SSH_REQUEST_TY_HAS_RESPONSE_BIT);
0051 
0052 TRACE_DEFINE_ENUM(SSH_REQUEST_FLAGS_SF_MASK);
0053 TRACE_DEFINE_ENUM(SSH_REQUEST_FLAGS_TY_MASK);
0054 
0055 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SAM);
0056 TRACE_DEFINE_ENUM(SSAM_SSH_TC_BAT);
0057 TRACE_DEFINE_ENUM(SSAM_SSH_TC_TMP);
0058 TRACE_DEFINE_ENUM(SSAM_SSH_TC_PMC);
0059 TRACE_DEFINE_ENUM(SSAM_SSH_TC_FAN);
0060 TRACE_DEFINE_ENUM(SSAM_SSH_TC_PoM);
0061 TRACE_DEFINE_ENUM(SSAM_SSH_TC_DBG);
0062 TRACE_DEFINE_ENUM(SSAM_SSH_TC_KBD);
0063 TRACE_DEFINE_ENUM(SSAM_SSH_TC_FWU);
0064 TRACE_DEFINE_ENUM(SSAM_SSH_TC_UNI);
0065 TRACE_DEFINE_ENUM(SSAM_SSH_TC_LPC);
0066 TRACE_DEFINE_ENUM(SSAM_SSH_TC_TCL);
0067 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SFL);
0068 TRACE_DEFINE_ENUM(SSAM_SSH_TC_KIP);
0069 TRACE_DEFINE_ENUM(SSAM_SSH_TC_EXT);
0070 TRACE_DEFINE_ENUM(SSAM_SSH_TC_BLD);
0071 TRACE_DEFINE_ENUM(SSAM_SSH_TC_BAS);
0072 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SEN);
0073 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SRQ);
0074 TRACE_DEFINE_ENUM(SSAM_SSH_TC_MCU);
0075 TRACE_DEFINE_ENUM(SSAM_SSH_TC_HID);
0076 TRACE_DEFINE_ENUM(SSAM_SSH_TC_TCH);
0077 TRACE_DEFINE_ENUM(SSAM_SSH_TC_BKL);
0078 TRACE_DEFINE_ENUM(SSAM_SSH_TC_TAM);
0079 TRACE_DEFINE_ENUM(SSAM_SSH_TC_ACC0);
0080 TRACE_DEFINE_ENUM(SSAM_SSH_TC_UFI);
0081 TRACE_DEFINE_ENUM(SSAM_SSH_TC_USC);
0082 TRACE_DEFINE_ENUM(SSAM_SSH_TC_PEN);
0083 TRACE_DEFINE_ENUM(SSAM_SSH_TC_VID);
0084 TRACE_DEFINE_ENUM(SSAM_SSH_TC_AUD);
0085 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SMC);
0086 TRACE_DEFINE_ENUM(SSAM_SSH_TC_KPD);
0087 TRACE_DEFINE_ENUM(SSAM_SSH_TC_REG);
0088 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SPT);
0089 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SYS);
0090 TRACE_DEFINE_ENUM(SSAM_SSH_TC_ACC1);
0091 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SHB);
0092 TRACE_DEFINE_ENUM(SSAM_SSH_TC_POS);
0093 
0094 #define SSAM_PTR_UID_LEN        9
0095 #define SSAM_U8_FIELD_NOT_APPLICABLE    ((u16)-1)
0096 #define SSAM_SEQ_NOT_APPLICABLE     ((u16)-1)
0097 #define SSAM_RQID_NOT_APPLICABLE    ((u32)-1)
0098 #define SSAM_SSH_TC_NOT_APPLICABLE  0
0099 
0100 #ifndef _SURFACE_AGGREGATOR_TRACE_HELPERS
0101 #define _SURFACE_AGGREGATOR_TRACE_HELPERS
0102 
0103 /**
0104  * ssam_trace_ptr_uid() - Convert the pointer to a non-pointer UID string.
0105  * @ptr: The pointer to convert.
0106  * @uid_str: A buffer of length SSAM_PTR_UID_LEN where the UID will be stored.
0107  *
0108  * Converts the given pointer into a UID string that is safe to be shared
0109  * with userspace and logs, i.e. doesn't give away the real memory location.
0110  */
0111 static inline void ssam_trace_ptr_uid(const void *ptr, char *uid_str)
0112 {
0113     char buf[2 * sizeof(void *) + 1];
0114 
0115     BUILD_BUG_ON(ARRAY_SIZE(buf) < SSAM_PTR_UID_LEN);
0116 
0117     snprintf(buf, ARRAY_SIZE(buf), "%p", ptr);
0118     memcpy(uid_str, &buf[ARRAY_SIZE(buf) - SSAM_PTR_UID_LEN],
0119            SSAM_PTR_UID_LEN);
0120 }
0121 
0122 /**
0123  * ssam_trace_get_packet_seq() - Read the packet's sequence ID.
0124  * @p: The packet.
0125  *
0126  * Return: Returns the packet's sequence ID (SEQ) field if present, or
0127  * %SSAM_SEQ_NOT_APPLICABLE if not (e.g. flush packet).
0128  */
0129 static inline u16 ssam_trace_get_packet_seq(const struct ssh_packet *p)
0130 {
0131     if (!p->data.ptr || p->data.len < SSH_MESSAGE_LENGTH(0))
0132         return SSAM_SEQ_NOT_APPLICABLE;
0133 
0134     return p->data.ptr[SSH_MSGOFFSET_FRAME(seq)];
0135 }
0136 
0137 /**
0138  * ssam_trace_get_request_id() - Read the packet's request ID.
0139  * @p: The packet.
0140  *
0141  * Return: Returns the packet's request ID (RQID) field if the packet
0142  * represents a request with command data, or %SSAM_RQID_NOT_APPLICABLE if not
0143  * (e.g. flush request, control packet).
0144  */
0145 static inline u32 ssam_trace_get_request_id(const struct ssh_packet *p)
0146 {
0147     if (!p->data.ptr || p->data.len < SSH_COMMAND_MESSAGE_LENGTH(0))
0148         return SSAM_RQID_NOT_APPLICABLE;
0149 
0150     return get_unaligned_le16(&p->data.ptr[SSH_MSGOFFSET_COMMAND(rqid)]);
0151 }
0152 
0153 /**
0154  * ssam_trace_get_request_tc() - Read the packet's request target category.
0155  * @p: The packet.
0156  *
0157  * Return: Returns the packet's request target category (TC) field if the
0158  * packet represents a request with command data, or %SSAM_TC_NOT_APPLICABLE
0159  * if not (e.g. flush request, control packet).
0160  */
0161 static inline u32 ssam_trace_get_request_tc(const struct ssh_packet *p)
0162 {
0163     if (!p->data.ptr || p->data.len < SSH_COMMAND_MESSAGE_LENGTH(0))
0164         return SSAM_SSH_TC_NOT_APPLICABLE;
0165 
0166     return get_unaligned_le16(&p->data.ptr[SSH_MSGOFFSET_COMMAND(tc)]);
0167 }
0168 
0169 #endif /* _SURFACE_AGGREGATOR_TRACE_HELPERS */
0170 
0171 #define ssam_trace_get_command_field_u8(packet, field) \
0172     ((!(packet) || (packet)->data.len < SSH_COMMAND_MESSAGE_LENGTH(0)) \
0173      ? 0 : (packet)->data.ptr[SSH_MSGOFFSET_COMMAND(field)])
0174 
0175 #define ssam_show_generic_u8_field(value)               \
0176     __print_symbolic(value,                     \
0177         { SSAM_U8_FIELD_NOT_APPLICABLE,     "N/A" }     \
0178     )
0179 
0180 #define ssam_show_frame_type(ty)                    \
0181     __print_symbolic(ty,                        \
0182         { SSH_FRAME_TYPE_DATA_SEQ,      "DSEQ" },   \
0183         { SSH_FRAME_TYPE_DATA_NSQ,      "DNSQ" },   \
0184         { SSH_FRAME_TYPE_ACK,           "ACK"  },   \
0185         { SSH_FRAME_TYPE_NAK,           "NAK"  }    \
0186     )
0187 
0188 #define ssam_show_packet_type(type)                 \
0189     __print_flags(flags & SSH_PACKET_FLAGS_TY_MASK, "",     \
0190         { BIT(SSH_PACKET_TY_FLUSH_BIT),     "F" },      \
0191         { BIT(SSH_PACKET_TY_SEQUENCED_BIT), "S" },      \
0192         { BIT(SSH_PACKET_TY_BLOCKING_BIT),  "B" }       \
0193     )
0194 
0195 #define ssam_show_packet_state(state)                   \
0196     __print_flags(flags & SSH_PACKET_FLAGS_SF_MASK, "",     \
0197         { BIT(SSH_PACKET_SF_LOCKED_BIT),    "L" },      \
0198         { BIT(SSH_PACKET_SF_QUEUED_BIT),    "Q" },      \
0199         { BIT(SSH_PACKET_SF_PENDING_BIT),   "P" },      \
0200         { BIT(SSH_PACKET_SF_TRANSMITTING_BIT),  "S" },      \
0201         { BIT(SSH_PACKET_SF_TRANSMITTED_BIT),   "T" },      \
0202         { BIT(SSH_PACKET_SF_ACKED_BIT),     "A" },      \
0203         { BIT(SSH_PACKET_SF_CANCELED_BIT),  "C" },      \
0204         { BIT(SSH_PACKET_SF_COMPLETED_BIT), "F" }       \
0205     )
0206 
0207 #define ssam_show_packet_seq(seq)                   \
0208     __print_symbolic(seq,                       \
0209         { SSAM_SEQ_NOT_APPLICABLE,      "N/A" }     \
0210     )
0211 
0212 #define ssam_show_request_type(flags)                   \
0213     __print_flags((flags) & SSH_REQUEST_FLAGS_TY_MASK, "",      \
0214         { BIT(SSH_REQUEST_TY_FLUSH_BIT),    "F" },      \
0215         { BIT(SSH_REQUEST_TY_HAS_RESPONSE_BIT), "R" }       \
0216     )
0217 
0218 #define ssam_show_request_state(flags)                  \
0219     __print_flags((flags) & SSH_REQUEST_FLAGS_SF_MASK, "",      \
0220         { BIT(SSH_REQUEST_SF_LOCKED_BIT),   "L" },      \
0221         { BIT(SSH_REQUEST_SF_QUEUED_BIT),   "Q" },      \
0222         { BIT(SSH_REQUEST_SF_PENDING_BIT),  "P" },      \
0223         { BIT(SSH_REQUEST_SF_TRANSMITTING_BIT), "S" },      \
0224         { BIT(SSH_REQUEST_SF_TRANSMITTED_BIT),  "T" },      \
0225         { BIT(SSH_REQUEST_SF_RSPRCVD_BIT),  "A" },      \
0226         { BIT(SSH_REQUEST_SF_CANCELED_BIT), "C" },      \
0227         { BIT(SSH_REQUEST_SF_COMPLETED_BIT),    "F" }       \
0228     )
0229 
0230 #define ssam_show_request_id(rqid)                  \
0231     __print_symbolic(rqid,                      \
0232         { SSAM_RQID_NOT_APPLICABLE,     "N/A" }     \
0233     )
0234 
0235 #define ssam_show_ssh_tc(rqid)                      \
0236     __print_symbolic(rqid,                      \
0237         { SSAM_SSH_TC_NOT_APPLICABLE,       "N/A"  },   \
0238         { SSAM_SSH_TC_SAM,          "SAM"  },   \
0239         { SSAM_SSH_TC_BAT,          "BAT"  },   \
0240         { SSAM_SSH_TC_TMP,          "TMP"  },   \
0241         { SSAM_SSH_TC_PMC,          "PMC"  },   \
0242         { SSAM_SSH_TC_FAN,          "FAN"  },   \
0243         { SSAM_SSH_TC_PoM,          "PoM"  },   \
0244         { SSAM_SSH_TC_DBG,          "DBG"  },   \
0245         { SSAM_SSH_TC_KBD,          "KBD"  },   \
0246         { SSAM_SSH_TC_FWU,          "FWU"  },   \
0247         { SSAM_SSH_TC_UNI,          "UNI"  },   \
0248         { SSAM_SSH_TC_LPC,          "LPC"  },   \
0249         { SSAM_SSH_TC_TCL,          "TCL"  },   \
0250         { SSAM_SSH_TC_SFL,          "SFL"  },   \
0251         { SSAM_SSH_TC_KIP,          "KIP"  },   \
0252         { SSAM_SSH_TC_EXT,          "EXT"  },   \
0253         { SSAM_SSH_TC_BLD,          "BLD"  },   \
0254         { SSAM_SSH_TC_BAS,          "BAS"  },   \
0255         { SSAM_SSH_TC_SEN,          "SEN"  },   \
0256         { SSAM_SSH_TC_SRQ,          "SRQ"  },   \
0257         { SSAM_SSH_TC_MCU,          "MCU"  },   \
0258         { SSAM_SSH_TC_HID,          "HID"  },   \
0259         { SSAM_SSH_TC_TCH,          "TCH"  },   \
0260         { SSAM_SSH_TC_BKL,          "BKL"  },   \
0261         { SSAM_SSH_TC_TAM,          "TAM"  },   \
0262         { SSAM_SSH_TC_ACC0,         "ACC0" },   \
0263         { SSAM_SSH_TC_UFI,          "UFI"  },   \
0264         { SSAM_SSH_TC_USC,          "USC"  },   \
0265         { SSAM_SSH_TC_PEN,          "PEN"  },   \
0266         { SSAM_SSH_TC_VID,          "VID"  },   \
0267         { SSAM_SSH_TC_AUD,          "AUD"  },   \
0268         { SSAM_SSH_TC_SMC,          "SMC"  },   \
0269         { SSAM_SSH_TC_KPD,          "KPD"  },   \
0270         { SSAM_SSH_TC_REG,          "REG"  },   \
0271         { SSAM_SSH_TC_SPT,          "SPT"  },   \
0272         { SSAM_SSH_TC_SYS,          "SYS"  },   \
0273         { SSAM_SSH_TC_ACC1,         "ACC1" },   \
0274         { SSAM_SSH_TC_SHB,          "SMB"  },   \
0275         { SSAM_SSH_TC_POS,          "POS"  }    \
0276     )
0277 
0278 DECLARE_EVENT_CLASS(ssam_frame_class,
0279     TP_PROTO(const struct ssh_frame *frame),
0280 
0281     TP_ARGS(frame),
0282 
0283     TP_STRUCT__entry(
0284         __field(u8, type)
0285         __field(u8, seq)
0286         __field(u16, len)
0287     ),
0288 
0289     TP_fast_assign(
0290         __entry->type = frame->type;
0291         __entry->seq = frame->seq;
0292         __entry->len = get_unaligned_le16(&frame->len);
0293     ),
0294 
0295     TP_printk("ty=%s, seq=%#04x, len=%u",
0296         ssam_show_frame_type(__entry->type),
0297         __entry->seq,
0298         __entry->len
0299     )
0300 );
0301 
0302 #define DEFINE_SSAM_FRAME_EVENT(name)               \
0303     DEFINE_EVENT(ssam_frame_class, ssam_##name,     \
0304         TP_PROTO(const struct ssh_frame *frame),    \
0305         TP_ARGS(frame)                  \
0306     )
0307 
0308 DECLARE_EVENT_CLASS(ssam_command_class,
0309     TP_PROTO(const struct ssh_command *cmd, u16 len),
0310 
0311     TP_ARGS(cmd, len),
0312 
0313     TP_STRUCT__entry(
0314         __field(u16, rqid)
0315         __field(u16, len)
0316         __field(u8, tc)
0317         __field(u8, cid)
0318         __field(u8, iid)
0319     ),
0320 
0321     TP_fast_assign(
0322         __entry->rqid = get_unaligned_le16(&cmd->rqid);
0323         __entry->tc = cmd->tc;
0324         __entry->cid = cmd->cid;
0325         __entry->iid = cmd->iid;
0326         __entry->len = len;
0327     ),
0328 
0329     TP_printk("rqid=%#06x, tc=%s, cid=%#04x, iid=%#04x, len=%u",
0330         __entry->rqid,
0331         ssam_show_ssh_tc(__entry->tc),
0332         __entry->cid,
0333         __entry->iid,
0334         __entry->len
0335     )
0336 );
0337 
0338 #define DEFINE_SSAM_COMMAND_EVENT(name)                 \
0339     DEFINE_EVENT(ssam_command_class, ssam_##name,           \
0340         TP_PROTO(const struct ssh_command *cmd, u16 len),   \
0341         TP_ARGS(cmd, len)                   \
0342     )
0343 
0344 DECLARE_EVENT_CLASS(ssam_packet_class,
0345     TP_PROTO(const struct ssh_packet *packet),
0346 
0347     TP_ARGS(packet),
0348 
0349     TP_STRUCT__entry(
0350         __field(unsigned long, state)
0351         __array(char, uid, SSAM_PTR_UID_LEN)
0352         __field(u8, priority)
0353         __field(u16, length)
0354         __field(u16, seq)
0355     ),
0356 
0357     TP_fast_assign(
0358         __entry->state = READ_ONCE(packet->state);
0359         ssam_trace_ptr_uid(packet, __entry->uid);
0360         __entry->priority = READ_ONCE(packet->priority);
0361         __entry->length = packet->data.len;
0362         __entry->seq = ssam_trace_get_packet_seq(packet);
0363     ),
0364 
0365     TP_printk("uid=%s, seq=%s, ty=%s, pri=%#04x, len=%u, sta=%s",
0366         __entry->uid,
0367         ssam_show_packet_seq(__entry->seq),
0368         ssam_show_packet_type(__entry->state),
0369         __entry->priority,
0370         __entry->length,
0371         ssam_show_packet_state(__entry->state)
0372     )
0373 );
0374 
0375 #define DEFINE_SSAM_PACKET_EVENT(name)              \
0376     DEFINE_EVENT(ssam_packet_class, ssam_##name,        \
0377         TP_PROTO(const struct ssh_packet *packet),  \
0378         TP_ARGS(packet)                 \
0379     )
0380 
0381 DECLARE_EVENT_CLASS(ssam_packet_status_class,
0382     TP_PROTO(const struct ssh_packet *packet, int status),
0383 
0384     TP_ARGS(packet, status),
0385 
0386     TP_STRUCT__entry(
0387         __field(unsigned long, state)
0388         __field(int, status)
0389         __array(char, uid, SSAM_PTR_UID_LEN)
0390         __field(u8, priority)
0391         __field(u16, length)
0392         __field(u16, seq)
0393     ),
0394 
0395     TP_fast_assign(
0396         __entry->state = READ_ONCE(packet->state);
0397         __entry->status = status;
0398         ssam_trace_ptr_uid(packet, __entry->uid);
0399         __entry->priority = READ_ONCE(packet->priority);
0400         __entry->length = packet->data.len;
0401         __entry->seq = ssam_trace_get_packet_seq(packet);
0402     ),
0403 
0404     TP_printk("uid=%s, seq=%s, ty=%s, pri=%#04x, len=%u, sta=%s, status=%d",
0405         __entry->uid,
0406         ssam_show_packet_seq(__entry->seq),
0407         ssam_show_packet_type(__entry->state),
0408         __entry->priority,
0409         __entry->length,
0410         ssam_show_packet_state(__entry->state),
0411         __entry->status
0412     )
0413 );
0414 
0415 #define DEFINE_SSAM_PACKET_STATUS_EVENT(name)               \
0416     DEFINE_EVENT(ssam_packet_status_class, ssam_##name,     \
0417         TP_PROTO(const struct ssh_packet *packet, int status),  \
0418         TP_ARGS(packet, status)                 \
0419     )
0420 
0421 DECLARE_EVENT_CLASS(ssam_request_class,
0422     TP_PROTO(const struct ssh_request *request),
0423 
0424     TP_ARGS(request),
0425 
0426     TP_STRUCT__entry(
0427         __field(unsigned long, state)
0428         __field(u32, rqid)
0429         __array(char, uid, SSAM_PTR_UID_LEN)
0430         __field(u8, tc)
0431         __field(u16, cid)
0432         __field(u16, iid)
0433     ),
0434 
0435     TP_fast_assign(
0436         const struct ssh_packet *p = &request->packet;
0437 
0438         /* Use packet for UID so we can match requests to packets. */
0439         __entry->state = READ_ONCE(request->state);
0440         __entry->rqid = ssam_trace_get_request_id(p);
0441         ssam_trace_ptr_uid(p, __entry->uid);
0442         __entry->tc = ssam_trace_get_request_tc(p);
0443         __entry->cid = ssam_trace_get_command_field_u8(p, cid);
0444         __entry->iid = ssam_trace_get_command_field_u8(p, iid);
0445     ),
0446 
0447     TP_printk("uid=%s, rqid=%s, ty=%s, sta=%s, tc=%s, cid=%s, iid=%s",
0448         __entry->uid,
0449         ssam_show_request_id(__entry->rqid),
0450         ssam_show_request_type(__entry->state),
0451         ssam_show_request_state(__entry->state),
0452         ssam_show_ssh_tc(__entry->tc),
0453         ssam_show_generic_u8_field(__entry->cid),
0454         ssam_show_generic_u8_field(__entry->iid)
0455     )
0456 );
0457 
0458 #define DEFINE_SSAM_REQUEST_EVENT(name)             \
0459     DEFINE_EVENT(ssam_request_class, ssam_##name,       \
0460         TP_PROTO(const struct ssh_request *request),    \
0461         TP_ARGS(request)                \
0462     )
0463 
0464 DECLARE_EVENT_CLASS(ssam_request_status_class,
0465     TP_PROTO(const struct ssh_request *request, int status),
0466 
0467     TP_ARGS(request, status),
0468 
0469     TP_STRUCT__entry(
0470         __field(unsigned long, state)
0471         __field(u32, rqid)
0472         __field(int, status)
0473         __array(char, uid, SSAM_PTR_UID_LEN)
0474         __field(u8, tc)
0475         __field(u16, cid)
0476         __field(u16, iid)
0477     ),
0478 
0479     TP_fast_assign(
0480         const struct ssh_packet *p = &request->packet;
0481 
0482         /* Use packet for UID so we can match requests to packets. */
0483         __entry->state = READ_ONCE(request->state);
0484         __entry->rqid = ssam_trace_get_request_id(p);
0485         __entry->status = status;
0486         ssam_trace_ptr_uid(p, __entry->uid);
0487         __entry->tc = ssam_trace_get_request_tc(p);
0488         __entry->cid = ssam_trace_get_command_field_u8(p, cid);
0489         __entry->iid = ssam_trace_get_command_field_u8(p, iid);
0490     ),
0491 
0492     TP_printk("uid=%s, rqid=%s, ty=%s, sta=%s, tc=%s, cid=%s, iid=%s, status=%d",
0493         __entry->uid,
0494         ssam_show_request_id(__entry->rqid),
0495         ssam_show_request_type(__entry->state),
0496         ssam_show_request_state(__entry->state),
0497         ssam_show_ssh_tc(__entry->tc),
0498         ssam_show_generic_u8_field(__entry->cid),
0499         ssam_show_generic_u8_field(__entry->iid),
0500         __entry->status
0501     )
0502 );
0503 
0504 #define DEFINE_SSAM_REQUEST_STATUS_EVENT(name)              \
0505     DEFINE_EVENT(ssam_request_status_class, ssam_##name,        \
0506         TP_PROTO(const struct ssh_request *request, int status),\
0507         TP_ARGS(request, status)                \
0508     )
0509 
0510 DECLARE_EVENT_CLASS(ssam_alloc_class,
0511     TP_PROTO(void *ptr, size_t len),
0512 
0513     TP_ARGS(ptr, len),
0514 
0515     TP_STRUCT__entry(
0516         __field(size_t, len)
0517         __array(char, uid, SSAM_PTR_UID_LEN)
0518     ),
0519 
0520     TP_fast_assign(
0521         __entry->len = len;
0522         ssam_trace_ptr_uid(ptr, __entry->uid);
0523     ),
0524 
0525     TP_printk("uid=%s, len=%zu", __entry->uid, __entry->len)
0526 );
0527 
0528 #define DEFINE_SSAM_ALLOC_EVENT(name)                   \
0529     DEFINE_EVENT(ssam_alloc_class, ssam_##name,         \
0530         TP_PROTO(void *ptr, size_t len),            \
0531         TP_ARGS(ptr, len)                   \
0532     )
0533 
0534 DECLARE_EVENT_CLASS(ssam_free_class,
0535     TP_PROTO(void *ptr),
0536 
0537     TP_ARGS(ptr),
0538 
0539     TP_STRUCT__entry(
0540         __array(char, uid, SSAM_PTR_UID_LEN)
0541     ),
0542 
0543     TP_fast_assign(
0544         ssam_trace_ptr_uid(ptr, __entry->uid);
0545     ),
0546 
0547     TP_printk("uid=%s", __entry->uid)
0548 );
0549 
0550 #define DEFINE_SSAM_FREE_EVENT(name)                    \
0551     DEFINE_EVENT(ssam_free_class, ssam_##name,          \
0552         TP_PROTO(void *ptr),                    \
0553         TP_ARGS(ptr)                        \
0554     )
0555 
0556 DECLARE_EVENT_CLASS(ssam_pending_class,
0557     TP_PROTO(unsigned int pending),
0558 
0559     TP_ARGS(pending),
0560 
0561     TP_STRUCT__entry(
0562         __field(unsigned int, pending)
0563     ),
0564 
0565     TP_fast_assign(
0566         __entry->pending = pending;
0567     ),
0568 
0569     TP_printk("pending=%u", __entry->pending)
0570 );
0571 
0572 #define DEFINE_SSAM_PENDING_EVENT(name)                 \
0573     DEFINE_EVENT(ssam_pending_class, ssam_##name,           \
0574         TP_PROTO(unsigned int pending),             \
0575         TP_ARGS(pending)                    \
0576     )
0577 
0578 DECLARE_EVENT_CLASS(ssam_data_class,
0579     TP_PROTO(size_t length),
0580 
0581     TP_ARGS(length),
0582 
0583     TP_STRUCT__entry(
0584         __field(size_t, length)
0585     ),
0586 
0587     TP_fast_assign(
0588         __entry->length = length;
0589     ),
0590 
0591     TP_printk("length=%zu", __entry->length)
0592 );
0593 
0594 #define DEFINE_SSAM_DATA_EVENT(name)                    \
0595     DEFINE_EVENT(ssam_data_class, ssam_##name,          \
0596         TP_PROTO(size_t length),                \
0597         TP_ARGS(length)                     \
0598     )
0599 
0600 DEFINE_SSAM_FRAME_EVENT(rx_frame_received);
0601 DEFINE_SSAM_COMMAND_EVENT(rx_response_received);
0602 DEFINE_SSAM_COMMAND_EVENT(rx_event_received);
0603 
0604 DEFINE_SSAM_PACKET_EVENT(packet_release);
0605 DEFINE_SSAM_PACKET_EVENT(packet_submit);
0606 DEFINE_SSAM_PACKET_EVENT(packet_resubmit);
0607 DEFINE_SSAM_PACKET_EVENT(packet_timeout);
0608 DEFINE_SSAM_PACKET_EVENT(packet_cancel);
0609 DEFINE_SSAM_PACKET_STATUS_EVENT(packet_complete);
0610 DEFINE_SSAM_PENDING_EVENT(ptl_timeout_reap);
0611 
0612 DEFINE_SSAM_REQUEST_EVENT(request_submit);
0613 DEFINE_SSAM_REQUEST_EVENT(request_timeout);
0614 DEFINE_SSAM_REQUEST_EVENT(request_cancel);
0615 DEFINE_SSAM_REQUEST_STATUS_EVENT(request_complete);
0616 DEFINE_SSAM_PENDING_EVENT(rtl_timeout_reap);
0617 
0618 DEFINE_SSAM_PACKET_EVENT(ei_tx_drop_ack_packet);
0619 DEFINE_SSAM_PACKET_EVENT(ei_tx_drop_nak_packet);
0620 DEFINE_SSAM_PACKET_EVENT(ei_tx_drop_dsq_packet);
0621 DEFINE_SSAM_PACKET_STATUS_EVENT(ei_tx_fail_write);
0622 DEFINE_SSAM_PACKET_EVENT(ei_tx_corrupt_data);
0623 DEFINE_SSAM_DATA_EVENT(ei_rx_corrupt_syn);
0624 DEFINE_SSAM_FRAME_EVENT(ei_rx_corrupt_data);
0625 DEFINE_SSAM_REQUEST_EVENT(ei_rx_drop_response);
0626 
0627 DEFINE_SSAM_ALLOC_EVENT(ctrl_packet_alloc);
0628 DEFINE_SSAM_FREE_EVENT(ctrl_packet_free);
0629 
0630 DEFINE_SSAM_ALLOC_EVENT(event_item_alloc);
0631 DEFINE_SSAM_FREE_EVENT(event_item_free);
0632 
0633 #endif /* _SURFACE_AGGREGATOR_TRACE_H */
0634 
0635 /* This part must be outside protection */
0636 #undef TRACE_INCLUDE_PATH
0637 #undef TRACE_INCLUDE_FILE
0638 
0639 #define TRACE_INCLUDE_PATH .
0640 #define TRACE_INCLUDE_FILE trace
0641 
0642 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!