Loading...
Note: File does not exist in v3.1.
1/* SPDX-License-Identifier: GPL-2.0-or-later */
2/* AF_RXRPC tracepoints
3 *
4 * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7#undef TRACE_SYSTEM
8#define TRACE_SYSTEM rxrpc
9
10#if !defined(_TRACE_RXRPC_H) || defined(TRACE_HEADER_MULTI_READ)
11#define _TRACE_RXRPC_H
12
13#include <linux/tracepoint.h>
14#include <linux/errqueue.h>
15
16/*
17 * Declare tracing information enums and their string mappings for display.
18 */
19#define rxrpc_abort_reasons \
20 /* AFS errors */ \
21 EM(afs_abort_general_error, "afs-error") \
22 EM(afs_abort_interrupted, "afs-intr") \
23 EM(afs_abort_oom, "afs-oom") \
24 EM(afs_abort_op_not_supported, "afs-op-notsupp") \
25 EM(afs_abort_probeuuid_negative, "afs-probeuuid-neg") \
26 EM(afs_abort_send_data_error, "afs-send-data") \
27 EM(afs_abort_unmarshal_error, "afs-unmarshal") \
28 /* rxperf errors */ \
29 EM(rxperf_abort_general_error, "rxperf-error") \
30 EM(rxperf_abort_oom, "rxperf-oom") \
31 EM(rxperf_abort_op_not_supported, "rxperf-op-notsupp") \
32 EM(rxperf_abort_unmarshal_error, "rxperf-unmarshal") \
33 /* RxKAD security errors */ \
34 EM(rxkad_abort_1_short_check, "rxkad1-short-check") \
35 EM(rxkad_abort_1_short_data, "rxkad1-short-data") \
36 EM(rxkad_abort_1_short_encdata, "rxkad1-short-encdata") \
37 EM(rxkad_abort_1_short_header, "rxkad1-short-hdr") \
38 EM(rxkad_abort_2_short_check, "rxkad2-short-check") \
39 EM(rxkad_abort_2_short_data, "rxkad2-short-data") \
40 EM(rxkad_abort_2_short_header, "rxkad2-short-hdr") \
41 EM(rxkad_abort_2_short_len, "rxkad2-short-len") \
42 EM(rxkad_abort_bad_checksum, "rxkad2-bad-cksum") \
43 EM(rxkad_abort_chall_key_expired, "rxkad-chall-key-exp") \
44 EM(rxkad_abort_chall_level, "rxkad-chall-level") \
45 EM(rxkad_abort_chall_no_key, "rxkad-chall-nokey") \
46 EM(rxkad_abort_chall_short, "rxkad-chall-short") \
47 EM(rxkad_abort_chall_version, "rxkad-chall-version") \
48 EM(rxkad_abort_resp_bad_callid, "rxkad-resp-bad-callid") \
49 EM(rxkad_abort_resp_bad_checksum, "rxkad-resp-bad-cksum") \
50 EM(rxkad_abort_resp_bad_param, "rxkad-resp-bad-param") \
51 EM(rxkad_abort_resp_call_ctr, "rxkad-resp-call-ctr") \
52 EM(rxkad_abort_resp_call_state, "rxkad-resp-call-state") \
53 EM(rxkad_abort_resp_key_expired, "rxkad-resp-key-exp") \
54 EM(rxkad_abort_resp_key_rejected, "rxkad-resp-key-rej") \
55 EM(rxkad_abort_resp_level, "rxkad-resp-level") \
56 EM(rxkad_abort_resp_nokey, "rxkad-resp-nokey") \
57 EM(rxkad_abort_resp_ooseq, "rxkad-resp-ooseq") \
58 EM(rxkad_abort_resp_short, "rxkad-resp-short") \
59 EM(rxkad_abort_resp_short_tkt, "rxkad-resp-short-tkt") \
60 EM(rxkad_abort_resp_tkt_aname, "rxkad-resp-tk-aname") \
61 EM(rxkad_abort_resp_tkt_expired, "rxkad-resp-tk-exp") \
62 EM(rxkad_abort_resp_tkt_future, "rxkad-resp-tk-future") \
63 EM(rxkad_abort_resp_tkt_inst, "rxkad-resp-tk-inst") \
64 EM(rxkad_abort_resp_tkt_len, "rxkad-resp-tk-len") \
65 EM(rxkad_abort_resp_tkt_realm, "rxkad-resp-tk-realm") \
66 EM(rxkad_abort_resp_tkt_short, "rxkad-resp-tk-short") \
67 EM(rxkad_abort_resp_tkt_sinst, "rxkad-resp-tk-sinst") \
68 EM(rxkad_abort_resp_tkt_sname, "rxkad-resp-tk-sname") \
69 EM(rxkad_abort_resp_unknown_tkt, "rxkad-resp-unknown-tkt") \
70 EM(rxkad_abort_resp_version, "rxkad-resp-version") \
71 /* rxrpc errors */ \
72 EM(rxrpc_abort_call_improper_term, "call-improper-term") \
73 EM(rxrpc_abort_call_reset, "call-reset") \
74 EM(rxrpc_abort_call_sendmsg, "call-sendmsg") \
75 EM(rxrpc_abort_call_sock_release, "call-sock-rel") \
76 EM(rxrpc_abort_call_sock_release_tba, "call-sock-rel-tba") \
77 EM(rxrpc_abort_call_timeout, "call-timeout") \
78 EM(rxrpc_abort_no_service_key, "no-serv-key") \
79 EM(rxrpc_abort_nomem, "nomem") \
80 EM(rxrpc_abort_service_not_offered, "serv-not-offered") \
81 EM(rxrpc_abort_shut_down, "shut-down") \
82 EM(rxrpc_abort_unsupported_security, "unsup-sec") \
83 EM(rxrpc_badmsg_bad_abort, "bad-abort") \
84 EM(rxrpc_badmsg_bad_jumbo, "bad-jumbo") \
85 EM(rxrpc_badmsg_short_ack, "short-ack") \
86 EM(rxrpc_badmsg_short_ack_trailer, "short-ack-trailer") \
87 EM(rxrpc_badmsg_short_hdr, "short-hdr") \
88 EM(rxrpc_badmsg_unsupported_packet, "unsup-pkt") \
89 EM(rxrpc_badmsg_zero_call, "zero-call") \
90 EM(rxrpc_badmsg_zero_seq, "zero-seq") \
91 EM(rxrpc_badmsg_zero_service, "zero-service") \
92 EM(rxrpc_eproto_ackr_outside_window, "ackr-out-win") \
93 EM(rxrpc_eproto_ackr_sack_overflow, "ackr-sack-over") \
94 EM(rxrpc_eproto_ackr_short_sack, "ackr-short-sack") \
95 EM(rxrpc_eproto_ackr_zero, "ackr-zero") \
96 EM(rxrpc_eproto_bad_upgrade, "bad-upgrade") \
97 EM(rxrpc_eproto_data_after_last, "data-after-last") \
98 EM(rxrpc_eproto_different_last, "diff-last") \
99 EM(rxrpc_eproto_early_reply, "early-reply") \
100 EM(rxrpc_eproto_improper_term, "improper-term") \
101 EM(rxrpc_eproto_no_client_call, "no-cl-call") \
102 EM(rxrpc_eproto_no_client_conn, "no-cl-conn") \
103 EM(rxrpc_eproto_no_service_call, "no-sv-call") \
104 EM(rxrpc_eproto_reupgrade, "re-upgrade") \
105 EM(rxrpc_eproto_rxnull_challenge, "rxnull-chall") \
106 EM(rxrpc_eproto_rxnull_response, "rxnull-resp") \
107 EM(rxrpc_eproto_tx_rot_last, "tx-rot-last") \
108 EM(rxrpc_eproto_unexpected_ack, "unex-ack") \
109 EM(rxrpc_eproto_unexpected_ackall, "unex-ackall") \
110 EM(rxrpc_eproto_unexpected_implicit_end, "unex-impl-end") \
111 EM(rxrpc_eproto_unexpected_reply, "unex-reply") \
112 EM(rxrpc_eproto_wrong_security, "wrong-sec") \
113 EM(rxrpc_recvmsg_excess_data, "recvmsg-excess") \
114 EM(rxrpc_recvmsg_short_data, "recvmsg-short") \
115 E_(rxrpc_sendmsg_late_send, "sendmsg-late")
116
117#define rxrpc_call_poke_traces \
118 EM(rxrpc_call_poke_abort, "Abort") \
119 EM(rxrpc_call_poke_complete, "Compl") \
120 EM(rxrpc_call_poke_conn_abort, "Conn-abort") \
121 EM(rxrpc_call_poke_error, "Error") \
122 EM(rxrpc_call_poke_idle, "Idle") \
123 EM(rxrpc_call_poke_set_timeout, "Set-timo") \
124 EM(rxrpc_call_poke_start, "Start") \
125 EM(rxrpc_call_poke_timer, "Timer") \
126 E_(rxrpc_call_poke_timer_now, "Timer-now")
127
128#define rxrpc_skb_traces \
129 EM(rxrpc_skb_eaten_by_unshare, "ETN unshare ") \
130 EM(rxrpc_skb_eaten_by_unshare_nomem, "ETN unshar-nm") \
131 EM(rxrpc_skb_get_conn_secured, "GET conn-secd") \
132 EM(rxrpc_skb_get_conn_work, "GET conn-work") \
133 EM(rxrpc_skb_get_last_nack, "GET last-nack") \
134 EM(rxrpc_skb_get_local_work, "GET locl-work") \
135 EM(rxrpc_skb_get_reject_work, "GET rej-work ") \
136 EM(rxrpc_skb_get_to_recvmsg, "GET to-recv ") \
137 EM(rxrpc_skb_get_to_recvmsg_oos, "GET to-recv-o") \
138 EM(rxrpc_skb_new_encap_rcv, "NEW encap-rcv") \
139 EM(rxrpc_skb_new_error_report, "NEW error-rpt") \
140 EM(rxrpc_skb_new_jumbo_subpacket, "NEW jumbo-sub") \
141 EM(rxrpc_skb_new_unshared, "NEW unshared ") \
142 EM(rxrpc_skb_put_conn_secured, "PUT conn-secd") \
143 EM(rxrpc_skb_put_conn_work, "PUT conn-work") \
144 EM(rxrpc_skb_put_error_report, "PUT error-rep") \
145 EM(rxrpc_skb_put_input, "PUT input ") \
146 EM(rxrpc_skb_put_jumbo_subpacket, "PUT jumbo-sub") \
147 EM(rxrpc_skb_put_last_nack, "PUT last-nack") \
148 EM(rxrpc_skb_put_purge, "PUT purge ") \
149 EM(rxrpc_skb_put_rotate, "PUT rotate ") \
150 EM(rxrpc_skb_put_unknown, "PUT unknown ") \
151 EM(rxrpc_skb_see_conn_work, "SEE conn-work") \
152 EM(rxrpc_skb_see_recvmsg, "SEE recvmsg ") \
153 EM(rxrpc_skb_see_reject, "SEE reject ") \
154 EM(rxrpc_skb_see_rotate, "SEE rotate ") \
155 E_(rxrpc_skb_see_version, "SEE version ")
156
157#define rxrpc_local_traces \
158 EM(rxrpc_local_free, "FREE ") \
159 EM(rxrpc_local_get_call, "GET call ") \
160 EM(rxrpc_local_get_client_conn, "GET conn-cln") \
161 EM(rxrpc_local_get_for_use, "GET for-use ") \
162 EM(rxrpc_local_get_peer, "GET peer ") \
163 EM(rxrpc_local_get_prealloc_conn, "GET conn-pre") \
164 EM(rxrpc_local_new, "NEW ") \
165 EM(rxrpc_local_put_bind, "PUT bind ") \
166 EM(rxrpc_local_put_call, "PUT call ") \
167 EM(rxrpc_local_put_for_use, "PUT for-use ") \
168 EM(rxrpc_local_put_kill_conn, "PUT conn-kil") \
169 EM(rxrpc_local_put_peer, "PUT peer ") \
170 EM(rxrpc_local_put_prealloc_peer, "PUT peer-pre") \
171 EM(rxrpc_local_put_release_sock, "PUT rel-sock") \
172 EM(rxrpc_local_stop, "STOP ") \
173 EM(rxrpc_local_stopped, "STOPPED ") \
174 EM(rxrpc_local_unuse_bind, "UNU bind ") \
175 EM(rxrpc_local_unuse_conn_work, "UNU conn-wrk") \
176 EM(rxrpc_local_unuse_peer_keepalive, "UNU peer-kpa") \
177 EM(rxrpc_local_unuse_release_sock, "UNU rel-sock") \
178 EM(rxrpc_local_use_conn_work, "USE conn-wrk") \
179 EM(rxrpc_local_use_lookup, "USE lookup ") \
180 E_(rxrpc_local_use_peer_keepalive, "USE peer-kpa")
181
182#define rxrpc_peer_traces \
183 EM(rxrpc_peer_free, "FREE ") \
184 EM(rxrpc_peer_get_accept, "GET accept ") \
185 EM(rxrpc_peer_get_application, "GET app ") \
186 EM(rxrpc_peer_get_bundle, "GET bundle ") \
187 EM(rxrpc_peer_get_call, "GET call ") \
188 EM(rxrpc_peer_get_client_conn, "GET cln-conn") \
189 EM(rxrpc_peer_get_input, "GET input ") \
190 EM(rxrpc_peer_get_input_error, "GET inpt-err") \
191 EM(rxrpc_peer_get_keepalive, "GET keepaliv") \
192 EM(rxrpc_peer_get_lookup_client, "GET look-cln") \
193 EM(rxrpc_peer_get_service_conn, "GET srv-conn") \
194 EM(rxrpc_peer_new_client, "NEW client ") \
195 EM(rxrpc_peer_new_prealloc, "NEW prealloc") \
196 EM(rxrpc_peer_put_application, "PUT app ") \
197 EM(rxrpc_peer_put_bundle, "PUT bundle ") \
198 EM(rxrpc_peer_put_call, "PUT call ") \
199 EM(rxrpc_peer_put_conn, "PUT conn ") \
200 EM(rxrpc_peer_put_input, "PUT input ") \
201 EM(rxrpc_peer_put_input_error, "PUT inpt-err") \
202 E_(rxrpc_peer_put_keepalive, "PUT keepaliv")
203
204#define rxrpc_bundle_traces \
205 EM(rxrpc_bundle_free, "FREE ") \
206 EM(rxrpc_bundle_get_client_call, "GET clt-call") \
207 EM(rxrpc_bundle_get_client_conn, "GET clt-conn") \
208 EM(rxrpc_bundle_get_service_conn, "GET svc-conn") \
209 EM(rxrpc_bundle_put_call, "PUT call ") \
210 EM(rxrpc_bundle_put_conn, "PUT conn ") \
211 EM(rxrpc_bundle_put_discard, "PUT discard ") \
212 E_(rxrpc_bundle_new, "NEW ")
213
214#define rxrpc_conn_traces \
215 EM(rxrpc_conn_free, "FREE ") \
216 EM(rxrpc_conn_get_activate_call, "GET act-call") \
217 EM(rxrpc_conn_get_call_input, "GET inp-call") \
218 EM(rxrpc_conn_get_conn_input, "GET inp-conn") \
219 EM(rxrpc_conn_get_idle, "GET idle ") \
220 EM(rxrpc_conn_get_poke_abort, "GET pk-abort") \
221 EM(rxrpc_conn_get_poke_secured, "GET secured ") \
222 EM(rxrpc_conn_get_poke_timer, "GET poke ") \
223 EM(rxrpc_conn_get_service_conn, "GET svc-conn") \
224 EM(rxrpc_conn_new_client, "NEW client ") \
225 EM(rxrpc_conn_new_service, "NEW service ") \
226 EM(rxrpc_conn_put_call, "PUT call ") \
227 EM(rxrpc_conn_put_call_input, "PUT inp-call") \
228 EM(rxrpc_conn_put_conn_input, "PUT inp-conn") \
229 EM(rxrpc_conn_put_discard_idle, "PUT disc-idl") \
230 EM(rxrpc_conn_put_local_dead, "PUT loc-dead") \
231 EM(rxrpc_conn_put_noreuse, "PUT noreuse ") \
232 EM(rxrpc_conn_put_poke, "PUT poke ") \
233 EM(rxrpc_conn_put_service_reaped, "PUT svc-reap") \
234 EM(rxrpc_conn_put_unbundle, "PUT unbundle") \
235 EM(rxrpc_conn_put_unidle, "PUT unidle ") \
236 EM(rxrpc_conn_put_work, "PUT work ") \
237 EM(rxrpc_conn_queue_challenge, "QUE chall ") \
238 EM(rxrpc_conn_queue_retry_work, "QUE retry-wk") \
239 EM(rxrpc_conn_queue_rx_work, "QUE rx-work ") \
240 EM(rxrpc_conn_see_new_service_conn, "SEE new-svc ") \
241 EM(rxrpc_conn_see_reap_service, "SEE reap-svc") \
242 E_(rxrpc_conn_see_work, "SEE work ")
243
244#define rxrpc_client_traces \
245 EM(rxrpc_client_activate_chans, "Activa") \
246 EM(rxrpc_client_alloc, "Alloc ") \
247 EM(rxrpc_client_chan_activate, "ChActv") \
248 EM(rxrpc_client_chan_disconnect, "ChDisc") \
249 EM(rxrpc_client_chan_pass, "ChPass") \
250 EM(rxrpc_client_cleanup, "Clean ") \
251 EM(rxrpc_client_discard, "Discar") \
252 EM(rxrpc_client_exposed, "Expose") \
253 EM(rxrpc_client_replace, "Replac") \
254 EM(rxrpc_client_queue_new_call, "Q-Call") \
255 EM(rxrpc_client_to_active, "->Actv") \
256 E_(rxrpc_client_to_idle, "->Idle")
257
258#define rxrpc_call_traces \
259 EM(rxrpc_call_get_io_thread, "GET iothread") \
260 EM(rxrpc_call_get_input, "GET input ") \
261 EM(rxrpc_call_get_kernel_service, "GET krnl-srv") \
262 EM(rxrpc_call_get_notify_socket, "GET notify ") \
263 EM(rxrpc_call_get_poke, "GET poke ") \
264 EM(rxrpc_call_get_recvmsg, "GET recvmsg ") \
265 EM(rxrpc_call_get_release_sock, "GET rel-sock") \
266 EM(rxrpc_call_get_sendmsg, "GET sendmsg ") \
267 EM(rxrpc_call_get_userid, "GET user-id ") \
268 EM(rxrpc_call_new_client, "NEW client ") \
269 EM(rxrpc_call_new_prealloc_service, "NEW prealloc") \
270 EM(rxrpc_call_put_discard_prealloc, "PUT disc-pre") \
271 EM(rxrpc_call_put_discard_error, "PUT disc-err") \
272 EM(rxrpc_call_put_io_thread, "PUT iothread") \
273 EM(rxrpc_call_put_input, "PUT input ") \
274 EM(rxrpc_call_put_kernel, "PUT kernel ") \
275 EM(rxrpc_call_put_poke, "PUT poke ") \
276 EM(rxrpc_call_put_recvmsg, "PUT recvmsg ") \
277 EM(rxrpc_call_put_release_sock, "PUT rls-sock") \
278 EM(rxrpc_call_put_release_sock_tba, "PUT rls-sk-a") \
279 EM(rxrpc_call_put_sendmsg, "PUT sendmsg ") \
280 EM(rxrpc_call_put_unnotify, "PUT unnotify") \
281 EM(rxrpc_call_put_userid_exists, "PUT u-exists") \
282 EM(rxrpc_call_put_userid, "PUT user-id ") \
283 EM(rxrpc_call_see_accept, "SEE accept ") \
284 EM(rxrpc_call_see_activate_client, "SEE act-clnt") \
285 EM(rxrpc_call_see_connect_failed, "SEE con-fail") \
286 EM(rxrpc_call_see_connected, "SEE connect ") \
287 EM(rxrpc_call_see_conn_abort, "SEE conn-abt") \
288 EM(rxrpc_call_see_disconnected, "SEE disconn ") \
289 EM(rxrpc_call_see_distribute_error, "SEE dist-err") \
290 EM(rxrpc_call_see_input, "SEE input ") \
291 EM(rxrpc_call_see_release, "SEE release ") \
292 EM(rxrpc_call_see_userid_exists, "SEE u-exists") \
293 EM(rxrpc_call_see_waiting_call, "SEE q-conn ") \
294 E_(rxrpc_call_see_zap, "SEE zap ")
295
296#define rxrpc_txqueue_traces \
297 EM(rxrpc_txqueue_await_reply, "AWR") \
298 EM(rxrpc_txqueue_dequeue, "DEQ") \
299 EM(rxrpc_txqueue_end, "END") \
300 EM(rxrpc_txqueue_queue, "QUE") \
301 EM(rxrpc_txqueue_queue_last, "QLS") \
302 EM(rxrpc_txqueue_rotate, "ROT") \
303 EM(rxrpc_txqueue_rotate_last, "RLS") \
304 E_(rxrpc_txqueue_wait, "WAI")
305
306#define rxrpc_receive_traces \
307 EM(rxrpc_receive_end, "END") \
308 EM(rxrpc_receive_front, "FRN") \
309 EM(rxrpc_receive_incoming, "INC") \
310 EM(rxrpc_receive_queue, "QUE") \
311 EM(rxrpc_receive_queue_last, "QLS") \
312 EM(rxrpc_receive_queue_oos, "QUO") \
313 EM(rxrpc_receive_queue_oos_last, "QOL") \
314 EM(rxrpc_receive_oos, "OOS") \
315 EM(rxrpc_receive_oos_last, "OSL") \
316 EM(rxrpc_receive_rotate, "ROT") \
317 E_(rxrpc_receive_rotate_last, "RLS")
318
319#define rxrpc_recvmsg_traces \
320 EM(rxrpc_recvmsg_cont, "CONT") \
321 EM(rxrpc_recvmsg_data_return, "DATA") \
322 EM(rxrpc_recvmsg_dequeue, "DEQU") \
323 EM(rxrpc_recvmsg_enter, "ENTR") \
324 EM(rxrpc_recvmsg_full, "FULL") \
325 EM(rxrpc_recvmsg_hole, "HOLE") \
326 EM(rxrpc_recvmsg_next, "NEXT") \
327 EM(rxrpc_recvmsg_requeue, "REQU") \
328 EM(rxrpc_recvmsg_return, "RETN") \
329 EM(rxrpc_recvmsg_terminal, "TERM") \
330 EM(rxrpc_recvmsg_to_be_accepted, "TBAC") \
331 EM(rxrpc_recvmsg_unqueue, "UNQU") \
332 E_(rxrpc_recvmsg_wait, "WAIT")
333
334#define rxrpc_rtt_tx_traces \
335 EM(rxrpc_rtt_tx_cancel, "CNCE") \
336 EM(rxrpc_rtt_tx_data, "DATA") \
337 EM(rxrpc_rtt_tx_no_slot, "FULL") \
338 E_(rxrpc_rtt_tx_ping, "PING")
339
340#define rxrpc_rtt_rx_traces \
341 EM(rxrpc_rtt_rx_other_ack, "OACK") \
342 EM(rxrpc_rtt_rx_obsolete, "OBSL") \
343 EM(rxrpc_rtt_rx_lost, "LOST") \
344 EM(rxrpc_rtt_rx_ping_response, "PONG") \
345 E_(rxrpc_rtt_rx_requested_ack, "RACK")
346
347#define rxrpc_timer_traces \
348 EM(rxrpc_timer_trace_delayed_ack, "DelayAck ") \
349 EM(rxrpc_timer_trace_expect_rx, "ExpectRx ") \
350 EM(rxrpc_timer_trace_hard, "HardLimit") \
351 EM(rxrpc_timer_trace_idle, "IdleLimit") \
352 EM(rxrpc_timer_trace_keepalive, "KeepAlive") \
353 EM(rxrpc_timer_trace_lost_ack, "LostAck ") \
354 EM(rxrpc_timer_trace_ping, "DelayPing") \
355 EM(rxrpc_timer_trace_resend, "Resend ") \
356 EM(rxrpc_timer_trace_resend_reset, "ResendRst") \
357 E_(rxrpc_timer_trace_resend_tx, "ResendTx ")
358
359#define rxrpc_propose_ack_traces \
360 EM(rxrpc_propose_ack_client_tx_end, "ClTxEnd") \
361 EM(rxrpc_propose_ack_delayed_ack, "DlydAck") \
362 EM(rxrpc_propose_ack_input_data, "DataIn ") \
363 EM(rxrpc_propose_ack_input_data_hole, "DataInH") \
364 EM(rxrpc_propose_ack_ping_for_keepalive, "KeepAlv") \
365 EM(rxrpc_propose_ack_ping_for_lost_ack, "LostAck") \
366 EM(rxrpc_propose_ack_ping_for_lost_reply, "LostRpl") \
367 EM(rxrpc_propose_ack_ping_for_0_retrans, "0-Retrn") \
368 EM(rxrpc_propose_ack_ping_for_old_rtt, "OldRtt ") \
369 EM(rxrpc_propose_ack_ping_for_params, "Params ") \
370 EM(rxrpc_propose_ack_ping_for_rtt, "Rtt ") \
371 EM(rxrpc_propose_ack_processing_op, "ProcOp ") \
372 EM(rxrpc_propose_ack_respond_to_ack, "Rsp2Ack") \
373 EM(rxrpc_propose_ack_respond_to_ping, "Rsp2Png") \
374 EM(rxrpc_propose_ack_retry_tx, "RetryTx") \
375 EM(rxrpc_propose_ack_rotate_rx, "RxAck ") \
376 EM(rxrpc_propose_ack_rx_idle, "RxIdle ") \
377 E_(rxrpc_propose_ack_terminal_ack, "ClTerm ")
378
379#define rxrpc_congest_modes \
380 EM(RXRPC_CALL_CONGEST_AVOIDANCE, "CongAvoid") \
381 EM(RXRPC_CALL_FAST_RETRANSMIT, "FastReTx ") \
382 EM(RXRPC_CALL_PACKET_LOSS, "PktLoss ") \
383 E_(RXRPC_CALL_SLOW_START, "SlowStart")
384
385#define rxrpc_congest_changes \
386 EM(rxrpc_cong_begin_retransmission, " Retrans") \
387 EM(rxrpc_cong_cleared_nacks, " Cleared") \
388 EM(rxrpc_cong_new_low_nack, " NewLowN") \
389 EM(rxrpc_cong_no_change, " -") \
390 EM(rxrpc_cong_progress, " Progres") \
391 EM(rxrpc_cong_idle_reset, " IdleRes") \
392 EM(rxrpc_cong_retransmit_again, " ReTxAgn") \
393 EM(rxrpc_cong_rtt_window_end, " RttWinE") \
394 E_(rxrpc_cong_saw_nack, " SawNack")
395
396#define rxrpc_pkts \
397 EM(0, "?00") \
398 EM(RXRPC_PACKET_TYPE_DATA, "DATA") \
399 EM(RXRPC_PACKET_TYPE_ACK, "ACK") \
400 EM(RXRPC_PACKET_TYPE_BUSY, "BUSY") \
401 EM(RXRPC_PACKET_TYPE_ABORT, "ABORT") \
402 EM(RXRPC_PACKET_TYPE_ACKALL, "ACKALL") \
403 EM(RXRPC_PACKET_TYPE_CHALLENGE, "CHALL") \
404 EM(RXRPC_PACKET_TYPE_RESPONSE, "RESP") \
405 EM(RXRPC_PACKET_TYPE_DEBUG, "DEBUG") \
406 EM(9, "?09") \
407 EM(10, "?10") \
408 EM(11, "?11") \
409 EM(12, "?12") \
410 EM(RXRPC_PACKET_TYPE_VERSION, "VERSION") \
411 EM(14, "?14") \
412 E_(15, "?15")
413
414#define rxrpc_ack_names \
415 EM(0, "-0-") \
416 EM(RXRPC_ACK_REQUESTED, "REQ") \
417 EM(RXRPC_ACK_DUPLICATE, "DUP") \
418 EM(RXRPC_ACK_OUT_OF_SEQUENCE, "OOS") \
419 EM(RXRPC_ACK_EXCEEDS_WINDOW, "WIN") \
420 EM(RXRPC_ACK_NOSPACE, "MEM") \
421 EM(RXRPC_ACK_PING, "PNG") \
422 EM(RXRPC_ACK_PING_RESPONSE, "PNR") \
423 EM(RXRPC_ACK_DELAY, "DLY") \
424 EM(RXRPC_ACK_IDLE, "IDL") \
425 E_(RXRPC_ACK__INVALID, "-?-")
426
427#define rxrpc_sack_traces \
428 EM(rxrpc_sack_advance, "ADV") \
429 EM(rxrpc_sack_fill, "FIL") \
430 EM(rxrpc_sack_nack, "NAK") \
431 EM(rxrpc_sack_none, "---") \
432 E_(rxrpc_sack_oos, "OOS")
433
434#define rxrpc_completions \
435 EM(RXRPC_CALL_SUCCEEDED, "Succeeded") \
436 EM(RXRPC_CALL_REMOTELY_ABORTED, "RemoteAbort") \
437 EM(RXRPC_CALL_LOCALLY_ABORTED, "LocalAbort") \
438 EM(RXRPC_CALL_LOCAL_ERROR, "LocalError") \
439 E_(RXRPC_CALL_NETWORK_ERROR, "NetError")
440
441#define rxrpc_tx_points \
442 EM(rxrpc_tx_point_call_abort, "CallAbort") \
443 EM(rxrpc_tx_point_call_ack, "CallAck") \
444 EM(rxrpc_tx_point_call_data_frag, "CallDataFrag") \
445 EM(rxrpc_tx_point_call_data_nofrag, "CallDataNofrag") \
446 EM(rxrpc_tx_point_call_final_resend, "CallFinalResend") \
447 EM(rxrpc_tx_point_conn_abort, "ConnAbort") \
448 EM(rxrpc_tx_point_reject, "Reject") \
449 EM(rxrpc_tx_point_rxkad_challenge, "RxkadChall") \
450 EM(rxrpc_tx_point_rxkad_response, "RxkadResp") \
451 EM(rxrpc_tx_point_version_keepalive, "VerKeepalive") \
452 E_(rxrpc_tx_point_version_reply, "VerReply")
453
454#define rxrpc_req_ack_traces \
455 EM(rxrpc_reqack_ack_lost, "ACK-LOST ") \
456 EM(rxrpc_reqack_already_on, "ALREADY-ON") \
457 EM(rxrpc_reqack_more_rtt, "MORE-RTT ") \
458 EM(rxrpc_reqack_no_srv_last, "NO-SRVLAST") \
459 EM(rxrpc_reqack_old_rtt, "OLD-RTT ") \
460 EM(rxrpc_reqack_retrans, "RETRANS ") \
461 EM(rxrpc_reqack_slow_start, "SLOW-START") \
462 E_(rxrpc_reqack_small_txwin, "SMALL-TXWN")
463/* ---- Must update size of stat_why_req_ack[] if more are added! */
464
465#define rxrpc_txbuf_traces \
466 EM(rxrpc_txbuf_alloc_ack, "ALLOC ACK ") \
467 EM(rxrpc_txbuf_alloc_data, "ALLOC DATA ") \
468 EM(rxrpc_txbuf_free, "FREE ") \
469 EM(rxrpc_txbuf_get_buffer, "GET BUFFER ") \
470 EM(rxrpc_txbuf_get_trans, "GET TRANS ") \
471 EM(rxrpc_txbuf_get_retrans, "GET RETRANS") \
472 EM(rxrpc_txbuf_put_ack_tx, "PUT ACK TX ") \
473 EM(rxrpc_txbuf_put_cleaned, "PUT CLEANED") \
474 EM(rxrpc_txbuf_put_nomem, "PUT NOMEM ") \
475 EM(rxrpc_txbuf_put_rotated, "PUT ROTATED") \
476 EM(rxrpc_txbuf_put_send_aborted, "PUT SEND-X ") \
477 EM(rxrpc_txbuf_put_trans, "PUT TRANS ") \
478 EM(rxrpc_txbuf_see_out_of_step, "OUT-OF-STEP") \
479 EM(rxrpc_txbuf_see_send_more, "SEE SEND+ ") \
480 E_(rxrpc_txbuf_see_unacked, "SEE UNACKED")
481
482/*
483 * Generate enums for tracing information.
484 */
485#ifndef __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
486#define __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
487
488#undef EM
489#undef E_
490#define EM(a, b) a,
491#define E_(a, b) a
492
493enum rxrpc_abort_reason { rxrpc_abort_reasons } __mode(byte);
494enum rxrpc_bundle_trace { rxrpc_bundle_traces } __mode(byte);
495enum rxrpc_call_poke_trace { rxrpc_call_poke_traces } __mode(byte);
496enum rxrpc_call_trace { rxrpc_call_traces } __mode(byte);
497enum rxrpc_client_trace { rxrpc_client_traces } __mode(byte);
498enum rxrpc_congest_change { rxrpc_congest_changes } __mode(byte);
499enum rxrpc_conn_trace { rxrpc_conn_traces } __mode(byte);
500enum rxrpc_local_trace { rxrpc_local_traces } __mode(byte);
501enum rxrpc_peer_trace { rxrpc_peer_traces } __mode(byte);
502enum rxrpc_propose_ack_outcome { rxrpc_propose_ack_outcomes } __mode(byte);
503enum rxrpc_propose_ack_trace { rxrpc_propose_ack_traces } __mode(byte);
504enum rxrpc_receive_trace { rxrpc_receive_traces } __mode(byte);
505enum rxrpc_recvmsg_trace { rxrpc_recvmsg_traces } __mode(byte);
506enum rxrpc_req_ack_trace { rxrpc_req_ack_traces } __mode(byte);
507enum rxrpc_rtt_rx_trace { rxrpc_rtt_rx_traces } __mode(byte);
508enum rxrpc_rtt_tx_trace { rxrpc_rtt_tx_traces } __mode(byte);
509enum rxrpc_sack_trace { rxrpc_sack_traces } __mode(byte);
510enum rxrpc_skb_trace { rxrpc_skb_traces } __mode(byte);
511enum rxrpc_timer_trace { rxrpc_timer_traces } __mode(byte);
512enum rxrpc_tx_point { rxrpc_tx_points } __mode(byte);
513enum rxrpc_txbuf_trace { rxrpc_txbuf_traces } __mode(byte);
514enum rxrpc_txqueue_trace { rxrpc_txqueue_traces } __mode(byte);
515
516#endif /* end __RXRPC_DECLARE_TRACE_ENUMS_ONCE_ONLY */
517
518/*
519 * Export enum symbols via userspace.
520 */
521#undef EM
522#undef E_
523
524#ifndef RXRPC_TRACE_ONLY_DEFINE_ENUMS
525
526#define EM(a, b) TRACE_DEFINE_ENUM(a);
527#define E_(a, b) TRACE_DEFINE_ENUM(a);
528
529rxrpc_abort_reasons;
530rxrpc_bundle_traces;
531rxrpc_call_poke_traces;
532rxrpc_call_traces;
533rxrpc_client_traces;
534rxrpc_congest_changes;
535rxrpc_congest_modes;
536rxrpc_conn_traces;
537rxrpc_local_traces;
538rxrpc_propose_ack_traces;
539rxrpc_receive_traces;
540rxrpc_recvmsg_traces;
541rxrpc_req_ack_traces;
542rxrpc_rtt_rx_traces;
543rxrpc_rtt_tx_traces;
544rxrpc_sack_traces;
545rxrpc_skb_traces;
546rxrpc_timer_traces;
547rxrpc_tx_points;
548rxrpc_txbuf_traces;
549rxrpc_txqueue_traces;
550
551/*
552 * Now redefine the EM() and E_() macros to map the enums to the strings that
553 * will be printed in the output.
554 */
555#undef EM
556#undef E_
557#define EM(a, b) { a, b },
558#define E_(a, b) { a, b }
559
560TRACE_EVENT(rxrpc_local,
561 TP_PROTO(unsigned int local_debug_id, enum rxrpc_local_trace op,
562 int ref, int usage),
563
564 TP_ARGS(local_debug_id, op, ref, usage),
565
566 TP_STRUCT__entry(
567 __field(unsigned int, local)
568 __field(int, op)
569 __field(int, ref)
570 __field(int, usage)
571 ),
572
573 TP_fast_assign(
574 __entry->local = local_debug_id;
575 __entry->op = op;
576 __entry->ref = ref;
577 __entry->usage = usage;
578 ),
579
580 TP_printk("L=%08x %s r=%d u=%d",
581 __entry->local,
582 __print_symbolic(__entry->op, rxrpc_local_traces),
583 __entry->ref,
584 __entry->usage)
585 );
586
587TRACE_EVENT(rxrpc_peer,
588 TP_PROTO(unsigned int peer_debug_id, int ref, enum rxrpc_peer_trace why),
589
590 TP_ARGS(peer_debug_id, ref, why),
591
592 TP_STRUCT__entry(
593 __field(unsigned int, peer)
594 __field(int, ref)
595 __field(enum rxrpc_peer_trace, why)
596 ),
597
598 TP_fast_assign(
599 __entry->peer = peer_debug_id;
600 __entry->ref = ref;
601 __entry->why = why;
602 ),
603
604 TP_printk("P=%08x %s r=%d",
605 __entry->peer,
606 __print_symbolic(__entry->why, rxrpc_peer_traces),
607 __entry->ref)
608 );
609
610TRACE_EVENT(rxrpc_bundle,
611 TP_PROTO(unsigned int bundle_debug_id, int ref, enum rxrpc_bundle_trace why),
612
613 TP_ARGS(bundle_debug_id, ref, why),
614
615 TP_STRUCT__entry(
616 __field(unsigned int, bundle)
617 __field(int, ref)
618 __field(int, why)
619 ),
620
621 TP_fast_assign(
622 __entry->bundle = bundle_debug_id;
623 __entry->ref = ref;
624 __entry->why = why;
625 ),
626
627 TP_printk("CB=%08x %s r=%d",
628 __entry->bundle,
629 __print_symbolic(__entry->why, rxrpc_bundle_traces),
630 __entry->ref)
631 );
632
633TRACE_EVENT(rxrpc_conn,
634 TP_PROTO(unsigned int conn_debug_id, int ref, enum rxrpc_conn_trace why),
635
636 TP_ARGS(conn_debug_id, ref, why),
637
638 TP_STRUCT__entry(
639 __field(unsigned int, conn)
640 __field(int, ref)
641 __field(int, why)
642 ),
643
644 TP_fast_assign(
645 __entry->conn = conn_debug_id;
646 __entry->ref = ref;
647 __entry->why = why;
648 ),
649
650 TP_printk("C=%08x %s r=%d",
651 __entry->conn,
652 __print_symbolic(__entry->why, rxrpc_conn_traces),
653 __entry->ref)
654 );
655
656TRACE_EVENT(rxrpc_client,
657 TP_PROTO(struct rxrpc_connection *conn, int channel,
658 enum rxrpc_client_trace op),
659
660 TP_ARGS(conn, channel, op),
661
662 TP_STRUCT__entry(
663 __field(unsigned int, conn)
664 __field(u32, cid)
665 __field(int, channel)
666 __field(int, usage)
667 __field(enum rxrpc_client_trace, op)
668 ),
669
670 TP_fast_assign(
671 __entry->conn = conn ? conn->debug_id : 0;
672 __entry->channel = channel;
673 __entry->usage = conn ? refcount_read(&conn->ref) : -2;
674 __entry->op = op;
675 __entry->cid = conn ? conn->proto.cid : 0;
676 ),
677
678 TP_printk("C=%08x h=%2d %s i=%08x u=%d",
679 __entry->conn,
680 __entry->channel,
681 __print_symbolic(__entry->op, rxrpc_client_traces),
682 __entry->cid,
683 __entry->usage)
684 );
685
686TRACE_EVENT(rxrpc_call,
687 TP_PROTO(unsigned int call_debug_id, int ref, unsigned long aux,
688 enum rxrpc_call_trace why),
689
690 TP_ARGS(call_debug_id, ref, aux, why),
691
692 TP_STRUCT__entry(
693 __field(unsigned int, call)
694 __field(int, ref)
695 __field(int, why)
696 __field(unsigned long, aux)
697 ),
698
699 TP_fast_assign(
700 __entry->call = call_debug_id;
701 __entry->ref = ref;
702 __entry->why = why;
703 __entry->aux = aux;
704 ),
705
706 TP_printk("c=%08x %s r=%d a=%lx",
707 __entry->call,
708 __print_symbolic(__entry->why, rxrpc_call_traces),
709 __entry->ref,
710 __entry->aux)
711 );
712
713TRACE_EVENT(rxrpc_skb,
714 TP_PROTO(struct sk_buff *skb, int usage, int mod_count,
715 enum rxrpc_skb_trace why),
716
717 TP_ARGS(skb, usage, mod_count, why),
718
719 TP_STRUCT__entry(
720 __field(struct sk_buff *, skb)
721 __field(int, usage)
722 __field(int, mod_count)
723 __field(enum rxrpc_skb_trace, why)
724 ),
725
726 TP_fast_assign(
727 __entry->skb = skb;
728 __entry->usage = usage;
729 __entry->mod_count = mod_count;
730 __entry->why = why;
731 ),
732
733 TP_printk("s=%p Rx %s u=%d m=%d",
734 __entry->skb,
735 __print_symbolic(__entry->why, rxrpc_skb_traces),
736 __entry->usage,
737 __entry->mod_count)
738 );
739
740TRACE_EVENT(rxrpc_rx_packet,
741 TP_PROTO(struct rxrpc_skb_priv *sp),
742
743 TP_ARGS(sp),
744
745 TP_STRUCT__entry(
746 __field_struct(struct rxrpc_host_header, hdr)
747 ),
748
749 TP_fast_assign(
750 memcpy(&__entry->hdr, &sp->hdr, sizeof(__entry->hdr));
751 ),
752
753 TP_printk("%08x:%08x:%08x:%04x %08x %08x %02x %02x %s",
754 __entry->hdr.epoch, __entry->hdr.cid,
755 __entry->hdr.callNumber, __entry->hdr.serviceId,
756 __entry->hdr.serial, __entry->hdr.seq,
757 __entry->hdr.securityIndex, __entry->hdr.flags,
758 __print_symbolic(__entry->hdr.type, rxrpc_pkts))
759 );
760
761TRACE_EVENT(rxrpc_rx_done,
762 TP_PROTO(int result, int abort_code),
763
764 TP_ARGS(result, abort_code),
765
766 TP_STRUCT__entry(
767 __field(int, result)
768 __field(int, abort_code)
769 ),
770
771 TP_fast_assign(
772 __entry->result = result;
773 __entry->abort_code = abort_code;
774 ),
775
776 TP_printk("r=%d a=%d", __entry->result, __entry->abort_code)
777 );
778
779TRACE_EVENT(rxrpc_abort_call,
780 TP_PROTO(const struct rxrpc_call *call, int abort_code),
781
782 TP_ARGS(call, abort_code),
783
784 TP_STRUCT__entry(
785 __field(unsigned int, call_nr)
786 __field(enum rxrpc_abort_reason, why)
787 __field(int, abort_code)
788 __field(int, error)
789 ),
790
791 TP_fast_assign(
792 __entry->call_nr = call->debug_id;
793 __entry->why = call->send_abort_why;
794 __entry->abort_code = abort_code;
795 __entry->error = call->send_abort_err;
796 ),
797
798 TP_printk("c=%08x a=%d e=%d %s",
799 __entry->call_nr,
800 __entry->abort_code, __entry->error,
801 __print_symbolic(__entry->why, rxrpc_abort_reasons))
802 );
803
804TRACE_EVENT(rxrpc_abort,
805 TP_PROTO(unsigned int call_nr, enum rxrpc_abort_reason why,
806 u32 cid, u32 call_id, rxrpc_seq_t seq, int abort_code, int error),
807
808 TP_ARGS(call_nr, why, cid, call_id, seq, abort_code, error),
809
810 TP_STRUCT__entry(
811 __field(unsigned int, call_nr)
812 __field(enum rxrpc_abort_reason, why)
813 __field(u32, cid)
814 __field(u32, call_id)
815 __field(rxrpc_seq_t, seq)
816 __field(int, abort_code)
817 __field(int, error)
818 ),
819
820 TP_fast_assign(
821 __entry->call_nr = call_nr;
822 __entry->why = why;
823 __entry->cid = cid;
824 __entry->call_id = call_id;
825 __entry->abort_code = abort_code;
826 __entry->error = error;
827 __entry->seq = seq;
828 ),
829
830 TP_printk("c=%08x %08x:%08x s=%u a=%d e=%d %s",
831 __entry->call_nr,
832 __entry->cid, __entry->call_id, __entry->seq,
833 __entry->abort_code, __entry->error,
834 __print_symbolic(__entry->why, rxrpc_abort_reasons))
835 );
836
837TRACE_EVENT(rxrpc_call_complete,
838 TP_PROTO(struct rxrpc_call *call),
839
840 TP_ARGS(call),
841
842 TP_STRUCT__entry(
843 __field(unsigned int, call)
844 __field(enum rxrpc_call_completion, compl)
845 __field(int, error)
846 __field(u32, abort_code)
847 ),
848
849 TP_fast_assign(
850 __entry->call = call->debug_id;
851 __entry->compl = call->completion;
852 __entry->error = call->error;
853 __entry->abort_code = call->abort_code;
854 ),
855
856 TP_printk("c=%08x %s r=%d ac=%d",
857 __entry->call,
858 __print_symbolic(__entry->compl, rxrpc_completions),
859 __entry->error,
860 __entry->abort_code)
861 );
862
863TRACE_EVENT(rxrpc_txqueue,
864 TP_PROTO(struct rxrpc_call *call, enum rxrpc_txqueue_trace why),
865
866 TP_ARGS(call, why),
867
868 TP_STRUCT__entry(
869 __field(unsigned int, call)
870 __field(enum rxrpc_txqueue_trace, why)
871 __field(rxrpc_seq_t, acks_hard_ack)
872 __field(rxrpc_seq_t, tx_bottom)
873 __field(rxrpc_seq_t, tx_top)
874 __field(rxrpc_seq_t, tx_prepared)
875 __field(int, tx_winsize)
876 ),
877
878 TP_fast_assign(
879 __entry->call = call->debug_id;
880 __entry->why = why;
881 __entry->acks_hard_ack = call->acks_hard_ack;
882 __entry->tx_bottom = call->tx_bottom;
883 __entry->tx_top = call->tx_top;
884 __entry->tx_prepared = call->tx_prepared;
885 __entry->tx_winsize = call->tx_winsize;
886 ),
887
888 TP_printk("c=%08x %s f=%08x h=%08x n=%u/%u/%u/%u",
889 __entry->call,
890 __print_symbolic(__entry->why, rxrpc_txqueue_traces),
891 __entry->tx_bottom,
892 __entry->acks_hard_ack,
893 __entry->tx_top - __entry->tx_bottom,
894 __entry->tx_top - __entry->acks_hard_ack,
895 __entry->tx_prepared - __entry->tx_bottom,
896 __entry->tx_winsize)
897 );
898
899TRACE_EVENT(rxrpc_rx_data,
900 TP_PROTO(unsigned int call, rxrpc_seq_t seq,
901 rxrpc_serial_t serial, u8 flags),
902
903 TP_ARGS(call, seq, serial, flags),
904
905 TP_STRUCT__entry(
906 __field(unsigned int, call)
907 __field(rxrpc_seq_t, seq)
908 __field(rxrpc_serial_t, serial)
909 __field(u8, flags)
910 ),
911
912 TP_fast_assign(
913 __entry->call = call;
914 __entry->seq = seq;
915 __entry->serial = serial;
916 __entry->flags = flags;
917 ),
918
919 TP_printk("c=%08x DATA %08x q=%08x fl=%02x",
920 __entry->call,
921 __entry->serial,
922 __entry->seq,
923 __entry->flags)
924 );
925
926TRACE_EVENT(rxrpc_rx_ack,
927 TP_PROTO(struct rxrpc_call *call,
928 rxrpc_serial_t serial, rxrpc_serial_t ack_serial,
929 rxrpc_seq_t first, rxrpc_seq_t prev, u8 reason, u8 n_acks),
930
931 TP_ARGS(call, serial, ack_serial, first, prev, reason, n_acks),
932
933 TP_STRUCT__entry(
934 __field(unsigned int, call)
935 __field(rxrpc_serial_t, serial)
936 __field(rxrpc_serial_t, ack_serial)
937 __field(rxrpc_seq_t, first)
938 __field(rxrpc_seq_t, prev)
939 __field(u8, reason)
940 __field(u8, n_acks)
941 ),
942
943 TP_fast_assign(
944 __entry->call = call->debug_id;
945 __entry->serial = serial;
946 __entry->ack_serial = ack_serial;
947 __entry->first = first;
948 __entry->prev = prev;
949 __entry->reason = reason;
950 __entry->n_acks = n_acks;
951 ),
952
953 TP_printk("c=%08x %08x %s r=%08x f=%08x p=%08x n=%u",
954 __entry->call,
955 __entry->serial,
956 __print_symbolic(__entry->reason, rxrpc_ack_names),
957 __entry->ack_serial,
958 __entry->first,
959 __entry->prev,
960 __entry->n_acks)
961 );
962
963TRACE_EVENT(rxrpc_rx_abort,
964 TP_PROTO(struct rxrpc_call *call, rxrpc_serial_t serial,
965 u32 abort_code),
966
967 TP_ARGS(call, serial, abort_code),
968
969 TP_STRUCT__entry(
970 __field(unsigned int, call)
971 __field(rxrpc_serial_t, serial)
972 __field(u32, abort_code)
973 ),
974
975 TP_fast_assign(
976 __entry->call = call->debug_id;
977 __entry->serial = serial;
978 __entry->abort_code = abort_code;
979 ),
980
981 TP_printk("c=%08x ABORT %08x ac=%d",
982 __entry->call,
983 __entry->serial,
984 __entry->abort_code)
985 );
986
987TRACE_EVENT(rxrpc_rx_conn_abort,
988 TP_PROTO(const struct rxrpc_connection *conn, const struct sk_buff *skb),
989
990 TP_ARGS(conn, skb),
991
992 TP_STRUCT__entry(
993 __field(unsigned int, conn)
994 __field(rxrpc_serial_t, serial)
995 __field(u32, abort_code)
996 ),
997
998 TP_fast_assign(
999 __entry->conn = conn->debug_id;
1000 __entry->serial = rxrpc_skb(skb)->hdr.serial;
1001 __entry->abort_code = skb->priority;
1002 ),
1003
1004 TP_printk("C=%08x ABORT %08x ac=%d",
1005 __entry->conn,
1006 __entry->serial,
1007 __entry->abort_code)
1008 );
1009
1010TRACE_EVENT(rxrpc_rx_challenge,
1011 TP_PROTO(struct rxrpc_connection *conn, rxrpc_serial_t serial,
1012 u32 version, u32 nonce, u32 min_level),
1013
1014 TP_ARGS(conn, serial, version, nonce, min_level),
1015
1016 TP_STRUCT__entry(
1017 __field(unsigned int, conn)
1018 __field(rxrpc_serial_t, serial)
1019 __field(u32, version)
1020 __field(u32, nonce)
1021 __field(u32, min_level)
1022 ),
1023
1024 TP_fast_assign(
1025 __entry->conn = conn->debug_id;
1026 __entry->serial = serial;
1027 __entry->version = version;
1028 __entry->nonce = nonce;
1029 __entry->min_level = min_level;
1030 ),
1031
1032 TP_printk("C=%08x CHALLENGE %08x v=%x n=%x ml=%x",
1033 __entry->conn,
1034 __entry->serial,
1035 __entry->version,
1036 __entry->nonce,
1037 __entry->min_level)
1038 );
1039
1040TRACE_EVENT(rxrpc_rx_response,
1041 TP_PROTO(struct rxrpc_connection *conn, rxrpc_serial_t serial,
1042 u32 version, u32 kvno, u32 ticket_len),
1043
1044 TP_ARGS(conn, serial, version, kvno, ticket_len),
1045
1046 TP_STRUCT__entry(
1047 __field(unsigned int, conn)
1048 __field(rxrpc_serial_t, serial)
1049 __field(u32, version)
1050 __field(u32, kvno)
1051 __field(u32, ticket_len)
1052 ),
1053
1054 TP_fast_assign(
1055 __entry->conn = conn->debug_id;
1056 __entry->serial = serial;
1057 __entry->version = version;
1058 __entry->kvno = kvno;
1059 __entry->ticket_len = ticket_len;
1060 ),
1061
1062 TP_printk("C=%08x RESPONSE %08x v=%x kvno=%x tl=%x",
1063 __entry->conn,
1064 __entry->serial,
1065 __entry->version,
1066 __entry->kvno,
1067 __entry->ticket_len)
1068 );
1069
1070TRACE_EVENT(rxrpc_rx_rwind_change,
1071 TP_PROTO(struct rxrpc_call *call, rxrpc_serial_t serial,
1072 u32 rwind, bool wake),
1073
1074 TP_ARGS(call, serial, rwind, wake),
1075
1076 TP_STRUCT__entry(
1077 __field(unsigned int, call)
1078 __field(rxrpc_serial_t, serial)
1079 __field(u32, rwind)
1080 __field(bool, wake)
1081 ),
1082
1083 TP_fast_assign(
1084 __entry->call = call->debug_id;
1085 __entry->serial = serial;
1086 __entry->rwind = rwind;
1087 __entry->wake = wake;
1088 ),
1089
1090 TP_printk("c=%08x %08x rw=%u%s",
1091 __entry->call,
1092 __entry->serial,
1093 __entry->rwind,
1094 __entry->wake ? " wake" : "")
1095 );
1096
1097TRACE_EVENT(rxrpc_tx_packet,
1098 TP_PROTO(unsigned int call_id, struct rxrpc_wire_header *whdr,
1099 enum rxrpc_tx_point where),
1100
1101 TP_ARGS(call_id, whdr, where),
1102
1103 TP_STRUCT__entry(
1104 __field(unsigned int, call)
1105 __field(enum rxrpc_tx_point, where)
1106 __field_struct(struct rxrpc_wire_header, whdr)
1107 ),
1108
1109 TP_fast_assign(
1110 __entry->call = call_id;
1111 memcpy(&__entry->whdr, whdr, sizeof(__entry->whdr));
1112 __entry->where = where;
1113 ),
1114
1115 TP_printk("c=%08x %08x:%08x:%08x:%04x %08x %08x %02x %02x %s %s",
1116 __entry->call,
1117 ntohl(__entry->whdr.epoch),
1118 ntohl(__entry->whdr.cid),
1119 ntohl(__entry->whdr.callNumber),
1120 ntohs(__entry->whdr.serviceId),
1121 ntohl(__entry->whdr.serial),
1122 ntohl(__entry->whdr.seq),
1123 __entry->whdr.type, __entry->whdr.flags,
1124 __entry->whdr.type <= 15 ?
1125 __print_symbolic(__entry->whdr.type, rxrpc_pkts) : "?UNK",
1126 __print_symbolic(__entry->where, rxrpc_tx_points))
1127 );
1128
1129TRACE_EVENT(rxrpc_tx_data,
1130 TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t seq,
1131 rxrpc_serial_t serial, unsigned int flags, bool lose),
1132
1133 TP_ARGS(call, seq, serial, flags, lose),
1134
1135 TP_STRUCT__entry(
1136 __field(unsigned int, call)
1137 __field(rxrpc_seq_t, seq)
1138 __field(rxrpc_serial_t, serial)
1139 __field(u32, cid)
1140 __field(u32, call_id)
1141 __field(u16, flags)
1142 __field(bool, lose)
1143 ),
1144
1145 TP_fast_assign(
1146 __entry->call = call->debug_id;
1147 __entry->cid = call->cid;
1148 __entry->call_id = call->call_id;
1149 __entry->seq = seq;
1150 __entry->serial = serial;
1151 __entry->flags = flags;
1152 __entry->lose = lose;
1153 ),
1154
1155 TP_printk("c=%08x DATA %08x:%08x %08x q=%08x fl=%02x%s%s",
1156 __entry->call,
1157 __entry->cid,
1158 __entry->call_id,
1159 __entry->serial,
1160 __entry->seq,
1161 __entry->flags & RXRPC_TXBUF_WIRE_FLAGS,
1162 __entry->flags & RXRPC_TXBUF_RESENT ? " *RETRANS*" : "",
1163 __entry->lose ? " *LOSE*" : "")
1164 );
1165
1166TRACE_EVENT(rxrpc_tx_ack,
1167 TP_PROTO(unsigned int call, rxrpc_serial_t serial,
1168 rxrpc_seq_t ack_first, rxrpc_serial_t ack_serial,
1169 u8 reason, u8 n_acks, u16 rwind),
1170
1171 TP_ARGS(call, serial, ack_first, ack_serial, reason, n_acks, rwind),
1172
1173 TP_STRUCT__entry(
1174 __field(unsigned int, call)
1175 __field(rxrpc_serial_t, serial)
1176 __field(rxrpc_seq_t, ack_first)
1177 __field(rxrpc_serial_t, ack_serial)
1178 __field(u8, reason)
1179 __field(u8, n_acks)
1180 __field(u16, rwind)
1181 ),
1182
1183 TP_fast_assign(
1184 __entry->call = call;
1185 __entry->serial = serial;
1186 __entry->ack_first = ack_first;
1187 __entry->ack_serial = ack_serial;
1188 __entry->reason = reason;
1189 __entry->n_acks = n_acks;
1190 __entry->rwind = rwind;
1191 ),
1192
1193 TP_printk(" c=%08x ACK %08x %s f=%08x r=%08x n=%u rw=%u",
1194 __entry->call,
1195 __entry->serial,
1196 __print_symbolic(__entry->reason, rxrpc_ack_names),
1197 __entry->ack_first,
1198 __entry->ack_serial,
1199 __entry->n_acks,
1200 __entry->rwind)
1201 );
1202
1203TRACE_EVENT(rxrpc_receive,
1204 TP_PROTO(struct rxrpc_call *call, enum rxrpc_receive_trace why,
1205 rxrpc_serial_t serial, rxrpc_seq_t seq),
1206
1207 TP_ARGS(call, why, serial, seq),
1208
1209 TP_STRUCT__entry(
1210 __field(unsigned int, call)
1211 __field(enum rxrpc_receive_trace, why)
1212 __field(rxrpc_serial_t, serial)
1213 __field(rxrpc_seq_t, seq)
1214 __field(rxrpc_seq_t, window)
1215 __field(rxrpc_seq_t, wtop)
1216 ),
1217
1218 TP_fast_assign(
1219 __entry->call = call->debug_id;
1220 __entry->why = why;
1221 __entry->serial = serial;
1222 __entry->seq = seq;
1223 __entry->window = call->ackr_window;
1224 __entry->wtop = call->ackr_wtop;
1225 ),
1226
1227 TP_printk("c=%08x %s r=%08x q=%08x w=%08x-%08x",
1228 __entry->call,
1229 __print_symbolic(__entry->why, rxrpc_receive_traces),
1230 __entry->serial,
1231 __entry->seq,
1232 __entry->window,
1233 __entry->wtop)
1234 );
1235
1236TRACE_EVENT(rxrpc_recvmsg,
1237 TP_PROTO(unsigned int call_debug_id, enum rxrpc_recvmsg_trace why,
1238 int ret),
1239
1240 TP_ARGS(call_debug_id, why, ret),
1241
1242 TP_STRUCT__entry(
1243 __field(unsigned int, call)
1244 __field(enum rxrpc_recvmsg_trace, why)
1245 __field(int, ret)
1246 ),
1247
1248 TP_fast_assign(
1249 __entry->call = call_debug_id;
1250 __entry->why = why;
1251 __entry->ret = ret;
1252 ),
1253
1254 TP_printk("c=%08x %s ret=%d",
1255 __entry->call,
1256 __print_symbolic(__entry->why, rxrpc_recvmsg_traces),
1257 __entry->ret)
1258 );
1259
1260TRACE_EVENT(rxrpc_recvdata,
1261 TP_PROTO(struct rxrpc_call *call, enum rxrpc_recvmsg_trace why,
1262 rxrpc_seq_t seq, unsigned int offset, unsigned int len,
1263 int ret),
1264
1265 TP_ARGS(call, why, seq, offset, len, ret),
1266
1267 TP_STRUCT__entry(
1268 __field(unsigned int, call)
1269 __field(enum rxrpc_recvmsg_trace, why)
1270 __field(rxrpc_seq_t, seq)
1271 __field(unsigned int, offset)
1272 __field(unsigned int, len)
1273 __field(int, ret)
1274 ),
1275
1276 TP_fast_assign(
1277 __entry->call = call ? call->debug_id : 0;
1278 __entry->why = why;
1279 __entry->seq = seq;
1280 __entry->offset = offset;
1281 __entry->len = len;
1282 __entry->ret = ret;
1283 ),
1284
1285 TP_printk("c=%08x %s q=%08x o=%u l=%u ret=%d",
1286 __entry->call,
1287 __print_symbolic(__entry->why, rxrpc_recvmsg_traces),
1288 __entry->seq,
1289 __entry->offset,
1290 __entry->len,
1291 __entry->ret)
1292 );
1293
1294TRACE_EVENT(rxrpc_rtt_tx,
1295 TP_PROTO(struct rxrpc_call *call, enum rxrpc_rtt_tx_trace why,
1296 int slot, rxrpc_serial_t send_serial),
1297
1298 TP_ARGS(call, why, slot, send_serial),
1299
1300 TP_STRUCT__entry(
1301 __field(unsigned int, call)
1302 __field(enum rxrpc_rtt_tx_trace, why)
1303 __field(int, slot)
1304 __field(rxrpc_serial_t, send_serial)
1305 ),
1306
1307 TP_fast_assign(
1308 __entry->call = call->debug_id;
1309 __entry->why = why;
1310 __entry->slot = slot;
1311 __entry->send_serial = send_serial;
1312 ),
1313
1314 TP_printk("c=%08x [%d] %s sr=%08x",
1315 __entry->call,
1316 __entry->slot,
1317 __print_symbolic(__entry->why, rxrpc_rtt_tx_traces),
1318 __entry->send_serial)
1319 );
1320
1321TRACE_EVENT(rxrpc_rtt_rx,
1322 TP_PROTO(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why,
1323 int slot,
1324 rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial,
1325 u32 rtt, u32 rto),
1326
1327 TP_ARGS(call, why, slot, send_serial, resp_serial, rtt, rto),
1328
1329 TP_STRUCT__entry(
1330 __field(unsigned int, call)
1331 __field(enum rxrpc_rtt_rx_trace, why)
1332 __field(int, slot)
1333 __field(rxrpc_serial_t, send_serial)
1334 __field(rxrpc_serial_t, resp_serial)
1335 __field(u32, rtt)
1336 __field(u32, rto)
1337 ),
1338
1339 TP_fast_assign(
1340 __entry->call = call->debug_id;
1341 __entry->why = why;
1342 __entry->slot = slot;
1343 __entry->send_serial = send_serial;
1344 __entry->resp_serial = resp_serial;
1345 __entry->rtt = rtt;
1346 __entry->rto = rto;
1347 ),
1348
1349 TP_printk("c=%08x [%d] %s sr=%08x rr=%08x rtt=%u rto=%u",
1350 __entry->call,
1351 __entry->slot,
1352 __print_symbolic(__entry->why, rxrpc_rtt_rx_traces),
1353 __entry->send_serial,
1354 __entry->resp_serial,
1355 __entry->rtt,
1356 __entry->rto)
1357 );
1358
1359TRACE_EVENT(rxrpc_timer_set,
1360 TP_PROTO(struct rxrpc_call *call, ktime_t delay,
1361 enum rxrpc_timer_trace why),
1362
1363 TP_ARGS(call, delay, why),
1364
1365 TP_STRUCT__entry(
1366 __field(unsigned int, call)
1367 __field(enum rxrpc_timer_trace, why)
1368 __field(ktime_t, delay)
1369 ),
1370
1371 TP_fast_assign(
1372 __entry->call = call->debug_id;
1373 __entry->why = why;
1374 __entry->delay = delay;
1375 ),
1376
1377 TP_printk("c=%08x %s to=%lld",
1378 __entry->call,
1379 __print_symbolic(__entry->why, rxrpc_timer_traces),
1380 ktime_to_us(__entry->delay))
1381 );
1382
1383TRACE_EVENT(rxrpc_timer_exp,
1384 TP_PROTO(struct rxrpc_call *call, ktime_t delay,
1385 enum rxrpc_timer_trace why),
1386
1387 TP_ARGS(call, delay, why),
1388
1389 TP_STRUCT__entry(
1390 __field(unsigned int, call)
1391 __field(enum rxrpc_timer_trace, why)
1392 __field(ktime_t, delay)
1393 ),
1394
1395 TP_fast_assign(
1396 __entry->call = call->debug_id;
1397 __entry->why = why;
1398 __entry->delay = delay;
1399 ),
1400
1401 TP_printk("c=%08x %s to=%lld",
1402 __entry->call,
1403 __print_symbolic(__entry->why, rxrpc_timer_traces),
1404 ktime_to_us(__entry->delay))
1405 );
1406
1407TRACE_EVENT(rxrpc_timer_can,
1408 TP_PROTO(struct rxrpc_call *call, enum rxrpc_timer_trace why),
1409
1410 TP_ARGS(call, why),
1411
1412 TP_STRUCT__entry(
1413 __field(unsigned int, call)
1414 __field(enum rxrpc_timer_trace, why)
1415 ),
1416
1417 TP_fast_assign(
1418 __entry->call = call->debug_id;
1419 __entry->why = why;
1420 ),
1421
1422 TP_printk("c=%08x %s",
1423 __entry->call,
1424 __print_symbolic(__entry->why, rxrpc_timer_traces))
1425 );
1426
1427TRACE_EVENT(rxrpc_timer_restart,
1428 TP_PROTO(struct rxrpc_call *call, ktime_t delay, unsigned long delayj),
1429
1430 TP_ARGS(call, delay, delayj),
1431
1432 TP_STRUCT__entry(
1433 __field(unsigned int, call)
1434 __field(unsigned long, delayj)
1435 __field(ktime_t, delay)
1436 ),
1437
1438 TP_fast_assign(
1439 __entry->call = call->debug_id;
1440 __entry->delayj = delayj;
1441 __entry->delay = delay;
1442 ),
1443
1444 TP_printk("c=%08x to=%lld j=%ld",
1445 __entry->call,
1446 ktime_to_us(__entry->delay),
1447 __entry->delayj)
1448 );
1449
1450TRACE_EVENT(rxrpc_timer_expired,
1451 TP_PROTO(struct rxrpc_call *call),
1452
1453 TP_ARGS(call),
1454
1455 TP_STRUCT__entry(
1456 __field(unsigned int, call)
1457 ),
1458
1459 TP_fast_assign(
1460 __entry->call = call->debug_id;
1461 ),
1462
1463 TP_printk("c=%08x EXPIRED",
1464 __entry->call)
1465 );
1466
1467TRACE_EVENT(rxrpc_rx_lose,
1468 TP_PROTO(struct rxrpc_skb_priv *sp),
1469
1470 TP_ARGS(sp),
1471
1472 TP_STRUCT__entry(
1473 __field_struct(struct rxrpc_host_header, hdr)
1474 ),
1475
1476 TP_fast_assign(
1477 memcpy(&__entry->hdr, &sp->hdr, sizeof(__entry->hdr));
1478 ),
1479
1480 TP_printk("%08x:%08x:%08x:%04x %08x %08x %02x %02x %s *LOSE*",
1481 __entry->hdr.epoch, __entry->hdr.cid,
1482 __entry->hdr.callNumber, __entry->hdr.serviceId,
1483 __entry->hdr.serial, __entry->hdr.seq,
1484 __entry->hdr.type, __entry->hdr.flags,
1485 __entry->hdr.type <= 15 ?
1486 __print_symbolic(__entry->hdr.type, rxrpc_pkts) : "?UNK")
1487 );
1488
1489TRACE_EVENT(rxrpc_propose_ack,
1490 TP_PROTO(struct rxrpc_call *call, enum rxrpc_propose_ack_trace why,
1491 u8 ack_reason, rxrpc_serial_t serial),
1492
1493 TP_ARGS(call, why, ack_reason, serial),
1494
1495 TP_STRUCT__entry(
1496 __field(unsigned int, call)
1497 __field(enum rxrpc_propose_ack_trace, why)
1498 __field(rxrpc_serial_t, serial)
1499 __field(u8, ack_reason)
1500 ),
1501
1502 TP_fast_assign(
1503 __entry->call = call->debug_id;
1504 __entry->why = why;
1505 __entry->serial = serial;
1506 __entry->ack_reason = ack_reason;
1507 ),
1508
1509 TP_printk("c=%08x %s %s r=%08x",
1510 __entry->call,
1511 __print_symbolic(__entry->why, rxrpc_propose_ack_traces),
1512 __print_symbolic(__entry->ack_reason, rxrpc_ack_names),
1513 __entry->serial)
1514 );
1515
1516TRACE_EVENT(rxrpc_send_ack,
1517 TP_PROTO(struct rxrpc_call *call, enum rxrpc_propose_ack_trace why,
1518 u8 ack_reason, rxrpc_serial_t serial),
1519
1520 TP_ARGS(call, why, ack_reason, serial),
1521
1522 TP_STRUCT__entry(
1523 __field(unsigned int, call)
1524 __field(enum rxrpc_propose_ack_trace, why)
1525 __field(rxrpc_serial_t, serial)
1526 __field(u8, ack_reason)
1527 ),
1528
1529 TP_fast_assign(
1530 __entry->call = call->debug_id;
1531 __entry->why = why;
1532 __entry->serial = serial;
1533 __entry->ack_reason = ack_reason;
1534 ),
1535
1536 TP_printk("c=%08x %s %s r=%08x",
1537 __entry->call,
1538 __print_symbolic(__entry->why, rxrpc_propose_ack_traces),
1539 __print_symbolic(__entry->ack_reason, rxrpc_ack_names),
1540 __entry->serial)
1541 );
1542
1543TRACE_EVENT(rxrpc_drop_ack,
1544 TP_PROTO(struct rxrpc_call *call, enum rxrpc_propose_ack_trace why,
1545 u8 ack_reason, rxrpc_serial_t serial, bool nobuf),
1546
1547 TP_ARGS(call, why, ack_reason, serial, nobuf),
1548
1549 TP_STRUCT__entry(
1550 __field(unsigned int, call)
1551 __field(enum rxrpc_propose_ack_trace, why)
1552 __field(rxrpc_serial_t, serial)
1553 __field(u8, ack_reason)
1554 __field(bool, nobuf)
1555 ),
1556
1557 TP_fast_assign(
1558 __entry->call = call->debug_id;
1559 __entry->why = why;
1560 __entry->serial = serial;
1561 __entry->ack_reason = ack_reason;
1562 __entry->nobuf = nobuf;
1563 ),
1564
1565 TP_printk("c=%08x %s %s r=%08x nbf=%u",
1566 __entry->call,
1567 __print_symbolic(__entry->why, rxrpc_propose_ack_traces),
1568 __print_symbolic(__entry->ack_reason, rxrpc_ack_names),
1569 __entry->serial, __entry->nobuf)
1570 );
1571
1572TRACE_EVENT(rxrpc_retransmit,
1573 TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t seq,
1574 rxrpc_serial_t serial, ktime_t expiry),
1575
1576 TP_ARGS(call, seq, serial, expiry),
1577
1578 TP_STRUCT__entry(
1579 __field(unsigned int, call)
1580 __field(rxrpc_seq_t, seq)
1581 __field(rxrpc_serial_t, serial)
1582 __field(ktime_t, expiry)
1583 ),
1584
1585 TP_fast_assign(
1586 __entry->call = call->debug_id;
1587 __entry->seq = seq;
1588 __entry->serial = serial;
1589 __entry->expiry = expiry;
1590 ),
1591
1592 TP_printk("c=%08x q=%x r=%x xp=%lld",
1593 __entry->call,
1594 __entry->seq,
1595 __entry->serial,
1596 ktime_to_us(__entry->expiry))
1597 );
1598
1599TRACE_EVENT(rxrpc_congest,
1600 TP_PROTO(struct rxrpc_call *call, struct rxrpc_ack_summary *summary,
1601 rxrpc_serial_t ack_serial, enum rxrpc_congest_change change),
1602
1603 TP_ARGS(call, summary, ack_serial, change),
1604
1605 TP_STRUCT__entry(
1606 __field(unsigned int, call)
1607 __field(enum rxrpc_congest_change, change)
1608 __field(rxrpc_seq_t, hard_ack)
1609 __field(rxrpc_seq_t, top)
1610 __field(rxrpc_seq_t, lowest_nak)
1611 __field(rxrpc_serial_t, ack_serial)
1612 __field_struct(struct rxrpc_ack_summary, sum)
1613 ),
1614
1615 TP_fast_assign(
1616 __entry->call = call->debug_id;
1617 __entry->change = change;
1618 __entry->hard_ack = call->acks_hard_ack;
1619 __entry->top = call->tx_top;
1620 __entry->lowest_nak = call->acks_lowest_nak;
1621 __entry->ack_serial = ack_serial;
1622 memcpy(&__entry->sum, summary, sizeof(__entry->sum));
1623 ),
1624
1625 TP_printk("c=%08x r=%08x %s q=%08x %s cw=%u ss=%u nA=%u,%u+%u,%u b=%u u=%u d=%u l=%x%s%s%s",
1626 __entry->call,
1627 __entry->ack_serial,
1628 __print_symbolic(__entry->sum.ack_reason, rxrpc_ack_names),
1629 __entry->hard_ack,
1630 __print_symbolic(__entry->sum.mode, rxrpc_congest_modes),
1631 __entry->sum.cwnd,
1632 __entry->sum.ssthresh,
1633 __entry->sum.nr_acks, __entry->sum.nr_retained_nacks,
1634 __entry->sum.nr_new_acks,
1635 __entry->sum.nr_new_nacks,
1636 __entry->top - __entry->hard_ack,
1637 __entry->sum.cumulative_acks,
1638 __entry->sum.dup_acks,
1639 __entry->lowest_nak, __entry->sum.new_low_nack ? "!" : "",
1640 __print_symbolic(__entry->change, rxrpc_congest_changes),
1641 __entry->sum.retrans_timeo ? " rTxTo" : "")
1642 );
1643
1644TRACE_EVENT(rxrpc_reset_cwnd,
1645 TP_PROTO(struct rxrpc_call *call, ktime_t now),
1646
1647 TP_ARGS(call, now),
1648
1649 TP_STRUCT__entry(
1650 __field(unsigned int, call)
1651 __field(enum rxrpc_congest_mode, mode)
1652 __field(unsigned short, cwnd)
1653 __field(unsigned short, extra)
1654 __field(rxrpc_seq_t, hard_ack)
1655 __field(rxrpc_seq_t, prepared)
1656 __field(ktime_t, since_last_tx)
1657 __field(bool, has_data)
1658 ),
1659
1660 TP_fast_assign(
1661 __entry->call = call->debug_id;
1662 __entry->mode = call->cong_mode;
1663 __entry->cwnd = call->cong_cwnd;
1664 __entry->extra = call->cong_extra;
1665 __entry->hard_ack = call->acks_hard_ack;
1666 __entry->prepared = call->tx_prepared - call->tx_bottom;
1667 __entry->since_last_tx = ktime_sub(now, call->tx_last_sent);
1668 __entry->has_data = !list_empty(&call->tx_sendmsg);
1669 ),
1670
1671 TP_printk("c=%08x q=%08x %s cw=%u+%u pr=%u tm=%llu d=%u",
1672 __entry->call,
1673 __entry->hard_ack,
1674 __print_symbolic(__entry->mode, rxrpc_congest_modes),
1675 __entry->cwnd,
1676 __entry->extra,
1677 __entry->prepared,
1678 ktime_to_ns(__entry->since_last_tx),
1679 __entry->has_data)
1680 );
1681
1682TRACE_EVENT(rxrpc_disconnect_call,
1683 TP_PROTO(struct rxrpc_call *call),
1684
1685 TP_ARGS(call),
1686
1687 TP_STRUCT__entry(
1688 __field(unsigned int, call)
1689 __field(u32, abort_code)
1690 ),
1691
1692 TP_fast_assign(
1693 __entry->call = call->debug_id;
1694 __entry->abort_code = call->abort_code;
1695 ),
1696
1697 TP_printk("c=%08x ab=%08x",
1698 __entry->call,
1699 __entry->abort_code)
1700 );
1701
1702TRACE_EVENT(rxrpc_improper_term,
1703 TP_PROTO(struct rxrpc_call *call),
1704
1705 TP_ARGS(call),
1706
1707 TP_STRUCT__entry(
1708 __field(unsigned int, call)
1709 __field(u32, abort_code)
1710 ),
1711
1712 TP_fast_assign(
1713 __entry->call = call->debug_id;
1714 __entry->abort_code = call->abort_code;
1715 ),
1716
1717 TP_printk("c=%08x ab=%08x",
1718 __entry->call,
1719 __entry->abort_code)
1720 );
1721
1722TRACE_EVENT(rxrpc_connect_call,
1723 TP_PROTO(struct rxrpc_call *call),
1724
1725 TP_ARGS(call),
1726
1727 TP_STRUCT__entry(
1728 __field(unsigned int, call)
1729 __field(unsigned long, user_call_ID)
1730 __field(u32, cid)
1731 __field(u32, call_id)
1732 __field_struct(struct sockaddr_rxrpc, srx)
1733 ),
1734
1735 TP_fast_assign(
1736 __entry->call = call->debug_id;
1737 __entry->user_call_ID = call->user_call_ID;
1738 __entry->cid = call->cid;
1739 __entry->call_id = call->call_id;
1740 __entry->srx = call->dest_srx;
1741 ),
1742
1743 TP_printk("c=%08x u=%p %08x:%08x dst=%pISp",
1744 __entry->call,
1745 (void *)__entry->user_call_ID,
1746 __entry->cid,
1747 __entry->call_id,
1748 &__entry->srx.transport)
1749 );
1750
1751TRACE_EVENT(rxrpc_resend,
1752 TP_PROTO(struct rxrpc_call *call, struct sk_buff *ack),
1753
1754 TP_ARGS(call, ack),
1755
1756 TP_STRUCT__entry(
1757 __field(unsigned int, call)
1758 __field(rxrpc_seq_t, seq)
1759 __field(rxrpc_seq_t, transmitted)
1760 __field(rxrpc_serial_t, ack_serial)
1761 ),
1762
1763 TP_fast_assign(
1764 struct rxrpc_skb_priv *sp = ack ? rxrpc_skb(ack) : NULL;
1765 __entry->call = call->debug_id;
1766 __entry->seq = call->acks_hard_ack;
1767 __entry->transmitted = call->tx_transmitted;
1768 __entry->ack_serial = sp ? sp->hdr.serial : 0;
1769 ),
1770
1771 TP_printk("c=%08x r=%x q=%x tq=%x",
1772 __entry->call,
1773 __entry->ack_serial,
1774 __entry->seq,
1775 __entry->transmitted)
1776 );
1777
1778TRACE_EVENT(rxrpc_rx_icmp,
1779 TP_PROTO(struct rxrpc_peer *peer, struct sock_extended_err *ee,
1780 struct sockaddr_rxrpc *srx),
1781
1782 TP_ARGS(peer, ee, srx),
1783
1784 TP_STRUCT__entry(
1785 __field(unsigned int, peer)
1786 __field_struct(struct sock_extended_err, ee)
1787 __field_struct(struct sockaddr_rxrpc, srx)
1788 ),
1789
1790 TP_fast_assign(
1791 __entry->peer = peer->debug_id;
1792 memcpy(&__entry->ee, ee, sizeof(__entry->ee));
1793 memcpy(&__entry->srx, srx, sizeof(__entry->srx));
1794 ),
1795
1796 TP_printk("P=%08x o=%u t=%u c=%u i=%u d=%u e=%d %pISp",
1797 __entry->peer,
1798 __entry->ee.ee_origin,
1799 __entry->ee.ee_type,
1800 __entry->ee.ee_code,
1801 __entry->ee.ee_info,
1802 __entry->ee.ee_data,
1803 __entry->ee.ee_errno,
1804 &__entry->srx.transport)
1805 );
1806
1807TRACE_EVENT(rxrpc_tx_fail,
1808 TP_PROTO(unsigned int debug_id, rxrpc_serial_t serial, int ret,
1809 enum rxrpc_tx_point where),
1810
1811 TP_ARGS(debug_id, serial, ret, where),
1812
1813 TP_STRUCT__entry(
1814 __field(unsigned int, debug_id)
1815 __field(rxrpc_serial_t, serial)
1816 __field(int, ret)
1817 __field(enum rxrpc_tx_point, where)
1818 ),
1819
1820 TP_fast_assign(
1821 __entry->debug_id = debug_id;
1822 __entry->serial = serial;
1823 __entry->ret = ret;
1824 __entry->where = where;
1825 ),
1826
1827 TP_printk("c=%08x r=%x ret=%d %s",
1828 __entry->debug_id,
1829 __entry->serial,
1830 __entry->ret,
1831 __print_symbolic(__entry->where, rxrpc_tx_points))
1832 );
1833
1834TRACE_EVENT(rxrpc_call_reset,
1835 TP_PROTO(struct rxrpc_call *call),
1836
1837 TP_ARGS(call),
1838
1839 TP_STRUCT__entry(
1840 __field(unsigned int, debug_id)
1841 __field(u32, cid)
1842 __field(u32, call_id)
1843 __field(rxrpc_serial_t, call_serial)
1844 __field(rxrpc_serial_t, conn_serial)
1845 __field(rxrpc_seq_t, tx_seq)
1846 __field(rxrpc_seq_t, rx_seq)
1847 ),
1848
1849 TP_fast_assign(
1850 __entry->debug_id = call->debug_id;
1851 __entry->cid = call->cid;
1852 __entry->call_id = call->call_id;
1853 __entry->call_serial = call->rx_serial;
1854 __entry->conn_serial = call->conn->hi_serial;
1855 __entry->tx_seq = call->acks_hard_ack;
1856 __entry->rx_seq = call->rx_highest_seq;
1857 ),
1858
1859 TP_printk("c=%08x %08x:%08x r=%08x/%08x tx=%08x rx=%08x",
1860 __entry->debug_id,
1861 __entry->cid, __entry->call_id,
1862 __entry->call_serial, __entry->conn_serial,
1863 __entry->tx_seq, __entry->rx_seq)
1864 );
1865
1866TRACE_EVENT(rxrpc_notify_socket,
1867 TP_PROTO(unsigned int debug_id, rxrpc_serial_t serial),
1868
1869 TP_ARGS(debug_id, serial),
1870
1871 TP_STRUCT__entry(
1872 __field(unsigned int, debug_id)
1873 __field(rxrpc_serial_t, serial)
1874 ),
1875
1876 TP_fast_assign(
1877 __entry->debug_id = debug_id;
1878 __entry->serial = serial;
1879 ),
1880
1881 TP_printk("c=%08x r=%08x",
1882 __entry->debug_id,
1883 __entry->serial)
1884 );
1885
1886TRACE_EVENT(rxrpc_rx_discard_ack,
1887 TP_PROTO(unsigned int debug_id, rxrpc_serial_t serial,
1888 rxrpc_seq_t first_soft_ack, rxrpc_seq_t call_ackr_first,
1889 rxrpc_seq_t prev_pkt, rxrpc_seq_t call_ackr_prev),
1890
1891 TP_ARGS(debug_id, serial, first_soft_ack, call_ackr_first,
1892 prev_pkt, call_ackr_prev),
1893
1894 TP_STRUCT__entry(
1895 __field(unsigned int, debug_id)
1896 __field(rxrpc_serial_t, serial)
1897 __field(rxrpc_seq_t, first_soft_ack)
1898 __field(rxrpc_seq_t, call_ackr_first)
1899 __field(rxrpc_seq_t, prev_pkt)
1900 __field(rxrpc_seq_t, call_ackr_prev)
1901 ),
1902
1903 TP_fast_assign(
1904 __entry->debug_id = debug_id;
1905 __entry->serial = serial;
1906 __entry->first_soft_ack = first_soft_ack;
1907 __entry->call_ackr_first = call_ackr_first;
1908 __entry->prev_pkt = prev_pkt;
1909 __entry->call_ackr_prev = call_ackr_prev;
1910 ),
1911
1912 TP_printk("c=%08x r=%08x %08x<%08x %08x<%08x",
1913 __entry->debug_id,
1914 __entry->serial,
1915 __entry->first_soft_ack,
1916 __entry->call_ackr_first,
1917 __entry->prev_pkt,
1918 __entry->call_ackr_prev)
1919 );
1920
1921TRACE_EVENT(rxrpc_req_ack,
1922 TP_PROTO(unsigned int call_debug_id, rxrpc_seq_t seq,
1923 enum rxrpc_req_ack_trace why),
1924
1925 TP_ARGS(call_debug_id, seq, why),
1926
1927 TP_STRUCT__entry(
1928 __field(unsigned int, call_debug_id)
1929 __field(rxrpc_seq_t, seq)
1930 __field(enum rxrpc_req_ack_trace, why)
1931 ),
1932
1933 TP_fast_assign(
1934 __entry->call_debug_id = call_debug_id;
1935 __entry->seq = seq;
1936 __entry->why = why;
1937 ),
1938
1939 TP_printk("c=%08x q=%08x REQ-%s",
1940 __entry->call_debug_id,
1941 __entry->seq,
1942 __print_symbolic(__entry->why, rxrpc_req_ack_traces))
1943 );
1944
1945TRACE_EVENT(rxrpc_txbuf,
1946 TP_PROTO(unsigned int debug_id,
1947 unsigned int call_debug_id, rxrpc_seq_t seq,
1948 int ref, enum rxrpc_txbuf_trace what),
1949
1950 TP_ARGS(debug_id, call_debug_id, seq, ref, what),
1951
1952 TP_STRUCT__entry(
1953 __field(unsigned int, debug_id)
1954 __field(unsigned int, call_debug_id)
1955 __field(rxrpc_seq_t, seq)
1956 __field(int, ref)
1957 __field(enum rxrpc_txbuf_trace, what)
1958 ),
1959
1960 TP_fast_assign(
1961 __entry->debug_id = debug_id;
1962 __entry->call_debug_id = call_debug_id;
1963 __entry->seq = seq;
1964 __entry->ref = ref;
1965 __entry->what = what;
1966 ),
1967
1968 TP_printk("B=%08x c=%08x q=%08x %s r=%d",
1969 __entry->debug_id,
1970 __entry->call_debug_id,
1971 __entry->seq,
1972 __print_symbolic(__entry->what, rxrpc_txbuf_traces),
1973 __entry->ref)
1974 );
1975
1976TRACE_EVENT(rxrpc_poke_call,
1977 TP_PROTO(struct rxrpc_call *call, bool busy,
1978 enum rxrpc_call_poke_trace what),
1979
1980 TP_ARGS(call, busy, what),
1981
1982 TP_STRUCT__entry(
1983 __field(unsigned int, call_debug_id)
1984 __field(bool, busy)
1985 __field(enum rxrpc_call_poke_trace, what)
1986 ),
1987
1988 TP_fast_assign(
1989 __entry->call_debug_id = call->debug_id;
1990 __entry->busy = busy;
1991 __entry->what = what;
1992 ),
1993
1994 TP_printk("c=%08x %s%s",
1995 __entry->call_debug_id,
1996 __print_symbolic(__entry->what, rxrpc_call_poke_traces),
1997 __entry->busy ? "!" : "")
1998 );
1999
2000TRACE_EVENT(rxrpc_call_poked,
2001 TP_PROTO(struct rxrpc_call *call),
2002
2003 TP_ARGS(call),
2004
2005 TP_STRUCT__entry(
2006 __field(unsigned int, call_debug_id)
2007 ),
2008
2009 TP_fast_assign(
2010 __entry->call_debug_id = call->debug_id;
2011 ),
2012
2013 TP_printk("c=%08x",
2014 __entry->call_debug_id)
2015 );
2016
2017TRACE_EVENT(rxrpc_sack,
2018 TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t seq,
2019 unsigned int sack, enum rxrpc_sack_trace what),
2020
2021 TP_ARGS(call, seq, sack, what),
2022
2023 TP_STRUCT__entry(
2024 __field(unsigned int, call_debug_id)
2025 __field(rxrpc_seq_t, seq)
2026 __field(unsigned int, sack)
2027 __field(enum rxrpc_sack_trace, what)
2028 ),
2029
2030 TP_fast_assign(
2031 __entry->call_debug_id = call->debug_id;
2032 __entry->seq = seq;
2033 __entry->sack = sack;
2034 __entry->what = what;
2035 ),
2036
2037 TP_printk("c=%08x q=%08x %s k=%x",
2038 __entry->call_debug_id,
2039 __entry->seq,
2040 __print_symbolic(__entry->what, rxrpc_sack_traces),
2041 __entry->sack)
2042 );
2043
2044#undef EM
2045#undef E_
2046
2047#endif /* RXRPC_TRACE_ONLY_DEFINE_ENUMS */
2048#endif /* _TRACE_RXRPC_H */
2049
2050/* This part must be outside protection */
2051#include <trace/define_trace.h>