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