aboutsummaryrefslogtreecommitdiffstats
path: root/include/trace
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2016-10-05 13:11:24 -0400
committerLinus Torvalds <torvalds@linux-foundation.org>2016-10-05 13:11:24 -0400
commit687ee0ad4e897e29f4b41f7a20c866d74c5e0660 (patch)
treeb31a2af35c24a54823674cdd126993b80daeac67 /include/trace
parent3ddf40e8c31964b744ff10abb48c8e36a83ec6e7 (diff)
parent03a1eabc3f54469abd4f1784182851b2e29630cc (diff)
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next
Pull networking updates from David Miller: 1) BBR TCP congestion control, from Neal Cardwell, Yuchung Cheng and co. at Google. https://lwn.net/Articles/701165/ 2) Do TCP Small Queues for retransmits, from Eric Dumazet. 3) Support collect_md mode for all IPV4 and IPV6 tunnels, from Alexei Starovoitov. 4) Allow cls_flower to classify packets in ip tunnels, from Amir Vadai. 5) Support DSA tagging in older mv88e6xxx switches, from Andrew Lunn. 6) Support GMAC protocol in iwlwifi mwm, from Ayala Beker. 7) Support ndo_poll_controller in mlx5, from Calvin Owens. 8) Move VRF processing to an output hook and allow l3mdev to be loopback, from David Ahern. 9) Support SOCK_DESTROY for UDP sockets. Also from David Ahern. 10) Congestion control in RXRPC, from David Howells. 11) Support geneve RX offload in ixgbe, from Emil Tantilov. 12) When hitting pressure for new incoming TCP data SKBs, perform a partial rathern than a full purge of the OFO queue (which could be huge). From Eric Dumazet. 13) Convert XFRM state and policy lookups to RCU, from Florian Westphal. 14) Support RX network flow classification to igb, from Gangfeng Huang. 15) Hardware offloading of eBPF in nfp driver, from Jakub Kicinski. 16) New skbmod packet action, from Jamal Hadi Salim. 17) Remove some inefficiencies in snmp proc output, from Jia He. 18) Add FIB notifications to properly propagate route changes to hardware which is doing forwarding offloading. From Jiri Pirko. 19) New dsa driver for qca8xxx chips, from John Crispin. 20) Implement RFC7559 ipv6 router solicitation backoff, from Maciej Żenczykowski. 21) Add L3 mode to ipvlan, from Mahesh Bandewar. 22) Support 802.1ad in mlx4, from Moshe Shemesh. 23) Support hardware LRO in mediatek driver, from Nelson Chang. 24) Add TC offloading to mlx5, from Or Gerlitz. 25) Convert various drivers to ethtool ksettings interfaces, from Philippe Reynes. 26) TX max rate limiting for cxgb4, from Rahul Lakkireddy. 27) NAPI support for ath10k, from Rajkumar Manoharan. 28) Support XDP in mlx5, from Rana Shahout and Saeed Mahameed. 29) UDP replicast support in TIPC, from Richard Alpe. 30) Per-queue statistics for qed driver, from Sudarsana Reddy Kalluru. 31) Support BQL in thunderx driver, from Sunil Goutham. 32) TSO support in alx driver, from Tobias Regnery. 33) Add stream parser engine and use it in kcm. 34) Support async DHCP replies in ipconfig module, from Uwe Kleine-König. 35) DSA port fast aging for mv88e6xxx driver, from Vivien Didelot. * git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next: (1715 commits) mlxsw: switchx2: Fix misuse of hard_header_len mlxsw: spectrum: Fix misuse of hard_header_len net/faraday: Stop NCSI device on shutdown net/ncsi: Introduce ncsi_stop_dev() net/ncsi: Rework the channel monitoring net/ncsi: Allow to extend NCSI request properties net/ncsi: Rework request index allocation net/ncsi: Don't probe on the reserved channel ID (0x1f) net/ncsi: Introduce NCSI_RESERVED_CHANNEL net/ncsi: Avoid unused-value build warning from ia64-linux-gcc net: Add netdev all_adj_list refcnt propagation to fix panic net: phy: Add Edge-rate driver for Microsemi PHYs. vmxnet3: Wake queue from reset work i40e: avoid NULL pointer dereference and recursive errors on early PCI error qed: Add RoCE ll2 & GSI support qed: Add support for memory registeration verbs qed: Add support for QP verbs qed: PD,PKEY and CQ verb support qed: Add support for RoCE hw init qede: Add qedr framework ...
Diffstat (limited to 'include/trace')
-rw-r--r--include/trace/events/rxrpc.h625
1 files changed, 625 insertions, 0 deletions
diff --git a/include/trace/events/rxrpc.h b/include/trace/events/rxrpc.h
new file mode 100644
index 000000000000..0383e5e9a0f3
--- /dev/null
+++ b/include/trace/events/rxrpc.h
@@ -0,0 +1,625 @@
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
19TRACE_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
46TRACE_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
79TRACE_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
109TRACE_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
139TRACE_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
160TRACE_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
178TRACE_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
207TRACE_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
233TRACE_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
259TRACE_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
292TRACE_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
326TRACE_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
359TRACE_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
393TRACE_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
417TRACE_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
454TRACE_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
491TRACE_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
512TRACE_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
550TRACE_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
577TRACE_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>
generated by cgit v1.2.2 (git 2.25.0) at 2026-02-28 23:19:52 -0500