xref: /openbmc/linux/include/trace/events/rxrpc.h (revision 82003e04)
1 /* AF_RXRPC tracepoints
2  *
3  * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public Licence
8  * as published by the Free Software Foundation; either version
9  * 2 of the Licence, or (at your option) any later version.
10  */
11 #undef TRACE_SYSTEM
12 #define TRACE_SYSTEM rxrpc
13 
14 #if !defined(_TRACE_RXRPC_H) || defined(TRACE_HEADER_MULTI_READ)
15 #define _TRACE_RXRPC_H
16 
17 #include <linux/tracepoint.h>
18 
19 TRACE_EVENT(rxrpc_conn,
20 	    TP_PROTO(struct rxrpc_connection *conn, enum rxrpc_conn_trace op,
21 		     int usage, const void *where),
22 
23 	    TP_ARGS(conn, op, usage, where),
24 
25 	    TP_STRUCT__entry(
26 		    __field(struct rxrpc_connection *,	conn		)
27 		    __field(int,			op		)
28 		    __field(int,			usage		)
29 		    __field(const void *,		where		)
30 			     ),
31 
32 	    TP_fast_assign(
33 		    __entry->conn = conn;
34 		    __entry->op = op;
35 		    __entry->usage = usage;
36 		    __entry->where = where;
37 			   ),
38 
39 	    TP_printk("C=%p %s u=%d sp=%pSR",
40 		      __entry->conn,
41 		      rxrpc_conn_traces[__entry->op],
42 		      __entry->usage,
43 		      __entry->where)
44 	    );
45 
46 TRACE_EVENT(rxrpc_client,
47 	    TP_PROTO(struct rxrpc_connection *conn, int channel,
48 		     enum rxrpc_client_trace op),
49 
50 	    TP_ARGS(conn, channel, op),
51 
52 	    TP_STRUCT__entry(
53 		    __field(struct rxrpc_connection *,	conn		)
54 		    __field(u32,			cid		)
55 		    __field(int,			channel		)
56 		    __field(int,			usage		)
57 		    __field(enum rxrpc_client_trace,	op		)
58 		    __field(enum rxrpc_conn_cache_state, cs		)
59 			     ),
60 
61 	    TP_fast_assign(
62 		    __entry->conn = conn;
63 		    __entry->channel = channel;
64 		    __entry->usage = atomic_read(&conn->usage);
65 		    __entry->op = op;
66 		    __entry->cid = conn->proto.cid;
67 		    __entry->cs = conn->cache_state;
68 			   ),
69 
70 	    TP_printk("C=%p h=%2d %s %s i=%08x u=%d",
71 		      __entry->conn,
72 		      __entry->channel,
73 		      rxrpc_client_traces[__entry->op],
74 		      rxrpc_conn_cache_states[__entry->cs],
75 		      __entry->cid,
76 		      __entry->usage)
77 	    );
78 
79 TRACE_EVENT(rxrpc_call,
80 	    TP_PROTO(struct rxrpc_call *call, enum rxrpc_call_trace op,
81 		     int usage, const void *where, const void *aux),
82 
83 	    TP_ARGS(call, op, usage, where, aux),
84 
85 	    TP_STRUCT__entry(
86 		    __field(struct rxrpc_call *,	call		)
87 		    __field(int,			op		)
88 		    __field(int,			usage		)
89 		    __field(const void *,		where		)
90 		    __field(const void *,		aux		)
91 			     ),
92 
93 	    TP_fast_assign(
94 		    __entry->call = call;
95 		    __entry->op = op;
96 		    __entry->usage = usage;
97 		    __entry->where = where;
98 		    __entry->aux = aux;
99 			   ),
100 
101 	    TP_printk("c=%p %s u=%d sp=%pSR a=%p",
102 		      __entry->call,
103 		      rxrpc_call_traces[__entry->op],
104 		      __entry->usage,
105 		      __entry->where,
106 		      __entry->aux)
107 	    );
108 
109 TRACE_EVENT(rxrpc_skb,
110 	    TP_PROTO(struct sk_buff *skb, enum rxrpc_skb_trace op,
111 		     int usage, int mod_count, const void *where),
112 
113 	    TP_ARGS(skb, op, usage, mod_count, where),
114 
115 	    TP_STRUCT__entry(
116 		    __field(struct sk_buff *,		skb		)
117 		    __field(enum rxrpc_skb_trace,	op		)
118 		    __field(int,			usage		)
119 		    __field(int,			mod_count	)
120 		    __field(const void *,		where		)
121 			     ),
122 
123 	    TP_fast_assign(
124 		    __entry->skb = skb;
125 		    __entry->op = op;
126 		    __entry->usage = usage;
127 		    __entry->mod_count = mod_count;
128 		    __entry->where = where;
129 			   ),
130 
131 	    TP_printk("s=%p %s u=%d m=%d p=%pSR",
132 		      __entry->skb,
133 		      rxrpc_skb_traces[__entry->op],
134 		      __entry->usage,
135 		      __entry->mod_count,
136 		      __entry->where)
137 	    );
138 
139 TRACE_EVENT(rxrpc_rx_packet,
140 	    TP_PROTO(struct rxrpc_skb_priv *sp),
141 
142 	    TP_ARGS(sp),
143 
144 	    TP_STRUCT__entry(
145 		    __field_struct(struct rxrpc_host_header,	hdr		)
146 			     ),
147 
148 	    TP_fast_assign(
149 		    memcpy(&__entry->hdr, &sp->hdr, sizeof(__entry->hdr));
150 			   ),
151 
152 	    TP_printk("%08x:%08x:%08x:%04x %08x %08x %02x %02x %s",
153 		      __entry->hdr.epoch, __entry->hdr.cid,
154 		      __entry->hdr.callNumber, __entry->hdr.serviceId,
155 		      __entry->hdr.serial, __entry->hdr.seq,
156 		      __entry->hdr.type, __entry->hdr.flags,
157 		      __entry->hdr.type <= 15 ? rxrpc_pkts[__entry->hdr.type] : "?UNK")
158 	    );
159 
160 TRACE_EVENT(rxrpc_rx_done,
161 	    TP_PROTO(int result, int abort_code),
162 
163 	    TP_ARGS(result, abort_code),
164 
165 	    TP_STRUCT__entry(
166 		    __field(int,			result		)
167 		    __field(int,			abort_code	)
168 			     ),
169 
170 	    TP_fast_assign(
171 		    __entry->result = result;
172 		    __entry->abort_code = abort_code;
173 			   ),
174 
175 	    TP_printk("r=%d a=%d", __entry->result, __entry->abort_code)
176 	    );
177 
178 TRACE_EVENT(rxrpc_abort,
179 	    TP_PROTO(const char *why, u32 cid, u32 call_id, rxrpc_seq_t seq,
180 		     int abort_code, int error),
181 
182 	    TP_ARGS(why, cid, call_id, seq, abort_code, error),
183 
184 	    TP_STRUCT__entry(
185 		    __array(char,			why, 4		)
186 		    __field(u32,			cid		)
187 		    __field(u32,			call_id		)
188 		    __field(rxrpc_seq_t,		seq		)
189 		    __field(int,			abort_code	)
190 		    __field(int,			error		)
191 			     ),
192 
193 	    TP_fast_assign(
194 		    memcpy(__entry->why, why, 4);
195 		    __entry->cid = cid;
196 		    __entry->call_id = call_id;
197 		    __entry->abort_code = abort_code;
198 		    __entry->error = error;
199 		    __entry->seq = seq;
200 			   ),
201 
202 	    TP_printk("%08x:%08x s=%u a=%d e=%d %s",
203 		      __entry->cid, __entry->call_id, __entry->seq,
204 		      __entry->abort_code, __entry->error, __entry->why)
205 	    );
206 
207 TRACE_EVENT(rxrpc_transmit,
208 	    TP_PROTO(struct rxrpc_call *call, enum rxrpc_transmit_trace why),
209 
210 	    TP_ARGS(call, why),
211 
212 	    TP_STRUCT__entry(
213 		    __field(struct rxrpc_call *,	call		)
214 		    __field(enum rxrpc_transmit_trace,	why		)
215 		    __field(rxrpc_seq_t,		tx_hard_ack	)
216 		    __field(rxrpc_seq_t,		tx_top		)
217 			     ),
218 
219 	    TP_fast_assign(
220 		    __entry->call = call;
221 		    __entry->why = why;
222 		    __entry->tx_hard_ack = call->tx_hard_ack;
223 		    __entry->tx_top = call->tx_top;
224 			   ),
225 
226 	    TP_printk("c=%p %s f=%08x n=%u",
227 		      __entry->call,
228 		      rxrpc_transmit_traces[__entry->why],
229 		      __entry->tx_hard_ack + 1,
230 		      __entry->tx_top - __entry->tx_hard_ack)
231 	    );
232 
233 TRACE_EVENT(rxrpc_rx_ack,
234 	    TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t first, u8 reason, u8 n_acks),
235 
236 	    TP_ARGS(call, first, reason, n_acks),
237 
238 	    TP_STRUCT__entry(
239 		    __field(struct rxrpc_call *,	call		)
240 		    __field(rxrpc_seq_t,		first		)
241 		    __field(u8,				reason		)
242 		    __field(u8,				n_acks		)
243 			     ),
244 
245 	    TP_fast_assign(
246 		    __entry->call = call;
247 		    __entry->first = first;
248 		    __entry->reason = reason;
249 		    __entry->n_acks = n_acks;
250 			   ),
251 
252 	    TP_printk("c=%p %s f=%08x n=%u",
253 		      __entry->call,
254 		      rxrpc_ack_names[__entry->reason],
255 		      __entry->first,
256 		      __entry->n_acks)
257 	    );
258 
259 TRACE_EVENT(rxrpc_tx_data,
260 	    TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t seq,
261 		     rxrpc_serial_t serial, u8 flags, bool retrans, bool lose),
262 
263 	    TP_ARGS(call, seq, serial, flags, retrans, lose),
264 
265 	    TP_STRUCT__entry(
266 		    __field(struct rxrpc_call *,	call		)
267 		    __field(rxrpc_seq_t,		seq		)
268 		    __field(rxrpc_serial_t,		serial		)
269 		    __field(u8,				flags		)
270 		    __field(bool,			retrans		)
271 		    __field(bool,			lose		)
272 			     ),
273 
274 	    TP_fast_assign(
275 		    __entry->call = call;
276 		    __entry->seq = seq;
277 		    __entry->serial = serial;
278 		    __entry->flags = flags;
279 		    __entry->retrans = retrans;
280 		    __entry->lose = lose;
281 			   ),
282 
283 	    TP_printk("c=%p DATA %08x q=%08x fl=%02x%s%s",
284 		      __entry->call,
285 		      __entry->serial,
286 		      __entry->seq,
287 		      __entry->flags,
288 		      __entry->retrans ? " *RETRANS*" : "",
289 		      __entry->lose ? " *LOSE*" : "")
290 	    );
291 
292 TRACE_EVENT(rxrpc_tx_ack,
293 	    TP_PROTO(struct rxrpc_call *call, rxrpc_serial_t serial,
294 		     rxrpc_seq_t ack_first, rxrpc_serial_t ack_serial,
295 		     u8 reason, u8 n_acks),
296 
297 	    TP_ARGS(call, serial, ack_first, ack_serial, reason, n_acks),
298 
299 	    TP_STRUCT__entry(
300 		    __field(struct rxrpc_call *,	call		)
301 		    __field(rxrpc_serial_t,		serial		)
302 		    __field(rxrpc_seq_t,		ack_first	)
303 		    __field(rxrpc_serial_t,		ack_serial	)
304 		    __field(u8,				reason		)
305 		    __field(u8,				n_acks		)
306 			     ),
307 
308 	    TP_fast_assign(
309 		    __entry->call = call;
310 		    __entry->serial = serial;
311 		    __entry->ack_first = ack_first;
312 		    __entry->ack_serial = ack_serial;
313 		    __entry->reason = reason;
314 		    __entry->n_acks = n_acks;
315 			   ),
316 
317 	    TP_printk(" c=%p ACK  %08x %s f=%08x r=%08x n=%u",
318 		      __entry->call,
319 		      __entry->serial,
320 		      rxrpc_ack_names[__entry->reason],
321 		      __entry->ack_first,
322 		      __entry->ack_serial,
323 		      __entry->n_acks)
324 	    );
325 
326 TRACE_EVENT(rxrpc_receive,
327 	    TP_PROTO(struct rxrpc_call *call, enum rxrpc_receive_trace why,
328 		     rxrpc_serial_t serial, rxrpc_seq_t seq),
329 
330 	    TP_ARGS(call, why, serial, seq),
331 
332 	    TP_STRUCT__entry(
333 		    __field(struct rxrpc_call *,	call		)
334 		    __field(enum rxrpc_receive_trace,	why		)
335 		    __field(rxrpc_serial_t,		serial		)
336 		    __field(rxrpc_seq_t,		seq		)
337 		    __field(rxrpc_seq_t,		hard_ack	)
338 		    __field(rxrpc_seq_t,		top		)
339 			     ),
340 
341 	    TP_fast_assign(
342 		    __entry->call = call;
343 		    __entry->why = why;
344 		    __entry->serial = serial;
345 		    __entry->seq = seq;
346 		    __entry->hard_ack = call->rx_hard_ack;
347 		    __entry->top = call->rx_top;
348 			   ),
349 
350 	    TP_printk("c=%p %s r=%08x q=%08x w=%08x-%08x",
351 		      __entry->call,
352 		      rxrpc_receive_traces[__entry->why],
353 		      __entry->serial,
354 		      __entry->seq,
355 		      __entry->hard_ack,
356 		      __entry->top)
357 	    );
358 
359 TRACE_EVENT(rxrpc_recvmsg,
360 	    TP_PROTO(struct rxrpc_call *call, enum rxrpc_recvmsg_trace why,
361 		     rxrpc_seq_t seq, unsigned int offset, unsigned int len,
362 		     int ret),
363 
364 	    TP_ARGS(call, why, seq, offset, len, ret),
365 
366 	    TP_STRUCT__entry(
367 		    __field(struct rxrpc_call *,	call		)
368 		    __field(enum rxrpc_recvmsg_trace,	why		)
369 		    __field(rxrpc_seq_t,		seq		)
370 		    __field(unsigned int,		offset		)
371 		    __field(unsigned int,		len		)
372 		    __field(int,			ret		)
373 			     ),
374 
375 	    TP_fast_assign(
376 		    __entry->call = call;
377 		    __entry->why = why;
378 		    __entry->seq = seq;
379 		    __entry->offset = offset;
380 		    __entry->len = len;
381 		    __entry->ret = ret;
382 			   ),
383 
384 	    TP_printk("c=%p %s q=%08x o=%u l=%u ret=%d",
385 		      __entry->call,
386 		      rxrpc_recvmsg_traces[__entry->why],
387 		      __entry->seq,
388 		      __entry->offset,
389 		      __entry->len,
390 		      __entry->ret)
391 	    );
392 
393 TRACE_EVENT(rxrpc_rtt_tx,
394 	    TP_PROTO(struct rxrpc_call *call, enum rxrpc_rtt_tx_trace why,
395 		     rxrpc_serial_t send_serial),
396 
397 	    TP_ARGS(call, why, send_serial),
398 
399 	    TP_STRUCT__entry(
400 		    __field(struct rxrpc_call *,	call		)
401 		    __field(enum rxrpc_rtt_tx_trace,	why		)
402 		    __field(rxrpc_serial_t,		send_serial	)
403 			     ),
404 
405 	    TP_fast_assign(
406 		    __entry->call = call;
407 		    __entry->why = why;
408 		    __entry->send_serial = send_serial;
409 			   ),
410 
411 	    TP_printk("c=%p %s sr=%08x",
412 		      __entry->call,
413 		      rxrpc_rtt_tx_traces[__entry->why],
414 		      __entry->send_serial)
415 	    );
416 
417 TRACE_EVENT(rxrpc_rtt_rx,
418 	    TP_PROTO(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why,
419 		     rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial,
420 		     s64 rtt, u8 nr, s64 avg),
421 
422 	    TP_ARGS(call, why, send_serial, resp_serial, rtt, nr, avg),
423 
424 	    TP_STRUCT__entry(
425 		    __field(struct rxrpc_call *,	call		)
426 		    __field(enum rxrpc_rtt_rx_trace,	why		)
427 		    __field(u8,				nr		)
428 		    __field(rxrpc_serial_t,		send_serial	)
429 		    __field(rxrpc_serial_t,		resp_serial	)
430 		    __field(s64,			rtt		)
431 		    __field(u64,			avg		)
432 			     ),
433 
434 	    TP_fast_assign(
435 		    __entry->call = call;
436 		    __entry->why = why;
437 		    __entry->send_serial = send_serial;
438 		    __entry->resp_serial = resp_serial;
439 		    __entry->rtt = rtt;
440 		    __entry->nr = nr;
441 		    __entry->avg = avg;
442 			   ),
443 
444 	    TP_printk("c=%p %s sr=%08x rr=%08x rtt=%lld nr=%u avg=%lld",
445 		      __entry->call,
446 		      rxrpc_rtt_rx_traces[__entry->why],
447 		      __entry->send_serial,
448 		      __entry->resp_serial,
449 		      __entry->rtt,
450 		      __entry->nr,
451 		      __entry->avg)
452 	    );
453 
454 TRACE_EVENT(rxrpc_timer,
455 	    TP_PROTO(struct rxrpc_call *call, enum rxrpc_timer_trace why,
456 		     ktime_t now, unsigned long now_j),
457 
458 	    TP_ARGS(call, why, now, now_j),
459 
460 	    TP_STRUCT__entry(
461 		    __field(struct rxrpc_call *,		call		)
462 		    __field(enum rxrpc_timer_trace,		why		)
463 		    __field_struct(ktime_t,			now		)
464 		    __field_struct(ktime_t,			expire_at	)
465 		    __field_struct(ktime_t,			ack_at		)
466 		    __field_struct(ktime_t,			resend_at	)
467 		    __field(unsigned long,			now_j		)
468 		    __field(unsigned long,			timer		)
469 			     ),
470 
471 	    TP_fast_assign(
472 		    __entry->call	= call;
473 		    __entry->why	= why;
474 		    __entry->now	= now;
475 		    __entry->expire_at	= call->expire_at;
476 		    __entry->ack_at	= call->ack_at;
477 		    __entry->resend_at	= call->resend_at;
478 		    __entry->now_j	= now_j;
479 		    __entry->timer	= call->timer.expires;
480 			   ),
481 
482 	    TP_printk("c=%p %s x=%lld a=%lld r=%lld t=%ld",
483 		      __entry->call,
484 		      rxrpc_timer_traces[__entry->why],
485 		      ktime_to_ns(ktime_sub(__entry->expire_at, __entry->now)),
486 		      ktime_to_ns(ktime_sub(__entry->ack_at, __entry->now)),
487 		      ktime_to_ns(ktime_sub(__entry->resend_at, __entry->now)),
488 		      __entry->timer - __entry->now_j)
489 	    );
490 
491 TRACE_EVENT(rxrpc_rx_lose,
492 	    TP_PROTO(struct rxrpc_skb_priv *sp),
493 
494 	    TP_ARGS(sp),
495 
496 	    TP_STRUCT__entry(
497 		    __field_struct(struct rxrpc_host_header,	hdr		)
498 			     ),
499 
500 	    TP_fast_assign(
501 		    memcpy(&__entry->hdr, &sp->hdr, sizeof(__entry->hdr));
502 			   ),
503 
504 	    TP_printk("%08x:%08x:%08x:%04x %08x %08x %02x %02x %s *LOSE*",
505 		      __entry->hdr.epoch, __entry->hdr.cid,
506 		      __entry->hdr.callNumber, __entry->hdr.serviceId,
507 		      __entry->hdr.serial, __entry->hdr.seq,
508 		      __entry->hdr.type, __entry->hdr.flags,
509 		      __entry->hdr.type <= 15 ? rxrpc_pkts[__entry->hdr.type] : "?UNK")
510 	    );
511 
512 TRACE_EVENT(rxrpc_propose_ack,
513 	    TP_PROTO(struct rxrpc_call *call, enum rxrpc_propose_ack_trace why,
514 		     u8 ack_reason, rxrpc_serial_t serial, bool immediate,
515 		     bool background, enum rxrpc_propose_ack_outcome outcome),
516 
517 	    TP_ARGS(call, why, ack_reason, serial, immediate, background,
518 		    outcome),
519 
520 	    TP_STRUCT__entry(
521 		    __field(struct rxrpc_call *,		call		)
522 		    __field(enum rxrpc_propose_ack_trace,	why		)
523 		    __field(rxrpc_serial_t,			serial		)
524 		    __field(u8,					ack_reason	)
525 		    __field(bool,				immediate	)
526 		    __field(bool,				background	)
527 		    __field(enum rxrpc_propose_ack_outcome,	outcome		)
528 			     ),
529 
530 	    TP_fast_assign(
531 		    __entry->call	= call;
532 		    __entry->why	= why;
533 		    __entry->serial	= serial;
534 		    __entry->ack_reason	= ack_reason;
535 		    __entry->immediate	= immediate;
536 		    __entry->background	= background;
537 		    __entry->outcome	= outcome;
538 			   ),
539 
540 	    TP_printk("c=%p %s %s r=%08x i=%u b=%u%s",
541 		      __entry->call,
542 		      rxrpc_propose_ack_traces[__entry->why],
543 		      rxrpc_ack_names[__entry->ack_reason],
544 		      __entry->serial,
545 		      __entry->immediate,
546 		      __entry->background,
547 		      rxrpc_propose_ack_outcomes[__entry->outcome])
548 	    );
549 
550 TRACE_EVENT(rxrpc_retransmit,
551 	    TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t seq, u8 annotation,
552 		     s64 expiry),
553 
554 	    TP_ARGS(call, seq, annotation, expiry),
555 
556 	    TP_STRUCT__entry(
557 		    __field(struct rxrpc_call *,	call		)
558 		    __field(rxrpc_seq_t,		seq		)
559 		    __field(u8,				annotation	)
560 		    __field(s64,			expiry		)
561 			     ),
562 
563 	    TP_fast_assign(
564 		    __entry->call = call;
565 		    __entry->seq = seq;
566 		    __entry->annotation = annotation;
567 		    __entry->expiry = expiry;
568 			   ),
569 
570 	    TP_printk("c=%p q=%x a=%02x xp=%lld",
571 		      __entry->call,
572 		      __entry->seq,
573 		      __entry->annotation,
574 		      __entry->expiry)
575 	    );
576 
577 TRACE_EVENT(rxrpc_congest,
578 	    TP_PROTO(struct rxrpc_call *call, struct rxrpc_ack_summary *summary,
579 		     rxrpc_serial_t ack_serial, enum rxrpc_congest_change change),
580 
581 	    TP_ARGS(call, summary, ack_serial, change),
582 
583 	    TP_STRUCT__entry(
584 		    __field(struct rxrpc_call *,		call		)
585 		    __field(enum rxrpc_congest_change,		change		)
586 		    __field(rxrpc_seq_t,			hard_ack	)
587 		    __field(rxrpc_seq_t,			top		)
588 		    __field(rxrpc_seq_t,			lowest_nak	)
589 		    __field(rxrpc_serial_t,			ack_serial	)
590 		    __field_struct(struct rxrpc_ack_summary,	sum		)
591 			     ),
592 
593 	    TP_fast_assign(
594 		    __entry->call	= call;
595 		    __entry->change	= change;
596 		    __entry->hard_ack	= call->tx_hard_ack;
597 		    __entry->top	= call->tx_top;
598 		    __entry->lowest_nak	= call->acks_lowest_nak;
599 		    __entry->ack_serial	= ack_serial;
600 		    memcpy(&__entry->sum, summary, sizeof(__entry->sum));
601 			   ),
602 
603 	    TP_printk("c=%p %08x %s %08x %s cw=%u ss=%u nr=%u,%u nw=%u,%u r=%u b=%u u=%u d=%u l=%x%s%s%s",
604 		      __entry->call,
605 		      __entry->ack_serial,
606 		      rxrpc_ack_names[__entry->sum.ack_reason],
607 		      __entry->hard_ack,
608 		      rxrpc_congest_modes[__entry->sum.mode],
609 		      __entry->sum.cwnd,
610 		      __entry->sum.ssthresh,
611 		      __entry->sum.nr_acks, __entry->sum.nr_nacks,
612 		      __entry->sum.nr_new_acks, __entry->sum.nr_new_nacks,
613 		      __entry->sum.nr_rot_new_acks,
614 		      __entry->top - __entry->hard_ack,
615 		      __entry->sum.cumulative_acks,
616 		      __entry->sum.dup_acks,
617 		      __entry->lowest_nak, __entry->sum.new_low_nack ? "!" : "",
618 		      rxrpc_congest_changes[__entry->change],
619 		      __entry->sum.retrans_timeo ? " rTxTo" : "")
620 	    );
621 
622 #endif /* _TRACE_RXRPC_H */
623 
624 /* This part must be outside protection */
625 #include <trace/define_trace.h>
626