Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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 EM(afs_abort_unsupported_sec_class, "afs-unsup-sec-class") \
29 /* rxperf errors */ \
30 EM(rxperf_abort_general_error, "rxperf-error") \
31 EM(rxperf_abort_oom, "rxperf-oom") \
32 EM(rxperf_abort_op_not_supported, "rxperf-op-notsupp") \
33 EM(rxperf_abort_unmarshal_error, "rxperf-unmarshal") \
34 /* RxKAD security errors */ \
35 EM(rxkad_abort_1_short_check, "rxkad1-short-check") \
36 EM(rxkad_abort_1_short_data, "rxkad1-short-data") \
37 EM(rxkad_abort_1_short_encdata, "rxkad1-short-encdata") \
38 EM(rxkad_abort_1_short_header, "rxkad1-short-hdr") \
39 EM(rxkad_abort_2_short_check, "rxkad2-short-check") \
40 EM(rxkad_abort_2_short_data, "rxkad2-short-data") \
41 EM(rxkad_abort_2_short_header, "rxkad2-short-hdr") \
42 EM(rxkad_abort_2_short_len, "rxkad2-short-len") \
43 EM(rxkad_abort_bad_checksum, "rxkad2-bad-cksum") \
44 EM(rxkad_abort_chall_key_expired, "rxkad-chall-key-exp") \
45 EM(rxkad_abort_chall_level, "rxkad-chall-level") \
46 EM(rxkad_abort_chall_no_key, "rxkad-chall-nokey") \
47 EM(rxkad_abort_chall_short, "rxkad-chall-short") \
48 EM(rxkad_abort_chall_version, "rxkad-chall-version") \
49 EM(rxkad_abort_resp_bad_callid, "rxkad-resp-bad-callid") \
50 EM(rxkad_abort_resp_bad_checksum, "rxkad-resp-bad-cksum") \
51 EM(rxkad_abort_resp_bad_param, "rxkad-resp-bad-param") \
52 EM(rxkad_abort_resp_call_ctr, "rxkad-resp-call-ctr") \
53 EM(rxkad_abort_resp_call_state, "rxkad-resp-call-state") \
54 EM(rxkad_abort_resp_key_expired, "rxkad-resp-key-exp") \
55 EM(rxkad_abort_resp_key_rejected, "rxkad-resp-key-rej") \
56 EM(rxkad_abort_resp_level, "rxkad-resp-level") \
57 EM(rxkad_abort_resp_nokey, "rxkad-resp-nokey") \
58 EM(rxkad_abort_resp_ooseq, "rxkad-resp-ooseq") \
59 EM(rxkad_abort_resp_short, "rxkad-resp-short") \
60 EM(rxkad_abort_resp_short_tkt, "rxkad-resp-short-tkt") \
61 EM(rxkad_abort_resp_tkt_aname, "rxkad-resp-tk-aname") \
62 EM(rxkad_abort_resp_tkt_expired, "rxkad-resp-tk-exp") \
63 EM(rxkad_abort_resp_tkt_future, "rxkad-resp-tk-future") \
64 EM(rxkad_abort_resp_tkt_inst, "rxkad-resp-tk-inst") \
65 EM(rxkad_abort_resp_tkt_len, "rxkad-resp-tk-len") \
66 EM(rxkad_abort_resp_tkt_realm, "rxkad-resp-tk-realm") \
67 EM(rxkad_abort_resp_tkt_short, "rxkad-resp-tk-short") \
68 EM(rxkad_abort_resp_tkt_sinst, "rxkad-resp-tk-sinst") \
69 EM(rxkad_abort_resp_tkt_sname, "rxkad-resp-tk-sname") \
70 EM(rxkad_abort_resp_unknown_tkt, "rxkad-resp-unknown-tkt") \
71 EM(rxkad_abort_resp_version, "rxkad-resp-version") \
72 /* RxGK security errors */ \
73 EM(rxgk_abort_1_verify_mic_eproto, "rxgk1-vfy-mic-eproto") \
74 EM(rxgk_abort_2_decrypt_eproto, "rxgk2-dec-eproto") \
75 EM(rxgk_abort_2_short_data, "rxgk2-short-data") \
76 EM(rxgk_abort_2_short_encdata, "rxgk2-short-encdata") \
77 EM(rxgk_abort_2_short_header, "rxgk2-short-hdr") \
78 EM(rxgk_abort_bad_key_number, "rxgk-bad-key-num") \
79 EM(rxgk_abort_chall_key_expired, "rxgk-chall-key-exp") \
80 EM(rxgk_abort_chall_no_key, "rxgk-chall-nokey") \
81 EM(rxgk_abort_chall_short, "rxgk-chall-short") \
82 EM(rxgk_abort_resp_auth_dec, "rxgk-resp-auth-dec") \
83 EM(rxgk_abort_resp_bad_callid, "rxgk-resp-bad-callid") \
84 EM(rxgk_abort_resp_bad_nonce, "rxgk-resp-bad-nonce") \
85 EM(rxgk_abort_resp_bad_param, "rxgk-resp-bad-param") \
86 EM(rxgk_abort_resp_call_ctr, "rxgk-resp-call-ctr") \
87 EM(rxgk_abort_resp_call_state, "rxgk-resp-call-state") \
88 EM(rxgk_abort_resp_internal_error, "rxgk-resp-int-error") \
89 EM(rxgk_abort_resp_nopkg, "rxgk-resp-nopkg") \
90 EM(rxgk_abort_resp_short_applen, "rxgk-resp-short-applen") \
91 EM(rxgk_abort_resp_short_auth, "rxgk-resp-short-auth") \
92 EM(rxgk_abort_resp_short_call_list, "rxgk-resp-short-callls") \
93 EM(rxgk_abort_resp_short_packet, "rxgk-resp-short-packet") \
94 EM(rxgk_abort_resp_short_yfs_klen, "rxgk-resp-short-yfs-klen") \
95 EM(rxgk_abort_resp_short_yfs_key, "rxgk-resp-short-yfs-key") \
96 EM(rxgk_abort_resp_short_yfs_tkt, "rxgk-resp-short-yfs-tkt") \
97 EM(rxgk_abort_resp_tok_dec, "rxgk-resp-tok-dec") \
98 EM(rxgk_abort_resp_tok_internal_error, "rxgk-resp-tok-int-err") \
99 EM(rxgk_abort_resp_tok_keyerr, "rxgk-resp-tok-keyerr") \
100 EM(rxgk_abort_resp_tok_nokey, "rxgk-resp-tok-nokey") \
101 EM(rxgk_abort_resp_tok_nopkg, "rxgk-resp-tok-nopkg") \
102 EM(rxgk_abort_resp_tok_short, "rxgk-resp-tok-short") \
103 EM(rxgk_abort_resp_xdr_align, "rxgk-resp-xdr-align") \
104 /* rxrpc errors */ \
105 EM(rxrpc_abort_call_improper_term, "call-improper-term") \
106 EM(rxrpc_abort_call_reset, "call-reset") \
107 EM(rxrpc_abort_call_sendmsg, "call-sendmsg") \
108 EM(rxrpc_abort_call_sock_release, "call-sock-rel") \
109 EM(rxrpc_abort_call_sock_release_tba, "call-sock-rel-tba") \
110 EM(rxrpc_abort_call_timeout, "call-timeout") \
111 EM(rxrpc_abort_no_service_key, "no-serv-key") \
112 EM(rxrpc_abort_nomem, "nomem") \
113 EM(rxrpc_abort_response_sendmsg, "resp-sendmsg") \
114 EM(rxrpc_abort_service_not_offered, "serv-not-offered") \
115 EM(rxrpc_abort_shut_down, "shut-down") \
116 EM(rxrpc_abort_unsupported_security, "unsup-sec") \
117 EM(rxrpc_badmsg_bad_abort, "bad-abort") \
118 EM(rxrpc_badmsg_bad_jumbo, "bad-jumbo") \
119 EM(rxrpc_badmsg_short_ack, "short-ack") \
120 EM(rxrpc_badmsg_short_ack_trailer, "short-ack-trailer") \
121 EM(rxrpc_badmsg_short_hdr, "short-hdr") \
122 EM(rxrpc_badmsg_unsupported_packet, "unsup-pkt") \
123 EM(rxrpc_badmsg_zero_call, "zero-call") \
124 EM(rxrpc_badmsg_zero_seq, "zero-seq") \
125 EM(rxrpc_badmsg_zero_service, "zero-service") \
126 EM(rxrpc_eproto_ackr_outside_window, "ackr-out-win") \
127 EM(rxrpc_eproto_ackr_sack_overflow, "ackr-sack-over") \
128 EM(rxrpc_eproto_ackr_short_sack, "ackr-short-sack") \
129 EM(rxrpc_eproto_ackr_zero, "ackr-zero") \
130 EM(rxrpc_eproto_bad_upgrade, "bad-upgrade") \
131 EM(rxrpc_eproto_data_after_last, "data-after-last") \
132 EM(rxrpc_eproto_different_last, "diff-last") \
133 EM(rxrpc_eproto_early_reply, "early-reply") \
134 EM(rxrpc_eproto_improper_term, "improper-term") \
135 EM(rxrpc_eproto_no_client_call, "no-cl-call") \
136 EM(rxrpc_eproto_no_client_conn, "no-cl-conn") \
137 EM(rxrpc_eproto_no_service_call, "no-sv-call") \
138 EM(rxrpc_eproto_reupgrade, "re-upgrade") \
139 EM(rxrpc_eproto_rxnull_challenge, "rxnull-chall") \
140 EM(rxrpc_eproto_rxnull_response, "rxnull-resp") \
141 EM(rxrpc_eproto_tx_rot_last, "tx-rot-last") \
142 EM(rxrpc_eproto_unexpected_ack, "unex-ack") \
143 EM(rxrpc_eproto_unexpected_ackall, "unex-ackall") \
144 EM(rxrpc_eproto_unexpected_implicit_end, "unex-impl-end") \
145 EM(rxrpc_eproto_unexpected_reply, "unex-reply") \
146 EM(rxrpc_eproto_wrong_security, "wrong-sec") \
147 EM(rxrpc_recvmsg_excess_data, "recvmsg-excess") \
148 EM(rxrpc_recvmsg_short_data, "recvmsg-short") \
149 E_(rxrpc_sendmsg_late_send, "sendmsg-late")
150
151#define rxrpc_call_poke_traces \
152 EM(rxrpc_call_poke_abort, "Abort") \
153 EM(rxrpc_call_poke_complete, "Compl") \
154 EM(rxrpc_call_poke_conn_abort, "Conn-abort") \
155 EM(rxrpc_call_poke_error, "Error") \
156 EM(rxrpc_call_poke_idle, "Idle") \
157 EM(rxrpc_call_poke_rx_packet, "Rx-packet") \
158 EM(rxrpc_call_poke_set_timeout, "Set-timo") \
159 EM(rxrpc_call_poke_start, "Start") \
160 EM(rxrpc_call_poke_timer, "Timer") \
161 E_(rxrpc_call_poke_timer_now, "Timer-now")
162
163#define rxrpc_skb_traces \
164 EM(rxrpc_skb_eaten_by_unshare, "ETN unshare ") \
165 EM(rxrpc_skb_eaten_by_unshare_nomem, "ETN unshar-nm") \
166 EM(rxrpc_skb_get_call_rx, "GET call-rx ") \
167 EM(rxrpc_skb_get_conn_secured, "GET conn-secd") \
168 EM(rxrpc_skb_get_conn_work, "GET conn-work") \
169 EM(rxrpc_skb_get_local_work, "GET locl-work") \
170 EM(rxrpc_skb_get_post_oob, "GET post-oob ") \
171 EM(rxrpc_skb_get_reject_work, "GET rej-work ") \
172 EM(rxrpc_skb_get_to_recvmsg, "GET to-recv ") \
173 EM(rxrpc_skb_get_to_recvmsg_oos, "GET to-recv-o") \
174 EM(rxrpc_skb_new_encap_rcv, "NEW encap-rcv") \
175 EM(rxrpc_skb_new_error_report, "NEW error-rpt") \
176 EM(rxrpc_skb_new_jumbo_subpacket, "NEW jumbo-sub") \
177 EM(rxrpc_skb_new_response_rxgk, "NEW resp-rxgk") \
178 EM(rxrpc_skb_new_response_rxkad, "NEW resp-rxkd") \
179 EM(rxrpc_skb_new_unshared, "NEW unshared ") \
180 EM(rxrpc_skb_put_call_rx, "PUT call-rx ") \
181 EM(rxrpc_skb_put_challenge, "PUT challenge") \
182 EM(rxrpc_skb_put_conn_secured, "PUT conn-secd") \
183 EM(rxrpc_skb_put_conn_work, "PUT conn-work") \
184 EM(rxrpc_skb_put_error_report, "PUT error-rep") \
185 EM(rxrpc_skb_put_input, "PUT input ") \
186 EM(rxrpc_skb_put_jumbo_subpacket, "PUT jumbo-sub") \
187 EM(rxrpc_skb_put_oob, "PUT oob ") \
188 EM(rxrpc_skb_put_purge, "PUT purge ") \
189 EM(rxrpc_skb_put_purge_oob, "PUT purge-oob") \
190 EM(rxrpc_skb_put_response, "PUT response ") \
191 EM(rxrpc_skb_put_rotate, "PUT rotate ") \
192 EM(rxrpc_skb_put_unknown, "PUT unknown ") \
193 EM(rxrpc_skb_see_conn_work, "SEE conn-work") \
194 EM(rxrpc_skb_see_oob_challenge, "SEE oob-chall") \
195 EM(rxrpc_skb_see_recvmsg, "SEE recvmsg ") \
196 EM(rxrpc_skb_see_recvmsg_oob, "SEE recvm-oob") \
197 EM(rxrpc_skb_see_reject, "SEE reject ") \
198 EM(rxrpc_skb_see_rotate, "SEE rotate ") \
199 E_(rxrpc_skb_see_version, "SEE version ")
200
201#define rxrpc_local_traces \
202 EM(rxrpc_local_free, "FREE ") \
203 EM(rxrpc_local_get_call, "GET call ") \
204 EM(rxrpc_local_get_client_conn, "GET conn-cln") \
205 EM(rxrpc_local_get_for_use, "GET for-use ") \
206 EM(rxrpc_local_get_peer, "GET peer ") \
207 EM(rxrpc_local_get_prealloc_conn, "GET conn-pre") \
208 EM(rxrpc_local_new, "NEW ") \
209 EM(rxrpc_local_put_bind, "PUT bind ") \
210 EM(rxrpc_local_put_call, "PUT call ") \
211 EM(rxrpc_local_put_for_use, "PUT for-use ") \
212 EM(rxrpc_local_put_kill_conn, "PUT conn-kil") \
213 EM(rxrpc_local_put_peer, "PUT peer ") \
214 EM(rxrpc_local_put_prealloc_peer, "PUT peer-pre") \
215 EM(rxrpc_local_put_release_sock, "PUT rel-sock") \
216 EM(rxrpc_local_stop, "STOP ") \
217 EM(rxrpc_local_stopped, "STOPPED ") \
218 EM(rxrpc_local_unuse_bind, "UNU bind ") \
219 EM(rxrpc_local_unuse_conn_work, "UNU conn-wrk") \
220 EM(rxrpc_local_unuse_peer_keepalive, "UNU peer-kpa") \
221 EM(rxrpc_local_unuse_release_sock, "UNU rel-sock") \
222 EM(rxrpc_local_use_conn_work, "USE conn-wrk") \
223 EM(rxrpc_local_use_lookup, "USE lookup ") \
224 E_(rxrpc_local_use_peer_keepalive, "USE peer-kpa")
225
226#define rxrpc_peer_traces \
227 EM(rxrpc_peer_free, "FREE ") \
228 EM(rxrpc_peer_get_accept, "GET accept ") \
229 EM(rxrpc_peer_get_application, "GET app ") \
230 EM(rxrpc_peer_get_bundle, "GET bundle ") \
231 EM(rxrpc_peer_get_call, "GET call ") \
232 EM(rxrpc_peer_get_client_conn, "GET cln-conn") \
233 EM(rxrpc_peer_get_input, "GET input ") \
234 EM(rxrpc_peer_get_input_error, "GET inpt-err") \
235 EM(rxrpc_peer_get_keepalive, "GET keepaliv") \
236 EM(rxrpc_peer_get_lookup_client, "GET look-cln") \
237 EM(rxrpc_peer_get_service_conn, "GET srv-conn") \
238 EM(rxrpc_peer_new_client, "NEW client ") \
239 EM(rxrpc_peer_new_prealloc, "NEW prealloc") \
240 EM(rxrpc_peer_put_application, "PUT app ") \
241 EM(rxrpc_peer_put_bundle, "PUT bundle ") \
242 EM(rxrpc_peer_put_call, "PUT call ") \
243 EM(rxrpc_peer_put_conn, "PUT conn ") \
244 EM(rxrpc_peer_put_input, "PUT input ") \
245 EM(rxrpc_peer_put_input_error, "PUT inpt-err") \
246 E_(rxrpc_peer_put_keepalive, "PUT keepaliv")
247
248#define rxrpc_bundle_traces \
249 EM(rxrpc_bundle_free, "FREE ") \
250 EM(rxrpc_bundle_get_client_call, "GET clt-call") \
251 EM(rxrpc_bundle_get_client_conn, "GET clt-conn") \
252 EM(rxrpc_bundle_get_service_conn, "GET svc-conn") \
253 EM(rxrpc_bundle_put_call, "PUT call ") \
254 EM(rxrpc_bundle_put_conn, "PUT conn ") \
255 EM(rxrpc_bundle_put_discard, "PUT discard ") \
256 E_(rxrpc_bundle_new, "NEW ")
257
258#define rxrpc_conn_traces \
259 EM(rxrpc_conn_free, "FREE ") \
260 EM(rxrpc_conn_get_activate_call, "GET act-call") \
261 EM(rxrpc_conn_get_call_input, "GET inp-call") \
262 EM(rxrpc_conn_get_challenge_input, "GET inp-chal") \
263 EM(rxrpc_conn_get_conn_input, "GET inp-conn") \
264 EM(rxrpc_conn_get_idle, "GET idle ") \
265 EM(rxrpc_conn_get_poke_abort, "GET pk-abort") \
266 EM(rxrpc_conn_get_poke_response, "GET response") \
267 EM(rxrpc_conn_get_poke_secured, "GET secured ") \
268 EM(rxrpc_conn_get_poke_timer, "GET poke ") \
269 EM(rxrpc_conn_get_service_conn, "GET svc-conn") \
270 EM(rxrpc_conn_new_client, "NEW client ") \
271 EM(rxrpc_conn_new_service, "NEW service ") \
272 EM(rxrpc_conn_put_call, "PUT call ") \
273 EM(rxrpc_conn_put_call_input, "PUT inp-call") \
274 EM(rxrpc_conn_put_challenge_input, "PUT inp-chal") \
275 EM(rxrpc_conn_put_conn_input, "PUT inp-conn") \
276 EM(rxrpc_conn_put_discard_idle, "PUT disc-idl") \
277 EM(rxrpc_conn_put_local_dead, "PUT loc-dead") \
278 EM(rxrpc_conn_put_noreuse, "PUT noreuse ") \
279 EM(rxrpc_conn_put_oob, "PUT oob ") \
280 EM(rxrpc_conn_put_poke, "PUT poke ") \
281 EM(rxrpc_conn_put_service_reaped, "PUT svc-reap") \
282 EM(rxrpc_conn_put_unbundle, "PUT unbundle") \
283 EM(rxrpc_conn_put_unidle, "PUT unidle ") \
284 EM(rxrpc_conn_put_work, "PUT work ") \
285 EM(rxrpc_conn_queue_challenge, "QUE chall ") \
286 EM(rxrpc_conn_queue_retry_work, "QUE retry-wk") \
287 EM(rxrpc_conn_queue_rx_work, "QUE rx-work ") \
288 EM(rxrpc_conn_see_new_service_conn, "SEE new-svc ") \
289 EM(rxrpc_conn_see_reap_service, "SEE reap-svc") \
290 E_(rxrpc_conn_see_work, "SEE work ")
291
292#define rxrpc_client_traces \
293 EM(rxrpc_client_activate_chans, "Activa") \
294 EM(rxrpc_client_alloc, "Alloc ") \
295 EM(rxrpc_client_chan_activate, "ChActv") \
296 EM(rxrpc_client_chan_disconnect, "ChDisc") \
297 EM(rxrpc_client_chan_pass, "ChPass") \
298 EM(rxrpc_client_cleanup, "Clean ") \
299 EM(rxrpc_client_discard, "Discar") \
300 EM(rxrpc_client_exposed, "Expose") \
301 EM(rxrpc_client_replace, "Replac") \
302 EM(rxrpc_client_queue_new_call, "Q-Call") \
303 EM(rxrpc_client_to_active, "->Actv") \
304 E_(rxrpc_client_to_idle, "->Idle")
305
306#define rxrpc_call_traces \
307 EM(rxrpc_call_get_io_thread, "GET iothread") \
308 EM(rxrpc_call_get_input, "GET input ") \
309 EM(rxrpc_call_get_kernel_service, "GET krnl-srv") \
310 EM(rxrpc_call_get_notify_socket, "GET notify ") \
311 EM(rxrpc_call_get_poke, "GET poke ") \
312 EM(rxrpc_call_get_recvmsg, "GET recvmsg ") \
313 EM(rxrpc_call_get_release_sock, "GET rel-sock") \
314 EM(rxrpc_call_get_sendmsg, "GET sendmsg ") \
315 EM(rxrpc_call_get_userid, "GET user-id ") \
316 EM(rxrpc_call_new_client, "NEW client ") \
317 EM(rxrpc_call_new_prealloc_service, "NEW prealloc") \
318 EM(rxrpc_call_put_discard_prealloc, "PUT disc-pre") \
319 EM(rxrpc_call_put_discard_error, "PUT disc-err") \
320 EM(rxrpc_call_put_io_thread, "PUT iothread") \
321 EM(rxrpc_call_put_input, "PUT input ") \
322 EM(rxrpc_call_put_kernel, "PUT kernel ") \
323 EM(rxrpc_call_put_poke, "PUT poke ") \
324 EM(rxrpc_call_put_recvmsg, "PUT recvmsg ") \
325 EM(rxrpc_call_put_release_recvmsg_q, "PUT rls-rcmq") \
326 EM(rxrpc_call_put_release_sock, "PUT rls-sock") \
327 EM(rxrpc_call_put_release_sock_tba, "PUT rls-sk-a") \
328 EM(rxrpc_call_put_sendmsg, "PUT sendmsg ") \
329 EM(rxrpc_call_put_userid_exists, "PUT u-exists") \
330 EM(rxrpc_call_put_userid, "PUT user-id ") \
331 EM(rxrpc_call_see_accept, "SEE accept ") \
332 EM(rxrpc_call_see_activate_client, "SEE act-clnt") \
333 EM(rxrpc_call_see_already_released, "SEE alrdy-rl") \
334 EM(rxrpc_call_see_connect_failed, "SEE con-fail") \
335 EM(rxrpc_call_see_connected, "SEE connect ") \
336 EM(rxrpc_call_see_conn_abort, "SEE conn-abt") \
337 EM(rxrpc_call_see_discard, "SEE discard ") \
338 EM(rxrpc_call_see_disconnected, "SEE disconn ") \
339 EM(rxrpc_call_see_distribute_error, "SEE dist-err") \
340 EM(rxrpc_call_see_input, "SEE input ") \
341 EM(rxrpc_call_see_notify_released, "SEE nfy-rlsd") \
342 EM(rxrpc_call_see_recvmsg, "SEE recvmsg ") \
343 EM(rxrpc_call_see_release, "SEE release ") \
344 EM(rxrpc_call_see_userid_exists, "SEE u-exists") \
345 EM(rxrpc_call_see_waiting_call, "SEE q-conn ") \
346 E_(rxrpc_call_see_zap, "SEE zap ")
347
348#define rxrpc_txqueue_traces \
349 EM(rxrpc_txqueue_await_reply, "AWR") \
350 EM(rxrpc_txqueue_end, "END") \
351 EM(rxrpc_txqueue_queue, "QUE") \
352 EM(rxrpc_txqueue_queue_last, "QLS") \
353 EM(rxrpc_txqueue_rotate, "ROT") \
354 EM(rxrpc_txqueue_rotate_last, "RLS") \
355 E_(rxrpc_txqueue_wait, "WAI")
356
357#define rxrpc_txdata_traces \
358 EM(rxrpc_txdata_inject_loss, " *INJ-LOSS*") \
359 EM(rxrpc_txdata_new_data, " ") \
360 EM(rxrpc_txdata_retransmit, " *RETRANS*") \
361 EM(rxrpc_txdata_tlp_new_data, " *TLP-NEW*") \
362 E_(rxrpc_txdata_tlp_retransmit, " *TLP-RETRANS*")
363
364#define rxrpc_receive_traces \
365 EM(rxrpc_receive_end, "END") \
366 EM(rxrpc_receive_front, "FRN") \
367 EM(rxrpc_receive_incoming, "INC") \
368 EM(rxrpc_receive_queue, "QUE") \
369 EM(rxrpc_receive_queue_last, "QLS") \
370 EM(rxrpc_receive_queue_oos, "QUO") \
371 EM(rxrpc_receive_queue_oos_last, "QOL") \
372 EM(rxrpc_receive_oos, "OOS") \
373 EM(rxrpc_receive_oos_last, "OSL") \
374 EM(rxrpc_receive_rotate, "ROT") \
375 E_(rxrpc_receive_rotate_last, "RLS")
376
377#define rxrpc_recvmsg_traces \
378 EM(rxrpc_recvmsg_cont, "CONT") \
379 EM(rxrpc_recvmsg_data_return, "DATA") \
380 EM(rxrpc_recvmsg_dequeue, "DEQU") \
381 EM(rxrpc_recvmsg_enter, "ENTR") \
382 EM(rxrpc_recvmsg_full, "FULL") \
383 EM(rxrpc_recvmsg_hole, "HOLE") \
384 EM(rxrpc_recvmsg_next, "NEXT") \
385 EM(rxrpc_recvmsg_oobq, "OOBQ") \
386 EM(rxrpc_recvmsg_requeue, "REQU") \
387 EM(rxrpc_recvmsg_return, "RETN") \
388 EM(rxrpc_recvmsg_terminal, "TERM") \
389 EM(rxrpc_recvmsg_to_be_accepted, "TBAC") \
390 EM(rxrpc_recvmsg_unqueue, "UNQU") \
391 E_(rxrpc_recvmsg_wait, "WAIT")
392
393#define rxrpc_rtt_tx_traces \
394 EM(rxrpc_rtt_tx_cancel, "CNCE") \
395 EM(rxrpc_rtt_tx_data, "DATA") \
396 EM(rxrpc_rtt_tx_no_slot, "FULL") \
397 E_(rxrpc_rtt_tx_ping, "PING")
398
399#define rxrpc_rtt_rx_traces \
400 EM(rxrpc_rtt_rx_data_ack, "DACK") \
401 EM(rxrpc_rtt_rx_obsolete, "OBSL") \
402 EM(rxrpc_rtt_rx_lost, "LOST") \
403 E_(rxrpc_rtt_rx_ping_response, "PONG")
404
405#define rxrpc_timer_traces \
406 EM(rxrpc_timer_trace_delayed_ack, "DelayAck ") \
407 EM(rxrpc_timer_trace_expect_rx, "ExpectRx ") \
408 EM(rxrpc_timer_trace_hard, "HardLimit") \
409 EM(rxrpc_timer_trace_idle, "IdleLimit") \
410 EM(rxrpc_timer_trace_keepalive, "KeepAlive") \
411 EM(rxrpc_timer_trace_ping, "DelayPing") \
412 EM(rxrpc_timer_trace_rack_off, "RACK-OFF ") \
413 EM(rxrpc_timer_trace_rack_zwp, "RACK-ZWP ") \
414 EM(rxrpc_timer_trace_rack_reo, "RACK-Reo ") \
415 EM(rxrpc_timer_trace_rack_tlp_pto, "TLP-PTO ") \
416 E_(rxrpc_timer_trace_rack_rto, "RTO ")
417
418#define rxrpc_propose_ack_traces \
419 EM(rxrpc_propose_ack_client_tx_end, "ClTxEnd") \
420 EM(rxrpc_propose_ack_delayed_ack, "DlydAck") \
421 EM(rxrpc_propose_ack_input_data, "DataIn ") \
422 EM(rxrpc_propose_ack_input_data_hole, "DataInH") \
423 EM(rxrpc_propose_ack_ping_for_keepalive, "KeepAlv") \
424 EM(rxrpc_propose_ack_ping_for_lost_ack, "LostAck") \
425 EM(rxrpc_propose_ack_ping_for_lost_reply, "LostRpl") \
426 EM(rxrpc_propose_ack_ping_for_0_retrans, "0-Retrn") \
427 EM(rxrpc_propose_ack_ping_for_mtu_probe, "MTUProb") \
428 EM(rxrpc_propose_ack_ping_for_old_rtt, "OldRtt ") \
429 EM(rxrpc_propose_ack_ping_for_params, "Params ") \
430 EM(rxrpc_propose_ack_ping_for_rtt, "Rtt ") \
431 EM(rxrpc_propose_ack_processing_op, "ProcOp ") \
432 EM(rxrpc_propose_ack_respond_to_ack, "Rsp2Ack") \
433 EM(rxrpc_propose_ack_respond_to_ping, "Rsp2Png") \
434 EM(rxrpc_propose_ack_retransmit, "Retrans") \
435 EM(rxrpc_propose_ack_retry_tx, "RetryTx") \
436 EM(rxrpc_propose_ack_rotate_rx, "RxAck ") \
437 EM(rxrpc_propose_ack_rx_idle, "RxIdle ") \
438 E_(rxrpc_propose_ack_terminal_ack, "ClTerm ")
439
440#define rxrpc_ca_states \
441 EM(RXRPC_CA_CONGEST_AVOIDANCE, "CongAvoid") \
442 EM(RXRPC_CA_FAST_RETRANSMIT, "FastReTx ") \
443 EM(RXRPC_CA_PACKET_LOSS, "PktLoss ") \
444 E_(RXRPC_CA_SLOW_START, "SlowStart")
445
446#define rxrpc_congest_changes \
447 EM(rxrpc_cong_begin_retransmission, " Retrans") \
448 EM(rxrpc_cong_cleared_nacks, " Cleared") \
449 EM(rxrpc_cong_new_low_nack, " NewLowN") \
450 EM(rxrpc_cong_no_change, " -") \
451 EM(rxrpc_cong_progress, " Progres") \
452 EM(rxrpc_cong_idle_reset, " IdleRes") \
453 EM(rxrpc_cong_retransmit_again, " ReTxAgn") \
454 EM(rxrpc_cong_rtt_window_end, " RttWinE") \
455 E_(rxrpc_cong_saw_nack, " SawNack")
456
457#define rxrpc_pkts \
458 EM(0, "?00") \
459 EM(RXRPC_PACKET_TYPE_DATA, "DATA") \
460 EM(RXRPC_PACKET_TYPE_ACK, "ACK") \
461 EM(RXRPC_PACKET_TYPE_BUSY, "BUSY") \
462 EM(RXRPC_PACKET_TYPE_ABORT, "ABORT") \
463 EM(RXRPC_PACKET_TYPE_ACKALL, "ACKALL") \
464 EM(RXRPC_PACKET_TYPE_CHALLENGE, "CHALL") \
465 EM(RXRPC_PACKET_TYPE_RESPONSE, "RESP") \
466 EM(RXRPC_PACKET_TYPE_DEBUG, "DEBUG") \
467 EM(9, "?09") \
468 EM(10, "?10") \
469 EM(11, "?11") \
470 EM(12, "?12") \
471 EM(RXRPC_PACKET_TYPE_VERSION, "VERSION") \
472 EM(14, "?14") \
473 E_(15, "?15")
474
475#define rxrpc_ack_names \
476 EM(0, "-0-") \
477 EM(RXRPC_ACK_REQUESTED, "REQ") \
478 EM(RXRPC_ACK_DUPLICATE, "DUP") \
479 EM(RXRPC_ACK_OUT_OF_SEQUENCE, "OOS") \
480 EM(RXRPC_ACK_EXCEEDS_WINDOW, "WIN") \
481 EM(RXRPC_ACK_NOSPACE, "MEM") \
482 EM(RXRPC_ACK_PING, "PNG") \
483 EM(RXRPC_ACK_PING_RESPONSE, "PNR") \
484 EM(RXRPC_ACK_DELAY, "DLY") \
485 EM(RXRPC_ACK_IDLE, "IDL") \
486 E_(RXRPC_ACK__INVALID, "-?-")
487
488#define rxrpc_sack_traces \
489 EM(rxrpc_sack_advance, "ADV") \
490 EM(rxrpc_sack_fill, "FIL") \
491 EM(rxrpc_sack_nack, "NAK") \
492 EM(rxrpc_sack_none, "---") \
493 E_(rxrpc_sack_oos, "OOS")
494
495#define rxrpc_completions \
496 EM(RXRPC_CALL_SUCCEEDED, "Succeeded") \
497 EM(RXRPC_CALL_REMOTELY_ABORTED, "RemoteAbort") \
498 EM(RXRPC_CALL_LOCALLY_ABORTED, "LocalAbort") \
499 EM(RXRPC_CALL_LOCAL_ERROR, "LocalError") \
500 E_(RXRPC_CALL_NETWORK_ERROR, "NetError")
501
502#define rxrpc_tx_points \
503 EM(rxrpc_tx_point_call_abort, "CallAbort") \
504 EM(rxrpc_tx_point_call_ack, "CallAck") \
505 EM(rxrpc_tx_point_call_data_frag, "CallDataFrag") \
506 EM(rxrpc_tx_point_call_data_nofrag, "CallDataNofrag") \
507 EM(rxrpc_tx_point_call_final_resend, "CallFinalResend") \
508 EM(rxrpc_tx_point_conn_abort, "ConnAbort") \
509 EM(rxrpc_tx_point_reject, "Reject") \
510 EM(rxrpc_tx_point_rxgk_challenge, "RxGKChall") \
511 EM(rxrpc_tx_point_rxkad_challenge, "RxkadChall") \
512 EM(rxrpc_tx_point_response, "Response") \
513 EM(rxrpc_tx_point_version_keepalive, "VerKeepalive") \
514 E_(rxrpc_tx_point_version_reply, "VerReply")
515
516#define rxrpc_req_ack_traces \
517 EM(rxrpc_reqack_ack_lost, "ACK-LOST ") \
518 EM(rxrpc_reqack_app_stall, "APP-STALL ") \
519 EM(rxrpc_reqack_more_rtt, "MORE-RTT ") \
520 EM(rxrpc_reqack_no_srv_last, "NO-SRVLAST") \
521 EM(rxrpc_reqack_old_rtt, "OLD-RTT ") \
522 EM(rxrpc_reqack_retrans, "RETRANS ") \
523 EM(rxrpc_reqack_slow_start, "SLOW-START") \
524 E_(rxrpc_reqack_small_txwin, "SMALL-TXWN")
525/* ---- Must update size of stat_why_req_ack[] if more are added! */
526
527#define rxrpc_txbuf_traces \
528 EM(rxrpc_txbuf_alloc_data, "ALLOC DATA ") \
529 EM(rxrpc_txbuf_alloc_response, "ALLOC RESP ") \
530 EM(rxrpc_txbuf_free, "FREE ") \
531 EM(rxrpc_txbuf_get_buffer, "GET BUFFER ") \
532 EM(rxrpc_txbuf_get_trans, "GET TRANS ") \
533 EM(rxrpc_txbuf_get_retrans, "GET RETRANS") \
534 EM(rxrpc_txbuf_put_cleaned, "PUT CLEANED") \
535 EM(rxrpc_txbuf_put_nomem, "PUT NOMEM ") \
536 EM(rxrpc_txbuf_put_rotated, "PUT ROTATED") \
537 EM(rxrpc_txbuf_put_response_tx, "PUT RESP TX") \
538 EM(rxrpc_txbuf_put_send_aborted, "PUT SEND-X ") \
539 EM(rxrpc_txbuf_put_trans, "PUT TRANS ") \
540 EM(rxrpc_txbuf_see_lost, "SEE LOST ") \
541 EM(rxrpc_txbuf_see_out_of_step, "OUT-OF-STEP") \
542 E_(rxrpc_txbuf_see_send_more, "SEE SEND+ ")
543
544#define rxrpc_tq_traces \
545 EM(rxrpc_tq_alloc, "ALLOC") \
546 EM(rxrpc_tq_cleaned, "CLEAN") \
547 EM(rxrpc_tq_decant, "DCNT ") \
548 EM(rxrpc_tq_decant_advance, "DCNT>") \
549 EM(rxrpc_tq_queue, "QUEUE") \
550 EM(rxrpc_tq_queue_dup, "QUE!!") \
551 EM(rxrpc_tq_rotate, "ROT ") \
552 EM(rxrpc_tq_rotate_and_free, "ROT-F") \
553 EM(rxrpc_tq_rotate_and_keep, "ROT-K") \
554 EM(rxrpc_tq_transmit, "XMIT ") \
555 E_(rxrpc_tq_transmit_advance, "XMIT>")
556
557#define rxrpc_pmtud_reduce_traces \
558 EM(rxrpc_pmtud_reduce_ack, "Ack ") \
559 EM(rxrpc_pmtud_reduce_icmp, "Icmp ") \
560 E_(rxrpc_pmtud_reduce_route, "Route")
561
562#define rxrpc_rotate_traces \
563 EM(rxrpc_rotate_trace_hack, "hard-ack") \
564 EM(rxrpc_rotate_trace_sack, "soft-ack") \
565 E_(rxrpc_rotate_trace_snak, "soft-nack")
566
567#define rxrpc_rack_timer_modes \
568 EM(RXRPC_CALL_RACKTIMER_OFF, "---") \
569 EM(RXRPC_CALL_RACKTIMER_RACK_REORDER, "REO") \
570 EM(RXRPC_CALL_RACKTIMER_TLP_PTO, "TLP") \
571 E_(RXRPC_CALL_RACKTIMER_RTO, "RTO")
572
573#define rxrpc_tlp_probe_traces \
574 EM(rxrpc_tlp_probe_trace_busy, "busy") \
575 EM(rxrpc_tlp_probe_trace_transmit_new, "transmit-new") \
576 E_(rxrpc_tlp_probe_trace_retransmit, "retransmit")
577
578#define rxrpc_tlp_ack_traces \
579 EM(rxrpc_tlp_ack_trace_acked, "acked") \
580 EM(rxrpc_tlp_ack_trace_dup_acked, "dup-acked") \
581 EM(rxrpc_tlp_ack_trace_hard_beyond, "hard-beyond") \
582 EM(rxrpc_tlp_ack_trace_incomplete, "incomplete") \
583 E_(rxrpc_tlp_ack_trace_new_data, "new-data")
584
585/*
586 * Generate enums for tracing information.
587 */
588#ifndef __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
589#define __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
590
591#undef EM
592#undef E_
593#define EM(a, b) a,
594#define E_(a, b) a
595
596enum rxrpc_abort_reason { rxrpc_abort_reasons } __mode(byte);
597enum rxrpc_bundle_trace { rxrpc_bundle_traces } __mode(byte);
598enum rxrpc_call_poke_trace { rxrpc_call_poke_traces } __mode(byte);
599enum rxrpc_call_trace { rxrpc_call_traces } __mode(byte);
600enum rxrpc_client_trace { rxrpc_client_traces } __mode(byte);
601enum rxrpc_congest_change { rxrpc_congest_changes } __mode(byte);
602enum rxrpc_conn_trace { rxrpc_conn_traces } __mode(byte);
603enum rxrpc_local_trace { rxrpc_local_traces } __mode(byte);
604enum rxrpc_peer_trace { rxrpc_peer_traces } __mode(byte);
605enum rxrpc_pmtud_reduce_trace { rxrpc_pmtud_reduce_traces } __mode(byte);
606enum rxrpc_propose_ack_outcome { rxrpc_propose_ack_outcomes } __mode(byte);
607enum rxrpc_propose_ack_trace { rxrpc_propose_ack_traces } __mode(byte);
608enum rxrpc_receive_trace { rxrpc_receive_traces } __mode(byte);
609enum rxrpc_recvmsg_trace { rxrpc_recvmsg_traces } __mode(byte);
610enum rxrpc_req_ack_trace { rxrpc_req_ack_traces } __mode(byte);
611enum rxrpc_rotate_trace { rxrpc_rotate_traces } __mode(byte);
612enum rxrpc_rtt_rx_trace { rxrpc_rtt_rx_traces } __mode(byte);
613enum rxrpc_rtt_tx_trace { rxrpc_rtt_tx_traces } __mode(byte);
614enum rxrpc_sack_trace { rxrpc_sack_traces } __mode(byte);
615enum rxrpc_skb_trace { rxrpc_skb_traces } __mode(byte);
616enum rxrpc_timer_trace { rxrpc_timer_traces } __mode(byte);
617enum rxrpc_tlp_ack_trace { rxrpc_tlp_ack_traces } __mode(byte);
618enum rxrpc_tlp_probe_trace { rxrpc_tlp_probe_traces } __mode(byte);
619enum rxrpc_tq_trace { rxrpc_tq_traces } __mode(byte);
620enum rxrpc_tx_point { rxrpc_tx_points } __mode(byte);
621enum rxrpc_txbuf_trace { rxrpc_txbuf_traces } __mode(byte);
622enum rxrpc_txdata_trace { rxrpc_txdata_traces } __mode(byte);
623enum rxrpc_txqueue_trace { rxrpc_txqueue_traces } __mode(byte);
624
625#endif /* end __RXRPC_DECLARE_TRACE_ENUMS_ONCE_ONLY */
626
627/*
628 * Export enum symbols via userspace.
629 */
630#undef EM
631#undef E_
632
633#ifndef RXRPC_TRACE_ONLY_DEFINE_ENUMS
634
635#define EM(a, b) TRACE_DEFINE_ENUM(a);
636#define E_(a, b) TRACE_DEFINE_ENUM(a);
637
638rxrpc_abort_reasons;
639rxrpc_bundle_traces;
640rxrpc_ca_states;
641rxrpc_call_poke_traces;
642rxrpc_call_traces;
643rxrpc_client_traces;
644rxrpc_congest_changes;
645rxrpc_conn_traces;
646rxrpc_local_traces;
647rxrpc_pmtud_reduce_traces;
648rxrpc_propose_ack_traces;
649rxrpc_rack_timer_modes;
650rxrpc_receive_traces;
651rxrpc_recvmsg_traces;
652rxrpc_req_ack_traces;
653rxrpc_rotate_traces;
654rxrpc_rtt_rx_traces;
655rxrpc_rtt_tx_traces;
656rxrpc_sack_traces;
657rxrpc_skb_traces;
658rxrpc_timer_traces;
659rxrpc_tlp_ack_traces;
660rxrpc_tlp_probe_traces;
661rxrpc_tq_traces;
662rxrpc_tx_points;
663rxrpc_txbuf_traces;
664rxrpc_txdata_traces;
665rxrpc_txqueue_traces;
666
667/*
668 * Now redefine the EM() and E_() macros to map the enums to the strings that
669 * will be printed in the output.
670 */
671#undef EM
672#undef E_
673#define EM(a, b) { a, b },
674#define E_(a, b) { a, b }
675
676TRACE_EVENT(rxrpc_local,
677 TP_PROTO(unsigned int local_debug_id, enum rxrpc_local_trace op,
678 int ref, int usage),
679
680 TP_ARGS(local_debug_id, op, ref, usage),
681
682 TP_STRUCT__entry(
683 __field(unsigned int, local)
684 __field(int, op)
685 __field(int, ref)
686 __field(int, usage)
687 ),
688
689 TP_fast_assign(
690 __entry->local = local_debug_id;
691 __entry->op = op;
692 __entry->ref = ref;
693 __entry->usage = usage;
694 ),
695
696 TP_printk("L=%08x %s r=%d u=%d",
697 __entry->local,
698 __print_symbolic(__entry->op, rxrpc_local_traces),
699 __entry->ref,
700 __entry->usage)
701 );
702
703TRACE_EVENT(rxrpc_iothread_rx,
704 TP_PROTO(struct rxrpc_local *local, unsigned int nr_rx),
705 TP_ARGS(local, nr_rx),
706 TP_STRUCT__entry(
707 __field(unsigned int, local)
708 __field(unsigned int, nr_rx)
709 ),
710 TP_fast_assign(
711 __entry->local = local->debug_id;
712 __entry->nr_rx = nr_rx;
713 ),
714 TP_printk("L=%08x nrx=%u", __entry->local, __entry->nr_rx)
715 );
716
717TRACE_EVENT(rxrpc_peer,
718 TP_PROTO(unsigned int peer_debug_id, int ref, enum rxrpc_peer_trace why),
719
720 TP_ARGS(peer_debug_id, ref, why),
721
722 TP_STRUCT__entry(
723 __field(unsigned int, peer)
724 __field(int, ref)
725 __field(enum rxrpc_peer_trace, why)
726 ),
727
728 TP_fast_assign(
729 __entry->peer = peer_debug_id;
730 __entry->ref = ref;
731 __entry->why = why;
732 ),
733
734 TP_printk("P=%08x %s r=%d",
735 __entry->peer,
736 __print_symbolic(__entry->why, rxrpc_peer_traces),
737 __entry->ref)
738 );
739
740TRACE_EVENT(rxrpc_bundle,
741 TP_PROTO(unsigned int bundle_debug_id, int ref, enum rxrpc_bundle_trace why),
742
743 TP_ARGS(bundle_debug_id, ref, why),
744
745 TP_STRUCT__entry(
746 __field(unsigned int, bundle)
747 __field(int, ref)
748 __field(int, why)
749 ),
750
751 TP_fast_assign(
752 __entry->bundle = bundle_debug_id;
753 __entry->ref = ref;
754 __entry->why = why;
755 ),
756
757 TP_printk("CB=%08x %s r=%d",
758 __entry->bundle,
759 __print_symbolic(__entry->why, rxrpc_bundle_traces),
760 __entry->ref)
761 );
762
763TRACE_EVENT(rxrpc_conn,
764 TP_PROTO(unsigned int conn_debug_id, int ref, enum rxrpc_conn_trace why),
765
766 TP_ARGS(conn_debug_id, ref, why),
767
768 TP_STRUCT__entry(
769 __field(unsigned int, conn)
770 __field(int, ref)
771 __field(int, why)
772 ),
773
774 TP_fast_assign(
775 __entry->conn = conn_debug_id;
776 __entry->ref = ref;
777 __entry->why = why;
778 ),
779
780 TP_printk("C=%08x %s r=%d",
781 __entry->conn,
782 __print_symbolic(__entry->why, rxrpc_conn_traces),
783 __entry->ref)
784 );
785
786TRACE_EVENT(rxrpc_client,
787 TP_PROTO(struct rxrpc_connection *conn, int channel,
788 enum rxrpc_client_trace op),
789
790 TP_ARGS(conn, channel, op),
791
792 TP_STRUCT__entry(
793 __field(unsigned int, conn)
794 __field(u32, cid)
795 __field(int, channel)
796 __field(int, usage)
797 __field(enum rxrpc_client_trace, op)
798 ),
799
800 TP_fast_assign(
801 __entry->conn = conn ? conn->debug_id : 0;
802 __entry->channel = channel;
803 __entry->usage = conn ? refcount_read(&conn->ref) : -2;
804 __entry->op = op;
805 __entry->cid = conn ? conn->proto.cid : 0;
806 ),
807
808 TP_printk("C=%08x h=%2d %s i=%08x u=%d",
809 __entry->conn,
810 __entry->channel,
811 __print_symbolic(__entry->op, rxrpc_client_traces),
812 __entry->cid,
813 __entry->usage)
814 );
815
816TRACE_EVENT(rxrpc_call,
817 TP_PROTO(unsigned int call_debug_id, int ref, unsigned long aux,
818 enum rxrpc_call_trace why),
819
820 TP_ARGS(call_debug_id, ref, aux, why),
821
822 TP_STRUCT__entry(
823 __field(unsigned int, call)
824 __field(int, ref)
825 __field(int, why)
826 __field(unsigned long, aux)
827 ),
828
829 TP_fast_assign(
830 __entry->call = call_debug_id;
831 __entry->ref = ref;
832 __entry->why = why;
833 __entry->aux = aux;
834 ),
835
836 TP_printk("c=%08x %s r=%d a=%lx",
837 __entry->call,
838 __print_symbolic(__entry->why, rxrpc_call_traces),
839 __entry->ref,
840 __entry->aux)
841 );
842
843TRACE_EVENT(rxrpc_skb,
844 TP_PROTO(struct sk_buff *skb, int usage, int mod_count,
845 enum rxrpc_skb_trace why),
846
847 TP_ARGS(skb, usage, mod_count, why),
848
849 TP_STRUCT__entry(
850 __field(struct sk_buff *, skb)
851 __field(int, usage)
852 __field(int, mod_count)
853 __field(enum rxrpc_skb_trace, why)
854 ),
855
856 TP_fast_assign(
857 __entry->skb = skb;
858 __entry->usage = usage;
859 __entry->mod_count = mod_count;
860 __entry->why = why;
861 ),
862
863 TP_printk("s=%p Rx %s u=%d m=%d",
864 __entry->skb,
865 __print_symbolic(__entry->why, rxrpc_skb_traces),
866 __entry->usage,
867 __entry->mod_count)
868 );
869
870TRACE_EVENT(rxrpc_rx_packet,
871 TP_PROTO(struct rxrpc_skb_priv *sp),
872
873 TP_ARGS(sp),
874
875 TP_STRUCT__entry(
876 __field_struct(struct rxrpc_host_header, hdr)
877 ),
878
879 TP_fast_assign(
880 memcpy(&__entry->hdr, &sp->hdr, sizeof(__entry->hdr));
881 ),
882
883 TP_printk("%08x:%08x:%08x:%04x %08x %08x %02x %02x %s",
884 __entry->hdr.epoch, __entry->hdr.cid,
885 __entry->hdr.callNumber, __entry->hdr.serviceId,
886 __entry->hdr.serial, __entry->hdr.seq,
887 __entry->hdr.securityIndex, __entry->hdr.flags,
888 __print_symbolic(__entry->hdr.type, rxrpc_pkts))
889 );
890
891TRACE_EVENT(rxrpc_rx_done,
892 TP_PROTO(int result, int abort_code),
893
894 TP_ARGS(result, abort_code),
895
896 TP_STRUCT__entry(
897 __field(int, result)
898 __field(int, abort_code)
899 ),
900
901 TP_fast_assign(
902 __entry->result = result;
903 __entry->abort_code = abort_code;
904 ),
905
906 TP_printk("r=%d a=%d", __entry->result, __entry->abort_code)
907 );
908
909TRACE_EVENT(rxrpc_abort_call,
910 TP_PROTO(const struct rxrpc_call *call, int abort_code),
911
912 TP_ARGS(call, abort_code),
913
914 TP_STRUCT__entry(
915 __field(unsigned int, call_nr)
916 __field(enum rxrpc_abort_reason, why)
917 __field(int, abort_code)
918 __field(int, error)
919 ),
920
921 TP_fast_assign(
922 __entry->call_nr = call->debug_id;
923 __entry->why = call->send_abort_why;
924 __entry->abort_code = abort_code;
925 __entry->error = call->send_abort_err;
926 ),
927
928 TP_printk("c=%08x a=%d e=%d %s",
929 __entry->call_nr,
930 __entry->abort_code, __entry->error,
931 __print_symbolic(__entry->why, rxrpc_abort_reasons))
932 );
933
934TRACE_EVENT(rxrpc_abort,
935 TP_PROTO(unsigned int call_nr, enum rxrpc_abort_reason why,
936 u32 cid, u32 call_id, rxrpc_seq_t seq, int abort_code, int error),
937
938 TP_ARGS(call_nr, why, cid, call_id, seq, abort_code, error),
939
940 TP_STRUCT__entry(
941 __field(unsigned int, call_nr)
942 __field(enum rxrpc_abort_reason, why)
943 __field(u32, cid)
944 __field(u32, call_id)
945 __field(rxrpc_seq_t, seq)
946 __field(int, abort_code)
947 __field(int, error)
948 ),
949
950 TP_fast_assign(
951 __entry->call_nr = call_nr;
952 __entry->why = why;
953 __entry->cid = cid;
954 __entry->call_id = call_id;
955 __entry->abort_code = abort_code;
956 __entry->error = error;
957 __entry->seq = seq;
958 ),
959
960 TP_printk("c=%08x %08x:%08x s=%u a=%d e=%d %s",
961 __entry->call_nr,
962 __entry->cid, __entry->call_id, __entry->seq,
963 __entry->abort_code, __entry->error,
964 __print_symbolic(__entry->why, rxrpc_abort_reasons))
965 );
966
967TRACE_EVENT(rxrpc_call_complete,
968 TP_PROTO(struct rxrpc_call *call),
969
970 TP_ARGS(call),
971
972 TP_STRUCT__entry(
973 __field(unsigned int, call)
974 __field(enum rxrpc_call_completion, compl)
975 __field(int, error)
976 __field(u32, abort_code)
977 ),
978
979 TP_fast_assign(
980 __entry->call = call->debug_id;
981 __entry->compl = call->completion;
982 __entry->error = call->error;
983 __entry->abort_code = call->abort_code;
984 ),
985
986 TP_printk("c=%08x %s r=%d ac=%d",
987 __entry->call,
988 __print_symbolic(__entry->compl, rxrpc_completions),
989 __entry->error,
990 __entry->abort_code)
991 );
992
993TRACE_EVENT(rxrpc_txqueue,
994 TP_PROTO(struct rxrpc_call *call, enum rxrpc_txqueue_trace why),
995
996 TP_ARGS(call, why),
997
998 TP_STRUCT__entry(
999 __field(unsigned int, call)
1000 __field(enum rxrpc_txqueue_trace, why)
1001 __field(rxrpc_seq_t, tx_bottom)
1002 __field(rxrpc_seq_t, acks_hard_ack)
1003 __field(rxrpc_seq_t, tx_top)
1004 __field(rxrpc_seq_t, send_top)
1005 __field(int, tx_winsize)
1006 ),
1007
1008 TP_fast_assign(
1009 __entry->call = call->debug_id;
1010 __entry->why = why;
1011 __entry->tx_bottom = call->tx_bottom;
1012 __entry->acks_hard_ack = call->acks_hard_ack;
1013 __entry->tx_top = call->tx_top;
1014 __entry->send_top = call->send_top;
1015 __entry->tx_winsize = call->tx_winsize;
1016 ),
1017
1018 TP_printk("c=%08x %s b=%08x h=%08x n=%u/%u/%u/%u",
1019 __entry->call,
1020 __print_symbolic(__entry->why, rxrpc_txqueue_traces),
1021 __entry->tx_bottom,
1022 __entry->acks_hard_ack,
1023 __entry->acks_hard_ack - __entry->tx_bottom,
1024 __entry->tx_top - __entry->acks_hard_ack,
1025 __entry->send_top - __entry->tx_top,
1026 __entry->tx_winsize)
1027 );
1028
1029TRACE_EVENT(rxrpc_transmit,
1030 TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t send_top, int space),
1031
1032 TP_ARGS(call, send_top, space),
1033
1034 TP_STRUCT__entry(
1035 __field(unsigned int, call)
1036 __field(rxrpc_seq_t, seq)
1037 __field(u16, space)
1038 __field(u16, tx_winsize)
1039 __field(u16, cong_cwnd)
1040 __field(u16, cong_extra)
1041 __field(u16, in_flight)
1042 __field(u16, prepared)
1043 __field(u16, pmtud_jumbo)
1044 ),
1045
1046 TP_fast_assign(
1047 __entry->call = call->debug_id;
1048 __entry->seq = call->tx_top + 1;
1049 __entry->space = space;
1050 __entry->tx_winsize = call->tx_winsize;
1051 __entry->cong_cwnd = call->cong_cwnd;
1052 __entry->cong_extra = call->cong_extra;
1053 __entry->prepared = send_top - call->tx_bottom;
1054 __entry->in_flight = call->tx_top - call->tx_bottom;
1055 __entry->pmtud_jumbo = call->peer->pmtud_jumbo;
1056 ),
1057
1058 TP_printk("c=%08x q=%08x sp=%u tw=%u cw=%u+%u pr=%u if=%u pj=%u",
1059 __entry->call,
1060 __entry->seq,
1061 __entry->space,
1062 __entry->tx_winsize,
1063 __entry->cong_cwnd,
1064 __entry->cong_extra,
1065 __entry->prepared,
1066 __entry->in_flight,
1067 __entry->pmtud_jumbo)
1068 );
1069
1070TRACE_EVENT(rxrpc_tx_rotate,
1071 TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t seq, rxrpc_seq_t to),
1072
1073 TP_ARGS(call, seq, to),
1074
1075 TP_STRUCT__entry(
1076 __field(unsigned int, call)
1077 __field(rxrpc_seq_t, seq)
1078 __field(rxrpc_seq_t, to)
1079 __field(rxrpc_seq_t, top)
1080 ),
1081
1082 TP_fast_assign(
1083 __entry->call = call->debug_id;
1084 __entry->seq = seq;
1085 __entry->to = to;
1086 __entry->top = call->tx_top;
1087 ),
1088
1089 TP_printk("c=%08x q=%08x-%08x-%08x",
1090 __entry->call,
1091 __entry->seq,
1092 __entry->to,
1093 __entry->top)
1094 );
1095
1096TRACE_EVENT(rxrpc_rx_data,
1097 TP_PROTO(unsigned int call, rxrpc_seq_t seq,
1098 rxrpc_serial_t serial, u8 flags),
1099
1100 TP_ARGS(call, seq, serial, flags),
1101
1102 TP_STRUCT__entry(
1103 __field(unsigned int, call)
1104 __field(rxrpc_seq_t, seq)
1105 __field(rxrpc_serial_t, serial)
1106 __field(u8, flags)
1107 ),
1108
1109 TP_fast_assign(
1110 __entry->call = call;
1111 __entry->seq = seq;
1112 __entry->serial = serial;
1113 __entry->flags = flags;
1114 ),
1115
1116 TP_printk("c=%08x DATA %08x q=%08x fl=%02x",
1117 __entry->call,
1118 __entry->serial,
1119 __entry->seq,
1120 __entry->flags)
1121 );
1122
1123TRACE_EVENT(rxrpc_rx_ack,
1124 TP_PROTO(struct rxrpc_call *call, struct rxrpc_skb_priv *sp),
1125
1126 TP_ARGS(call, sp),
1127
1128 TP_STRUCT__entry(
1129 __field(unsigned int, call)
1130 __field(rxrpc_serial_t, serial)
1131 __field(rxrpc_serial_t, ack_serial)
1132 __field(rxrpc_seq_t, first)
1133 __field(rxrpc_seq_t, prev)
1134 __field(u8, reason)
1135 __field(u8, n_acks)
1136 __field(u8, user_status)
1137 ),
1138
1139 TP_fast_assign(
1140 __entry->call = call->debug_id;
1141 __entry->serial = sp->hdr.serial;
1142 __entry->user_status = sp->hdr.userStatus;
1143 __entry->ack_serial = sp->ack.acked_serial;
1144 __entry->first = sp->ack.first_ack;
1145 __entry->prev = sp->ack.prev_ack;
1146 __entry->reason = sp->ack.reason;
1147 __entry->n_acks = sp->ack.nr_acks;
1148 ),
1149
1150 TP_printk("c=%08x %08x %s r=%08x us=%02x f=%08x p=%08x n=%u",
1151 __entry->call,
1152 __entry->serial,
1153 __print_symbolic(__entry->reason, rxrpc_ack_names),
1154 __entry->ack_serial,
1155 __entry->user_status,
1156 __entry->first,
1157 __entry->prev,
1158 __entry->n_acks)
1159 );
1160
1161TRACE_EVENT(rxrpc_rx_abort,
1162 TP_PROTO(struct rxrpc_call *call, rxrpc_serial_t serial,
1163 u32 abort_code),
1164
1165 TP_ARGS(call, serial, abort_code),
1166
1167 TP_STRUCT__entry(
1168 __field(unsigned int, call)
1169 __field(rxrpc_serial_t, serial)
1170 __field(u32, abort_code)
1171 ),
1172
1173 TP_fast_assign(
1174 __entry->call = call->debug_id;
1175 __entry->serial = serial;
1176 __entry->abort_code = abort_code;
1177 ),
1178
1179 TP_printk("c=%08x ABORT %08x ac=%d",
1180 __entry->call,
1181 __entry->serial,
1182 __entry->abort_code)
1183 );
1184
1185TRACE_EVENT(rxrpc_rx_conn_abort,
1186 TP_PROTO(const struct rxrpc_connection *conn, const struct sk_buff *skb),
1187
1188 TP_ARGS(conn, skb),
1189
1190 TP_STRUCT__entry(
1191 __field(unsigned int, conn)
1192 __field(rxrpc_serial_t, serial)
1193 __field(u32, abort_code)
1194 ),
1195
1196 TP_fast_assign(
1197 __entry->conn = conn->debug_id;
1198 __entry->serial = rxrpc_skb(skb)->hdr.serial;
1199 __entry->abort_code = skb->priority;
1200 ),
1201
1202 TP_printk("C=%08x ABORT %08x ac=%d",
1203 __entry->conn,
1204 __entry->serial,
1205 __entry->abort_code)
1206 );
1207
1208TRACE_EVENT(rxrpc_tx_challenge,
1209 TP_PROTO(struct rxrpc_connection *conn, rxrpc_serial_t serial,
1210 u32 version, u32 nonce),
1211
1212 TP_ARGS(conn, serial, version, nonce),
1213
1214 TP_STRUCT__entry(
1215 __field(unsigned int, conn)
1216 __field(rxrpc_serial_t, serial)
1217 __field(u32, version)
1218 __field(u32, nonce)
1219 __field(u16, service_id)
1220 __field(u8, security_ix)
1221 ),
1222
1223 TP_fast_assign(
1224 __entry->conn = conn->debug_id;
1225 __entry->serial = serial;
1226 __entry->version = version;
1227 __entry->nonce = nonce;
1228 __entry->service_id = conn->service_id;
1229 __entry->security_ix = conn->security_ix;
1230 ),
1231
1232 TP_printk("C=%08x CHALLENGE r=%08x sv=%u+%u v=%x n=%x",
1233 __entry->conn,
1234 __entry->serial,
1235 __entry->service_id,
1236 __entry->security_ix,
1237 __entry->version,
1238 __entry->nonce)
1239 );
1240
1241TRACE_EVENT(rxrpc_rx_challenge,
1242 TP_PROTO(struct rxrpc_connection *conn, rxrpc_serial_t serial,
1243 u32 version, u32 nonce, u32 min_level),
1244
1245 TP_ARGS(conn, serial, version, nonce, min_level),
1246
1247 TP_STRUCT__entry(
1248 __field(unsigned int, conn)
1249 __field(rxrpc_serial_t, serial)
1250 __field(u32, version)
1251 __field(u32, nonce)
1252 __field(u32, min_level)
1253 __field(u16, service_id)
1254 __field(u8, security_ix)
1255 ),
1256
1257 TP_fast_assign(
1258 __entry->conn = conn->debug_id;
1259 __entry->serial = serial;
1260 __entry->version = version;
1261 __entry->nonce = nonce;
1262 __entry->min_level = min_level;
1263 __entry->service_id = conn->service_id;
1264 __entry->security_ix = conn->security_ix;
1265 ),
1266
1267 TP_printk("C=%08x CHALLENGE r=%08x sv=%u+%u v=%x n=%x ml=%x",
1268 __entry->conn,
1269 __entry->serial,
1270 __entry->service_id,
1271 __entry->security_ix,
1272 __entry->version,
1273 __entry->nonce,
1274 __entry->min_level)
1275 );
1276
1277TRACE_EVENT(rxrpc_tx_response,
1278 TP_PROTO(struct rxrpc_connection *conn, rxrpc_serial_t serial,
1279 struct rxrpc_skb_priv *rsp),
1280
1281 TP_ARGS(conn, serial, rsp),
1282
1283 TP_STRUCT__entry(
1284 __field(unsigned int, conn)
1285 __field(rxrpc_serial_t, serial)
1286 __field(rxrpc_serial_t, challenge)
1287 __field(u32, version)
1288 __field(u32, kvno)
1289 __field(u16, ticket_len)
1290 __field(u16, appdata_len)
1291 __field(u16, service_id)
1292 __field(u8, security_ix)
1293 ),
1294
1295 TP_fast_assign(
1296 __entry->conn = conn->debug_id;
1297 __entry->serial = serial;
1298 __entry->challenge = rsp->resp.challenge_serial;
1299 __entry->version = rsp->resp.version;
1300 __entry->kvno = rsp->resp.kvno;
1301 __entry->ticket_len = rsp->resp.ticket_len;
1302 __entry->service_id = conn->service_id;
1303 __entry->security_ix = conn->security_ix;
1304 ),
1305
1306 TP_printk("C=%08x RESPONSE r=%08x cr=%08x sv=%u+%u v=%x kv=%x tl=%u",
1307 __entry->conn,
1308 __entry->serial,
1309 __entry->challenge,
1310 __entry->service_id,
1311 __entry->security_ix,
1312 __entry->version,
1313 __entry->kvno,
1314 __entry->ticket_len)
1315 );
1316
1317TRACE_EVENT(rxrpc_rx_response,
1318 TP_PROTO(struct rxrpc_connection *conn, rxrpc_serial_t serial,
1319 u32 version, u32 kvno, u32 ticket_len),
1320
1321 TP_ARGS(conn, serial, version, kvno, ticket_len),
1322
1323 TP_STRUCT__entry(
1324 __field(unsigned int, conn)
1325 __field(rxrpc_serial_t, serial)
1326 __field(u32, version)
1327 __field(u32, kvno)
1328 __field(u32, ticket_len)
1329 __field(u8, security_ix)
1330 ),
1331
1332 TP_fast_assign(
1333 __entry->conn = conn->debug_id;
1334 __entry->serial = serial;
1335 __entry->version = version;
1336 __entry->kvno = kvno;
1337 __entry->ticket_len = ticket_len;
1338 __entry->security_ix = conn->security_ix;
1339 ),
1340
1341 TP_printk("C=%08x RESPONSE r=%08x sx=%u v=%x kvno=%x tl=%x",
1342 __entry->conn,
1343 __entry->serial,
1344 __entry->security_ix,
1345 __entry->version,
1346 __entry->kvno,
1347 __entry->ticket_len)
1348 );
1349
1350TRACE_EVENT(rxrpc_rx_rwind_change,
1351 TP_PROTO(struct rxrpc_call *call, rxrpc_serial_t serial,
1352 u32 rwind, bool wake),
1353
1354 TP_ARGS(call, serial, rwind, wake),
1355
1356 TP_STRUCT__entry(
1357 __field(unsigned int, call)
1358 __field(rxrpc_serial_t, serial)
1359 __field(u32, rwind)
1360 __field(bool, wake)
1361 ),
1362
1363 TP_fast_assign(
1364 __entry->call = call->debug_id;
1365 __entry->serial = serial;
1366 __entry->rwind = rwind;
1367 __entry->wake = wake;
1368 ),
1369
1370 TP_printk("c=%08x %08x rw=%u%s",
1371 __entry->call,
1372 __entry->serial,
1373 __entry->rwind,
1374 __entry->wake ? " wake" : "")
1375 );
1376
1377TRACE_EVENT(rxrpc_tx_packet,
1378 TP_PROTO(unsigned int call_id, struct rxrpc_wire_header *whdr,
1379 enum rxrpc_tx_point where),
1380
1381 TP_ARGS(call_id, whdr, where),
1382
1383 TP_STRUCT__entry(
1384 __field(unsigned int, call)
1385 __field(enum rxrpc_tx_point, where)
1386 __field_struct(struct rxrpc_wire_header, whdr)
1387 ),
1388
1389 TP_fast_assign(
1390 __entry->call = call_id;
1391 memcpy(&__entry->whdr, whdr, sizeof(__entry->whdr));
1392 __entry->where = where;
1393 ),
1394
1395 TP_printk("c=%08x %08x:%08x:%08x:%04x %08x %08x %02x %02x %s %s",
1396 __entry->call,
1397 ntohl(__entry->whdr.epoch),
1398 ntohl(__entry->whdr.cid),
1399 ntohl(__entry->whdr.callNumber),
1400 ntohs(__entry->whdr.serviceId),
1401 ntohl(__entry->whdr.serial),
1402 ntohl(__entry->whdr.seq),
1403 __entry->whdr.type, __entry->whdr.flags,
1404 __entry->whdr.type <= 15 ?
1405 __print_symbolic(__entry->whdr.type, rxrpc_pkts) : "?UNK",
1406 __print_symbolic(__entry->where, rxrpc_tx_points))
1407 );
1408
1409TRACE_EVENT(rxrpc_tx_data,
1410 TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t seq,
1411 rxrpc_serial_t serial, unsigned int flags,
1412 enum rxrpc_txdata_trace trace),
1413
1414 TP_ARGS(call, seq, serial, flags, trace),
1415
1416 TP_STRUCT__entry(
1417 __field(unsigned int, call)
1418 __field(rxrpc_seq_t, seq)
1419 __field(rxrpc_serial_t, serial)
1420 __field(u32, cid)
1421 __field(u32, call_id)
1422 __field(u16, flags)
1423 __field(enum rxrpc_txdata_trace, trace)
1424 ),
1425
1426 TP_fast_assign(
1427 __entry->call = call->debug_id;
1428 __entry->cid = call->cid;
1429 __entry->call_id = call->call_id;
1430 __entry->seq = seq;
1431 __entry->serial = serial;
1432 __entry->flags = flags;
1433 __entry->trace = trace;
1434 ),
1435
1436 TP_printk("c=%08x DATA %08x:%08x %08x q=%08x fl=%02x%s",
1437 __entry->call,
1438 __entry->cid,
1439 __entry->call_id,
1440 __entry->serial,
1441 __entry->seq,
1442 __entry->flags & RXRPC_TXBUF_WIRE_FLAGS,
1443 __print_symbolic(__entry->trace, rxrpc_txdata_traces))
1444 );
1445
1446TRACE_EVENT(rxrpc_tx_ack,
1447 TP_PROTO(unsigned int call, rxrpc_serial_t serial,
1448 rxrpc_seq_t ack_first, rxrpc_serial_t ack_serial,
1449 u8 reason, u8 n_acks, u16 rwind,
1450 enum rxrpc_propose_ack_trace trace),
1451
1452 TP_ARGS(call, serial, ack_first, ack_serial, reason, n_acks, rwind, trace),
1453
1454 TP_STRUCT__entry(
1455 __field(unsigned int, call)
1456 __field(rxrpc_serial_t, serial)
1457 __field(rxrpc_seq_t, ack_first)
1458 __field(rxrpc_serial_t, ack_serial)
1459 __field(u8, reason)
1460 __field(u8, n_acks)
1461 __field(u16, rwind)
1462 __field(enum rxrpc_propose_ack_trace, trace)
1463 ),
1464
1465 TP_fast_assign(
1466 __entry->call = call;
1467 __entry->serial = serial;
1468 __entry->ack_first = ack_first;
1469 __entry->ack_serial = ack_serial;
1470 __entry->reason = reason;
1471 __entry->n_acks = n_acks;
1472 __entry->rwind = rwind;
1473 __entry->trace = trace;
1474 ),
1475
1476 TP_printk(" c=%08x ACK %08x %s f=%08x r=%08x n=%u rw=%u %s",
1477 __entry->call,
1478 __entry->serial,
1479 __print_symbolic(__entry->reason, rxrpc_ack_names),
1480 __entry->ack_first,
1481 __entry->ack_serial,
1482 __entry->n_acks,
1483 __entry->rwind,
1484 __print_symbolic(__entry->trace, rxrpc_propose_ack_traces))
1485 );
1486
1487TRACE_EVENT(rxrpc_receive,
1488 TP_PROTO(struct rxrpc_call *call, enum rxrpc_receive_trace why,
1489 rxrpc_serial_t serial, rxrpc_seq_t seq),
1490
1491 TP_ARGS(call, why, serial, seq),
1492
1493 TP_STRUCT__entry(
1494 __field(unsigned int, call)
1495 __field(enum rxrpc_receive_trace, why)
1496 __field(rxrpc_serial_t, serial)
1497 __field(rxrpc_seq_t, seq)
1498 __field(rxrpc_seq_t, window)
1499 __field(rxrpc_seq_t, wtop)
1500 ),
1501
1502 TP_fast_assign(
1503 __entry->call = call->debug_id;
1504 __entry->why = why;
1505 __entry->serial = serial;
1506 __entry->seq = seq;
1507 __entry->window = call->ackr_window;
1508 __entry->wtop = call->ackr_wtop;
1509 ),
1510
1511 TP_printk("c=%08x %s r=%08x q=%08x w=%08x-%08x",
1512 __entry->call,
1513 __print_symbolic(__entry->why, rxrpc_receive_traces),
1514 __entry->serial,
1515 __entry->seq,
1516 __entry->window,
1517 __entry->wtop)
1518 );
1519
1520TRACE_EVENT(rxrpc_recvmsg,
1521 TP_PROTO(unsigned int call_debug_id, enum rxrpc_recvmsg_trace why,
1522 int ret),
1523
1524 TP_ARGS(call_debug_id, why, ret),
1525
1526 TP_STRUCT__entry(
1527 __field(unsigned int, call)
1528 __field(enum rxrpc_recvmsg_trace, why)
1529 __field(int, ret)
1530 ),
1531
1532 TP_fast_assign(
1533 __entry->call = call_debug_id;
1534 __entry->why = why;
1535 __entry->ret = ret;
1536 ),
1537
1538 TP_printk("c=%08x %s ret=%d",
1539 __entry->call,
1540 __print_symbolic(__entry->why, rxrpc_recvmsg_traces),
1541 __entry->ret)
1542 );
1543
1544TRACE_EVENT(rxrpc_recvdata,
1545 TP_PROTO(struct rxrpc_call *call, enum rxrpc_recvmsg_trace why,
1546 rxrpc_seq_t seq, unsigned int offset, unsigned int len,
1547 int ret),
1548
1549 TP_ARGS(call, why, seq, offset, len, ret),
1550
1551 TP_STRUCT__entry(
1552 __field(unsigned int, call)
1553 __field(enum rxrpc_recvmsg_trace, why)
1554 __field(rxrpc_seq_t, seq)
1555 __field(unsigned int, offset)
1556 __field(unsigned int, len)
1557 __field(int, ret)
1558 ),
1559
1560 TP_fast_assign(
1561 __entry->call = call ? call->debug_id : 0;
1562 __entry->why = why;
1563 __entry->seq = seq;
1564 __entry->offset = offset;
1565 __entry->len = len;
1566 __entry->ret = ret;
1567 ),
1568
1569 TP_printk("c=%08x %s q=%08x o=%u l=%u ret=%d",
1570 __entry->call,
1571 __print_symbolic(__entry->why, rxrpc_recvmsg_traces),
1572 __entry->seq,
1573 __entry->offset,
1574 __entry->len,
1575 __entry->ret)
1576 );
1577
1578TRACE_EVENT(rxrpc_rtt_tx,
1579 TP_PROTO(struct rxrpc_call *call, enum rxrpc_rtt_tx_trace why,
1580 int slot, rxrpc_serial_t send_serial),
1581
1582 TP_ARGS(call, why, slot, send_serial),
1583
1584 TP_STRUCT__entry(
1585 __field(unsigned int, call)
1586 __field(enum rxrpc_rtt_tx_trace, why)
1587 __field(int, slot)
1588 __field(rxrpc_serial_t, send_serial)
1589 ),
1590
1591 TP_fast_assign(
1592 __entry->call = call->debug_id;
1593 __entry->why = why;
1594 __entry->slot = slot;
1595 __entry->send_serial = send_serial;
1596 ),
1597
1598 TP_printk("c=%08x [%d] %s sr=%08x",
1599 __entry->call,
1600 __entry->slot,
1601 __print_symbolic(__entry->why, rxrpc_rtt_tx_traces),
1602 __entry->send_serial)
1603 );
1604
1605TRACE_EVENT(rxrpc_rtt_rx,
1606 TP_PROTO(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why,
1607 int slot,
1608 rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial,
1609 u32 rtt, u32 srtt, u32 rto),
1610
1611 TP_ARGS(call, why, slot, send_serial, resp_serial, rtt, srtt, rto),
1612
1613 TP_STRUCT__entry(
1614 __field(unsigned int, call)
1615 __field(enum rxrpc_rtt_rx_trace, why)
1616 __field(int, slot)
1617 __field(rxrpc_serial_t, send_serial)
1618 __field(rxrpc_serial_t, resp_serial)
1619 __field(u32, rtt)
1620 __field(u32, srtt)
1621 __field(u32, rto)
1622 __field(u32, min_rtt)
1623 ),
1624
1625 TP_fast_assign(
1626 __entry->call = call->debug_id;
1627 __entry->why = why;
1628 __entry->slot = slot;
1629 __entry->send_serial = send_serial;
1630 __entry->resp_serial = resp_serial;
1631 __entry->rtt = rtt;
1632 __entry->srtt = srtt;
1633 __entry->rto = rto;
1634 __entry->min_rtt = minmax_get(&call->min_rtt)
1635 ),
1636
1637 TP_printk("c=%08x [%d] %s sr=%08x rr=%08x rtt=%u srtt=%u rto=%u min=%u",
1638 __entry->call,
1639 __entry->slot,
1640 __print_symbolic(__entry->why, rxrpc_rtt_rx_traces),
1641 __entry->send_serial,
1642 __entry->resp_serial,
1643 __entry->rtt,
1644 __entry->srtt / 8,
1645 __entry->rto,
1646 __entry->min_rtt)
1647 );
1648
1649TRACE_EVENT(rxrpc_timer_set,
1650 TP_PROTO(struct rxrpc_call *call, ktime_t delay,
1651 enum rxrpc_timer_trace why),
1652
1653 TP_ARGS(call, delay, why),
1654
1655 TP_STRUCT__entry(
1656 __field(unsigned int, call)
1657 __field(enum rxrpc_timer_trace, why)
1658 __field(ktime_t, delay)
1659 ),
1660
1661 TP_fast_assign(
1662 __entry->call = call->debug_id;
1663 __entry->why = why;
1664 __entry->delay = delay;
1665 ),
1666
1667 TP_printk("c=%08x %s to=%lld",
1668 __entry->call,
1669 __print_symbolic(__entry->why, rxrpc_timer_traces),
1670 ktime_to_us(__entry->delay))
1671 );
1672
1673TRACE_EVENT(rxrpc_timer_exp,
1674 TP_PROTO(struct rxrpc_call *call, ktime_t delay,
1675 enum rxrpc_timer_trace why),
1676
1677 TP_ARGS(call, delay, why),
1678
1679 TP_STRUCT__entry(
1680 __field(unsigned int, call)
1681 __field(enum rxrpc_timer_trace, why)
1682 __field(ktime_t, delay)
1683 ),
1684
1685 TP_fast_assign(
1686 __entry->call = call->debug_id;
1687 __entry->why = why;
1688 __entry->delay = delay;
1689 ),
1690
1691 TP_printk("c=%08x %s to=%lld",
1692 __entry->call,
1693 __print_symbolic(__entry->why, rxrpc_timer_traces),
1694 ktime_to_us(__entry->delay))
1695 );
1696
1697TRACE_EVENT(rxrpc_timer_can,
1698 TP_PROTO(struct rxrpc_call *call, enum rxrpc_timer_trace why),
1699
1700 TP_ARGS(call, why),
1701
1702 TP_STRUCT__entry(
1703 __field(unsigned int, call)
1704 __field(enum rxrpc_timer_trace, why)
1705 ),
1706
1707 TP_fast_assign(
1708 __entry->call = call->debug_id;
1709 __entry->why = why;
1710 ),
1711
1712 TP_printk("c=%08x %s",
1713 __entry->call,
1714 __print_symbolic(__entry->why, rxrpc_timer_traces))
1715 );
1716
1717TRACE_EVENT(rxrpc_timer_restart,
1718 TP_PROTO(struct rxrpc_call *call, ktime_t delay, unsigned long delayj),
1719
1720 TP_ARGS(call, delay, delayj),
1721
1722 TP_STRUCT__entry(
1723 __field(unsigned int, call)
1724 __field(unsigned long, delayj)
1725 __field(ktime_t, delay)
1726 ),
1727
1728 TP_fast_assign(
1729 __entry->call = call->debug_id;
1730 __entry->delayj = delayj;
1731 __entry->delay = delay;
1732 ),
1733
1734 TP_printk("c=%08x to=%lld j=%ld",
1735 __entry->call,
1736 ktime_to_us(__entry->delay),
1737 __entry->delayj)
1738 );
1739
1740TRACE_EVENT(rxrpc_timer_expired,
1741 TP_PROTO(struct rxrpc_call *call),
1742
1743 TP_ARGS(call),
1744
1745 TP_STRUCT__entry(
1746 __field(unsigned int, call)
1747 ),
1748
1749 TP_fast_assign(
1750 __entry->call = call->debug_id;
1751 ),
1752
1753 TP_printk("c=%08x EXPIRED",
1754 __entry->call)
1755 );
1756
1757TRACE_EVENT(rxrpc_rx_lose,
1758 TP_PROTO(struct rxrpc_skb_priv *sp),
1759
1760 TP_ARGS(sp),
1761
1762 TP_STRUCT__entry(
1763 __field_struct(struct rxrpc_host_header, hdr)
1764 ),
1765
1766 TP_fast_assign(
1767 memcpy(&__entry->hdr, &sp->hdr, sizeof(__entry->hdr));
1768 ),
1769
1770 TP_printk("%08x:%08x:%08x:%04x %08x %08x %02x %02x %s *LOSE*",
1771 __entry->hdr.epoch, __entry->hdr.cid,
1772 __entry->hdr.callNumber, __entry->hdr.serviceId,
1773 __entry->hdr.serial, __entry->hdr.seq,
1774 __entry->hdr.type, __entry->hdr.flags,
1775 __entry->hdr.type <= 15 ?
1776 __print_symbolic(__entry->hdr.type, rxrpc_pkts) : "?UNK")
1777 );
1778
1779TRACE_EVENT(rxrpc_propose_ack,
1780 TP_PROTO(struct rxrpc_call *call, enum rxrpc_propose_ack_trace why,
1781 u8 ack_reason, rxrpc_serial_t serial),
1782
1783 TP_ARGS(call, why, ack_reason, serial),
1784
1785 TP_STRUCT__entry(
1786 __field(unsigned int, call)
1787 __field(enum rxrpc_propose_ack_trace, why)
1788 __field(rxrpc_serial_t, serial)
1789 __field(u8, ack_reason)
1790 ),
1791
1792 TP_fast_assign(
1793 __entry->call = call->debug_id;
1794 __entry->why = why;
1795 __entry->serial = serial;
1796 __entry->ack_reason = ack_reason;
1797 ),
1798
1799 TP_printk("c=%08x %s %s r=%08x",
1800 __entry->call,
1801 __print_symbolic(__entry->why, rxrpc_propose_ack_traces),
1802 __print_symbolic(__entry->ack_reason, rxrpc_ack_names),
1803 __entry->serial)
1804 );
1805
1806TRACE_EVENT(rxrpc_send_ack,
1807 TP_PROTO(struct rxrpc_call *call, enum rxrpc_propose_ack_trace why,
1808 u8 ack_reason, rxrpc_serial_t serial),
1809
1810 TP_ARGS(call, why, ack_reason, serial),
1811
1812 TP_STRUCT__entry(
1813 __field(unsigned int, call)
1814 __field(enum rxrpc_propose_ack_trace, why)
1815 __field(rxrpc_serial_t, serial)
1816 __field(u8, ack_reason)
1817 ),
1818
1819 TP_fast_assign(
1820 __entry->call = call->debug_id;
1821 __entry->why = why;
1822 __entry->serial = serial;
1823 __entry->ack_reason = ack_reason;
1824 ),
1825
1826 TP_printk("c=%08x %s %s r=%08x",
1827 __entry->call,
1828 __print_symbolic(__entry->why, rxrpc_propose_ack_traces),
1829 __print_symbolic(__entry->ack_reason, rxrpc_ack_names),
1830 __entry->serial)
1831 );
1832
1833TRACE_EVENT(rxrpc_drop_ack,
1834 TP_PROTO(struct rxrpc_call *call, enum rxrpc_propose_ack_trace why,
1835 u8 ack_reason, rxrpc_serial_t serial, bool nobuf),
1836
1837 TP_ARGS(call, why, ack_reason, serial, nobuf),
1838
1839 TP_STRUCT__entry(
1840 __field(unsigned int, call)
1841 __field(enum rxrpc_propose_ack_trace, why)
1842 __field(rxrpc_serial_t, serial)
1843 __field(u8, ack_reason)
1844 __field(bool, nobuf)
1845 ),
1846
1847 TP_fast_assign(
1848 __entry->call = call->debug_id;
1849 __entry->why = why;
1850 __entry->serial = serial;
1851 __entry->ack_reason = ack_reason;
1852 __entry->nobuf = nobuf;
1853 ),
1854
1855 TP_printk("c=%08x %s %s r=%08x nbf=%u",
1856 __entry->call,
1857 __print_symbolic(__entry->why, rxrpc_propose_ack_traces),
1858 __print_symbolic(__entry->ack_reason, rxrpc_ack_names),
1859 __entry->serial, __entry->nobuf)
1860 );
1861
1862TRACE_EVENT(rxrpc_retransmit,
1863 TP_PROTO(struct rxrpc_call *call,
1864 struct rxrpc_send_data_req *req,
1865 struct rxrpc_txbuf *txb),
1866
1867 TP_ARGS(call, req, txb),
1868
1869 TP_STRUCT__entry(
1870 __field(unsigned int, call)
1871 __field(unsigned int, qbase)
1872 __field(rxrpc_seq_t, seq)
1873 __field(rxrpc_serial_t, serial)
1874 ),
1875
1876 TP_fast_assign(
1877 __entry->call = call->debug_id;
1878 __entry->qbase = req->tq->qbase;
1879 __entry->seq = req->seq;
1880 __entry->serial = txb->serial;
1881 ),
1882
1883 TP_printk("c=%08x tq=%x q=%x r=%x",
1884 __entry->call,
1885 __entry->qbase,
1886 __entry->seq,
1887 __entry->serial)
1888 );
1889
1890TRACE_EVENT(rxrpc_congest,
1891 TP_PROTO(struct rxrpc_call *call, struct rxrpc_ack_summary *summary),
1892
1893 TP_ARGS(call, summary),
1894
1895 TP_STRUCT__entry(
1896 __field(unsigned int, call)
1897 __field(enum rxrpc_ca_state, ca_state)
1898 __field(rxrpc_seq_t, hard_ack)
1899 __field(rxrpc_seq_t, top)
1900 __field(rxrpc_seq_t, lowest_nak)
1901 __field(u16, nr_sacks)
1902 __field(u16, nr_snacks)
1903 __field(u16, cwnd)
1904 __field(u16, ssthresh)
1905 __field(u16, cumul_acks)
1906 __field(u16, dup_acks)
1907 __field_struct(struct rxrpc_ack_summary, sum)
1908 ),
1909
1910 TP_fast_assign(
1911 __entry->call = call->debug_id;
1912 __entry->ca_state = call->cong_ca_state;
1913 __entry->hard_ack = call->acks_hard_ack;
1914 __entry->top = call->tx_top;
1915 __entry->lowest_nak = call->acks_lowest_nak;
1916 __entry->nr_sacks = call->acks_nr_sacks;
1917 __entry->nr_snacks = call->acks_nr_snacks;
1918 __entry->cwnd = call->cong_cwnd;
1919 __entry->ssthresh = call->cong_ssthresh;
1920 __entry->cumul_acks = call->cong_cumul_acks;
1921 __entry->dup_acks = call->cong_dup_acks;
1922 memcpy(&__entry->sum, summary, sizeof(__entry->sum));
1923 ),
1924
1925 TP_printk("c=%08x r=%08x %s q=%08x %s cw=%u ss=%u A=%u+%u/%u+%u r=%u b=%u u=%u d=%u l=%x%s%s%s",
1926 __entry->call,
1927 __entry->sum.acked_serial,
1928 __print_symbolic(__entry->sum.ack_reason, rxrpc_ack_names),
1929 __entry->hard_ack,
1930 __print_symbolic(__entry->ca_state, rxrpc_ca_states),
1931 __entry->cwnd,
1932 __entry->ssthresh,
1933 __entry->nr_sacks, __entry->sum.nr_new_sacks,
1934 __entry->nr_snacks, __entry->sum.nr_new_snacks,
1935 __entry->sum.nr_new_hacks,
1936 __entry->top - __entry->hard_ack,
1937 __entry->cumul_acks,
1938 __entry->dup_acks,
1939 __entry->lowest_nak, __entry->sum.new_low_snack ? "!" : "",
1940 __print_symbolic(__entry->sum.change, rxrpc_congest_changes),
1941 __entry->sum.retrans_timeo ? " rTxTo" : "")
1942 );
1943
1944TRACE_EVENT(rxrpc_reset_cwnd,
1945 TP_PROTO(struct rxrpc_call *call, ktime_t since_last_tx, ktime_t rtt),
1946
1947 TP_ARGS(call, since_last_tx, rtt),
1948
1949 TP_STRUCT__entry(
1950 __field(unsigned int, call)
1951 __field(enum rxrpc_ca_state, ca_state)
1952 __field(unsigned short, cwnd)
1953 __field(unsigned short, extra)
1954 __field(rxrpc_seq_t, hard_ack)
1955 __field(rxrpc_seq_t, prepared)
1956 __field(ktime_t, since_last_tx)
1957 __field(ktime_t, rtt)
1958 __field(bool, has_data)
1959 ),
1960
1961 TP_fast_assign(
1962 __entry->call = call->debug_id;
1963 __entry->ca_state = call->cong_ca_state;
1964 __entry->cwnd = call->cong_cwnd;
1965 __entry->extra = call->cong_extra;
1966 __entry->hard_ack = call->acks_hard_ack;
1967 __entry->prepared = call->send_top - call->tx_bottom;
1968 __entry->since_last_tx = since_last_tx;
1969 __entry->rtt = rtt;
1970 __entry->has_data = call->tx_bottom != call->tx_top;
1971 ),
1972
1973 TP_printk("c=%08x q=%08x %s cw=%u+%u pr=%u tm=%llu/%llu d=%u",
1974 __entry->call,
1975 __entry->hard_ack,
1976 __print_symbolic(__entry->ca_state, rxrpc_ca_states),
1977 __entry->cwnd,
1978 __entry->extra,
1979 __entry->prepared,
1980 ktime_to_us(__entry->since_last_tx),
1981 ktime_to_us(__entry->rtt),
1982 __entry->has_data)
1983 );
1984
1985TRACE_EVENT(rxrpc_disconnect_call,
1986 TP_PROTO(struct rxrpc_call *call),
1987
1988 TP_ARGS(call),
1989
1990 TP_STRUCT__entry(
1991 __field(unsigned int, call)
1992 __field(u32, abort_code)
1993 ),
1994
1995 TP_fast_assign(
1996 __entry->call = call->debug_id;
1997 __entry->abort_code = call->abort_code;
1998 ),
1999
2000 TP_printk("c=%08x ab=%08x",
2001 __entry->call,
2002 __entry->abort_code)
2003 );
2004
2005TRACE_EVENT(rxrpc_improper_term,
2006 TP_PROTO(struct rxrpc_call *call),
2007
2008 TP_ARGS(call),
2009
2010 TP_STRUCT__entry(
2011 __field(unsigned int, call)
2012 __field(u32, abort_code)
2013 ),
2014
2015 TP_fast_assign(
2016 __entry->call = call->debug_id;
2017 __entry->abort_code = call->abort_code;
2018 ),
2019
2020 TP_printk("c=%08x ab=%08x",
2021 __entry->call,
2022 __entry->abort_code)
2023 );
2024
2025TRACE_EVENT(rxrpc_connect_call,
2026 TP_PROTO(struct rxrpc_call *call),
2027
2028 TP_ARGS(call),
2029
2030 TP_STRUCT__entry(
2031 __field(unsigned int, call)
2032 __field(unsigned long, user_call_ID)
2033 __field(u32, cid)
2034 __field(u32, call_id)
2035 __field_struct(struct sockaddr_rxrpc, srx)
2036 ),
2037
2038 TP_fast_assign(
2039 __entry->call = call->debug_id;
2040 __entry->user_call_ID = call->user_call_ID;
2041 __entry->cid = call->cid;
2042 __entry->call_id = call->call_id;
2043 __entry->srx = call->dest_srx;
2044 ),
2045
2046 TP_printk("c=%08x u=%p %08x:%08x dst=%pISp",
2047 __entry->call,
2048 (void *)__entry->user_call_ID,
2049 __entry->cid,
2050 __entry->call_id,
2051 &__entry->srx.transport)
2052 );
2053
2054TRACE_EVENT(rxrpc_apply_acks,
2055 TP_PROTO(struct rxrpc_call *call, struct rxrpc_txqueue *tq),
2056
2057 TP_ARGS(call, tq),
2058
2059 TP_STRUCT__entry(
2060 __field(unsigned int, call)
2061 __field(unsigned int, nr_rep)
2062 __field(rxrpc_seq_t, qbase)
2063 __field(unsigned long, acks)
2064 ),
2065
2066 TP_fast_assign(
2067 __entry->call = call->debug_id;
2068 __entry->qbase = tq->qbase;
2069 __entry->acks = tq->segment_acked;
2070 __entry->nr_rep = tq->nr_reported_acks;
2071 ),
2072
2073 TP_printk("c=%08x tq=%x acks=%016lx rep=%u",
2074 __entry->call,
2075 __entry->qbase,
2076 __entry->acks,
2077 __entry->nr_rep)
2078 );
2079
2080TRACE_EVENT(rxrpc_resend,
2081 TP_PROTO(struct rxrpc_call *call, rxrpc_serial_t ack_serial),
2082
2083 TP_ARGS(call, ack_serial),
2084
2085 TP_STRUCT__entry(
2086 __field(unsigned int, call)
2087 __field(rxrpc_seq_t, seq)
2088 __field(rxrpc_seq_t, transmitted)
2089 __field(rxrpc_serial_t, ack_serial)
2090 ),
2091
2092 TP_fast_assign(
2093 __entry->call = call->debug_id;
2094 __entry->seq = call->acks_hard_ack;
2095 __entry->transmitted = call->tx_transmitted;
2096 __entry->ack_serial = ack_serial;
2097 ),
2098
2099 TP_printk("c=%08x r=%x q=%x tq=%x",
2100 __entry->call,
2101 __entry->ack_serial,
2102 __entry->seq,
2103 __entry->transmitted)
2104 );
2105
2106TRACE_EVENT(rxrpc_resend_lost,
2107 TP_PROTO(struct rxrpc_call *call, struct rxrpc_txqueue *tq, unsigned long lost),
2108
2109 TP_ARGS(call, tq, lost),
2110
2111 TP_STRUCT__entry(
2112 __field(unsigned int, call)
2113 __field(rxrpc_seq_t, qbase)
2114 __field(u8, nr_rep)
2115 __field(unsigned long, lost)
2116 ),
2117
2118 TP_fast_assign(
2119 __entry->call = call->debug_id;
2120 __entry->qbase = tq->qbase;
2121 __entry->nr_rep = tq->nr_reported_acks;
2122 __entry->lost = lost;
2123 ),
2124
2125 TP_printk("c=%08x tq=%x lost=%016lx nr=%u",
2126 __entry->call,
2127 __entry->qbase,
2128 __entry->lost,
2129 __entry->nr_rep)
2130 );
2131
2132TRACE_EVENT(rxrpc_rotate,
2133 TP_PROTO(struct rxrpc_call *call, struct rxrpc_txqueue *tq,
2134 struct rxrpc_ack_summary *summary, rxrpc_seq_t seq,
2135 enum rxrpc_rotate_trace trace),
2136
2137 TP_ARGS(call, tq, summary, seq, trace),
2138
2139 TP_STRUCT__entry(
2140 __field(unsigned int, call)
2141 __field(rxrpc_seq_t, qbase)
2142 __field(rxrpc_seq_t, seq)
2143 __field(unsigned int, nr_rep)
2144 __field(enum rxrpc_rotate_trace, trace)
2145 ),
2146
2147 TP_fast_assign(
2148 __entry->call = call->debug_id;
2149 __entry->qbase = tq->qbase;
2150 __entry->seq = seq;
2151 __entry->nr_rep = tq->nr_reported_acks;
2152 __entry->trace = trace;
2153 ),
2154
2155 TP_printk("c=%08x tq=%x q=%x nr=%x %s",
2156 __entry->call,
2157 __entry->qbase,
2158 __entry->seq,
2159 __entry->nr_rep,
2160 __print_symbolic(__entry->trace, rxrpc_rotate_traces))
2161 );
2162
2163TRACE_EVENT(rxrpc_rx_icmp,
2164 TP_PROTO(struct rxrpc_peer *peer, struct sock_extended_err *ee,
2165 struct sockaddr_rxrpc *srx),
2166
2167 TP_ARGS(peer, ee, srx),
2168
2169 TP_STRUCT__entry(
2170 __field(unsigned int, peer)
2171 __field_struct(struct sock_extended_err, ee)
2172 __field_struct(struct sockaddr_rxrpc, srx)
2173 ),
2174
2175 TP_fast_assign(
2176 __entry->peer = peer->debug_id;
2177 memcpy(&__entry->ee, ee, sizeof(__entry->ee));
2178 memcpy(&__entry->srx, srx, sizeof(__entry->srx));
2179 ),
2180
2181 TP_printk("P=%08x o=%u t=%u c=%u i=%u d=%u e=%d %pISp",
2182 __entry->peer,
2183 __entry->ee.ee_origin,
2184 __entry->ee.ee_type,
2185 __entry->ee.ee_code,
2186 __entry->ee.ee_info,
2187 __entry->ee.ee_data,
2188 __entry->ee.ee_errno,
2189 &__entry->srx.transport)
2190 );
2191
2192TRACE_EVENT(rxrpc_tx_fail,
2193 TP_PROTO(unsigned int debug_id, rxrpc_serial_t serial, int ret,
2194 enum rxrpc_tx_point where),
2195
2196 TP_ARGS(debug_id, serial, ret, where),
2197
2198 TP_STRUCT__entry(
2199 __field(unsigned int, debug_id)
2200 __field(rxrpc_serial_t, serial)
2201 __field(int, ret)
2202 __field(enum rxrpc_tx_point, where)
2203 ),
2204
2205 TP_fast_assign(
2206 __entry->debug_id = debug_id;
2207 __entry->serial = serial;
2208 __entry->ret = ret;
2209 __entry->where = where;
2210 ),
2211
2212 TP_printk("c=%08x r=%x ret=%d %s",
2213 __entry->debug_id,
2214 __entry->serial,
2215 __entry->ret,
2216 __print_symbolic(__entry->where, rxrpc_tx_points))
2217 );
2218
2219TRACE_EVENT(rxrpc_call_reset,
2220 TP_PROTO(struct rxrpc_call *call),
2221
2222 TP_ARGS(call),
2223
2224 TP_STRUCT__entry(
2225 __field(unsigned int, debug_id)
2226 __field(u32, cid)
2227 __field(u32, call_id)
2228 __field(rxrpc_serial_t, call_serial)
2229 __field(rxrpc_serial_t, conn_serial)
2230 __field(rxrpc_seq_t, tx_seq)
2231 __field(rxrpc_seq_t, rx_seq)
2232 ),
2233
2234 TP_fast_assign(
2235 __entry->debug_id = call->debug_id;
2236 __entry->cid = call->cid;
2237 __entry->call_id = call->call_id;
2238 __entry->call_serial = call->rx_serial;
2239 __entry->conn_serial = call->conn->hi_serial;
2240 __entry->tx_seq = call->acks_hard_ack;
2241 __entry->rx_seq = call->rx_highest_seq;
2242 ),
2243
2244 TP_printk("c=%08x %08x:%08x r=%08x/%08x tx=%08x rx=%08x",
2245 __entry->debug_id,
2246 __entry->cid, __entry->call_id,
2247 __entry->call_serial, __entry->conn_serial,
2248 __entry->tx_seq, __entry->rx_seq)
2249 );
2250
2251TRACE_EVENT(rxrpc_notify_socket,
2252 TP_PROTO(unsigned int debug_id, rxrpc_serial_t serial),
2253
2254 TP_ARGS(debug_id, serial),
2255
2256 TP_STRUCT__entry(
2257 __field(unsigned int, debug_id)
2258 __field(rxrpc_serial_t, serial)
2259 ),
2260
2261 TP_fast_assign(
2262 __entry->debug_id = debug_id;
2263 __entry->serial = serial;
2264 ),
2265
2266 TP_printk("c=%08x r=%08x",
2267 __entry->debug_id,
2268 __entry->serial)
2269 );
2270
2271TRACE_EVENT(rxrpc_rx_discard_ack,
2272 TP_PROTO(struct rxrpc_call *call, rxrpc_serial_t serial,
2273 rxrpc_seq_t hard_ack, rxrpc_seq_t prev_pkt),
2274
2275 TP_ARGS(call, serial, hard_ack, prev_pkt),
2276
2277 TP_STRUCT__entry(
2278 __field(unsigned int, debug_id)
2279 __field(rxrpc_serial_t, serial)
2280 __field(rxrpc_seq_t, hard_ack)
2281 __field(rxrpc_seq_t, prev_pkt)
2282 __field(rxrpc_seq_t, acks_hard_ack)
2283 __field(rxrpc_seq_t, acks_prev_seq)
2284 ),
2285
2286 TP_fast_assign(
2287 __entry->debug_id = call->debug_id;
2288 __entry->serial = serial;
2289 __entry->hard_ack = hard_ack;
2290 __entry->prev_pkt = prev_pkt;
2291 __entry->acks_hard_ack = call->acks_hard_ack;
2292 __entry->acks_prev_seq = call->acks_prev_seq;
2293 ),
2294
2295 TP_printk("c=%08x r=%08x %08x<%08x %08x<%08x",
2296 __entry->debug_id,
2297 __entry->serial,
2298 __entry->hard_ack,
2299 __entry->acks_hard_ack,
2300 __entry->prev_pkt,
2301 __entry->acks_prev_seq)
2302 );
2303
2304TRACE_EVENT(rxrpc_req_ack,
2305 TP_PROTO(unsigned int call_debug_id, rxrpc_seq_t seq,
2306 enum rxrpc_req_ack_trace why),
2307
2308 TP_ARGS(call_debug_id, seq, why),
2309
2310 TP_STRUCT__entry(
2311 __field(unsigned int, call_debug_id)
2312 __field(rxrpc_seq_t, seq)
2313 __field(enum rxrpc_req_ack_trace, why)
2314 ),
2315
2316 TP_fast_assign(
2317 __entry->call_debug_id = call_debug_id;
2318 __entry->seq = seq;
2319 __entry->why = why;
2320 ),
2321
2322 TP_printk("c=%08x q=%08x REQ-%s",
2323 __entry->call_debug_id,
2324 __entry->seq,
2325 __print_symbolic(__entry->why, rxrpc_req_ack_traces))
2326 );
2327
2328TRACE_EVENT(rxrpc_txbuf,
2329 TP_PROTO(unsigned int debug_id,
2330 unsigned int call_debug_id, rxrpc_seq_t seq,
2331 int ref, enum rxrpc_txbuf_trace what),
2332
2333 TP_ARGS(debug_id, call_debug_id, seq, ref, what),
2334
2335 TP_STRUCT__entry(
2336 __field(unsigned int, debug_id)
2337 __field(unsigned int, call_debug_id)
2338 __field(rxrpc_seq_t, seq)
2339 __field(int, ref)
2340 __field(enum rxrpc_txbuf_trace, what)
2341 ),
2342
2343 TP_fast_assign(
2344 __entry->debug_id = debug_id;
2345 __entry->call_debug_id = call_debug_id;
2346 __entry->seq = seq;
2347 __entry->ref = ref;
2348 __entry->what = what;
2349 ),
2350
2351 TP_printk("B=%08x c=%08x q=%08x %s r=%d",
2352 __entry->debug_id,
2353 __entry->call_debug_id,
2354 __entry->seq,
2355 __print_symbolic(__entry->what, rxrpc_txbuf_traces),
2356 __entry->ref)
2357 );
2358
2359TRACE_EVENT(rxrpc_tq,
2360 TP_PROTO(struct rxrpc_call *call, struct rxrpc_txqueue *tq,
2361 rxrpc_seq_t seq, enum rxrpc_tq_trace trace),
2362
2363 TP_ARGS(call, tq, seq, trace),
2364
2365 TP_STRUCT__entry(
2366 __field(unsigned int, call_debug_id)
2367 __field(rxrpc_seq_t, qbase)
2368 __field(rxrpc_seq_t, seq)
2369 __field(enum rxrpc_tq_trace, trace)
2370 ),
2371
2372 TP_fast_assign(
2373 __entry->call_debug_id = call->debug_id;
2374 __entry->qbase = tq ? tq->qbase : call->tx_qbase;
2375 __entry->seq = seq;
2376 __entry->trace = trace;
2377 ),
2378
2379 TP_printk("c=%08x bq=%08x q=%08x %s",
2380 __entry->call_debug_id,
2381 __entry->qbase,
2382 __entry->seq,
2383 __print_symbolic(__entry->trace, rxrpc_tq_traces))
2384 );
2385
2386TRACE_EVENT(rxrpc_poke_call,
2387 TP_PROTO(struct rxrpc_call *call, bool busy,
2388 enum rxrpc_call_poke_trace what),
2389
2390 TP_ARGS(call, busy, what),
2391
2392 TP_STRUCT__entry(
2393 __field(unsigned int, call_debug_id)
2394 __field(bool, busy)
2395 __field(enum rxrpc_call_poke_trace, what)
2396 ),
2397
2398 TP_fast_assign(
2399 __entry->call_debug_id = call->debug_id;
2400 __entry->busy = busy;
2401 __entry->what = what;
2402 ),
2403
2404 TP_printk("c=%08x %s%s",
2405 __entry->call_debug_id,
2406 __print_symbolic(__entry->what, rxrpc_call_poke_traces),
2407 __entry->busy ? "!" : "")
2408 );
2409
2410TRACE_EVENT(rxrpc_call_poked,
2411 TP_PROTO(struct rxrpc_call *call),
2412
2413 TP_ARGS(call),
2414
2415 TP_STRUCT__entry(
2416 __field(unsigned int, call_debug_id)
2417 ),
2418
2419 TP_fast_assign(
2420 __entry->call_debug_id = call->debug_id;
2421 ),
2422
2423 TP_printk("c=%08x",
2424 __entry->call_debug_id)
2425 );
2426
2427TRACE_EVENT(rxrpc_sack,
2428 TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t seq,
2429 unsigned int sack, enum rxrpc_sack_trace what),
2430
2431 TP_ARGS(call, seq, sack, what),
2432
2433 TP_STRUCT__entry(
2434 __field(unsigned int, call_debug_id)
2435 __field(rxrpc_seq_t, seq)
2436 __field(unsigned int, sack)
2437 __field(enum rxrpc_sack_trace, what)
2438 ),
2439
2440 TP_fast_assign(
2441 __entry->call_debug_id = call->debug_id;
2442 __entry->seq = seq;
2443 __entry->sack = sack;
2444 __entry->what = what;
2445 ),
2446
2447 TP_printk("c=%08x q=%08x %s k=%x",
2448 __entry->call_debug_id,
2449 __entry->seq,
2450 __print_symbolic(__entry->what, rxrpc_sack_traces),
2451 __entry->sack)
2452 );
2453
2454TRACE_EVENT(rxrpc_pmtud_tx,
2455 TP_PROTO(struct rxrpc_call *call),
2456
2457 TP_ARGS(call),
2458
2459 TP_STRUCT__entry(
2460 __field(unsigned int, peer_debug_id)
2461 __field(unsigned int, call_debug_id)
2462 __field(rxrpc_serial_t, ping_serial)
2463 __field(unsigned short, pmtud_trial)
2464 __field(unsigned short, pmtud_good)
2465 __field(unsigned short, pmtud_bad)
2466 ),
2467
2468 TP_fast_assign(
2469 __entry->peer_debug_id = call->peer->debug_id;
2470 __entry->call_debug_id = call->debug_id;
2471 __entry->ping_serial = call->conn->pmtud_probe;
2472 __entry->pmtud_trial = call->peer->pmtud_trial;
2473 __entry->pmtud_good = call->peer->pmtud_good;
2474 __entry->pmtud_bad = call->peer->pmtud_bad;
2475 ),
2476
2477 TP_printk("P=%08x c=%08x pr=%08x %u-%u-%u",
2478 __entry->peer_debug_id,
2479 __entry->call_debug_id,
2480 __entry->ping_serial,
2481 __entry->pmtud_good,
2482 __entry->pmtud_trial,
2483 __entry->pmtud_bad)
2484 );
2485
2486TRACE_EVENT(rxrpc_pmtud_rx,
2487 TP_PROTO(struct rxrpc_connection *conn, rxrpc_serial_t resp_serial),
2488
2489 TP_ARGS(conn, resp_serial),
2490
2491 TP_STRUCT__entry(
2492 __field(unsigned int, peer_debug_id)
2493 __field(unsigned int, call_debug_id)
2494 __field(rxrpc_serial_t, ping_serial)
2495 __field(rxrpc_serial_t, resp_serial)
2496 __field(unsigned short, max_data)
2497 __field(u8, jumbo_max)
2498 ),
2499
2500 TP_fast_assign(
2501 __entry->peer_debug_id = conn->peer->debug_id;
2502 __entry->call_debug_id = conn->pmtud_call;
2503 __entry->ping_serial = conn->pmtud_probe;
2504 __entry->resp_serial = resp_serial;
2505 __entry->max_data = conn->peer->max_data;
2506 __entry->jumbo_max = conn->peer->pmtud_jumbo;
2507 ),
2508
2509 TP_printk("P=%08x c=%08x pr=%08x rr=%08x max=%u jm=%u",
2510 __entry->peer_debug_id,
2511 __entry->call_debug_id,
2512 __entry->ping_serial,
2513 __entry->resp_serial,
2514 __entry->max_data,
2515 __entry->jumbo_max)
2516 );
2517
2518TRACE_EVENT(rxrpc_pmtud_lost,
2519 TP_PROTO(struct rxrpc_connection *conn, rxrpc_serial_t resp_serial),
2520
2521 TP_ARGS(conn, resp_serial),
2522
2523 TP_STRUCT__entry(
2524 __field(unsigned int, peer_debug_id)
2525 __field(unsigned int, call_debug_id)
2526 __field(rxrpc_serial_t, ping_serial)
2527 __field(rxrpc_serial_t, resp_serial)
2528 ),
2529
2530 TP_fast_assign(
2531 __entry->peer_debug_id = conn->peer->debug_id;
2532 __entry->call_debug_id = conn->pmtud_call;
2533 __entry->ping_serial = conn->pmtud_probe;
2534 __entry->resp_serial = resp_serial;
2535 ),
2536
2537 TP_printk("P=%08x c=%08x pr=%08x rr=%08x",
2538 __entry->peer_debug_id,
2539 __entry->call_debug_id,
2540 __entry->ping_serial,
2541 __entry->resp_serial)
2542 );
2543
2544TRACE_EVENT(rxrpc_pmtud_reduce,
2545 TP_PROTO(struct rxrpc_peer *peer, rxrpc_serial_t serial,
2546 unsigned int max_data, enum rxrpc_pmtud_reduce_trace reason),
2547
2548 TP_ARGS(peer, serial, max_data, reason),
2549
2550 TP_STRUCT__entry(
2551 __field(unsigned int, peer_debug_id)
2552 __field(rxrpc_serial_t, serial)
2553 __field(unsigned int, max_data)
2554 __field(enum rxrpc_pmtud_reduce_trace, reason)
2555 ),
2556
2557 TP_fast_assign(
2558 __entry->peer_debug_id = peer->debug_id;
2559 __entry->serial = serial;
2560 __entry->max_data = max_data;
2561 __entry->reason = reason;
2562 ),
2563
2564 TP_printk("P=%08x %s r=%08x m=%u",
2565 __entry->peer_debug_id,
2566 __print_symbolic(__entry->reason, rxrpc_pmtud_reduce_traces),
2567 __entry->serial, __entry->max_data)
2568 );
2569
2570TRACE_EVENT(rxrpc_rack,
2571 TP_PROTO(struct rxrpc_call *call, ktime_t timo),
2572
2573 TP_ARGS(call, timo),
2574
2575 TP_STRUCT__entry(
2576 __field(unsigned int, call)
2577 __field(rxrpc_serial_t, ack_serial)
2578 __field(rxrpc_seq_t, seq)
2579 __field(enum rxrpc_rack_timer_mode, mode)
2580 __field(unsigned short, nr_sent)
2581 __field(unsigned short, nr_lost)
2582 __field(unsigned short, nr_resent)
2583 __field(unsigned short, nr_sacked)
2584 __field(ktime_t, timo)
2585 ),
2586
2587 TP_fast_assign(
2588 __entry->call = call->debug_id;
2589 __entry->ack_serial = call->rx_serial;
2590 __entry->seq = call->rack_end_seq;
2591 __entry->mode = call->rack_timer_mode;
2592 __entry->nr_sent = call->tx_nr_sent;
2593 __entry->nr_lost = call->tx_nr_lost;
2594 __entry->nr_resent = call->tx_nr_resent;
2595 __entry->nr_sacked = call->acks_nr_sacks;
2596 __entry->timo = timo;
2597 ),
2598
2599 TP_printk("c=%08x r=%08x q=%08x %s slrs=%u,%u,%u,%u t=%lld",
2600 __entry->call, __entry->ack_serial, __entry->seq,
2601 __print_symbolic(__entry->mode, rxrpc_rack_timer_modes),
2602 __entry->nr_sent, __entry->nr_lost,
2603 __entry->nr_resent, __entry->nr_sacked,
2604 ktime_to_us(__entry->timo))
2605 );
2606
2607TRACE_EVENT(rxrpc_rack_update,
2608 TP_PROTO(struct rxrpc_call *call, struct rxrpc_ack_summary *summary),
2609
2610 TP_ARGS(call, summary),
2611
2612 TP_STRUCT__entry(
2613 __field(unsigned int, call)
2614 __field(rxrpc_serial_t, ack_serial)
2615 __field(rxrpc_seq_t, seq)
2616 __field(int, xmit_ts)
2617 ),
2618
2619 TP_fast_assign(
2620 __entry->call = call->debug_id;
2621 __entry->ack_serial = call->rx_serial;
2622 __entry->seq = call->rack_end_seq;
2623 __entry->xmit_ts = ktime_sub(call->acks_latest_ts, call->rack_xmit_ts);
2624 ),
2625
2626 TP_printk("c=%08x r=%08x q=%08x xt=%lld",
2627 __entry->call, __entry->ack_serial, __entry->seq,
2628 ktime_to_us(__entry->xmit_ts))
2629 );
2630
2631TRACE_EVENT(rxrpc_rack_scan_loss,
2632 TP_PROTO(struct rxrpc_call *call),
2633
2634 TP_ARGS(call),
2635
2636 TP_STRUCT__entry(
2637 __field(unsigned int, call)
2638 __field(ktime_t, rack_rtt)
2639 __field(ktime_t, rack_reo_wnd)
2640 ),
2641
2642 TP_fast_assign(
2643 __entry->call = call->debug_id;
2644 __entry->rack_rtt = call->rack_rtt;
2645 __entry->rack_reo_wnd = call->rack_reo_wnd;
2646 ),
2647
2648 TP_printk("c=%08x rtt=%lld reow=%lld",
2649 __entry->call, ktime_to_us(__entry->rack_rtt),
2650 ktime_to_us(__entry->rack_reo_wnd))
2651 );
2652
2653TRACE_EVENT(rxrpc_rack_scan_loss_tq,
2654 TP_PROTO(struct rxrpc_call *call, const struct rxrpc_txqueue *tq,
2655 unsigned long nacks),
2656
2657 TP_ARGS(call, tq, nacks),
2658
2659 TP_STRUCT__entry(
2660 __field(unsigned int, call)
2661 __field(rxrpc_seq_t, qbase)
2662 __field(unsigned long, nacks)
2663 __field(unsigned long, lost)
2664 __field(unsigned long, retrans)
2665 ),
2666
2667 TP_fast_assign(
2668 __entry->call = call->debug_id;
2669 __entry->qbase = tq->qbase;
2670 __entry->nacks = nacks;
2671 __entry->lost = tq->segment_lost;
2672 __entry->retrans = tq->segment_retransmitted;
2673 ),
2674
2675 TP_printk("c=%08x q=%08x n=%lx l=%lx r=%lx",
2676 __entry->call, __entry->qbase,
2677 __entry->nacks, __entry->lost, __entry->retrans)
2678 );
2679
2680TRACE_EVENT(rxrpc_rack_detect_loss,
2681 TP_PROTO(struct rxrpc_call *call, struct rxrpc_ack_summary *summary,
2682 rxrpc_seq_t seq),
2683
2684 TP_ARGS(call, summary, seq),
2685
2686 TP_STRUCT__entry(
2687 __field(unsigned int, call)
2688 __field(rxrpc_serial_t, ack_serial)
2689 __field(rxrpc_seq_t, seq)
2690 ),
2691
2692 TP_fast_assign(
2693 __entry->call = call->debug_id;
2694 __entry->ack_serial = call->rx_serial;
2695 __entry->seq = seq;
2696 ),
2697
2698 TP_printk("c=%08x r=%08x q=%08x",
2699 __entry->call, __entry->ack_serial, __entry->seq)
2700 );
2701
2702TRACE_EVENT(rxrpc_rack_mark_loss_tq,
2703 TP_PROTO(struct rxrpc_call *call, const struct rxrpc_txqueue *tq),
2704
2705 TP_ARGS(call, tq),
2706
2707 TP_STRUCT__entry(
2708 __field(unsigned int, call)
2709 __field(rxrpc_seq_t, qbase)
2710 __field(rxrpc_seq_t, trans)
2711 __field(unsigned long, acked)
2712 __field(unsigned long, lost)
2713 __field(unsigned long, retrans)
2714 ),
2715
2716 TP_fast_assign(
2717 __entry->call = call->debug_id;
2718 __entry->qbase = tq->qbase;
2719 __entry->trans = call->tx_transmitted;
2720 __entry->acked = tq->segment_acked;
2721 __entry->lost = tq->segment_lost;
2722 __entry->retrans = tq->segment_retransmitted;
2723 ),
2724
2725 TP_printk("c=%08x tq=%08x txq=%08x a=%lx l=%lx r=%lx",
2726 __entry->call, __entry->qbase, __entry->trans,
2727 __entry->acked, __entry->lost, __entry->retrans)
2728 );
2729
2730TRACE_EVENT(rxrpc_tlp_probe,
2731 TP_PROTO(struct rxrpc_call *call, enum rxrpc_tlp_probe_trace trace),
2732
2733 TP_ARGS(call, trace),
2734
2735 TP_STRUCT__entry(
2736 __field(unsigned int, call)
2737 __field(rxrpc_serial_t, serial)
2738 __field(rxrpc_seq_t, seq)
2739 __field(enum rxrpc_tlp_probe_trace, trace)
2740 ),
2741
2742 TP_fast_assign(
2743 __entry->call = call->debug_id;
2744 __entry->serial = call->tlp_serial;
2745 __entry->seq = call->tlp_seq;
2746 __entry->trace = trace;
2747 ),
2748
2749 TP_printk("c=%08x r=%08x pq=%08x %s",
2750 __entry->call, __entry->serial, __entry->seq,
2751 __print_symbolic(__entry->trace, rxrpc_tlp_probe_traces))
2752 );
2753
2754TRACE_EVENT(rxrpc_tlp_ack,
2755 TP_PROTO(struct rxrpc_call *call, struct rxrpc_ack_summary *summary,
2756 enum rxrpc_tlp_ack_trace trace),
2757
2758 TP_ARGS(call, summary, trace),
2759
2760 TP_STRUCT__entry(
2761 __field(unsigned int, call)
2762 __field(rxrpc_serial_t, serial)
2763 __field(rxrpc_seq_t, tlp_seq)
2764 __field(rxrpc_seq_t, hard_ack)
2765 __field(enum rxrpc_tlp_ack_trace, trace)
2766 ),
2767
2768 TP_fast_assign(
2769 __entry->call = call->debug_id;
2770 __entry->serial = call->tlp_serial;
2771 __entry->tlp_seq = call->tlp_seq;
2772 __entry->hard_ack = call->acks_hard_ack;
2773 __entry->trace = trace;
2774 ),
2775
2776 TP_printk("c=%08x r=%08x pq=%08x hq=%08x %s",
2777 __entry->call, __entry->serial,
2778 __entry->tlp_seq, __entry->hard_ack,
2779 __print_symbolic(__entry->trace, rxrpc_tlp_ack_traces))
2780 );
2781
2782TRACE_EVENT(rxrpc_rack_timer,
2783 TP_PROTO(struct rxrpc_call *call, ktime_t delay, bool exp),
2784
2785 TP_ARGS(call, delay, exp),
2786
2787 TP_STRUCT__entry(
2788 __field(unsigned int, call)
2789 __field(bool, exp)
2790 __field(enum rxrpc_rack_timer_mode, mode)
2791 __field(ktime_t, delay)
2792 ),
2793
2794 TP_fast_assign(
2795 __entry->call = call->debug_id;
2796 __entry->exp = exp;
2797 __entry->mode = call->rack_timer_mode;
2798 __entry->delay = delay;
2799 ),
2800
2801 TP_printk("c=%08x %s %s to=%lld",
2802 __entry->call,
2803 __entry->exp ? "Exp" : "Set",
2804 __print_symbolic(__entry->mode, rxrpc_rack_timer_modes),
2805 ktime_to_us(__entry->delay))
2806 );
2807
2808TRACE_EVENT(rxrpc_rxgk_rekey,
2809 TP_PROTO(struct rxrpc_connection *conn,
2810 unsigned int current_key, unsigned int requested_key),
2811
2812 TP_ARGS(conn, current_key, requested_key),
2813
2814 TP_STRUCT__entry(
2815 __field(unsigned int, conn)
2816 __field(unsigned int, current_key)
2817 __field(unsigned int, requested_key)
2818 ),
2819
2820 TP_fast_assign(
2821 __entry->conn = conn->debug_id;
2822 __entry->current_key = current_key;
2823 __entry->requested_key = requested_key;
2824 ),
2825
2826 TP_printk("C=%08x cur=%x req=%x",
2827 __entry->conn,
2828 __entry->current_key,
2829 __entry->requested_key)
2830 );
2831
2832#undef EM
2833#undef E_
2834
2835#endif /* RXRPC_TRACE_ONLY_DEFINE_ENUMS */
2836#endif /* _TRACE_RXRPC_H */
2837
2838/* This part must be outside protection */
2839#include <trace/define_trace.h>