1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /*
3 * Trace points for SSAM/SSH.
4 *
5 * Copyright (C) 2020-2021 Maximilian Luz <luzmaximilian@gmail.com>
6 */
7
8 #undef TRACE_SYSTEM
9 #define TRACE_SYSTEM surface_aggregator
10
11 #if !defined(_SURFACE_AGGREGATOR_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
12 #define _SURFACE_AGGREGATOR_TRACE_H
13
14 #include <linux/surface_aggregator/serial_hub.h>
15
16 #include <asm/unaligned.h>
17 #include <linux/tracepoint.h>
18
19 TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_DATA_SEQ);
20 TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_DATA_NSQ);
21 TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_ACK);
22 TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_NAK);
23
24 TRACE_DEFINE_ENUM(SSH_PACKET_SF_LOCKED_BIT);
25 TRACE_DEFINE_ENUM(SSH_PACKET_SF_QUEUED_BIT);
26 TRACE_DEFINE_ENUM(SSH_PACKET_SF_PENDING_BIT);
27 TRACE_DEFINE_ENUM(SSH_PACKET_SF_TRANSMITTING_BIT);
28 TRACE_DEFINE_ENUM(SSH_PACKET_SF_TRANSMITTED_BIT);
29 TRACE_DEFINE_ENUM(SSH_PACKET_SF_ACKED_BIT);
30 TRACE_DEFINE_ENUM(SSH_PACKET_SF_CANCELED_BIT);
31 TRACE_DEFINE_ENUM(SSH_PACKET_SF_COMPLETED_BIT);
32
33 TRACE_DEFINE_ENUM(SSH_PACKET_TY_FLUSH_BIT);
34 TRACE_DEFINE_ENUM(SSH_PACKET_TY_SEQUENCED_BIT);
35 TRACE_DEFINE_ENUM(SSH_PACKET_TY_BLOCKING_BIT);
36
37 TRACE_DEFINE_ENUM(SSH_PACKET_FLAGS_SF_MASK);
38 TRACE_DEFINE_ENUM(SSH_PACKET_FLAGS_TY_MASK);
39
40 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_LOCKED_BIT);
41 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_QUEUED_BIT);
42 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_PENDING_BIT);
43 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_TRANSMITTING_BIT);
44 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_TRANSMITTED_BIT);
45 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_RSPRCVD_BIT);
46 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_CANCELED_BIT);
47 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_COMPLETED_BIT);
48
49 TRACE_DEFINE_ENUM(SSH_REQUEST_TY_FLUSH_BIT);
50 TRACE_DEFINE_ENUM(SSH_REQUEST_TY_HAS_RESPONSE_BIT);
51
52 TRACE_DEFINE_ENUM(SSH_REQUEST_FLAGS_SF_MASK);
53 TRACE_DEFINE_ENUM(SSH_REQUEST_FLAGS_TY_MASK);
54
55 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SAM);
56 TRACE_DEFINE_ENUM(SSAM_SSH_TC_BAT);
57 TRACE_DEFINE_ENUM(SSAM_SSH_TC_TMP);
58 TRACE_DEFINE_ENUM(SSAM_SSH_TC_PMC);
59 TRACE_DEFINE_ENUM(SSAM_SSH_TC_FAN);
60 TRACE_DEFINE_ENUM(SSAM_SSH_TC_PoM);
61 TRACE_DEFINE_ENUM(SSAM_SSH_TC_DBG);
62 TRACE_DEFINE_ENUM(SSAM_SSH_TC_KBD);
63 TRACE_DEFINE_ENUM(SSAM_SSH_TC_FWU);
64 TRACE_DEFINE_ENUM(SSAM_SSH_TC_UNI);
65 TRACE_DEFINE_ENUM(SSAM_SSH_TC_LPC);
66 TRACE_DEFINE_ENUM(SSAM_SSH_TC_TCL);
67 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SFL);
68 TRACE_DEFINE_ENUM(SSAM_SSH_TC_KIP);
69 TRACE_DEFINE_ENUM(SSAM_SSH_TC_EXT);
70 TRACE_DEFINE_ENUM(SSAM_SSH_TC_BLD);
71 TRACE_DEFINE_ENUM(SSAM_SSH_TC_BAS);
72 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SEN);
73 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SRQ);
74 TRACE_DEFINE_ENUM(SSAM_SSH_TC_MCU);
75 TRACE_DEFINE_ENUM(SSAM_SSH_TC_HID);
76 TRACE_DEFINE_ENUM(SSAM_SSH_TC_TCH);
77 TRACE_DEFINE_ENUM(SSAM_SSH_TC_BKL);
78 TRACE_DEFINE_ENUM(SSAM_SSH_TC_TAM);
79 TRACE_DEFINE_ENUM(SSAM_SSH_TC_ACC);
80 TRACE_DEFINE_ENUM(SSAM_SSH_TC_UFI);
81 TRACE_DEFINE_ENUM(SSAM_SSH_TC_USC);
82 TRACE_DEFINE_ENUM(SSAM_SSH_TC_PEN);
83 TRACE_DEFINE_ENUM(SSAM_SSH_TC_VID);
84 TRACE_DEFINE_ENUM(SSAM_SSH_TC_AUD);
85 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SMC);
86 TRACE_DEFINE_ENUM(SSAM_SSH_TC_KPD);
87 TRACE_DEFINE_ENUM(SSAM_SSH_TC_REG);
88
89 #define SSAM_PTR_UID_LEN 9
90 #define SSAM_U8_FIELD_NOT_APPLICABLE ((u16)-1)
91 #define SSAM_SEQ_NOT_APPLICABLE ((u16)-1)
92 #define SSAM_RQID_NOT_APPLICABLE ((u32)-1)
93 #define SSAM_SSH_TC_NOT_APPLICABLE 0
94
95 #ifndef _SURFACE_AGGREGATOR_TRACE_HELPERS
96 #define _SURFACE_AGGREGATOR_TRACE_HELPERS
97
98 /**
99 * ssam_trace_ptr_uid() - Convert the pointer to a non-pointer UID string.
100 * @ptr: The pointer to convert.
101 * @uid_str: A buffer of length SSAM_PTR_UID_LEN where the UID will be stored.
102 *
103 * Converts the given pointer into a UID string that is safe to be shared
104 * with userspace and logs, i.e. doesn't give away the real memory location.
105 */
ssam_trace_ptr_uid(const void * ptr,char * uid_str)106 static inline void ssam_trace_ptr_uid(const void *ptr, char *uid_str)
107 {
108 char buf[2 * sizeof(void *) + 1];
109
110 BUILD_BUG_ON(ARRAY_SIZE(buf) < SSAM_PTR_UID_LEN);
111
112 snprintf(buf, ARRAY_SIZE(buf), "%p", ptr);
113 memcpy(uid_str, &buf[ARRAY_SIZE(buf) - SSAM_PTR_UID_LEN],
114 SSAM_PTR_UID_LEN);
115 }
116
117 /**
118 * ssam_trace_get_packet_seq() - Read the packet's sequence ID.
119 * @p: The packet.
120 *
121 * Return: Returns the packet's sequence ID (SEQ) field if present, or
122 * %SSAM_SEQ_NOT_APPLICABLE if not (e.g. flush packet).
123 */
ssam_trace_get_packet_seq(const struct ssh_packet * p)124 static inline u16 ssam_trace_get_packet_seq(const struct ssh_packet *p)
125 {
126 if (!p->data.ptr || p->data.len < SSH_MESSAGE_LENGTH(0))
127 return SSAM_SEQ_NOT_APPLICABLE;
128
129 return p->data.ptr[SSH_MSGOFFSET_FRAME(seq)];
130 }
131
132 /**
133 * ssam_trace_get_request_id() - Read the packet's request ID.
134 * @p: The packet.
135 *
136 * Return: Returns the packet's request ID (RQID) field if the packet
137 * represents a request with command data, or %SSAM_RQID_NOT_APPLICABLE if not
138 * (e.g. flush request, control packet).
139 */
ssam_trace_get_request_id(const struct ssh_packet * p)140 static inline u32 ssam_trace_get_request_id(const struct ssh_packet *p)
141 {
142 if (!p->data.ptr || p->data.len < SSH_COMMAND_MESSAGE_LENGTH(0))
143 return SSAM_RQID_NOT_APPLICABLE;
144
145 return get_unaligned_le16(&p->data.ptr[SSH_MSGOFFSET_COMMAND(rqid)]);
146 }
147
148 /**
149 * ssam_trace_get_request_tc() - Read the packet's request target category.
150 * @p: The packet.
151 *
152 * Return: Returns the packet's request target category (TC) field if the
153 * packet represents a request with command data, or %SSAM_TC_NOT_APPLICABLE
154 * if not (e.g. flush request, control packet).
155 */
ssam_trace_get_request_tc(const struct ssh_packet * p)156 static inline u32 ssam_trace_get_request_tc(const struct ssh_packet *p)
157 {
158 if (!p->data.ptr || p->data.len < SSH_COMMAND_MESSAGE_LENGTH(0))
159 return SSAM_SSH_TC_NOT_APPLICABLE;
160
161 return get_unaligned_le16(&p->data.ptr[SSH_MSGOFFSET_COMMAND(tc)]);
162 }
163
164 #endif /* _SURFACE_AGGREGATOR_TRACE_HELPERS */
165
166 #define ssam_trace_get_command_field_u8(packet, field) \
167 ((!(packet) || (packet)->data.len < SSH_COMMAND_MESSAGE_LENGTH(0)) \
168 ? 0 : (packet)->data.ptr[SSH_MSGOFFSET_COMMAND(field)])
169
170 #define ssam_show_generic_u8_field(value) \
171 __print_symbolic(value, \
172 { SSAM_U8_FIELD_NOT_APPLICABLE, "N/A" } \
173 )
174
175 #define ssam_show_frame_type(ty) \
176 __print_symbolic(ty, \
177 { SSH_FRAME_TYPE_DATA_SEQ, "DSEQ" }, \
178 { SSH_FRAME_TYPE_DATA_NSQ, "DNSQ" }, \
179 { SSH_FRAME_TYPE_ACK, "ACK" }, \
180 { SSH_FRAME_TYPE_NAK, "NAK" } \
181 )
182
183 #define ssam_show_packet_type(type) \
184 __print_flags(flags & SSH_PACKET_FLAGS_TY_MASK, "", \
185 { BIT(SSH_PACKET_TY_FLUSH_BIT), "F" }, \
186 { BIT(SSH_PACKET_TY_SEQUENCED_BIT), "S" }, \
187 { BIT(SSH_PACKET_TY_BLOCKING_BIT), "B" } \
188 )
189
190 #define ssam_show_packet_state(state) \
191 __print_flags(flags & SSH_PACKET_FLAGS_SF_MASK, "", \
192 { BIT(SSH_PACKET_SF_LOCKED_BIT), "L" }, \
193 { BIT(SSH_PACKET_SF_QUEUED_BIT), "Q" }, \
194 { BIT(SSH_PACKET_SF_PENDING_BIT), "P" }, \
195 { BIT(SSH_PACKET_SF_TRANSMITTING_BIT), "S" }, \
196 { BIT(SSH_PACKET_SF_TRANSMITTED_BIT), "T" }, \
197 { BIT(SSH_PACKET_SF_ACKED_BIT), "A" }, \
198 { BIT(SSH_PACKET_SF_CANCELED_BIT), "C" }, \
199 { BIT(SSH_PACKET_SF_COMPLETED_BIT), "F" } \
200 )
201
202 #define ssam_show_packet_seq(seq) \
203 __print_symbolic(seq, \
204 { SSAM_SEQ_NOT_APPLICABLE, "N/A" } \
205 )
206
207 #define ssam_show_request_type(flags) \
208 __print_flags((flags) & SSH_REQUEST_FLAGS_TY_MASK, "", \
209 { BIT(SSH_REQUEST_TY_FLUSH_BIT), "F" }, \
210 { BIT(SSH_REQUEST_TY_HAS_RESPONSE_BIT), "R" } \
211 )
212
213 #define ssam_show_request_state(flags) \
214 __print_flags((flags) & SSH_REQUEST_FLAGS_SF_MASK, "", \
215 { BIT(SSH_REQUEST_SF_LOCKED_BIT), "L" }, \
216 { BIT(SSH_REQUEST_SF_QUEUED_BIT), "Q" }, \
217 { BIT(SSH_REQUEST_SF_PENDING_BIT), "P" }, \
218 { BIT(SSH_REQUEST_SF_TRANSMITTING_BIT), "S" }, \
219 { BIT(SSH_REQUEST_SF_TRANSMITTED_BIT), "T" }, \
220 { BIT(SSH_REQUEST_SF_RSPRCVD_BIT), "A" }, \
221 { BIT(SSH_REQUEST_SF_CANCELED_BIT), "C" }, \
222 { BIT(SSH_REQUEST_SF_COMPLETED_BIT), "F" } \
223 )
224
225 #define ssam_show_request_id(rqid) \
226 __print_symbolic(rqid, \
227 { SSAM_RQID_NOT_APPLICABLE, "N/A" } \
228 )
229
230 #define ssam_show_ssh_tc(rqid) \
231 __print_symbolic(rqid, \
232 { SSAM_SSH_TC_NOT_APPLICABLE, "N/A" }, \
233 { SSAM_SSH_TC_SAM, "SAM" }, \
234 { SSAM_SSH_TC_BAT, "BAT" }, \
235 { SSAM_SSH_TC_TMP, "TMP" }, \
236 { SSAM_SSH_TC_PMC, "PMC" }, \
237 { SSAM_SSH_TC_FAN, "FAN" }, \
238 { SSAM_SSH_TC_PoM, "PoM" }, \
239 { SSAM_SSH_TC_DBG, "DBG" }, \
240 { SSAM_SSH_TC_KBD, "KBD" }, \
241 { SSAM_SSH_TC_FWU, "FWU" }, \
242 { SSAM_SSH_TC_UNI, "UNI" }, \
243 { SSAM_SSH_TC_LPC, "LPC" }, \
244 { SSAM_SSH_TC_TCL, "TCL" }, \
245 { SSAM_SSH_TC_SFL, "SFL" }, \
246 { SSAM_SSH_TC_KIP, "KIP" }, \
247 { SSAM_SSH_TC_EXT, "EXT" }, \
248 { SSAM_SSH_TC_BLD, "BLD" }, \
249 { SSAM_SSH_TC_BAS, "BAS" }, \
250 { SSAM_SSH_TC_SEN, "SEN" }, \
251 { SSAM_SSH_TC_SRQ, "SRQ" }, \
252 { SSAM_SSH_TC_MCU, "MCU" }, \
253 { SSAM_SSH_TC_HID, "HID" }, \
254 { SSAM_SSH_TC_TCH, "TCH" }, \
255 { SSAM_SSH_TC_BKL, "BKL" }, \
256 { SSAM_SSH_TC_TAM, "TAM" }, \
257 { SSAM_SSH_TC_ACC, "ACC" }, \
258 { SSAM_SSH_TC_UFI, "UFI" }, \
259 { SSAM_SSH_TC_USC, "USC" }, \
260 { SSAM_SSH_TC_PEN, "PEN" }, \
261 { SSAM_SSH_TC_VID, "VID" }, \
262 { SSAM_SSH_TC_AUD, "AUD" }, \
263 { SSAM_SSH_TC_SMC, "SMC" }, \
264 { SSAM_SSH_TC_KPD, "KPD" }, \
265 { SSAM_SSH_TC_REG, "REG" } \
266 )
267
268 DECLARE_EVENT_CLASS(ssam_frame_class,
269 TP_PROTO(const struct ssh_frame *frame),
270
271 TP_ARGS(frame),
272
273 TP_STRUCT__entry(
274 __field(u8, type)
275 __field(u8, seq)
276 __field(u16, len)
277 ),
278
279 TP_fast_assign(
280 __entry->type = frame->type;
281 __entry->seq = frame->seq;
282 __entry->len = get_unaligned_le16(&frame->len);
283 ),
284
285 TP_printk("ty=%s, seq=%#04x, len=%u",
286 ssam_show_frame_type(__entry->type),
287 __entry->seq,
288 __entry->len
289 )
290 );
291
292 #define DEFINE_SSAM_FRAME_EVENT(name) \
293 DEFINE_EVENT(ssam_frame_class, ssam_##name, \
294 TP_PROTO(const struct ssh_frame *frame), \
295 TP_ARGS(frame) \
296 )
297
298 DECLARE_EVENT_CLASS(ssam_command_class,
299 TP_PROTO(const struct ssh_command *cmd, u16 len),
300
301 TP_ARGS(cmd, len),
302
303 TP_STRUCT__entry(
304 __field(u16, rqid)
305 __field(u16, len)
306 __field(u8, tc)
307 __field(u8, cid)
308 __field(u8, iid)
309 ),
310
311 TP_fast_assign(
312 __entry->rqid = get_unaligned_le16(&cmd->rqid);
313 __entry->tc = cmd->tc;
314 __entry->cid = cmd->cid;
315 __entry->iid = cmd->iid;
316 __entry->len = len;
317 ),
318
319 TP_printk("rqid=%#06x, tc=%s, cid=%#04x, iid=%#04x, len=%u",
320 __entry->rqid,
321 ssam_show_ssh_tc(__entry->tc),
322 __entry->cid,
323 __entry->iid,
324 __entry->len
325 )
326 );
327
328 #define DEFINE_SSAM_COMMAND_EVENT(name) \
329 DEFINE_EVENT(ssam_command_class, ssam_##name, \
330 TP_PROTO(const struct ssh_command *cmd, u16 len), \
331 TP_ARGS(cmd, len) \
332 )
333
334 DECLARE_EVENT_CLASS(ssam_packet_class,
335 TP_PROTO(const struct ssh_packet *packet),
336
337 TP_ARGS(packet),
338
339 TP_STRUCT__entry(
340 __field(unsigned long, state)
341 __array(char, uid, SSAM_PTR_UID_LEN)
342 __field(u8, priority)
343 __field(u16, length)
344 __field(u16, seq)
345 ),
346
347 TP_fast_assign(
348 __entry->state = READ_ONCE(packet->state);
349 ssam_trace_ptr_uid(packet, __entry->uid);
350 __entry->priority = READ_ONCE(packet->priority);
351 __entry->length = packet->data.len;
352 __entry->seq = ssam_trace_get_packet_seq(packet);
353 ),
354
355 TP_printk("uid=%s, seq=%s, ty=%s, pri=%#04x, len=%u, sta=%s",
356 __entry->uid,
357 ssam_show_packet_seq(__entry->seq),
358 ssam_show_packet_type(__entry->state),
359 __entry->priority,
360 __entry->length,
361 ssam_show_packet_state(__entry->state)
362 )
363 );
364
365 #define DEFINE_SSAM_PACKET_EVENT(name) \
366 DEFINE_EVENT(ssam_packet_class, ssam_##name, \
367 TP_PROTO(const struct ssh_packet *packet), \
368 TP_ARGS(packet) \
369 )
370
371 DECLARE_EVENT_CLASS(ssam_packet_status_class,
372 TP_PROTO(const struct ssh_packet *packet, int status),
373
374 TP_ARGS(packet, status),
375
376 TP_STRUCT__entry(
377 __field(unsigned long, state)
378 __field(int, status)
379 __array(char, uid, SSAM_PTR_UID_LEN)
380 __field(u8, priority)
381 __field(u16, length)
382 __field(u16, seq)
383 ),
384
385 TP_fast_assign(
386 __entry->state = READ_ONCE(packet->state);
387 __entry->status = status;
388 ssam_trace_ptr_uid(packet, __entry->uid);
389 __entry->priority = READ_ONCE(packet->priority);
390 __entry->length = packet->data.len;
391 __entry->seq = ssam_trace_get_packet_seq(packet);
392 ),
393
394 TP_printk("uid=%s, seq=%s, ty=%s, pri=%#04x, len=%u, sta=%s, status=%d",
395 __entry->uid,
396 ssam_show_packet_seq(__entry->seq),
397 ssam_show_packet_type(__entry->state),
398 __entry->priority,
399 __entry->length,
400 ssam_show_packet_state(__entry->state),
401 __entry->status
402 )
403 );
404
405 #define DEFINE_SSAM_PACKET_STATUS_EVENT(name) \
406 DEFINE_EVENT(ssam_packet_status_class, ssam_##name, \
407 TP_PROTO(const struct ssh_packet *packet, int status), \
408 TP_ARGS(packet, status) \
409 )
410
411 DECLARE_EVENT_CLASS(ssam_request_class,
412 TP_PROTO(const struct ssh_request *request),
413
414 TP_ARGS(request),
415
416 TP_STRUCT__entry(
417 __field(unsigned long, state)
418 __field(u32, rqid)
419 __array(char, uid, SSAM_PTR_UID_LEN)
420 __field(u8, tc)
421 __field(u16, cid)
422 __field(u16, iid)
423 ),
424
425 TP_fast_assign(
426 const struct ssh_packet *p = &request->packet;
427
428 /* Use packet for UID so we can match requests to packets. */
429 __entry->state = READ_ONCE(request->state);
430 __entry->rqid = ssam_trace_get_request_id(p);
431 ssam_trace_ptr_uid(p, __entry->uid);
432 __entry->tc = ssam_trace_get_request_tc(p);
433 __entry->cid = ssam_trace_get_command_field_u8(p, cid);
434 __entry->iid = ssam_trace_get_command_field_u8(p, iid);
435 ),
436
437 TP_printk("uid=%s, rqid=%s, ty=%s, sta=%s, tc=%s, cid=%s, iid=%s",
438 __entry->uid,
439 ssam_show_request_id(__entry->rqid),
440 ssam_show_request_type(__entry->state),
441 ssam_show_request_state(__entry->state),
442 ssam_show_ssh_tc(__entry->tc),
443 ssam_show_generic_u8_field(__entry->cid),
444 ssam_show_generic_u8_field(__entry->iid)
445 )
446 );
447
448 #define DEFINE_SSAM_REQUEST_EVENT(name) \
449 DEFINE_EVENT(ssam_request_class, ssam_##name, \
450 TP_PROTO(const struct ssh_request *request), \
451 TP_ARGS(request) \
452 )
453
454 DECLARE_EVENT_CLASS(ssam_request_status_class,
455 TP_PROTO(const struct ssh_request *request, int status),
456
457 TP_ARGS(request, status),
458
459 TP_STRUCT__entry(
460 __field(unsigned long, state)
461 __field(u32, rqid)
462 __field(int, status)
463 __array(char, uid, SSAM_PTR_UID_LEN)
464 __field(u8, tc)
465 __field(u16, cid)
466 __field(u16, iid)
467 ),
468
469 TP_fast_assign(
470 const struct ssh_packet *p = &request->packet;
471
472 /* Use packet for UID so we can match requests to packets. */
473 __entry->state = READ_ONCE(request->state);
474 __entry->rqid = ssam_trace_get_request_id(p);
475 __entry->status = status;
476 ssam_trace_ptr_uid(p, __entry->uid);
477 __entry->tc = ssam_trace_get_request_tc(p);
478 __entry->cid = ssam_trace_get_command_field_u8(p, cid);
479 __entry->iid = ssam_trace_get_command_field_u8(p, iid);
480 ),
481
482 TP_printk("uid=%s, rqid=%s, ty=%s, sta=%s, tc=%s, cid=%s, iid=%s, status=%d",
483 __entry->uid,
484 ssam_show_request_id(__entry->rqid),
485 ssam_show_request_type(__entry->state),
486 ssam_show_request_state(__entry->state),
487 ssam_show_ssh_tc(__entry->tc),
488 ssam_show_generic_u8_field(__entry->cid),
489 ssam_show_generic_u8_field(__entry->iid),
490 __entry->status
491 )
492 );
493
494 #define DEFINE_SSAM_REQUEST_STATUS_EVENT(name) \
495 DEFINE_EVENT(ssam_request_status_class, ssam_##name, \
496 TP_PROTO(const struct ssh_request *request, int status),\
497 TP_ARGS(request, status) \
498 )
499
500 DECLARE_EVENT_CLASS(ssam_alloc_class,
501 TP_PROTO(void *ptr, size_t len),
502
503 TP_ARGS(ptr, len),
504
505 TP_STRUCT__entry(
506 __field(size_t, len)
507 __array(char, uid, SSAM_PTR_UID_LEN)
508 ),
509
510 TP_fast_assign(
511 __entry->len = len;
512 ssam_trace_ptr_uid(ptr, __entry->uid);
513 ),
514
515 TP_printk("uid=%s, len=%zu", __entry->uid, __entry->len)
516 );
517
518 #define DEFINE_SSAM_ALLOC_EVENT(name) \
519 DEFINE_EVENT(ssam_alloc_class, ssam_##name, \
520 TP_PROTO(void *ptr, size_t len), \
521 TP_ARGS(ptr, len) \
522 )
523
524 DECLARE_EVENT_CLASS(ssam_free_class,
525 TP_PROTO(void *ptr),
526
527 TP_ARGS(ptr),
528
529 TP_STRUCT__entry(
530 __array(char, uid, SSAM_PTR_UID_LEN)
531 ),
532
533 TP_fast_assign(
534 ssam_trace_ptr_uid(ptr, __entry->uid);
535 ),
536
537 TP_printk("uid=%s", __entry->uid)
538 );
539
540 #define DEFINE_SSAM_FREE_EVENT(name) \
541 DEFINE_EVENT(ssam_free_class, ssam_##name, \
542 TP_PROTO(void *ptr), \
543 TP_ARGS(ptr) \
544 )
545
546 DECLARE_EVENT_CLASS(ssam_pending_class,
547 TP_PROTO(unsigned int pending),
548
549 TP_ARGS(pending),
550
551 TP_STRUCT__entry(
552 __field(unsigned int, pending)
553 ),
554
555 TP_fast_assign(
556 __entry->pending = pending;
557 ),
558
559 TP_printk("pending=%u", __entry->pending)
560 );
561
562 #define DEFINE_SSAM_PENDING_EVENT(name) \
563 DEFINE_EVENT(ssam_pending_class, ssam_##name, \
564 TP_PROTO(unsigned int pending), \
565 TP_ARGS(pending) \
566 )
567
568 DECLARE_EVENT_CLASS(ssam_data_class,
569 TP_PROTO(size_t length),
570
571 TP_ARGS(length),
572
573 TP_STRUCT__entry(
574 __field(size_t, length)
575 ),
576
577 TP_fast_assign(
578 __entry->length = length;
579 ),
580
581 TP_printk("length=%zu", __entry->length)
582 );
583
584 #define DEFINE_SSAM_DATA_EVENT(name) \
585 DEFINE_EVENT(ssam_data_class, ssam_##name, \
586 TP_PROTO(size_t length), \
587 TP_ARGS(length) \
588 )
589
590 DEFINE_SSAM_FRAME_EVENT(rx_frame_received);
591 DEFINE_SSAM_COMMAND_EVENT(rx_response_received);
592 DEFINE_SSAM_COMMAND_EVENT(rx_event_received);
593
594 DEFINE_SSAM_PACKET_EVENT(packet_release);
595 DEFINE_SSAM_PACKET_EVENT(packet_submit);
596 DEFINE_SSAM_PACKET_EVENT(packet_resubmit);
597 DEFINE_SSAM_PACKET_EVENT(packet_timeout);
598 DEFINE_SSAM_PACKET_EVENT(packet_cancel);
599 DEFINE_SSAM_PACKET_STATUS_EVENT(packet_complete);
600 DEFINE_SSAM_PENDING_EVENT(ptl_timeout_reap);
601
602 DEFINE_SSAM_REQUEST_EVENT(request_submit);
603 DEFINE_SSAM_REQUEST_EVENT(request_timeout);
604 DEFINE_SSAM_REQUEST_EVENT(request_cancel);
605 DEFINE_SSAM_REQUEST_STATUS_EVENT(request_complete);
606 DEFINE_SSAM_PENDING_EVENT(rtl_timeout_reap);
607
608 DEFINE_SSAM_PACKET_EVENT(ei_tx_drop_ack_packet);
609 DEFINE_SSAM_PACKET_EVENT(ei_tx_drop_nak_packet);
610 DEFINE_SSAM_PACKET_EVENT(ei_tx_drop_dsq_packet);
611 DEFINE_SSAM_PACKET_STATUS_EVENT(ei_tx_fail_write);
612 DEFINE_SSAM_PACKET_EVENT(ei_tx_corrupt_data);
613 DEFINE_SSAM_DATA_EVENT(ei_rx_corrupt_syn);
614 DEFINE_SSAM_FRAME_EVENT(ei_rx_corrupt_data);
615 DEFINE_SSAM_REQUEST_EVENT(ei_rx_drop_response);
616
617 DEFINE_SSAM_ALLOC_EVENT(ctrl_packet_alloc);
618 DEFINE_SSAM_FREE_EVENT(ctrl_packet_free);
619
620 DEFINE_SSAM_ALLOC_EVENT(event_item_alloc);
621 DEFINE_SSAM_FREE_EVENT(event_item_free);
622
623 #endif /* _SURFACE_AGGREGATOR_TRACE_H */
624
625 /* This part must be outside protection */
626 #undef TRACE_INCLUDE_PATH
627 #undef TRACE_INCLUDE_FILE
628
629 #define TRACE_INCLUDE_PATH .
630 #define TRACE_INCLUDE_FILE trace
631
632 #include <trace/define_trace.h>
633