xref: /linux/include/trace/events/afs.h (revision 357660d7596bd40d1004762739e426b1fbe10a14)
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /* AFS 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 afs
9 
10 #if !defined(_TRACE_AFS_H) || defined(TRACE_HEADER_MULTI_READ)
11 #define _TRACE_AFS_H
12 
13 #include <linux/tracepoint.h>
14 
15 /*
16  * Define enums for tracing information.
17  */
18 #ifndef __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
19 #define __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
20 
21 enum afs_fs_operation {
22 	afs_FS_FetchData		= 130,	/* AFS Fetch file data */
23 	afs_FS_FetchACL			= 131,	/* AFS Fetch file ACL */
24 	afs_FS_FetchStatus		= 132,	/* AFS Fetch file status */
25 	afs_FS_StoreData		= 133,	/* AFS Store file data */
26 	afs_FS_StoreACL			= 134,	/* AFS Store file ACL */
27 	afs_FS_StoreStatus		= 135,	/* AFS Store file status */
28 	afs_FS_RemoveFile		= 136,	/* AFS Remove a file */
29 	afs_FS_CreateFile		= 137,	/* AFS Create a file */
30 	afs_FS_Rename			= 138,	/* AFS Rename or move a file or directory */
31 	afs_FS_Symlink			= 139,	/* AFS Create a symbolic link */
32 	afs_FS_Link			= 140,	/* AFS Create a hard link */
33 	afs_FS_MakeDir			= 141,	/* AFS Create a directory */
34 	afs_FS_RemoveDir		= 142,	/* AFS Remove a directory */
35 	afs_FS_GetVolumeInfo		= 148,	/* AFS Get information about a volume */
36 	afs_FS_GetVolumeStatus		= 149,	/* AFS Get volume status information */
37 	afs_FS_GetRootVolume		= 151,	/* AFS Get root volume name */
38 	afs_FS_SetLock			= 156,	/* AFS Request a file lock */
39 	afs_FS_ExtendLock		= 157,	/* AFS Extend a file lock */
40 	afs_FS_ReleaseLock		= 158,	/* AFS Release a file lock */
41 	afs_FS_Lookup			= 161,	/* AFS lookup file in directory */
42 	afs_FS_InlineBulkStatus		= 65536, /* AFS Fetch multiple file statuses with errors */
43 	afs_FS_FetchData64		= 65537, /* AFS Fetch file data */
44 	afs_FS_StoreData64		= 65538, /* AFS Store file data */
45 	afs_FS_GiveUpAllCallBacks	= 65539, /* AFS Give up all our callbacks on a server */
46 	afs_FS_GetCapabilities		= 65540, /* AFS Get FS server capabilities */
47 
48 	yfs_FS_FetchData		= 130,	 /* YFS Fetch file data */
49 	yfs_FS_FetchACL			= 64131, /* YFS Fetch file ACL */
50 	yfs_FS_FetchStatus		= 64132, /* YFS Fetch file status */
51 	yfs_FS_StoreACL			= 64134, /* YFS Store file ACL */
52 	yfs_FS_StoreStatus		= 64135, /* YFS Store file status */
53 	yfs_FS_RemoveFile		= 64136, /* YFS Remove a file */
54 	yfs_FS_CreateFile		= 64137, /* YFS Create a file */
55 	yfs_FS_Rename			= 64138, /* YFS Rename or move a file or directory */
56 	yfs_FS_Symlink			= 64139, /* YFS Create a symbolic link */
57 	yfs_FS_Link			= 64140, /* YFS Create a hard link */
58 	yfs_FS_MakeDir			= 64141, /* YFS Create a directory */
59 	yfs_FS_RemoveDir		= 64142, /* YFS Remove a directory */
60 	yfs_FS_GetVolumeStatus		= 64149, /* YFS Get volume status information */
61 	yfs_FS_SetVolumeStatus		= 64150, /* YFS Set volume status information */
62 	yfs_FS_SetLock			= 64156, /* YFS Request a file lock */
63 	yfs_FS_ExtendLock		= 64157, /* YFS Extend a file lock */
64 	yfs_FS_ReleaseLock		= 64158, /* YFS Release a file lock */
65 	yfs_FS_Lookup			= 64161, /* YFS lookup file in directory */
66 	yfs_FS_FlushCPS			= 64165,
67 	yfs_FS_FetchOpaqueACL		= 64168,
68 	yfs_FS_WhoAmI			= 64170,
69 	yfs_FS_RemoveACL		= 64171,
70 	yfs_FS_RemoveFile2		= 64173,
71 	yfs_FS_StoreOpaqueACL2		= 64174,
72 	yfs_FS_InlineBulkStatus		= 64536, /* YFS Fetch multiple file statuses with errors */
73 	yfs_FS_FetchData64		= 64537, /* YFS Fetch file data */
74 	yfs_FS_StoreData64		= 64538, /* YFS Store file data */
75 	yfs_FS_UpdateSymlink		= 64540,
76 };
77 
78 enum afs_vl_operation {
79 	afs_VL_GetEntryByNameU	= 527,		/* AFS Get Vol Entry By Name operation ID */
80 	afs_VL_GetAddrsU	= 533,		/* AFS Get FS server addresses */
81 	afs_YFSVL_GetEndpoints	= 64002,	/* YFS Get FS & Vol server addresses */
82 	afs_YFSVL_GetCellName	= 64014,	/* YFS Get actual cell name */
83 	afs_VL_GetCapabilities	= 65537,	/* AFS Get VL server capabilities */
84 };
85 
86 enum afs_cm_operation {
87 	afs_CB_CallBack			= 204,	/* AFS break callback promises */
88 	afs_CB_InitCallBackState	= 205,	/* AFS initialise callback state */
89 	afs_CB_Probe			= 206,	/* AFS probe client */
90 	afs_CB_GetLock			= 207,	/* AFS get contents of CM lock table */
91 	afs_CB_GetCE			= 208,	/* AFS get cache file description */
92 	afs_CB_GetXStatsVersion		= 209,	/* AFS get version of extended statistics */
93 	afs_CB_GetXStats		= 210,	/* AFS get contents of extended statistics data */
94 	afs_CB_InitCallBackState3	= 213,	/* AFS initialise callback state, version 3 */
95 	afs_CB_ProbeUuid		= 214,	/* AFS check the client hasn't rebooted */
96 };
97 
98 enum yfs_cm_operation {
99 	yfs_CB_Probe			= 206,	/* YFS probe client */
100 	yfs_CB_GetLock			= 207,	/* YFS get contents of CM lock table */
101 	yfs_CB_XStatsVersion		= 209,	/* YFS get version of extended statistics */
102 	yfs_CB_GetXStats		= 210,	/* YFS get contents of extended statistics data */
103 	yfs_CB_InitCallBackState3	= 213,	/* YFS initialise callback state, version 3 */
104 	yfs_CB_ProbeUuid		= 214,	/* YFS check the client hasn't rebooted */
105 	yfs_CB_GetServerPrefs		= 215,
106 	yfs_CB_GetCellServDV		= 216,
107 	yfs_CB_GetLocalCell		= 217,
108 	yfs_CB_GetCacheConfig		= 218,
109 	yfs_CB_GetCellByNum		= 65537,
110 	yfs_CB_TellMeAboutYourself	= 65538, /* get client capabilities */
111 	yfs_CB_CallBack			= 64204,
112 };
113 
114 #endif /* end __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY */
115 
116 /*
117  * Declare tracing information enums and their string mappings for display.
118  */
119 #define afs_call_traces \
120 	EM(afs_call_trace_alloc,		"ALLOC") \
121 	EM(afs_call_trace_async_abort,		"ASYAB") \
122 	EM(afs_call_trace_async_kill,		"ASYKL") \
123 	EM(afs_call_trace_free,			"FREE ") \
124 	EM(afs_call_trace_get,			"GET  ") \
125 	EM(afs_call_trace_put,			"PUT  ") \
126 	EM(afs_call_trace_wake,			"WAKE ") \
127 	E_(afs_call_trace_work,			"QUEUE")
128 
129 #define afs_server_traces \
130 	EM(afs_server_trace_callback,		"CALLBACK ") \
131 	EM(afs_server_trace_destroy,		"DESTROY  ") \
132 	EM(afs_server_trace_free,		"FREE     ") \
133 	EM(afs_server_trace_gc,			"GC       ") \
134 	EM(afs_server_trace_get_probe,		"GET probe") \
135 	EM(afs_server_trace_purging,		"PURGE    ") \
136 	EM(afs_server_trace_put_cbi,		"PUT cbi  ") \
137 	EM(afs_server_trace_put_probe,		"PUT probe") \
138 	EM(afs_server_trace_see_destroyer,	"SEE destr") \
139 	EM(afs_server_trace_see_expired,	"SEE expd ") \
140 	EM(afs_server_trace_see_purge,		"SEE purge") \
141 	EM(afs_server_trace_see_timer,		"SEE timer") \
142 	EM(afs_server_trace_unuse_call,		"UNU call ") \
143 	EM(afs_server_trace_unuse_create_fail,	"UNU cfail") \
144 	EM(afs_server_trace_unuse_slist,	"UNU slist") \
145 	EM(afs_server_trace_unuse_slist_isort,	"UNU isort") \
146 	EM(afs_server_trace_update,		"UPDATE   ") \
147 	EM(afs_server_trace_use_by_uuid,	"USE uuid ") \
148 	EM(afs_server_trace_use_cm_call,	"USE cm-cl") \
149 	EM(afs_server_trace_use_get_caps,	"USE gcaps") \
150 	EM(afs_server_trace_use_give_up_cb,	"USE gvupc") \
151 	EM(afs_server_trace_use_install,	"USE inst ") \
152 	E_(afs_server_trace_wait_create,	"WAIT crt ")
153 
154 #define afs_volume_traces \
155 	EM(afs_volume_trace_alloc,		"ALLOC         ") \
156 	EM(afs_volume_trace_free,		"FREE          ") \
157 	EM(afs_volume_trace_get_alloc_sbi,	"GET sbi-alloc ") \
158 	EM(afs_volume_trace_get_callback,	"GET callback  ") \
159 	EM(afs_volume_trace_get_cell_insert,	"GET cell-insrt") \
160 	EM(afs_volume_trace_get_new_op,		"GET op-new    ") \
161 	EM(afs_volume_trace_get_query_alias,	"GET cell-alias") \
162 	EM(afs_volume_trace_put_callback,	"PUT callback  ") \
163 	EM(afs_volume_trace_put_cell_dup,	"PUT cell-dup  ") \
164 	EM(afs_volume_trace_put_cell_root,	"PUT cell-root ") \
165 	EM(afs_volume_trace_put_destroy_sbi,	"PUT sbi-destry") \
166 	EM(afs_volume_trace_put_free_fc,	"PUT fc-free   ") \
167 	EM(afs_volume_trace_put_put_op,		"PUT op-put    ") \
168 	EM(afs_volume_trace_put_query_alias,	"PUT cell-alias") \
169 	EM(afs_volume_trace_put_validate_fc,	"PUT fc-validat") \
170 	E_(afs_volume_trace_remove,		"REMOVE        ")
171 
172 #define afs_cell_traces \
173 	EM(afs_cell_trace_alloc,		"ALLOC     ") \
174 	EM(afs_cell_trace_destroy,		"DESTROY   ") \
175 	EM(afs_cell_trace_free,			"FREE      ") \
176 	EM(afs_cell_trace_get_atcell,		"GET atcell") \
177 	EM(afs_cell_trace_get_server,		"GET server") \
178 	EM(afs_cell_trace_get_vol,		"GET vol   ") \
179 	EM(afs_cell_trace_purge,		"PURGE     ") \
180 	EM(afs_cell_trace_put_atcell,		"PUT atcell") \
181 	EM(afs_cell_trace_put_candidate,	"PUT candid") \
182 	EM(afs_cell_trace_put_final,		"PUT final ") \
183 	EM(afs_cell_trace_put_server,		"PUT server") \
184 	EM(afs_cell_trace_put_vol,		"PUT vol   ") \
185 	EM(afs_cell_trace_queue_again,		"QUE again ") \
186 	EM(afs_cell_trace_queue_dns,		"QUE dns   ") \
187 	EM(afs_cell_trace_queue_new,		"QUE new   ") \
188 	EM(afs_cell_trace_queue_purge,		"QUE purge ") \
189 	EM(afs_cell_trace_manage,		"MANAGE    ") \
190 	EM(afs_cell_trace_managed,		"MANAGED   ") \
191 	EM(afs_cell_trace_see_source,		"SEE source") \
192 	EM(afs_cell_trace_see_mgmt_timer,	"SEE mtimer") \
193 	EM(afs_cell_trace_unuse_alias,		"UNU alias ") \
194 	EM(afs_cell_trace_unuse_check_alias,	"UNU chk-al") \
195 	EM(afs_cell_trace_unuse_delete,		"UNU delete") \
196 	EM(afs_cell_trace_unuse_dynroot_mntpt,	"UNU dyn-mp") \
197 	EM(afs_cell_trace_unuse_fc,		"UNU fc    ") \
198 	EM(afs_cell_trace_unuse_lookup_dynroot,	"UNU lu-dyn") \
199 	EM(afs_cell_trace_unuse_lookup_error,	"UNU lu-err") \
200 	EM(afs_cell_trace_unuse_mntpt,		"UNU mntpt ") \
201 	EM(afs_cell_trace_unuse_no_pin,		"UNU no-pin") \
202 	EM(afs_cell_trace_unuse_parse,		"UNU parse ") \
203 	EM(afs_cell_trace_unuse_pin,		"UNU pin   ") \
204 	EM(afs_cell_trace_unuse_sbi,		"UNU sbi   ") \
205 	EM(afs_cell_trace_unuse_ws,		"UNU ws    ") \
206 	EM(afs_cell_trace_use_alias,		"USE alias ") \
207 	EM(afs_cell_trace_use_check_alias,	"USE chk-al") \
208 	EM(afs_cell_trace_use_fc,		"USE fc    ") \
209 	EM(afs_cell_trace_use_fc_alias,		"USE fc-al ") \
210 	EM(afs_cell_trace_use_lookup_add,	"USE lu-add") \
211 	EM(afs_cell_trace_use_lookup_canonical,	"USE lu-can") \
212 	EM(afs_cell_trace_use_lookup_dynroot,	"USE lu-dyn") \
213 	EM(afs_cell_trace_use_lookup_mntpt,	"USE lu-mpt") \
214 	EM(afs_cell_trace_use_lookup_mount,	"USE lu-mnt") \
215 	EM(afs_cell_trace_use_lookup_ws,	"USE lu-ws ") \
216 	EM(afs_cell_trace_use_mntpt,		"USE mntpt ") \
217 	EM(afs_cell_trace_use_pin,		"USE pin   ") \
218 	EM(afs_cell_trace_use_probe,		"USE probe ") \
219 	EM(afs_cell_trace_use_sbi,		"USE sbi   ") \
220 	E_(afs_cell_trace_wait,			"WAIT      ")
221 
222 #define afs_alist_traces \
223 	EM(afs_alist_trace_alloc,		"ALLOC     ") \
224 	EM(afs_alist_trace_get_estate,		"GET estate") \
225 	EM(afs_alist_trace_get_vlgetcaps,	"GET vgtcap") \
226 	EM(afs_alist_trace_get_vlprobe,		"GET vprobe") \
227 	EM(afs_alist_trace_get_vlrotate_set,	"GET vl-rot") \
228 	EM(afs_alist_trace_put_estate,		"PUT estate") \
229 	EM(afs_alist_trace_put_getaddru,	"PUT GtAdrU") \
230 	EM(afs_alist_trace_put_parse_empty,	"PUT p-empt") \
231 	EM(afs_alist_trace_put_parse_error,	"PUT p-err ") \
232 	EM(afs_alist_trace_put_server_create,	"PUT sv-crt") \
233 	EM(afs_alist_trace_put_server_oom,	"PUT sv-oom") \
234 	EM(afs_alist_trace_put_server_update,	"PUT sv-upd") \
235 	EM(afs_alist_trace_put_vlgetcaps,	"PUT vgtcap") \
236 	EM(afs_alist_trace_put_vlprobe,		"PUT vprobe") \
237 	EM(afs_alist_trace_put_vlrotate_end,	"PUT vr-end") \
238 	EM(afs_alist_trace_put_vlrotate_fail,	"PUT vr-fai") \
239 	EM(afs_alist_trace_put_vlrotate_next,	"PUT vr-nxt") \
240 	EM(afs_alist_trace_put_vlrotate_restart,"PUT vr-rst") \
241 	EM(afs_alist_trace_put_vlserver,	"PUT vlsrvr") \
242 	EM(afs_alist_trace_put_vlserver_old,	"PUT vs-old") \
243 	E_(afs_alist_trace_free,		"FREE      ")
244 
245 #define afs_estate_traces \
246 	EM(afs_estate_trace_alloc_probe,	"ALLOC prob") \
247 	EM(afs_estate_trace_alloc_server,	"ALLOC srvr") \
248 	EM(afs_estate_trace_get_server_state,	"GET srv-st") \
249 	EM(afs_estate_trace_get_getcaps,	"GET getcap") \
250 	EM(afs_estate_trace_put_getcaps,	"PUT getcap") \
251 	EM(afs_estate_trace_put_probe,		"PUT probe ") \
252 	EM(afs_estate_trace_put_server,		"PUT server") \
253 	EM(afs_estate_trace_put_server_state,	"PUT srv-st") \
254 	E_(afs_estate_trace_free,		"FREE      ")
255 
256 #define afs_fs_operations \
257 	EM(afs_FS_FetchData,			"FS.FetchData") \
258 	EM(afs_FS_FetchStatus,			"FS.FetchStatus") \
259 	EM(afs_FS_StoreData,			"FS.StoreData") \
260 	EM(afs_FS_StoreStatus,			"FS.StoreStatus") \
261 	EM(afs_FS_RemoveFile,			"FS.RemoveFile") \
262 	EM(afs_FS_CreateFile,			"FS.CreateFile") \
263 	EM(afs_FS_Rename,			"FS.Rename") \
264 	EM(afs_FS_Symlink,			"FS.Symlink") \
265 	EM(afs_FS_Link,				"FS.Link") \
266 	EM(afs_FS_MakeDir,			"FS.MakeDir") \
267 	EM(afs_FS_RemoveDir,			"FS.RemoveDir") \
268 	EM(afs_FS_GetVolumeInfo,		"FS.GetVolumeInfo") \
269 	EM(afs_FS_GetVolumeStatus,		"FS.GetVolumeStatus") \
270 	EM(afs_FS_GetRootVolume,		"FS.GetRootVolume") \
271 	EM(afs_FS_SetLock,			"FS.SetLock") \
272 	EM(afs_FS_ExtendLock,			"FS.ExtendLock") \
273 	EM(afs_FS_ReleaseLock,			"FS.ReleaseLock") \
274 	EM(afs_FS_Lookup,			"FS.Lookup") \
275 	EM(afs_FS_InlineBulkStatus,		"FS.InlineBulkStatus") \
276 	EM(afs_FS_FetchData64,			"FS.FetchData64") \
277 	EM(afs_FS_StoreData64,			"FS.StoreData64") \
278 	EM(afs_FS_GiveUpAllCallBacks,		"FS.GiveUpAllCallBacks") \
279 	EM(afs_FS_GetCapabilities,		"FS.GetCapabilities") \
280 	EM(yfs_FS_FetchACL,			"YFS.FetchACL") \
281 	EM(yfs_FS_FetchStatus,			"YFS.FetchStatus") \
282 	EM(yfs_FS_StoreACL,			"YFS.StoreACL") \
283 	EM(yfs_FS_StoreStatus,			"YFS.StoreStatus") \
284 	EM(yfs_FS_RemoveFile,			"YFS.RemoveFile") \
285 	EM(yfs_FS_CreateFile,			"YFS.CreateFile") \
286 	EM(yfs_FS_Rename,			"YFS.Rename") \
287 	EM(yfs_FS_Symlink,			"YFS.Symlink") \
288 	EM(yfs_FS_Link,				"YFS.Link") \
289 	EM(yfs_FS_MakeDir,			"YFS.MakeDir") \
290 	EM(yfs_FS_RemoveDir,			"YFS.RemoveDir") \
291 	EM(yfs_FS_GetVolumeStatus,		"YFS.GetVolumeStatus") \
292 	EM(yfs_FS_SetVolumeStatus,		"YFS.SetVolumeStatus") \
293 	EM(yfs_FS_SetLock,			"YFS.SetLock") \
294 	EM(yfs_FS_ExtendLock,			"YFS.ExtendLock") \
295 	EM(yfs_FS_ReleaseLock,			"YFS.ReleaseLock") \
296 	EM(yfs_FS_Lookup,			"YFS.Lookup") \
297 	EM(yfs_FS_FlushCPS,			"YFS.FlushCPS") \
298 	EM(yfs_FS_FetchOpaqueACL,		"YFS.FetchOpaqueACL") \
299 	EM(yfs_FS_WhoAmI,			"YFS.WhoAmI") \
300 	EM(yfs_FS_RemoveACL,			"YFS.RemoveACL") \
301 	EM(yfs_FS_RemoveFile2,			"YFS.RemoveFile2") \
302 	EM(yfs_FS_StoreOpaqueACL2,		"YFS.StoreOpaqueACL2") \
303 	EM(yfs_FS_InlineBulkStatus,		"YFS.InlineBulkStatus") \
304 	EM(yfs_FS_FetchData64,			"YFS.FetchData64") \
305 	EM(yfs_FS_StoreData64,			"YFS.StoreData64") \
306 	E_(yfs_FS_UpdateSymlink,		"YFS.UpdateSymlink")
307 
308 #define afs_vl_operations \
309 	EM(afs_VL_GetEntryByNameU,		"VL.GetEntryByNameU") \
310 	EM(afs_VL_GetAddrsU,			"VL.GetAddrsU") \
311 	EM(afs_YFSVL_GetEndpoints,		"YFSVL.GetEndpoints") \
312 	EM(afs_YFSVL_GetCellName,		"YFSVL.GetCellName") \
313 	E_(afs_VL_GetCapabilities,		"VL.GetCapabilities")
314 
315 #define afs_cm_operations \
316 	EM(afs_CB_CallBack,			"CB.CallBack") \
317 	EM(afs_CB_InitCallBackState,		"CB.InitCallBackState") \
318 	EM(afs_CB_Probe,			"CB.Probe") \
319 	EM(afs_CB_GetLock,			"CB.GetLock") \
320 	EM(afs_CB_GetCE,			"CB.GetCE") \
321 	EM(afs_CB_GetXStatsVersion,		"CB.GetXStatsVersion") \
322 	EM(afs_CB_GetXStats,			"CB.GetXStats") \
323 	EM(afs_CB_InitCallBackState3,		"CB.InitCallBackState3") \
324 	E_(afs_CB_ProbeUuid,			"CB.ProbeUuid")
325 
326 #define yfs_cm_operations \
327 	EM(yfs_CB_Probe,			"YFSCB.Probe") \
328 	EM(yfs_CB_GetLock,			"YFSCB.GetLock") \
329 	EM(yfs_CB_XStatsVersion,		"YFSCB.XStatsVersion") \
330 	EM(yfs_CB_GetXStats,			"YFSCB.GetXStats") \
331 	EM(yfs_CB_InitCallBackState3,		"YFSCB.InitCallBackState3") \
332 	EM(yfs_CB_ProbeUuid,			"YFSCB.ProbeUuid") \
333 	EM(yfs_CB_GetServerPrefs,		"YFSCB.GetServerPrefs") \
334 	EM(yfs_CB_GetCellServDV,		"YFSCB.GetCellServDV") \
335 	EM(yfs_CB_GetLocalCell,			"YFSCB.GetLocalCell") \
336 	EM(yfs_CB_GetCacheConfig,		"YFSCB.GetCacheConfig") \
337 	EM(yfs_CB_GetCellByNum,			"YFSCB.GetCellByNum") \
338 	EM(yfs_CB_TellMeAboutYourself,		"YFSCB.TellMeAboutYourself") \
339 	E_(yfs_CB_CallBack,			"YFSCB.CallBack")
340 
341 #define afs_cb_promise_traces \
342 	EM(afs_cb_promise_clear_cb_break,	"CLEAR cb-break") \
343 	EM(afs_cb_promise_clear_rmdir,		"CLEAR rmdir") \
344 	EM(afs_cb_promise_clear_rotate_server,	"CLEAR rot-srv") \
345 	EM(afs_cb_promise_clear_server_change,	"CLEAR srv-chg") \
346 	EM(afs_cb_promise_clear_vol_init_cb,	"CLEAR vol-init-cb") \
347 	EM(afs_cb_promise_set_apply_cb,		"SET apply-cb") \
348 	EM(afs_cb_promise_set_new_inode,	"SET new-inode") \
349 	E_(afs_cb_promise_set_new_symlink,	"SET new-symlink")
350 
351 #define afs_vnode_invalid_traces \
352 	EM(afs_vnode_invalid_trace_cb_ro_snapshot, "cb-ro-snapshot") \
353 	EM(afs_vnode_invalid_trace_cb_scrub,	"cb-scrub") \
354 	EM(afs_vnode_invalid_trace_cb_v_break,	"cb-v-break") \
355 	EM(afs_vnode_invalid_trace_expired,	"expired") \
356 	EM(afs_vnode_invalid_trace_no_cb_promise, "no-cb-promise") \
357 	EM(afs_vnode_invalid_trace_vol_expired,	"vol-expired") \
358 	EM(afs_vnode_invalid_trace_zap_data,	"zap-data") \
359 	E_(afs_vnode_valid_trace,		"valid")
360 
361 #define afs_dir_invalid_traces			\
362 	EM(afs_dir_invalid_edit_add_bad_size,	"edit-add-bad-size") \
363 	EM(afs_dir_invalid_edit_add_no_slots,	"edit-add-no-slots") \
364 	EM(afs_dir_invalid_edit_add_too_many_blocks, "edit-add-too-many-blocks") \
365 	EM(afs_dir_invalid_edit_get_block,	"edit-get-block") \
366 	EM(afs_dir_invalid_edit_mkdir,		"edit-mkdir") \
367 	EM(afs_dir_invalid_edit_rem_bad_size,	"edit-rem-bad-size") \
368 	EM(afs_dir_invalid_edit_rem_wrong_name,	"edit-rem-wrong_name") \
369 	EM(afs_dir_invalid_edit_upd_bad_size,	"edit-upd-bad-size") \
370 	EM(afs_dir_invalid_edit_upd_no_dd,	"edit-upd-no-dotdot") \
371 	EM(afs_dir_invalid_dv_mismatch,		"dv-mismatch") \
372 	EM(afs_dir_invalid_inval_folio,		"inv-folio") \
373 	EM(afs_dir_invalid_iter_stale,		"iter-stale") \
374 	EM(afs_dir_invalid_reclaimed_folio,	"reclaimed-folio") \
375 	EM(afs_dir_invalid_release_folio,	"rel-folio") \
376 	EM(afs_dir_invalid_remote,		"remote") \
377 	E_(afs_dir_invalid_subdir_removed,	"subdir-removed")
378 
379 #define afs_edit_dir_ops				  \
380 	EM(afs_edit_dir_create,			"create") \
381 	EM(afs_edit_dir_create_error,		"c_fail") \
382 	EM(afs_edit_dir_create_inval,		"c_invl") \
383 	EM(afs_edit_dir_create_nospc,		"c_nspc") \
384 	EM(afs_edit_dir_delete,			"delete") \
385 	EM(afs_edit_dir_delete_error,		"d_err ") \
386 	EM(afs_edit_dir_delete_inval,		"d_invl") \
387 	EM(afs_edit_dir_delete_noent,		"d_nent") \
388 	EM(afs_edit_dir_mkdir,			"mk_ent") \
389 	EM(afs_edit_dir_update_dd,		"u_ddot") \
390 	EM(afs_edit_dir_update_error,		"u_fail") \
391 	EM(afs_edit_dir_update_inval,		"u_invl") \
392 	E_(afs_edit_dir_update_nodd,		"u_nodd")
393 
394 #define afs_edit_dir_reasons				  \
395 	EM(afs_edit_dir_for_create,		"Create") \
396 	EM(afs_edit_dir_for_link,		"Link  ") \
397 	EM(afs_edit_dir_for_mkdir,		"MkDir ") \
398 	EM(afs_edit_dir_for_rename_0,		"Renam0") \
399 	EM(afs_edit_dir_for_rename_1,		"Renam1") \
400 	EM(afs_edit_dir_for_rename_2,		"Renam2") \
401 	EM(afs_edit_dir_for_rename_sub,		"RnmSub") \
402 	EM(afs_edit_dir_for_rmdir,		"RmDir ") \
403 	EM(afs_edit_dir_for_silly_0,		"S_Ren0") \
404 	EM(afs_edit_dir_for_silly_1,		"S_Ren1") \
405 	EM(afs_edit_dir_for_symlink,		"Symlnk") \
406 	E_(afs_edit_dir_for_unlink,		"Unlink")
407 
408 #define afs_eproto_causes			\
409 	EM(afs_eproto_bad_status,	"BadStatus") \
410 	EM(afs_eproto_cb_count,		"CbCount") \
411 	EM(afs_eproto_cb_fid_count,	"CbFidCount") \
412 	EM(afs_eproto_cellname_len,	"CellNameLen") \
413 	EM(afs_eproto_file_type,	"FileTYpe") \
414 	EM(afs_eproto_ibulkst_cb_count,	"IBS.CbCount") \
415 	EM(afs_eproto_ibulkst_count,	"IBS.FidCount") \
416 	EM(afs_eproto_motd_len,		"MotdLen") \
417 	EM(afs_eproto_offline_msg_len,	"OfflineMsgLen") \
418 	EM(afs_eproto_volname_len,	"VolNameLen") \
419 	EM(afs_eproto_yvl_fsendpt4_len,	"YVL.FsEnd4Len") \
420 	EM(afs_eproto_yvl_fsendpt6_len,	"YVL.FsEnd6Len") \
421 	EM(afs_eproto_yvl_fsendpt_num,	"YVL.FsEndCount") \
422 	EM(afs_eproto_yvl_fsendpt_type,	"YVL.FsEndType") \
423 	EM(afs_eproto_yvl_vlendpt4_len,	"YVL.VlEnd4Len") \
424 	EM(afs_eproto_yvl_vlendpt6_len,	"YVL.VlEnd6Len") \
425 	E_(afs_eproto_yvl_vlendpt_type,	"YVL.VlEndType")
426 
427 #define afs_io_errors							\
428 	EM(afs_io_error_cm_reply,		"CM_REPLY")		\
429 	EM(afs_io_error_extract,		"EXTRACT")		\
430 	EM(afs_io_error_fs_probe_fail,		"FS_PROBE_FAIL")	\
431 	EM(afs_io_error_vl_lookup_fail,		"VL_LOOKUP_FAIL")	\
432 	E_(afs_io_error_vl_probe_fail,		"VL_PROBE_FAIL")
433 
434 #define afs_file_errors							\
435 	EM(afs_file_error_dir_bad_magic,	"DIR_BAD_MAGIC")	\
436 	EM(afs_file_error_dir_big,		"DIR_BIG")		\
437 	EM(afs_file_error_dir_missing_page,	"DIR_MISSING_PAGE")	\
438 	EM(afs_file_error_dir_name_too_long,	"DIR_NAME_TOO_LONG")	\
439 	EM(afs_file_error_dir_over_end,		"DIR_ENT_OVER_END")	\
440 	EM(afs_file_error_dir_small,		"DIR_SMALL")		\
441 	EM(afs_file_error_dir_unmarked_ext,	"DIR_UNMARKED_EXT")	\
442 	EM(afs_file_error_symlink_big,		"SYM_BIG")		\
443 	EM(afs_file_error_mntpt,		"MNTPT_READ_FAILED")	\
444 	E_(afs_file_error_writeback_fail,	"WRITEBACK_FAILED")
445 
446 #define afs_flock_types							\
447 	EM(F_RDLCK,				"RDLCK")		\
448 	EM(F_WRLCK,				"WRLCK")		\
449 	E_(F_UNLCK,				"UNLCK")
450 
451 #define afs_flock_states						\
452 	EM(AFS_VNODE_LOCK_NONE,			"NONE")			\
453 	EM(AFS_VNODE_LOCK_WAITING_FOR_CB,	"WAIT_FOR_CB")		\
454 	EM(AFS_VNODE_LOCK_SETTING,		"SETTING")		\
455 	EM(AFS_VNODE_LOCK_GRANTED,		"GRANTED")		\
456 	EM(AFS_VNODE_LOCK_EXTENDING,		"EXTENDING")		\
457 	EM(AFS_VNODE_LOCK_NEED_UNLOCK,		"NEED_UNLOCK")		\
458 	EM(AFS_VNODE_LOCK_UNLOCKING,		"UNLOCKING")		\
459 	E_(AFS_VNODE_LOCK_DELETED,		"DELETED")
460 
461 #define afs_flock_events						\
462 	EM(afs_flock_acquired,			"Acquired")		\
463 	EM(afs_flock_callback_break,		"Callback")		\
464 	EM(afs_flock_defer_unlock,		"D-Unlock")		\
465 	EM(afs_flock_extend_fail,		"Ext_Fail")		\
466 	EM(afs_flock_fail_other,		"ErrOther")		\
467 	EM(afs_flock_fail_perm,			"ErrPerm ")		\
468 	EM(afs_flock_no_lockers,		"NoLocker")		\
469 	EM(afs_flock_release_fail,		"Rel_Fail")		\
470 	EM(afs_flock_silly_delete,		"SillyDel")		\
471 	EM(afs_flock_timestamp,			"Timestmp")		\
472 	EM(afs_flock_try_to_lock,		"TryToLck")		\
473 	EM(afs_flock_vfs_lock,			"VFSLock ")		\
474 	EM(afs_flock_vfs_locking,		"VFSLking")		\
475 	EM(afs_flock_waited,			"Waited  ")		\
476 	EM(afs_flock_waiting,			"Waiting ")		\
477 	EM(afs_flock_work_extending,		"Extendng")		\
478 	EM(afs_flock_work_retry,		"Retry   ")		\
479 	EM(afs_flock_work_unlocking,		"Unlcking")		\
480 	E_(afs_flock_would_block,		"EWOULDBL")
481 
482 #define afs_flock_operations						\
483 	EM(afs_flock_op_copy_lock,		"COPY    ")		\
484 	EM(afs_flock_op_flock,			"->flock ")		\
485 	EM(afs_flock_op_grant,			"GRANT   ")		\
486 	EM(afs_flock_op_lock,			"->lock  ")		\
487 	EM(afs_flock_op_release_lock,		"RELEASE ")		\
488 	EM(afs_flock_op_return_ok,		"<-OK    ")		\
489 	EM(afs_flock_op_return_edeadlk,		"<-EDEADL")		\
490 	EM(afs_flock_op_return_eagain,		"<-EAGAIN")		\
491 	EM(afs_flock_op_return_error,		"<-ERROR ")		\
492 	EM(afs_flock_op_set_lock,		"SET     ")		\
493 	EM(afs_flock_op_unlock,			"UNLOCK  ")		\
494 	E_(afs_flock_op_wake,			"WAKE    ")
495 
496 #define afs_cb_break_reasons						\
497 	EM(afs_cb_break_no_break,		"no-break")		\
498 	EM(afs_cb_break_for_callback,		"break-cb")		\
499 	EM(afs_cb_break_for_creation_regress,	"creation-regress")	\
500 	EM(afs_cb_break_for_deleted,		"break-del")		\
501 	EM(afs_cb_break_for_s_reinit,		"s-reinit")		\
502 	EM(afs_cb_break_for_unlink,		"break-unlink")		\
503 	EM(afs_cb_break_for_update_regress,	"update-regress")	\
504 	EM(afs_cb_break_for_volume_callback,	"break-v-cb")		\
505 	EM(afs_cb_break_for_vos_release,	"break-vos-release")	\
506 	E_(afs_cb_break_volume_excluded,	"vol-excluded")
507 
508 #define afs_rotate_traces						\
509 	EM(afs_rotate_trace_aborted,		"Abortd")		\
510 	EM(afs_rotate_trace_busy_sleep,		"BsySlp")		\
511 	EM(afs_rotate_trace_check_vol_status,	"VolStt")		\
512 	EM(afs_rotate_trace_failed,		"Failed")		\
513 	EM(afs_rotate_trace_iter,		"Iter  ")		\
514 	EM(afs_rotate_trace_iterate_addr,	"ItAddr")		\
515 	EM(afs_rotate_trace_next_server,	"NextSv")		\
516 	EM(afs_rotate_trace_no_more_servers,	"NoMore")		\
517 	EM(afs_rotate_trace_nomem,		"Nomem ")		\
518 	EM(afs_rotate_trace_probe_error,	"PrbErr")		\
519 	EM(afs_rotate_trace_probe_fileserver,	"PrbFsv")		\
520 	EM(afs_rotate_trace_probe_none,		"PrbNon")		\
521 	EM(afs_rotate_trace_probe_response,	"PrbRsp")		\
522 	EM(afs_rotate_trace_probe_superseded,	"PrbSup")		\
523 	EM(afs_rotate_trace_restart,		"Rstart")		\
524 	EM(afs_rotate_trace_retry_server,	"RtrySv")		\
525 	EM(afs_rotate_trace_selected_server,	"SlctSv")		\
526 	EM(afs_rotate_trace_stale_lock,		"StlLck")		\
527 	EM(afs_rotate_trace_start,		"Start ")		\
528 	EM(afs_rotate_trace_stop,		"Stop  ")		\
529 	E_(afs_rotate_trace_stopped,		"Stoppd")
530 
531 /*
532  * Generate enums for tracing information.
533  */
534 #ifndef __AFS_GENERATE_TRACE_ENUMS_ONCE_ONLY
535 #define __AFS_GENERATE_TRACE_ENUMS_ONCE_ONLY
536 
537 #undef EM
538 #undef E_
539 #define EM(a, b) a,
540 #define E_(a, b) a
541 
542 enum afs_alist_trace		{ afs_alist_traces } __mode(byte);
543 enum afs_call_trace		{ afs_call_traces } __mode(byte);
544 enum afs_cb_break_reason	{ afs_cb_break_reasons } __mode(byte);
545 enum afs_cb_promise_trace	{ afs_cb_promise_traces } __mode(byte);
546 enum afs_cell_trace		{ afs_cell_traces } __mode(byte);
547 enum afs_dir_invalid_trace	{ afs_dir_invalid_traces} __mode(byte);
548 enum afs_edit_dir_op		{ afs_edit_dir_ops } __mode(byte);
549 enum afs_edit_dir_reason	{ afs_edit_dir_reasons } __mode(byte);
550 enum afs_eproto_cause		{ afs_eproto_causes } __mode(byte);
551 enum afs_estate_trace		{ afs_estate_traces } __mode(byte);
552 enum afs_file_error		{ afs_file_errors } __mode(byte);
553 enum afs_flock_event		{ afs_flock_events } __mode(byte);
554 enum afs_flock_operation	{ afs_flock_operations } __mode(byte);
555 enum afs_io_error		{ afs_io_errors } __mode(byte);
556 enum afs_rotate_trace		{ afs_rotate_traces } __mode(byte);
557 enum afs_server_trace		{ afs_server_traces } __mode(byte);
558 enum afs_vnode_invalid_trace	{ afs_vnode_invalid_traces} __mode(byte);
559 enum afs_volume_trace		{ afs_volume_traces } __mode(byte);
560 
561 #endif /* end __AFS_GENERATE_TRACE_ENUMS_ONCE_ONLY */
562 
563 /*
564  * Export enum symbols via userspace.
565  */
566 #undef EM
567 #undef E_
568 #define EM(a, b) TRACE_DEFINE_ENUM(a);
569 #define E_(a, b) TRACE_DEFINE_ENUM(a);
570 
571 afs_alist_traces;
572 afs_call_traces;
573 afs_cb_break_reasons;
574 afs_cb_promise_traces;
575 afs_cell_traces;
576 afs_cm_operations;
577 afs_dir_invalid_traces;
578 afs_edit_dir_ops;
579 afs_edit_dir_reasons;
580 afs_eproto_causes;
581 afs_estate_traces;
582 afs_file_errors;
583 afs_flock_operations;
584 afs_flock_types;
585 afs_fs_operations;
586 afs_io_errors;
587 afs_rotate_traces;
588 afs_server_traces;
589 afs_vnode_invalid_traces;
590 afs_vl_operations;
591 yfs_cm_operations;
592 
593 /*
594  * Now redefine the EM() and E_() macros to map the enums to the strings that
595  * will be printed in the output.
596  */
597 #undef EM
598 #undef E_
599 #define EM(a, b)	{ a, b },
600 #define E_(a, b)	{ a, b }
601 
602 TRACE_EVENT(afs_receive_data,
603 	    TP_PROTO(struct afs_call *call, struct iov_iter *iter,
604 		     bool want_more, int ret),
605 
606 	    TP_ARGS(call, iter, want_more, ret),
607 
608 	    TP_STRUCT__entry(
609 		    __field(loff_t,			remain)
610 		    __field(unsigned int,		call)
611 		    __field(enum afs_call_state,	state)
612 		    __field(unsigned short,		unmarshall)
613 		    __field(bool,			want_more)
614 		    __field(int,			ret)
615 			     ),
616 
617 	    TP_fast_assign(
618 		    __entry->call	= call->debug_id;
619 		    __entry->state	= call->state;
620 		    __entry->unmarshall	= call->unmarshall;
621 		    __entry->remain	= iov_iter_count(iter);
622 		    __entry->want_more	= want_more;
623 		    __entry->ret	= ret;
624 			   ),
625 
626 	    TP_printk("c=%08x r=%llu u=%u w=%u s=%u ret=%d",
627 		      __entry->call,
628 		      __entry->remain,
629 		      __entry->unmarshall,
630 		      __entry->want_more,
631 		      __entry->state,
632 		      __entry->ret)
633 	    );
634 
635 TRACE_EVENT(afs_notify_call,
636 	    TP_PROTO(struct rxrpc_call *rxcall, struct afs_call *call),
637 
638 	    TP_ARGS(rxcall, call),
639 
640 	    TP_STRUCT__entry(
641 		    __field(unsigned int,		call)
642 		    __field(enum afs_call_state,	state)
643 		    __field(unsigned short,		unmarshall)
644 			     ),
645 
646 	    TP_fast_assign(
647 		    __entry->call	= call->debug_id;
648 		    __entry->state	= call->state;
649 		    __entry->unmarshall	= call->unmarshall;
650 			   ),
651 
652 	    TP_printk("c=%08x s=%u u=%u",
653 		      __entry->call,
654 		      __entry->state, __entry->unmarshall)
655 	    );
656 
657 TRACE_EVENT(afs_cb_call,
658 	    TP_PROTO(struct afs_call *call),
659 
660 	    TP_ARGS(call),
661 
662 	    TP_STRUCT__entry(
663 		    __field(unsigned int,		call)
664 		    __field(u32,			op)
665 		    __field(u16,			service_id)
666 			     ),
667 
668 	    TP_fast_assign(
669 		    __entry->call	= call->debug_id;
670 		    __entry->op		= call->operation_ID;
671 		    __entry->service_id	= call->service_id;
672 			   ),
673 
674 	    TP_printk("c=%08x %s",
675 		      __entry->call,
676 		      __entry->service_id == 2501 ?
677 		      __print_symbolic(__entry->op, yfs_cm_operations) :
678 		      __print_symbolic(__entry->op, afs_cm_operations))
679 	    );
680 
681 TRACE_EVENT(afs_call,
682 	    TP_PROTO(unsigned int call_debug_id, enum afs_call_trace op,
683 		     int ref, int outstanding, const void *where),
684 
685 	    TP_ARGS(call_debug_id, op, ref, outstanding, where),
686 
687 	    TP_STRUCT__entry(
688 		    __field(unsigned int,		call)
689 		    __field(int,			op)
690 		    __field(int,			ref)
691 		    __field(int,			outstanding)
692 		    __field(const void *,		where)
693 			     ),
694 
695 	    TP_fast_assign(
696 		    __entry->call = call_debug_id;
697 		    __entry->op = op;
698 		    __entry->ref = ref;
699 		    __entry->outstanding = outstanding;
700 		    __entry->where = where;
701 			   ),
702 
703 	    TP_printk("c=%08x %s r=%d o=%d sp=%pSR",
704 		      __entry->call,
705 		      __print_symbolic(__entry->op, afs_call_traces),
706 		      __entry->ref,
707 		      __entry->outstanding,
708 		      __entry->where)
709 	    );
710 
711 TRACE_EVENT(afs_make_fs_call,
712 	    TP_PROTO(struct afs_call *call, const struct afs_fid *fid),
713 
714 	    TP_ARGS(call, fid),
715 
716 	    TP_STRUCT__entry(
717 		    __field(unsigned int,		call)
718 		    __field(enum afs_fs_operation,	op)
719 		    __field_struct(struct afs_fid,	fid)
720 			     ),
721 
722 	    TP_fast_assign(
723 		    __entry->call = call->debug_id;
724 		    __entry->op = call->operation_ID;
725 		    if (fid) {
726 			    __entry->fid = *fid;
727 		    } else {
728 			    __entry->fid.vid = 0;
729 			    __entry->fid.vnode = 0;
730 			    __entry->fid.unique = 0;
731 		    }
732 			   ),
733 
734 	    TP_printk("c=%08x V=%llx i=%llx:%x %s",
735 		      __entry->call,
736 		      __entry->fid.vid,
737 		      __entry->fid.vnode,
738 		      __entry->fid.unique,
739 		      __print_symbolic(__entry->op, afs_fs_operations))
740 	    );
741 
742 TRACE_EVENT(afs_make_fs_calli,
743 	    TP_PROTO(struct afs_call *call, const struct afs_fid *fid,
744 		     unsigned int i),
745 
746 	    TP_ARGS(call, fid, i),
747 
748 	    TP_STRUCT__entry(
749 		    __field(unsigned int,		call)
750 		    __field(unsigned int,		i)
751 		    __field(enum afs_fs_operation,	op)
752 		    __field_struct(struct afs_fid,	fid)
753 			     ),
754 
755 	    TP_fast_assign(
756 		    __entry->call = call->debug_id;
757 		    __entry->i = i;
758 		    __entry->op = call->operation_ID;
759 		    if (fid) {
760 			    __entry->fid = *fid;
761 		    } else {
762 			    __entry->fid.vid = 0;
763 			    __entry->fid.vnode = 0;
764 			    __entry->fid.unique = 0;
765 		    }
766 			   ),
767 
768 	    TP_printk("c=%08x V=%llx i=%llx:%x %s i=%u",
769 		      __entry->call,
770 		      __entry->fid.vid,
771 		      __entry->fid.vnode,
772 		      __entry->fid.unique,
773 		      __print_symbolic(__entry->op, afs_fs_operations),
774 		      __entry->i)
775 	    );
776 
777 TRACE_EVENT(afs_make_fs_call1,
778 	    TP_PROTO(struct afs_call *call, const struct afs_fid *fid,
779 		     const struct qstr *name),
780 
781 	    TP_ARGS(call, fid, name),
782 
783 	    TP_STRUCT__entry(
784 		    __field(unsigned int,		call)
785 		    __field(enum afs_fs_operation,	op)
786 		    __field_struct(struct afs_fid,	fid)
787 		    __array(char,			name, 24)
788 			     ),
789 
790 	    TP_fast_assign(
791 		    unsigned int __len = min_t(unsigned int, name->len, 23);
792 		    __entry->call = call->debug_id;
793 		    __entry->op = call->operation_ID;
794 		    if (fid) {
795 			    __entry->fid = *fid;
796 		    } else {
797 			    __entry->fid.vid = 0;
798 			    __entry->fid.vnode = 0;
799 			    __entry->fid.unique = 0;
800 		    }
801 		    memcpy(__entry->name, name->name, __len);
802 		    __entry->name[__len] = 0;
803 			   ),
804 
805 	    TP_printk("c=%08x V=%llx i=%llx:%x %s \"%s\"",
806 		      __entry->call,
807 		      __entry->fid.vid,
808 		      __entry->fid.vnode,
809 		      __entry->fid.unique,
810 		      __print_symbolic(__entry->op, afs_fs_operations),
811 		      __entry->name)
812 	    );
813 
814 TRACE_EVENT(afs_make_fs_call2,
815 	    TP_PROTO(struct afs_call *call, const struct afs_fid *fid,
816 		     const struct qstr *name, const struct qstr *name2),
817 
818 	    TP_ARGS(call, fid, name, name2),
819 
820 	    TP_STRUCT__entry(
821 		    __field(unsigned int,		call)
822 		    __field(enum afs_fs_operation,	op)
823 		    __field_struct(struct afs_fid,	fid)
824 		    __array(char,			name, 24)
825 		    __array(char,			name2, 24)
826 			     ),
827 
828 	    TP_fast_assign(
829 		    unsigned int __len = min_t(unsigned int, name->len, 23);
830 		    unsigned int __len2 = min_t(unsigned int, name2->len, 23);
831 		    __entry->call = call->debug_id;
832 		    __entry->op = call->operation_ID;
833 		    if (fid) {
834 			    __entry->fid = *fid;
835 		    } else {
836 			    __entry->fid.vid = 0;
837 			    __entry->fid.vnode = 0;
838 			    __entry->fid.unique = 0;
839 		    }
840 		    memcpy(__entry->name, name->name, __len);
841 		    __entry->name[__len] = 0;
842 		    memcpy(__entry->name2, name2->name, __len2);
843 		    __entry->name2[__len2] = 0;
844 			   ),
845 
846 	    TP_printk("c=%08x V=%llx i=%llx:%x %s \"%s\" \"%s\"",
847 		      __entry->call,
848 		      __entry->fid.vid,
849 		      __entry->fid.vnode,
850 		      __entry->fid.unique,
851 		      __print_symbolic(__entry->op, afs_fs_operations),
852 		      __entry->name,
853 		      __entry->name2)
854 	    );
855 
856 TRACE_EVENT(afs_make_vl_call,
857 	    TP_PROTO(struct afs_call *call),
858 
859 	    TP_ARGS(call),
860 
861 	    TP_STRUCT__entry(
862 		    __field(unsigned int,		call)
863 		    __field(enum afs_vl_operation,	op)
864 			     ),
865 
866 	    TP_fast_assign(
867 		    __entry->call = call->debug_id;
868 		    __entry->op = call->operation_ID;
869 			   ),
870 
871 	    TP_printk("c=%08x %s",
872 		      __entry->call,
873 		      __print_symbolic(__entry->op, afs_vl_operations))
874 	    );
875 
876 TRACE_EVENT(afs_call_done,
877 	    TP_PROTO(struct afs_call *call),
878 
879 	    TP_ARGS(call),
880 
881 	    TP_STRUCT__entry(
882 		    __field(unsigned int,		call)
883 		    __field(struct rxrpc_call *,	rx_call)
884 		    __field(int,			ret)
885 		    __field(u32,			abort_code)
886 			     ),
887 
888 	    TP_fast_assign(
889 		    __entry->call = call->debug_id;
890 		    __entry->rx_call = call->rxcall;
891 		    __entry->ret = call->error;
892 		    __entry->abort_code = call->abort_code;
893 			   ),
894 
895 	    TP_printk("   c=%08x ret=%d ab=%d [%p]",
896 		      __entry->call,
897 		      __entry->ret,
898 		      __entry->abort_code,
899 		      __entry->rx_call)
900 	    );
901 
902 TRACE_EVENT(afs_send_data,
903 	    TP_PROTO(struct afs_call *call, struct msghdr *msg),
904 
905 	    TP_ARGS(call, msg),
906 
907 	    TP_STRUCT__entry(
908 		    __field(unsigned int,		call)
909 		    __field(unsigned int,		flags)
910 		    __field(loff_t,			offset)
911 		    __field(loff_t,			count)
912 			     ),
913 
914 	    TP_fast_assign(
915 		    __entry->call = call->debug_id;
916 		    __entry->flags = msg->msg_flags;
917 		    __entry->offset = msg->msg_iter.xarray_start + msg->msg_iter.iov_offset;
918 		    __entry->count = iov_iter_count(&msg->msg_iter);
919 			   ),
920 
921 	    TP_printk(" c=%08x o=%llx n=%llx f=%x",
922 		      __entry->call, __entry->offset, __entry->count,
923 		      __entry->flags)
924 	    );
925 
926 TRACE_EVENT(afs_sent_data,
927 	    TP_PROTO(struct afs_call *call, struct msghdr *msg, int ret),
928 
929 	    TP_ARGS(call, msg, ret),
930 
931 	    TP_STRUCT__entry(
932 		    __field(unsigned int,		call)
933 		    __field(int,			ret)
934 		    __field(loff_t,			offset)
935 		    __field(loff_t,			count)
936 			     ),
937 
938 	    TP_fast_assign(
939 		    __entry->call = call->debug_id;
940 		    __entry->ret = ret;
941 		    __entry->offset = msg->msg_iter.xarray_start + msg->msg_iter.iov_offset;
942 		    __entry->count = iov_iter_count(&msg->msg_iter);
943 			   ),
944 
945 	    TP_printk(" c=%08x o=%llx n=%llx r=%x",
946 		      __entry->call, __entry->offset, __entry->count,
947 		      __entry->ret)
948 	    );
949 
950 TRACE_EVENT(afs_dir_check_failed,
951 	    TP_PROTO(struct afs_vnode *vnode, loff_t off),
952 
953 	    TP_ARGS(vnode, off),
954 
955 	    TP_STRUCT__entry(
956 		    __field(struct afs_vnode *,		vnode)
957 		    __field(loff_t,			off)
958 		    __field(loff_t,			i_size)
959 			     ),
960 
961 	    TP_fast_assign(
962 		    __entry->vnode = vnode;
963 		    __entry->off = off;
964 		    __entry->i_size = i_size_read(&vnode->netfs.inode);
965 			   ),
966 
967 	    TP_printk("vn=%p %llx/%llx",
968 		      __entry->vnode, __entry->off, __entry->i_size)
969 	    );
970 
971 TRACE_EVENT(afs_call_state,
972 	    TP_PROTO(struct afs_call *call,
973 		     enum afs_call_state from,
974 		     enum afs_call_state to,
975 		     int ret, u32 remote_abort),
976 
977 	    TP_ARGS(call, from, to, ret, remote_abort),
978 
979 	    TP_STRUCT__entry(
980 		    __field(unsigned int,		call)
981 		    __field(enum afs_call_state,	from)
982 		    __field(enum afs_call_state,	to)
983 		    __field(int,			ret)
984 		    __field(u32,			abort)
985 			     ),
986 
987 	    TP_fast_assign(
988 		    __entry->call = call->debug_id;
989 		    __entry->from = from;
990 		    __entry->to = to;
991 		    __entry->ret = ret;
992 		    __entry->abort = remote_abort;
993 			   ),
994 
995 	    TP_printk("c=%08x %u->%u r=%d ab=%d",
996 		      __entry->call,
997 		      __entry->from, __entry->to,
998 		      __entry->ret, __entry->abort)
999 	    );
1000 
1001 TRACE_EVENT(afs_lookup,
1002 	    TP_PROTO(struct afs_vnode *dvnode, const struct qstr *name,
1003 		     struct afs_fid *fid),
1004 
1005 	    TP_ARGS(dvnode, name, fid),
1006 
1007 	    TP_STRUCT__entry(
1008 		    __field_struct(struct afs_fid,	dfid)
1009 		    __field_struct(struct afs_fid,	fid)
1010 		    __array(char,			name, 24)
1011 			     ),
1012 
1013 	    TP_fast_assign(
1014 		    int __len = min_t(int, name->len, 23);
1015 		    __entry->dfid = dvnode->fid;
1016 		    __entry->fid = *fid;
1017 		    memcpy(__entry->name, name->name, __len);
1018 		    __entry->name[__len] = 0;
1019 			   ),
1020 
1021 	    TP_printk("d=%llx:%llx:%x \"%s\" f=%llx:%x",
1022 		      __entry->dfid.vid, __entry->dfid.vnode, __entry->dfid.unique,
1023 		      __entry->name,
1024 		      __entry->fid.vnode, __entry->fid.unique)
1025 	    );
1026 
1027 TRACE_EVENT(afs_edit_dir,
1028 	    TP_PROTO(struct afs_vnode *dvnode,
1029 		     enum afs_edit_dir_reason why,
1030 		     enum afs_edit_dir_op op,
1031 		     unsigned int block,
1032 		     unsigned int slot,
1033 		     unsigned int f_vnode,
1034 		     unsigned int f_unique,
1035 		     const char *name),
1036 
1037 	    TP_ARGS(dvnode, why, op, block, slot, f_vnode, f_unique, name),
1038 
1039 	    TP_STRUCT__entry(
1040 		    __field(unsigned int,		vnode)
1041 		    __field(unsigned int,		unique)
1042 		    __field(enum afs_edit_dir_reason,	why)
1043 		    __field(enum afs_edit_dir_op,	op)
1044 		    __field(unsigned int,		block)
1045 		    __field(unsigned short,		slot)
1046 		    __field(unsigned int,		f_vnode)
1047 		    __field(unsigned int,		f_unique)
1048 		    __array(char,			name, 24)
1049 			     ),
1050 
1051 	    TP_fast_assign(
1052 		    int __len = strlen(name);
1053 		    __len = min(__len, 23);
1054 		    __entry->vnode	= dvnode->fid.vnode;
1055 		    __entry->unique	= dvnode->fid.unique;
1056 		    __entry->why	= why;
1057 		    __entry->op		= op;
1058 		    __entry->block	= block;
1059 		    __entry->slot	= slot;
1060 		    __entry->f_vnode	= f_vnode;
1061 		    __entry->f_unique	= f_unique;
1062 		    memcpy(__entry->name, name, __len);
1063 		    __entry->name[__len] = 0;
1064 			   ),
1065 
1066 	    TP_printk("di=%x:%x %s %s %u[%u] fi=%x:%x \"%s\"",
1067 		      __entry->vnode, __entry->unique,
1068 		      __print_symbolic(__entry->why, afs_edit_dir_reasons),
1069 		      __print_symbolic(__entry->op, afs_edit_dir_ops),
1070 		      __entry->block, __entry->slot,
1071 		      __entry->f_vnode, __entry->f_unique,
1072 		      __entry->name)
1073 	    );
1074 
1075 TRACE_EVENT(afs_dir_invalid,
1076 	    TP_PROTO(const struct afs_vnode *dvnode, enum afs_dir_invalid_trace trace),
1077 
1078 	    TP_ARGS(dvnode, trace),
1079 
1080 	    TP_STRUCT__entry(
1081 		    __field(unsigned int,		vnode)
1082 		    __field(unsigned int,		unique)
1083 		    __field(enum afs_dir_invalid_trace,	trace)
1084 			     ),
1085 
1086 	    TP_fast_assign(
1087 		    __entry->vnode	= dvnode->fid.vnode;
1088 		    __entry->unique	= dvnode->fid.unique;
1089 		    __entry->trace	= trace;
1090 			   ),
1091 
1092 	    TP_printk("di=%x:%x %s",
1093 		      __entry->vnode, __entry->unique,
1094 		      __print_symbolic(__entry->trace, afs_dir_invalid_traces))
1095 	    );
1096 
1097 TRACE_EVENT(afs_cb_promise,
1098 	    TP_PROTO(const struct afs_vnode *vnode, enum afs_cb_promise_trace trace),
1099 
1100 	    TP_ARGS(vnode, trace),
1101 
1102 	    TP_STRUCT__entry(
1103 		    __field(unsigned int,		vnode)
1104 		    __field(unsigned int,		unique)
1105 		    __field(enum afs_cb_promise_trace,	trace)
1106 			     ),
1107 
1108 	    TP_fast_assign(
1109 		    __entry->vnode	= vnode->fid.vnode;
1110 		    __entry->unique	= vnode->fid.unique;
1111 		    __entry->trace	= trace;
1112 			   ),
1113 
1114 	    TP_printk("di=%x:%x %s",
1115 		      __entry->vnode, __entry->unique,
1116 		      __print_symbolic(__entry->trace, afs_cb_promise_traces))
1117 	    );
1118 
1119 TRACE_EVENT(afs_vnode_invalid,
1120 	    TP_PROTO(const struct afs_vnode *vnode, enum afs_vnode_invalid_trace trace),
1121 
1122 	    TP_ARGS(vnode, trace),
1123 
1124 	    TP_STRUCT__entry(
1125 		    __field(unsigned int,		vnode)
1126 		    __field(unsigned int,		unique)
1127 		    __field(enum afs_vnode_invalid_trace, trace)
1128 			     ),
1129 
1130 	    TP_fast_assign(
1131 		    __entry->vnode	= vnode->fid.vnode;
1132 		    __entry->unique	= vnode->fid.unique;
1133 		    __entry->trace	= trace;
1134 			   ),
1135 
1136 	    TP_printk("di=%x:%x %s",
1137 		      __entry->vnode, __entry->unique,
1138 		      __print_symbolic(__entry->trace, afs_vnode_invalid_traces))
1139 	    );
1140 
1141 TRACE_EVENT(afs_set_dv,
1142 	    TP_PROTO(const struct afs_vnode *dvnode, u64 new_dv),
1143 
1144 	    TP_ARGS(dvnode, new_dv),
1145 
1146 	    TP_STRUCT__entry(
1147 		    __field(unsigned int,		vnode)
1148 		    __field(unsigned int,		unique)
1149 		    __field(u64,			old_dv)
1150 		    __field(u64,			new_dv)
1151 			     ),
1152 
1153 	    TP_fast_assign(
1154 		    __entry->vnode	= dvnode->fid.vnode;
1155 		    __entry->unique	= dvnode->fid.unique;
1156 		    __entry->old_dv	= dvnode->status.data_version;
1157 		    __entry->new_dv	= new_dv;
1158 			   ),
1159 
1160 	    TP_printk("di=%x:%x dv=%llx -> dv=%llx",
1161 		      __entry->vnode, __entry->unique,
1162 		      __entry->old_dv, __entry->new_dv)
1163 	    );
1164 
1165 TRACE_EVENT(afs_dv_mismatch,
1166 	    TP_PROTO(const struct afs_vnode *dvnode, u64 before_dv, int delta, u64 new_dv),
1167 
1168 	    TP_ARGS(dvnode, before_dv, delta, new_dv),
1169 
1170 	    TP_STRUCT__entry(
1171 		    __field(unsigned int,		vnode)
1172 		    __field(unsigned int,		unique)
1173 		    __field(int,			delta)
1174 		    __field(u64,			before_dv)
1175 		    __field(u64,			new_dv)
1176 			     ),
1177 
1178 	    TP_fast_assign(
1179 		    __entry->vnode	= dvnode->fid.vnode;
1180 		    __entry->unique	= dvnode->fid.unique;
1181 		    __entry->delta	= delta;
1182 		    __entry->before_dv	= before_dv;
1183 		    __entry->new_dv	= new_dv;
1184 			   ),
1185 
1186 	    TP_printk("di=%x:%x xdv=%llx+%d dv=%llx",
1187 		      __entry->vnode, __entry->unique,
1188 		      __entry->before_dv, __entry->delta, __entry->new_dv)
1189 	    );
1190 
1191 TRACE_EVENT(afs_protocol_error,
1192 	    TP_PROTO(struct afs_call *call, enum afs_eproto_cause cause),
1193 
1194 	    TP_ARGS(call, cause),
1195 
1196 	    TP_STRUCT__entry(
1197 		    __field(unsigned int,		call)
1198 		    __field(enum afs_eproto_cause,	cause)
1199 			     ),
1200 
1201 	    TP_fast_assign(
1202 		    __entry->call = call ? call->debug_id : 0;
1203 		    __entry->cause = cause;
1204 			   ),
1205 
1206 	    TP_printk("c=%08x %s",
1207 		      __entry->call,
1208 		      __print_symbolic(__entry->cause, afs_eproto_causes))
1209 	    );
1210 
1211 TRACE_EVENT(afs_io_error,
1212 	    TP_PROTO(unsigned int call, int error, enum afs_io_error where),
1213 
1214 	    TP_ARGS(call, error, where),
1215 
1216 	    TP_STRUCT__entry(
1217 		    __field(unsigned int,	call)
1218 		    __field(int,		error)
1219 		    __field(enum afs_io_error,	where)
1220 			     ),
1221 
1222 	    TP_fast_assign(
1223 		    __entry->call = call;
1224 		    __entry->error = error;
1225 		    __entry->where = where;
1226 			   ),
1227 
1228 	    TP_printk("c=%08x r=%d %s",
1229 		      __entry->call, __entry->error,
1230 		      __print_symbolic(__entry->where, afs_io_errors))
1231 	    );
1232 
1233 TRACE_EVENT(afs_file_error,
1234 	    TP_PROTO(struct afs_vnode *vnode, int error, enum afs_file_error where),
1235 
1236 	    TP_ARGS(vnode, error, where),
1237 
1238 	    TP_STRUCT__entry(
1239 		    __field_struct(struct afs_fid,	fid)
1240 		    __field(int,			error)
1241 		    __field(enum afs_file_error,	where)
1242 			     ),
1243 
1244 	    TP_fast_assign(
1245 		    __entry->fid = vnode->fid;
1246 		    __entry->error = error;
1247 		    __entry->where = where;
1248 			   ),
1249 
1250 	    TP_printk("%llx:%llx:%x r=%d %s",
1251 		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1252 		      __entry->error,
1253 		      __print_symbolic(__entry->where, afs_file_errors))
1254 	    );
1255 
1256 TRACE_EVENT(afs_bulkstat_error,
1257 	    TP_PROTO(struct afs_operation *op, struct afs_fid *fid, unsigned int index, s32 abort),
1258 
1259 	    TP_ARGS(op, fid, index, abort),
1260 
1261 	    TP_STRUCT__entry(
1262 		    __field_struct(struct afs_fid,	fid)
1263 		    __field(unsigned int,		op)
1264 		    __field(unsigned int,		index)
1265 		    __field(s32,			abort)
1266 			     ),
1267 
1268 	    TP_fast_assign(
1269 		    __entry->op = op->debug_id;
1270 		    __entry->fid = *fid;
1271 		    __entry->index = index;
1272 		    __entry->abort = abort;
1273 			   ),
1274 
1275 	    TP_printk("OP=%08x[%02x] %llx:%llx:%x a=%d",
1276 		      __entry->op, __entry->index,
1277 		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1278 		      __entry->abort)
1279 	    );
1280 
1281 TRACE_EVENT(afs_cm_no_server,
1282 	    TP_PROTO(struct afs_call *call, const struct sockaddr_rxrpc *srx),
1283 
1284 	    TP_ARGS(call, srx),
1285 
1286 	    TP_STRUCT__entry(
1287 		    __field(unsigned int,			call)
1288 		    __field(unsigned int,			op_id)
1289 		    __field_struct(struct sockaddr_rxrpc,	srx)
1290 			     ),
1291 
1292 	    TP_fast_assign(
1293 		    __entry->call = call->debug_id;
1294 		    __entry->op_id = call->operation_ID;
1295 		    memcpy(&__entry->srx, srx, sizeof(__entry->srx));
1296 			   ),
1297 
1298 	    TP_printk("c=%08x op=%u %pISpc",
1299 		      __entry->call, __entry->op_id, &__entry->srx.transport)
1300 	    );
1301 
1302 TRACE_EVENT(afs_cm_no_server_u,
1303 	    TP_PROTO(struct afs_call *call, const uuid_t *uuid),
1304 
1305 	    TP_ARGS(call, uuid),
1306 
1307 	    TP_STRUCT__entry(
1308 		    __field(unsigned int,			call)
1309 		    __field(unsigned int,			op_id)
1310 		    __field_struct(uuid_t,			uuid)
1311 			     ),
1312 
1313 	    TP_fast_assign(
1314 		    __entry->call = call->debug_id;
1315 		    __entry->op_id = call->operation_ID;
1316 		    memcpy(&__entry->uuid, uuid, sizeof(__entry->uuid));
1317 			   ),
1318 
1319 	    TP_printk("c=%08x op=%u %pU",
1320 		      __entry->call, __entry->op_id, &__entry->uuid)
1321 	    );
1322 
1323 TRACE_EVENT(afs_flock_ev,
1324 	    TP_PROTO(struct afs_vnode *vnode, struct file_lock *fl,
1325 		     enum afs_flock_event event, int error),
1326 
1327 	    TP_ARGS(vnode, fl, event, error),
1328 
1329 	    TP_STRUCT__entry(
1330 		    __field_struct(struct afs_fid,	fid)
1331 		    __field(enum afs_flock_event,	event)
1332 		    __field(enum afs_lock_state,	state)
1333 		    __field(int,			error)
1334 		    __field(unsigned int,		debug_id)
1335 			     ),
1336 
1337 	    TP_fast_assign(
1338 		    __entry->fid = vnode->fid;
1339 		    __entry->event = event;
1340 		    __entry->state = vnode->lock_state;
1341 		    __entry->error = error;
1342 		    __entry->debug_id = fl ? fl->fl_u.afs.debug_id : 0;
1343 			   ),
1344 
1345 	    TP_printk("%llx:%llx:%x %04x %s s=%s e=%d",
1346 		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1347 		      __entry->debug_id,
1348 		      __print_symbolic(__entry->event, afs_flock_events),
1349 		      __print_symbolic(__entry->state, afs_flock_states),
1350 		      __entry->error)
1351 	    );
1352 
1353 TRACE_EVENT(afs_flock_op,
1354 	    TP_PROTO(struct afs_vnode *vnode, struct file_lock *fl,
1355 		     enum afs_flock_operation op),
1356 
1357 	    TP_ARGS(vnode, fl, op),
1358 
1359 	    TP_STRUCT__entry(
1360 		    __field_struct(struct afs_fid,	fid)
1361 		    __field(loff_t,			from)
1362 		    __field(loff_t,			len)
1363 		    __field(enum afs_flock_operation,	op)
1364 		    __field(unsigned char,		type)
1365 		    __field(unsigned int,		flags)
1366 		    __field(unsigned int,		debug_id)
1367 			     ),
1368 
1369 	    TP_fast_assign(
1370 		    __entry->fid = vnode->fid;
1371 		    __entry->from = fl->fl_start;
1372 		    __entry->len = fl->fl_end - fl->fl_start + 1;
1373 		    __entry->op = op;
1374 		    __entry->type = fl->c.flc_type;
1375 		    __entry->flags = fl->c.flc_flags;
1376 		    __entry->debug_id = fl->fl_u.afs.debug_id;
1377 			   ),
1378 
1379 	    TP_printk("%llx:%llx:%x %04x %s t=%s R=%llx/%llx f=%x",
1380 		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1381 		      __entry->debug_id,
1382 		      __print_symbolic(__entry->op, afs_flock_operations),
1383 		      __print_symbolic(__entry->type, afs_flock_types),
1384 		      __entry->from, __entry->len, __entry->flags)
1385 	    );
1386 
1387 TRACE_EVENT(afs_reload_dir,
1388 	    TP_PROTO(struct afs_vnode *vnode),
1389 
1390 	    TP_ARGS(vnode),
1391 
1392 	    TP_STRUCT__entry(
1393 		    __field_struct(struct afs_fid,	fid)
1394 			     ),
1395 
1396 	    TP_fast_assign(
1397 		    __entry->fid = vnode->fid;
1398 			   ),
1399 
1400 	    TP_printk("%llx:%llx:%x",
1401 		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique)
1402 	    );
1403 
1404 TRACE_EVENT(afs_silly_rename,
1405 	    TP_PROTO(struct afs_vnode *vnode, bool done),
1406 
1407 	    TP_ARGS(vnode, done),
1408 
1409 	    TP_STRUCT__entry(
1410 		    __field_struct(struct afs_fid,	fid)
1411 		    __field(bool,			done)
1412 			     ),
1413 
1414 	    TP_fast_assign(
1415 		    __entry->fid = vnode->fid;
1416 		    __entry->done = done;
1417 			   ),
1418 
1419 	    TP_printk("%llx:%llx:%x done=%u",
1420 		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1421 		      __entry->done)
1422 	    );
1423 
1424 TRACE_EVENT(afs_get_tree,
1425 	    TP_PROTO(struct afs_cell *cell, struct afs_volume *volume),
1426 
1427 	    TP_ARGS(cell, volume),
1428 
1429 	    TP_STRUCT__entry(
1430 		    __field(u64,			vid)
1431 		    __array(char,			cell, 24)
1432 		    __array(char,			volume, 24)
1433 			     ),
1434 
1435 	    TP_fast_assign(
1436 		    int __len;
1437 		    __entry->vid = volume->vid;
1438 		    __len = min_t(int, cell->name_len, 23);
1439 		    memcpy(__entry->cell, cell->name, __len);
1440 		    __entry->cell[__len] = 0;
1441 		    __len = min_t(int, volume->name_len, 23);
1442 		    memcpy(__entry->volume, volume->name, __len);
1443 		    __entry->volume[__len] = 0;
1444 			   ),
1445 
1446 	    TP_printk("--- MOUNT %s:%s %llx",
1447 		      __entry->cell, __entry->volume, __entry->vid)
1448 	    );
1449 
1450 TRACE_EVENT(afs_cb_v_break,
1451 	    TP_PROTO(afs_volid_t vid, unsigned int cb_v_break,
1452 		     enum afs_cb_break_reason reason),
1453 
1454 	    TP_ARGS(vid, cb_v_break, reason),
1455 
1456 	    TP_STRUCT__entry(
1457 		    __field(afs_volid_t,		vid)
1458 		    __field(unsigned int,		cb_v_break)
1459 		    __field(enum afs_cb_break_reason,	reason)
1460 			     ),
1461 
1462 	    TP_fast_assign(
1463 		    __entry->vid	= vid;
1464 		    __entry->cb_v_break	= cb_v_break;
1465 		    __entry->reason	= reason;
1466 			   ),
1467 
1468 	    TP_printk("%llx vb=%x %s",
1469 		      __entry->vid,
1470 		      __entry->cb_v_break,
1471 		      __print_symbolic(__entry->reason, afs_cb_break_reasons))
1472 	    );
1473 
1474 TRACE_EVENT(afs_cb_break,
1475 	    TP_PROTO(struct afs_fid *fid, unsigned int cb_break,
1476 		     enum afs_cb_break_reason reason, bool skipped),
1477 
1478 	    TP_ARGS(fid, cb_break, reason, skipped),
1479 
1480 	    TP_STRUCT__entry(
1481 		    __field_struct(struct afs_fid,	fid)
1482 		    __field(unsigned int,		cb_break)
1483 		    __field(enum afs_cb_break_reason,	reason)
1484 		    __field(bool,			skipped)
1485 			     ),
1486 
1487 	    TP_fast_assign(
1488 		    __entry->fid	= *fid;
1489 		    __entry->cb_break	= cb_break;
1490 		    __entry->reason	= reason;
1491 		    __entry->skipped	= skipped;
1492 			   ),
1493 
1494 	    TP_printk("%llx:%llx:%x b=%x s=%u %s",
1495 		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1496 		      __entry->cb_break,
1497 		      __entry->skipped,
1498 		      __print_symbolic(__entry->reason, afs_cb_break_reasons))
1499 	    );
1500 
1501 TRACE_EVENT(afs_cb_miss,
1502 	    TP_PROTO(struct afs_fid *fid, enum afs_cb_break_reason reason),
1503 
1504 	    TP_ARGS(fid, reason),
1505 
1506 	    TP_STRUCT__entry(
1507 		    __field_struct(struct afs_fid,	fid)
1508 		    __field(enum afs_cb_break_reason,	reason)
1509 			     ),
1510 
1511 	    TP_fast_assign(
1512 		    __entry->fid	= *fid;
1513 		    __entry->reason	= reason;
1514 			   ),
1515 
1516 	    TP_printk(" %llx:%llx:%x %s",
1517 		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1518 		      __print_symbolic(__entry->reason, afs_cb_break_reasons))
1519 	    );
1520 
1521 TRACE_EVENT(afs_server,
1522 	    TP_PROTO(unsigned int server_debug_id, int ref, int active,
1523 		     enum afs_server_trace reason),
1524 
1525 	    TP_ARGS(server_debug_id, ref, active, reason),
1526 
1527 	    TP_STRUCT__entry(
1528 		    __field(unsigned int,		server)
1529 		    __field(int,			ref)
1530 		    __field(int,			active)
1531 		    __field(int,			reason)
1532 			     ),
1533 
1534 	    TP_fast_assign(
1535 		    __entry->server = server_debug_id;
1536 		    __entry->ref = ref;
1537 		    __entry->active = active;
1538 		    __entry->reason = reason;
1539 			   ),
1540 
1541 	    TP_printk("s=%08x %s r=%d a=%d",
1542 		      __entry->server,
1543 		      __print_symbolic(__entry->reason, afs_server_traces),
1544 		      __entry->ref,
1545 		      __entry->active)
1546 	    );
1547 
1548 TRACE_EVENT(afs_volume,
1549 	    TP_PROTO(unsigned int debug_id, afs_volid_t vid, int ref,
1550 		     enum afs_volume_trace reason),
1551 
1552 	    TP_ARGS(debug_id, vid, ref, reason),
1553 
1554 	    TP_STRUCT__entry(
1555 		    __field(unsigned int,		debug_id)
1556 		    __field(afs_volid_t,		vid)
1557 		    __field(int,			ref)
1558 		    __field(enum afs_volume_trace,	reason)
1559 			     ),
1560 
1561 	    TP_fast_assign(
1562 		    __entry->debug_id	= debug_id;
1563 		    __entry->vid	= vid;
1564 		    __entry->ref	= ref;
1565 		    __entry->reason	= reason;
1566 			   ),
1567 
1568 	    TP_printk("V=%08x %s vid=%llx r=%d",
1569 		      __entry->debug_id,
1570 		      __print_symbolic(__entry->reason, afs_volume_traces),
1571 		      __entry->vid,
1572 		      __entry->ref)
1573 	    );
1574 
1575 TRACE_EVENT(afs_cell,
1576 	    TP_PROTO(unsigned int cell_debug_id, int ref, int active,
1577 		     enum afs_cell_trace reason),
1578 
1579 	    TP_ARGS(cell_debug_id, ref, active, reason),
1580 
1581 	    TP_STRUCT__entry(
1582 		    __field(unsigned int,		cell)
1583 		    __field(int,			ref)
1584 		    __field(int,			active)
1585 		    __field(int,			reason)
1586 			     ),
1587 
1588 	    TP_fast_assign(
1589 		    __entry->cell = cell_debug_id;
1590 		    __entry->ref = ref;
1591 		    __entry->active = active;
1592 		    __entry->reason = reason;
1593 			   ),
1594 
1595 	    TP_printk("L=%08x %s r=%d a=%d",
1596 		      __entry->cell,
1597 		      __print_symbolic(__entry->reason, afs_cell_traces),
1598 		      __entry->ref,
1599 		      __entry->active)
1600 	    );
1601 
1602 TRACE_EVENT(afs_alist,
1603 	    TP_PROTO(unsigned int alist_debug_id, int ref, enum afs_alist_trace reason),
1604 
1605 	    TP_ARGS(alist_debug_id, ref, reason),
1606 
1607 	    TP_STRUCT__entry(
1608 		    __field(unsigned int,		alist)
1609 		    __field(int,			ref)
1610 		    __field(int,			active)
1611 		    __field(int,			reason)
1612 			     ),
1613 
1614 	    TP_fast_assign(
1615 		    __entry->alist = alist_debug_id;
1616 		    __entry->ref = ref;
1617 		    __entry->reason = reason;
1618 			   ),
1619 
1620 	    TP_printk("AL=%08x %s r=%d",
1621 		      __entry->alist,
1622 		      __print_symbolic(__entry->reason, afs_alist_traces),
1623 		      __entry->ref)
1624 	    );
1625 
1626 TRACE_EVENT(afs_estate,
1627 	    TP_PROTO(unsigned int server_debug_id, unsigned int estate_debug_id,
1628 		     int ref, enum afs_estate_trace reason),
1629 
1630 	    TP_ARGS(server_debug_id, estate_debug_id, ref, reason),
1631 
1632 	    TP_STRUCT__entry(
1633 		    __field(unsigned int,		server)
1634 		    __field(unsigned int,		estate)
1635 		    __field(int,			ref)
1636 		    __field(int,			active)
1637 		    __field(int,			reason)
1638 			     ),
1639 
1640 	    TP_fast_assign(
1641 		    __entry->server = server_debug_id;
1642 		    __entry->estate = estate_debug_id;
1643 		    __entry->ref = ref;
1644 		    __entry->reason = reason;
1645 			   ),
1646 
1647 	    TP_printk("ES=%08x[%x] %s r=%d",
1648 		      __entry->server,
1649 		      __entry->estate,
1650 		      __print_symbolic(__entry->reason, afs_estate_traces),
1651 		      __entry->ref)
1652 	    );
1653 
1654 TRACE_EVENT(afs_fs_probe,
1655 	    TP_PROTO(struct afs_server *server, bool tx, struct afs_endpoint_state *estate,
1656 		     unsigned int addr_index, int error, s32 abort_code, unsigned int rtt_us),
1657 
1658 	    TP_ARGS(server, tx, estate, addr_index, error, abort_code, rtt_us),
1659 
1660 	    TP_STRUCT__entry(
1661 		    __field(unsigned int,		server)
1662 		    __field(unsigned int,		estate)
1663 		    __field(bool,			tx)
1664 		    __field(u16,			addr_index)
1665 		    __field(short,			error)
1666 		    __field(s32,			abort_code)
1667 		    __field(unsigned int,		rtt_us)
1668 		    __field_struct(struct sockaddr_rxrpc, srx)
1669 			     ),
1670 
1671 	    TP_fast_assign(
1672 		    struct afs_addr_list *alist = estate->addresses;
1673 		    __entry->server = server->debug_id;
1674 		    __entry->estate = estate->probe_seq;
1675 		    __entry->tx = tx;
1676 		    __entry->addr_index = addr_index;
1677 		    __entry->error = error;
1678 		    __entry->abort_code = abort_code;
1679 		    __entry->rtt_us = rtt_us;
1680 		    memcpy(&__entry->srx, rxrpc_kernel_remote_srx(alist->addrs[addr_index].peer),
1681 			   sizeof(__entry->srx));
1682 			   ),
1683 
1684 	    TP_printk("s=%08x %s pq=%x ax=%u e=%d ac=%d rtt=%d %pISpc",
1685 		      __entry->server, __entry->tx ? "tx" : "rx", __entry->estate,
1686 		      __entry->addr_index, __entry->error, __entry->abort_code, __entry->rtt_us,
1687 		      &__entry->srx.transport)
1688 	    );
1689 
1690 TRACE_EVENT(afs_vl_probe,
1691 	    TP_PROTO(struct afs_vlserver *server, bool tx, struct afs_addr_list *alist,
1692 		     unsigned int addr_index, int error, s32 abort_code, unsigned int rtt_us),
1693 
1694 	    TP_ARGS(server, tx, alist, addr_index, error, abort_code, rtt_us),
1695 
1696 	    TP_STRUCT__entry(
1697 		    __field(unsigned int,		server)
1698 		    __field(bool,			tx)
1699 		    __field(unsigned short,		flags)
1700 		    __field(u16,			addr_index)
1701 		    __field(short,			error)
1702 		    __field(s32,			abort_code)
1703 		    __field(unsigned int,		rtt_us)
1704 		    __field_struct(struct sockaddr_rxrpc, srx)
1705 			     ),
1706 
1707 	    TP_fast_assign(
1708 		    __entry->server = server->debug_id;
1709 		    __entry->tx = tx;
1710 		    __entry->addr_index = addr_index;
1711 		    __entry->error = error;
1712 		    __entry->abort_code = abort_code;
1713 		    __entry->rtt_us = rtt_us;
1714 		    memcpy(&__entry->srx, rxrpc_kernel_remote_srx(alist->addrs[addr_index].peer),
1715 			   sizeof(__entry->srx));
1716 			   ),
1717 
1718 	    TP_printk("vl=%08x %s ax=%u e=%d ac=%d rtt=%d %pISpc",
1719 		      __entry->server, __entry->tx ? "tx" : "rx", __entry->addr_index,
1720 		      __entry->error, __entry->abort_code, __entry->rtt_us,
1721 		      &__entry->srx.transport)
1722 	    );
1723 
1724 TRACE_EVENT(afs_rotate,
1725 	    TP_PROTO(struct afs_operation *op, enum afs_rotate_trace reason, unsigned int extra),
1726 
1727 	    TP_ARGS(op, reason, extra),
1728 
1729 	    TP_STRUCT__entry(
1730 		    __field(unsigned int,		op)
1731 		    __field(unsigned int,		flags)
1732 		    __field(unsigned int,		extra)
1733 		    __field(unsigned short,		iteration)
1734 		    __field(short,			server_index)
1735 		    __field(short,			addr_index)
1736 		    __field(enum afs_rotate_trace,	reason)
1737 			     ),
1738 
1739 	    TP_fast_assign(
1740 		    __entry->op = op->debug_id;
1741 		    __entry->flags = op->flags;
1742 		    __entry->iteration = op->nr_iterations;
1743 		    __entry->server_index = op->server_index;
1744 		    __entry->addr_index = op->addr_index;
1745 		    __entry->reason = reason;
1746 		    __entry->extra = extra;
1747 			   ),
1748 
1749 	    TP_printk("OP=%08x it=%02x %s fl=%x sx=%d ax=%d ext=%d",
1750 		      __entry->op,
1751 		      __entry->iteration,
1752 		      __print_symbolic(__entry->reason, afs_rotate_traces),
1753 		      __entry->flags,
1754 		      __entry->server_index,
1755 		      __entry->addr_index,
1756 		      __entry->extra)
1757 	    );
1758 
1759 TRACE_EVENT(afs_make_call,
1760 	    TP_PROTO(struct afs_call *call),
1761 
1762 	    TP_ARGS(call),
1763 
1764 	    TP_STRUCT__entry(
1765 		    __field(unsigned int,		call)
1766 		    __field(bool,			is_vl)
1767 		    __field(enum afs_fs_operation,	op)
1768 		    __field_struct(struct afs_fid,	fid)
1769 		    __field_struct(struct sockaddr_rxrpc, srx)
1770 			     ),
1771 
1772 	    TP_fast_assign(
1773 		    __entry->call = call->debug_id;
1774 		    __entry->op = call->operation_ID;
1775 		    __entry->fid = call->fid;
1776 		    memcpy(&__entry->srx, rxrpc_kernel_remote_srx(call->peer),
1777 			   sizeof(__entry->srx));
1778 		    __entry->srx.srx_service = call->service_id;
1779 		    __entry->is_vl = (__entry->srx.srx_service == VL_SERVICE ||
1780 				      __entry->srx.srx_service == YFS_VL_SERVICE);
1781 			   ),
1782 
1783 	    TP_printk("c=%08x %pISpc+%u %s %llx:%llx:%x",
1784 		      __entry->call,
1785 		      &__entry->srx.transport,
1786 		      __entry->srx.srx_service,
1787 		      __entry->is_vl ?
1788 		      __print_symbolic(__entry->op, afs_vl_operations) :
1789 		      __print_symbolic(__entry->op, afs_fs_operations),
1790 		      __entry->fid.vid,
1791 		      __entry->fid.vnode,
1792 		      __entry->fid.unique)
1793 	    );
1794 
1795 TRACE_EVENT(afs_read_recv,
1796 	    TP_PROTO(const struct afs_operation *op, const struct afs_call *call),
1797 
1798 	    TP_ARGS(op, call),
1799 
1800 	    TP_STRUCT__entry(
1801 		    __field(unsigned int,		rreq)
1802 		    __field(unsigned int,		sreq)
1803 		    __field(unsigned int,		op)
1804 		    __field(unsigned int,		op_flags)
1805 		    __field(unsigned int,		call)
1806 		    __field(enum afs_call_state,	call_state)
1807 			     ),
1808 
1809 	    TP_fast_assign(
1810 		    __entry->op = op->debug_id;
1811 		    __entry->sreq = op->fetch.subreq->debug_index;
1812 		    __entry->rreq = op->fetch.subreq->rreq->debug_id;
1813 		    __entry->op_flags = op->flags;
1814 		    __entry->call = call->debug_id;
1815 		    __entry->call_state = call->state;
1816 			   ),
1817 
1818 	    TP_printk("R=%08x[%x] OP=%08x c=%08x cs=%x of=%x",
1819 		      __entry->rreq, __entry->sreq,
1820 		      __entry->op,
1821 		      __entry->call, __entry->call_state,
1822 		      __entry->op_flags)
1823 	    );
1824 
1825 #endif /* _TRACE_AFS_H */
1826 
1827 /* This part must be outside protection */
1828 #include <trace/define_trace.h>
1829