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