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
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  21enum 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
  78enum 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
  86enum 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
  98enum 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_alloc,		"ALLOC    ") \
 131	EM(afs_server_trace_callback,		"CALLBACK ") \
 132	EM(afs_server_trace_destroy,		"DESTROY  ") \
 133	EM(afs_server_trace_free,		"FREE     ") \
 134	EM(afs_server_trace_gc,			"GC       ") \
 135	EM(afs_server_trace_get_by_addr,	"GET addr ") \
 136	EM(afs_server_trace_get_by_uuid,	"GET uuid ") \
 137	EM(afs_server_trace_get_caps,		"GET caps ") \
 138	EM(afs_server_trace_get_install,	"GET inst ") \
 139	EM(afs_server_trace_get_new_cbi,	"GET cbi  ") \
 140	EM(afs_server_trace_get_probe,		"GET probe") \
 141	EM(afs_server_trace_give_up_cb,		"giveup-cb") \
 142	EM(afs_server_trace_purging,		"PURGE    ") \
 143	EM(afs_server_trace_put_call,		"PUT call ") \
 144	EM(afs_server_trace_put_cbi,		"PUT cbi  ") \
 145	EM(afs_server_trace_put_find_rsq,	"PUT f-rsq") \
 146	EM(afs_server_trace_put_probe,		"PUT probe") \
 147	EM(afs_server_trace_put_slist,		"PUT slist") \
 148	EM(afs_server_trace_put_slist_isort,	"PUT isort") \
 149	EM(afs_server_trace_put_uuid_rsq,	"PUT u-req") \
 150	E_(afs_server_trace_update,		"UPDATE")
 151
 152#define afs_volume_traces \
 153	EM(afs_volume_trace_alloc,		"ALLOC         ") \
 154	EM(afs_volume_trace_free,		"FREE          ") \
 155	EM(afs_volume_trace_get_alloc_sbi,	"GET sbi-alloc ") \
 156	EM(afs_volume_trace_get_callback,	"GET callback  ") \
 157	EM(afs_volume_trace_get_cell_insert,	"GET cell-insrt") \
 158	EM(afs_volume_trace_get_new_op,		"GET op-new    ") \
 159	EM(afs_volume_trace_get_query_alias,	"GET cell-alias") \
 160	EM(afs_volume_trace_put_callback,	"PUT callback  ") \
 161	EM(afs_volume_trace_put_cell_dup,	"PUT cell-dup  ") \
 162	EM(afs_volume_trace_put_cell_root,	"PUT cell-root ") \
 163	EM(afs_volume_trace_put_destroy_sbi,	"PUT sbi-destry") \
 164	EM(afs_volume_trace_put_free_fc,	"PUT fc-free   ") \
 165	EM(afs_volume_trace_put_put_op,		"PUT op-put    ") \
 166	EM(afs_volume_trace_put_query_alias,	"PUT cell-alias") \
 167	EM(afs_volume_trace_put_validate_fc,	"PUT fc-validat") \
 168	E_(afs_volume_trace_remove,		"REMOVE        ")
 169
 170#define afs_cell_traces \
 171	EM(afs_cell_trace_alloc,		"ALLOC     ") \
 172	EM(afs_cell_trace_free,			"FREE      ") \
 173	EM(afs_cell_trace_get_queue_dns,	"GET q-dns ") \
 174	EM(afs_cell_trace_get_queue_manage,	"GET q-mng ") \
 175	EM(afs_cell_trace_get_queue_new,	"GET q-new ") \
 176	EM(afs_cell_trace_get_server,		"GET server") \
 177	EM(afs_cell_trace_get_vol,		"GET vol   ") \
 178	EM(afs_cell_trace_insert,		"INSERT    ") \
 179	EM(afs_cell_trace_manage,		"MANAGE    ") \
 180	EM(afs_cell_trace_put_candidate,	"PUT candid") \
 181	EM(afs_cell_trace_put_destroy,		"PUT destry") \
 182	EM(afs_cell_trace_put_queue_work,	"PUT q-work") \
 183	EM(afs_cell_trace_put_queue_fail,	"PUT q-fail") \
 184	EM(afs_cell_trace_put_server,		"PUT server") \
 185	EM(afs_cell_trace_put_vol,		"PUT vol   ") \
 186	EM(afs_cell_trace_see_source,		"SEE source") \
 187	EM(afs_cell_trace_see_ws,		"SEE ws    ") \
 188	EM(afs_cell_trace_unuse_alias,		"UNU alias ") \
 189	EM(afs_cell_trace_unuse_check_alias,	"UNU chk-al") \
 190	EM(afs_cell_trace_unuse_delete,		"UNU delete") \
 191	EM(afs_cell_trace_unuse_fc,		"UNU fc    ") \
 192	EM(afs_cell_trace_unuse_lookup,		"UNU lookup") \
 193	EM(afs_cell_trace_unuse_mntpt,		"UNU mntpt ") \
 194	EM(afs_cell_trace_unuse_no_pin,		"UNU no-pin") \
 195	EM(afs_cell_trace_unuse_parse,		"UNU parse ") \
 196	EM(afs_cell_trace_unuse_pin,		"UNU pin   ") \
 197	EM(afs_cell_trace_unuse_probe,		"UNU probe ") \
 198	EM(afs_cell_trace_unuse_sbi,		"UNU sbi   ") \
 199	EM(afs_cell_trace_unuse_ws,		"UNU ws    ") \
 200	EM(afs_cell_trace_use_alias,		"USE alias ") \
 201	EM(afs_cell_trace_use_check_alias,	"USE chk-al") \
 202	EM(afs_cell_trace_use_fc,		"USE fc    ") \
 203	EM(afs_cell_trace_use_fc_alias,		"USE fc-al ") \
 204	EM(afs_cell_trace_use_lookup,		"USE lookup") \
 205	EM(afs_cell_trace_use_mntpt,		"USE mntpt ") \
 206	EM(afs_cell_trace_use_pin,		"USE pin   ") \
 207	EM(afs_cell_trace_use_probe,		"USE probe ") \
 208	EM(afs_cell_trace_use_sbi,		"USE sbi   ") \
 209	E_(afs_cell_trace_wait,			"WAIT      ")
 210
 211#define afs_alist_traces \
 212	EM(afs_alist_trace_alloc,		"ALLOC     ") \
 213	EM(afs_alist_trace_get_estate,		"GET estate") \
 214	EM(afs_alist_trace_get_vlgetcaps,	"GET vgtcap") \
 215	EM(afs_alist_trace_get_vlprobe,		"GET vprobe") \
 216	EM(afs_alist_trace_get_vlrotate_set,	"GET vl-rot") \
 217	EM(afs_alist_trace_put_estate,		"PUT estate") \
 218	EM(afs_alist_trace_put_getaddru,	"PUT GtAdrU") \
 219	EM(afs_alist_trace_put_parse_empty,	"PUT p-empt") \
 220	EM(afs_alist_trace_put_parse_error,	"PUT p-err ") \
 221	EM(afs_alist_trace_put_server_dup,	"PUT sv-dup") \
 222	EM(afs_alist_trace_put_server_oom,	"PUT sv-oom") \
 223	EM(afs_alist_trace_put_server_update,	"PUT sv-upd") \
 224	EM(afs_alist_trace_put_vlgetcaps,	"PUT vgtcap") \
 225	EM(afs_alist_trace_put_vlprobe,		"PUT vprobe") \
 226	EM(afs_alist_trace_put_vlrotate_end,	"PUT vr-end") \
 227	EM(afs_alist_trace_put_vlrotate_fail,	"PUT vr-fai") \
 228	EM(afs_alist_trace_put_vlrotate_next,	"PUT vr-nxt") \
 229	EM(afs_alist_trace_put_vlrotate_restart,"PUT vr-rst") \
 230	EM(afs_alist_trace_put_vlserver,	"PUT vlsrvr") \
 231	EM(afs_alist_trace_put_vlserver_old,	"PUT vs-old") \
 232	E_(afs_alist_trace_free,		"FREE      ")
 233
 234#define afs_estate_traces \
 235	EM(afs_estate_trace_alloc_probe,	"ALLOC prob") \
 236	EM(afs_estate_trace_alloc_server,	"ALLOC srvr") \
 237	EM(afs_estate_trace_get_server_state,	"GET srv-st") \
 238	EM(afs_estate_trace_get_getcaps,	"GET getcap") \
 239	EM(afs_estate_trace_put_getcaps,	"PUT getcap") \
 240	EM(afs_estate_trace_put_probe,		"PUT probe ") \
 241	EM(afs_estate_trace_put_server,		"PUT server") \
 242	EM(afs_estate_trace_put_server_state,	"PUT srv-st") \
 243	E_(afs_estate_trace_free,		"FREE      ")
 244
 245#define afs_fs_operations \
 246	EM(afs_FS_FetchData,			"FS.FetchData") \
 247	EM(afs_FS_FetchStatus,			"FS.FetchStatus") \
 248	EM(afs_FS_StoreData,			"FS.StoreData") \
 249	EM(afs_FS_StoreStatus,			"FS.StoreStatus") \
 250	EM(afs_FS_RemoveFile,			"FS.RemoveFile") \
 251	EM(afs_FS_CreateFile,			"FS.CreateFile") \
 252	EM(afs_FS_Rename,			"FS.Rename") \
 253	EM(afs_FS_Symlink,			"FS.Symlink") \
 254	EM(afs_FS_Link,				"FS.Link") \
 255	EM(afs_FS_MakeDir,			"FS.MakeDir") \
 256	EM(afs_FS_RemoveDir,			"FS.RemoveDir") \
 257	EM(afs_FS_GetVolumeInfo,		"FS.GetVolumeInfo") \
 258	EM(afs_FS_GetVolumeStatus,		"FS.GetVolumeStatus") \
 259	EM(afs_FS_GetRootVolume,		"FS.GetRootVolume") \
 260	EM(afs_FS_SetLock,			"FS.SetLock") \
 261	EM(afs_FS_ExtendLock,			"FS.ExtendLock") \
 262	EM(afs_FS_ReleaseLock,			"FS.ReleaseLock") \
 263	EM(afs_FS_Lookup,			"FS.Lookup") \
 264	EM(afs_FS_InlineBulkStatus,		"FS.InlineBulkStatus") \
 265	EM(afs_FS_FetchData64,			"FS.FetchData64") \
 266	EM(afs_FS_StoreData64,			"FS.StoreData64") \
 267	EM(afs_FS_GiveUpAllCallBacks,		"FS.GiveUpAllCallBacks") \
 268	EM(afs_FS_GetCapabilities,		"FS.GetCapabilities") \
 269	EM(yfs_FS_FetchACL,			"YFS.FetchACL") \
 270	EM(yfs_FS_FetchStatus,			"YFS.FetchStatus") \
 271	EM(yfs_FS_StoreACL,			"YFS.StoreACL") \
 272	EM(yfs_FS_StoreStatus,			"YFS.StoreStatus") \
 273	EM(yfs_FS_RemoveFile,			"YFS.RemoveFile") \
 274	EM(yfs_FS_CreateFile,			"YFS.CreateFile") \
 275	EM(yfs_FS_Rename,			"YFS.Rename") \
 276	EM(yfs_FS_Symlink,			"YFS.Symlink") \
 277	EM(yfs_FS_Link,				"YFS.Link") \
 278	EM(yfs_FS_MakeDir,			"YFS.MakeDir") \
 279	EM(yfs_FS_RemoveDir,			"YFS.RemoveDir") \
 280	EM(yfs_FS_GetVolumeStatus,		"YFS.GetVolumeStatus") \
 281	EM(yfs_FS_SetVolumeStatus,		"YFS.SetVolumeStatus") \
 282	EM(yfs_FS_SetLock,			"YFS.SetLock") \
 283	EM(yfs_FS_ExtendLock,			"YFS.ExtendLock") \
 284	EM(yfs_FS_ReleaseLock,			"YFS.ReleaseLock") \
 285	EM(yfs_FS_Lookup,			"YFS.Lookup") \
 286	EM(yfs_FS_FlushCPS,			"YFS.FlushCPS") \
 287	EM(yfs_FS_FetchOpaqueACL,		"YFS.FetchOpaqueACL") \
 288	EM(yfs_FS_WhoAmI,			"YFS.WhoAmI") \
 289	EM(yfs_FS_RemoveACL,			"YFS.RemoveACL") \
 290	EM(yfs_FS_RemoveFile2,			"YFS.RemoveFile2") \
 291	EM(yfs_FS_StoreOpaqueACL2,		"YFS.StoreOpaqueACL2") \
 292	EM(yfs_FS_InlineBulkStatus,		"YFS.InlineBulkStatus") \
 293	EM(yfs_FS_FetchData64,			"YFS.FetchData64") \
 294	EM(yfs_FS_StoreData64,			"YFS.StoreData64") \
 295	E_(yfs_FS_UpdateSymlink,		"YFS.UpdateSymlink")
 296
 297#define afs_vl_operations \
 298	EM(afs_VL_GetEntryByNameU,		"VL.GetEntryByNameU") \
 299	EM(afs_VL_GetAddrsU,			"VL.GetAddrsU") \
 300	EM(afs_YFSVL_GetEndpoints,		"YFSVL.GetEndpoints") \
 301	EM(afs_YFSVL_GetCellName,		"YFSVL.GetCellName") \
 302	E_(afs_VL_GetCapabilities,		"VL.GetCapabilities")
 303
 304#define afs_cm_operations \
 305	EM(afs_CB_CallBack,			"CB.CallBack") \
 306	EM(afs_CB_InitCallBackState,		"CB.InitCallBackState") \
 307	EM(afs_CB_Probe,			"CB.Probe") \
 308	EM(afs_CB_GetLock,			"CB.GetLock") \
 309	EM(afs_CB_GetCE,			"CB.GetCE") \
 310	EM(afs_CB_GetXStatsVersion,		"CB.GetXStatsVersion") \
 311	EM(afs_CB_GetXStats,			"CB.GetXStats") \
 312	EM(afs_CB_InitCallBackState3,		"CB.InitCallBackState3") \
 313	E_(afs_CB_ProbeUuid,			"CB.ProbeUuid")
 314
 315#define yfs_cm_operations \
 316	EM(yfs_CB_Probe,			"YFSCB.Probe") \
 317	EM(yfs_CB_GetLock,			"YFSCB.GetLock") \
 318	EM(yfs_CB_XStatsVersion,		"YFSCB.XStatsVersion") \
 319	EM(yfs_CB_GetXStats,			"YFSCB.GetXStats") \
 320	EM(yfs_CB_InitCallBackState3,		"YFSCB.InitCallBackState3") \
 321	EM(yfs_CB_ProbeUuid,			"YFSCB.ProbeUuid") \
 322	EM(yfs_CB_GetServerPrefs,		"YFSCB.GetServerPrefs") \
 323	EM(yfs_CB_GetCellServDV,		"YFSCB.GetCellServDV") \
 324	EM(yfs_CB_GetLocalCell,			"YFSCB.GetLocalCell") \
 325	EM(yfs_CB_GetCacheConfig,		"YFSCB.GetCacheConfig") \
 326	EM(yfs_CB_GetCellByNum,			"YFSCB.GetCellByNum") \
 327	EM(yfs_CB_TellMeAboutYourself,		"YFSCB.TellMeAboutYourself") \
 328	E_(yfs_CB_CallBack,			"YFSCB.CallBack")
 329
 330#define afs_edit_dir_ops				  \
 331	EM(afs_edit_dir_create,			"create") \
 332	EM(afs_edit_dir_create_error,		"c_fail") \
 333	EM(afs_edit_dir_create_inval,		"c_invl") \
 334	EM(afs_edit_dir_create_nospc,		"c_nspc") \
 335	EM(afs_edit_dir_delete,			"delete") \
 336	EM(afs_edit_dir_delete_error,		"d_err ") \
 337	EM(afs_edit_dir_delete_inval,		"d_invl") \
 338	EM(afs_edit_dir_delete_noent,		"d_nent") \
 339	EM(afs_edit_dir_update_dd,		"u_ddot") \
 340	EM(afs_edit_dir_update_error,		"u_fail") \
 341	EM(afs_edit_dir_update_inval,		"u_invl") \
 342	E_(afs_edit_dir_update_nodd,		"u_nodd")
 343
 344#define afs_edit_dir_reasons				  \
 345	EM(afs_edit_dir_for_create,		"Create") \
 346	EM(afs_edit_dir_for_link,		"Link  ") \
 347	EM(afs_edit_dir_for_mkdir,		"MkDir ") \
 348	EM(afs_edit_dir_for_rename_0,		"Renam0") \
 349	EM(afs_edit_dir_for_rename_1,		"Renam1") \
 350	EM(afs_edit_dir_for_rename_2,		"Renam2") \
 351	EM(afs_edit_dir_for_rename_sub,		"RnmSub") \
 352	EM(afs_edit_dir_for_rmdir,		"RmDir ") \
 353	EM(afs_edit_dir_for_silly_0,		"S_Ren0") \
 354	EM(afs_edit_dir_for_silly_1,		"S_Ren1") \
 355	EM(afs_edit_dir_for_symlink,		"Symlnk") \
 356	E_(afs_edit_dir_for_unlink,		"Unlink")
 357
 358#define afs_eproto_causes			\
 359	EM(afs_eproto_bad_status,	"BadStatus") \
 360	EM(afs_eproto_cb_count,		"CbCount") \
 361	EM(afs_eproto_cb_fid_count,	"CbFidCount") \
 362	EM(afs_eproto_cellname_len,	"CellNameLen") \
 363	EM(afs_eproto_file_type,	"FileTYpe") \
 364	EM(afs_eproto_ibulkst_cb_count,	"IBS.CbCount") \
 365	EM(afs_eproto_ibulkst_count,	"IBS.FidCount") \
 366	EM(afs_eproto_motd_len,		"MotdLen") \
 367	EM(afs_eproto_offline_msg_len,	"OfflineMsgLen") \
 368	EM(afs_eproto_volname_len,	"VolNameLen") \
 369	EM(afs_eproto_yvl_fsendpt4_len,	"YVL.FsEnd4Len") \
 370	EM(afs_eproto_yvl_fsendpt6_len,	"YVL.FsEnd6Len") \
 371	EM(afs_eproto_yvl_fsendpt_num,	"YVL.FsEndCount") \
 372	EM(afs_eproto_yvl_fsendpt_type,	"YVL.FsEndType") \
 373	EM(afs_eproto_yvl_vlendpt4_len,	"YVL.VlEnd4Len") \
 374	EM(afs_eproto_yvl_vlendpt6_len,	"YVL.VlEnd6Len") \
 375	E_(afs_eproto_yvl_vlendpt_type,	"YVL.VlEndType")
 376
 377#define afs_io_errors							\
 378	EM(afs_io_error_cm_reply,		"CM_REPLY")		\
 379	EM(afs_io_error_extract,		"EXTRACT")		\
 380	EM(afs_io_error_fs_probe_fail,		"FS_PROBE_FAIL")	\
 381	EM(afs_io_error_vl_lookup_fail,		"VL_LOOKUP_FAIL")	\
 382	E_(afs_io_error_vl_probe_fail,		"VL_PROBE_FAIL")
 383
 384#define afs_file_errors							\
 385	EM(afs_file_error_dir_bad_magic,	"DIR_BAD_MAGIC")	\
 386	EM(afs_file_error_dir_big,		"DIR_BIG")		\
 387	EM(afs_file_error_dir_missing_page,	"DIR_MISSING_PAGE")	\
 388	EM(afs_file_error_dir_name_too_long,	"DIR_NAME_TOO_LONG")	\
 389	EM(afs_file_error_dir_over_end,		"DIR_ENT_OVER_END")	\
 390	EM(afs_file_error_dir_small,		"DIR_SMALL")		\
 391	EM(afs_file_error_dir_unmarked_ext,	"DIR_UNMARKED_EXT")	\
 392	EM(afs_file_error_mntpt,		"MNTPT_READ_FAILED")	\
 393	E_(afs_file_error_writeback_fail,	"WRITEBACK_FAILED")
 394
 395#define afs_flock_types							\
 396	EM(F_RDLCK,				"RDLCK")		\
 397	EM(F_WRLCK,				"WRLCK")		\
 398	E_(F_UNLCK,				"UNLCK")
 399
 400#define afs_flock_states						\
 401	EM(AFS_VNODE_LOCK_NONE,			"NONE")			\
 402	EM(AFS_VNODE_LOCK_WAITING_FOR_CB,	"WAIT_FOR_CB")		\
 403	EM(AFS_VNODE_LOCK_SETTING,		"SETTING")		\
 404	EM(AFS_VNODE_LOCK_GRANTED,		"GRANTED")		\
 405	EM(AFS_VNODE_LOCK_EXTENDING,		"EXTENDING")		\
 406	EM(AFS_VNODE_LOCK_NEED_UNLOCK,		"NEED_UNLOCK")		\
 407	EM(AFS_VNODE_LOCK_UNLOCKING,		"UNLOCKING")		\
 408	E_(AFS_VNODE_LOCK_DELETED,		"DELETED")
 409
 410#define afs_flock_events						\
 411	EM(afs_flock_acquired,			"Acquired")		\
 412	EM(afs_flock_callback_break,		"Callback")		\
 413	EM(afs_flock_defer_unlock,		"D-Unlock")		\
 414	EM(afs_flock_extend_fail,		"Ext_Fail")		\
 415	EM(afs_flock_fail_other,		"ErrOther")		\
 416	EM(afs_flock_fail_perm,			"ErrPerm ")		\
 417	EM(afs_flock_no_lockers,		"NoLocker")		\
 418	EM(afs_flock_release_fail,		"Rel_Fail")		\
 419	EM(afs_flock_silly_delete,		"SillyDel")		\
 420	EM(afs_flock_timestamp,			"Timestmp")		\
 421	EM(afs_flock_try_to_lock,		"TryToLck")		\
 422	EM(afs_flock_vfs_lock,			"VFSLock ")		\
 423	EM(afs_flock_vfs_locking,		"VFSLking")		\
 424	EM(afs_flock_waited,			"Waited  ")		\
 425	EM(afs_flock_waiting,			"Waiting ")		\
 426	EM(afs_flock_work_extending,		"Extendng")		\
 427	EM(afs_flock_work_retry,		"Retry   ")		\
 428	EM(afs_flock_work_unlocking,		"Unlcking")		\
 429	E_(afs_flock_would_block,		"EWOULDBL")
 430
 431#define afs_flock_operations						\
 432	EM(afs_flock_op_copy_lock,		"COPY    ")		\
 433	EM(afs_flock_op_flock,			"->flock ")		\
 434	EM(afs_flock_op_grant,			"GRANT   ")		\
 435	EM(afs_flock_op_lock,			"->lock  ")		\
 436	EM(afs_flock_op_release_lock,		"RELEASE ")		\
 437	EM(afs_flock_op_return_ok,		"<-OK    ")		\
 438	EM(afs_flock_op_return_edeadlk,		"<-EDEADL")		\
 439	EM(afs_flock_op_return_eagain,		"<-EAGAIN")		\
 440	EM(afs_flock_op_return_error,		"<-ERROR ")		\
 441	EM(afs_flock_op_set_lock,		"SET     ")		\
 442	EM(afs_flock_op_unlock,			"UNLOCK  ")		\
 443	E_(afs_flock_op_wake,			"WAKE    ")
 444
 445#define afs_cb_break_reasons						\
 446	EM(afs_cb_break_no_break,		"no-break")		\
 447	EM(afs_cb_break_for_callback,		"break-cb")		\
 448	EM(afs_cb_break_for_creation_regress,	"creation-regress")	\
 449	EM(afs_cb_break_for_deleted,		"break-del")		\
 450	EM(afs_cb_break_for_s_reinit,		"s-reinit")		\
 451	EM(afs_cb_break_for_unlink,		"break-unlink")		\
 452	EM(afs_cb_break_for_update_regress,	"update-regress")	\
 453	EM(afs_cb_break_for_volume_callback,	"break-v-cb")		\
 454	EM(afs_cb_break_for_vos_release,	"break-vos-release")	\
 455	E_(afs_cb_break_volume_excluded,	"vol-excluded")
 456
 457#define afs_rotate_traces						\
 458	EM(afs_rotate_trace_aborted,		"Abortd")		\
 459	EM(afs_rotate_trace_busy_sleep,		"BsySlp")		\
 460	EM(afs_rotate_trace_check_vol_status,	"VolStt")		\
 461	EM(afs_rotate_trace_failed,		"Failed")		\
 462	EM(afs_rotate_trace_iter,		"Iter  ")		\
 463	EM(afs_rotate_trace_iterate_addr,	"ItAddr")		\
 464	EM(afs_rotate_trace_next_server,	"NextSv")		\
 465	EM(afs_rotate_trace_no_more_servers,	"NoMore")		\
 466	EM(afs_rotate_trace_nomem,		"Nomem ")		\
 467	EM(afs_rotate_trace_probe_error,	"PrbErr")		\
 468	EM(afs_rotate_trace_probe_fileserver,	"PrbFsv")		\
 469	EM(afs_rotate_trace_probe_none,		"PrbNon")		\
 470	EM(afs_rotate_trace_probe_response,	"PrbRsp")		\
 471	EM(afs_rotate_trace_probe_superseded,	"PrbSup")		\
 472	EM(afs_rotate_trace_restart,		"Rstart")		\
 473	EM(afs_rotate_trace_retry_server,	"RtrySv")		\
 474	EM(afs_rotate_trace_selected_server,	"SlctSv")		\
 475	EM(afs_rotate_trace_stale_lock,		"StlLck")		\
 476	EM(afs_rotate_trace_start,		"Start ")		\
 477	EM(afs_rotate_trace_stop,		"Stop  ")		\
 478	E_(afs_rotate_trace_stopped,		"Stoppd")
 479
 480/*
 481 * Generate enums for tracing information.
 482 */
 483#ifndef __AFS_GENERATE_TRACE_ENUMS_ONCE_ONLY
 484#define __AFS_GENERATE_TRACE_ENUMS_ONCE_ONLY
 485
 486#undef EM
 487#undef E_
 488#define EM(a, b) a,
 489#define E_(a, b) a
 490
 491enum afs_alist_trace		{ afs_alist_traces } __mode(byte);
 492enum afs_call_trace		{ afs_call_traces } __mode(byte);
 493enum afs_cb_break_reason	{ afs_cb_break_reasons } __mode(byte);
 494enum afs_cell_trace		{ afs_cell_traces } __mode(byte);
 495enum afs_edit_dir_op		{ afs_edit_dir_ops } __mode(byte);
 496enum afs_edit_dir_reason	{ afs_edit_dir_reasons } __mode(byte);
 497enum afs_eproto_cause		{ afs_eproto_causes } __mode(byte);
 498enum afs_estate_trace		{ afs_estate_traces } __mode(byte);
 499enum afs_file_error		{ afs_file_errors } __mode(byte);
 500enum afs_flock_event		{ afs_flock_events } __mode(byte);
 501enum afs_flock_operation	{ afs_flock_operations } __mode(byte);
 502enum afs_io_error		{ afs_io_errors } __mode(byte);
 503enum afs_rotate_trace		{ afs_rotate_traces } __mode(byte);
 504enum afs_server_trace		{ afs_server_traces } __mode(byte);
 505enum afs_volume_trace		{ afs_volume_traces } __mode(byte);
 506
 507#endif /* end __AFS_GENERATE_TRACE_ENUMS_ONCE_ONLY */
 508
 509/*
 510 * Export enum symbols via userspace.
 511 */
 512#undef EM
 513#undef E_
 514#define EM(a, b) TRACE_DEFINE_ENUM(a);
 515#define E_(a, b) TRACE_DEFINE_ENUM(a);
 516
 517afs_alist_traces;
 518afs_call_traces;
 519afs_cb_break_reasons;
 520afs_cell_traces;
 521afs_cm_operations;
 522afs_edit_dir_ops;
 523afs_edit_dir_reasons;
 524afs_eproto_causes;
 525afs_estate_traces;
 526afs_file_errors;
 527afs_flock_operations;
 528afs_flock_types;
 529afs_fs_operations;
 530afs_io_errors;
 531afs_rotate_traces;
 532afs_server_traces;
 533afs_vl_operations;
 534yfs_cm_operations;
 535
 536/*
 537 * Now redefine the EM() and E_() macros to map the enums to the strings that
 538 * will be printed in the output.
 539 */
 540#undef EM
 541#undef E_
 542#define EM(a, b)	{ a, b },
 543#define E_(a, b)	{ a, b }
 544
 545TRACE_EVENT(afs_receive_data,
 546	    TP_PROTO(struct afs_call *call, struct iov_iter *iter,
 547		     bool want_more, int ret),
 548
 549	    TP_ARGS(call, iter, want_more, ret),
 550
 551	    TP_STRUCT__entry(
 552		    __field(loff_t,			remain)
 553		    __field(unsigned int,		call)
 554		    __field(enum afs_call_state,	state)
 555		    __field(unsigned short,		unmarshall)
 556		    __field(bool,			want_more)
 557		    __field(int,			ret)
 558			     ),
 559
 560	    TP_fast_assign(
 561		    __entry->call	= call->debug_id;
 562		    __entry->state	= call->state;
 563		    __entry->unmarshall	= call->unmarshall;
 564		    __entry->remain	= iov_iter_count(iter);
 565		    __entry->want_more	= want_more;
 566		    __entry->ret	= ret;
 567			   ),
 568
 569	    TP_printk("c=%08x r=%llu u=%u w=%u s=%u ret=%d",
 570		      __entry->call,
 571		      __entry->remain,
 572		      __entry->unmarshall,
 573		      __entry->want_more,
 574		      __entry->state,
 575		      __entry->ret)
 576	    );
 577
 578TRACE_EVENT(afs_notify_call,
 579	    TP_PROTO(struct rxrpc_call *rxcall, struct afs_call *call),
 580
 581	    TP_ARGS(rxcall, call),
 582
 583	    TP_STRUCT__entry(
 584		    __field(unsigned int,		call)
 585		    __field(enum afs_call_state,	state)
 586		    __field(unsigned short,		unmarshall)
 587			     ),
 588
 589	    TP_fast_assign(
 590		    __entry->call	= call->debug_id;
 591		    __entry->state	= call->state;
 592		    __entry->unmarshall	= call->unmarshall;
 593			   ),
 594
 595	    TP_printk("c=%08x s=%u u=%u",
 596		      __entry->call,
 597		      __entry->state, __entry->unmarshall)
 598	    );
 599
 600TRACE_EVENT(afs_cb_call,
 601	    TP_PROTO(struct afs_call *call),
 602
 603	    TP_ARGS(call),
 604
 605	    TP_STRUCT__entry(
 606		    __field(unsigned int,		call)
 607		    __field(u32,			op)
 608		    __field(u16,			service_id)
 609			     ),
 610
 611	    TP_fast_assign(
 612		    __entry->call	= call->debug_id;
 
 613		    __entry->op		= call->operation_ID;
 614		    __entry->service_id	= call->service_id;
 615			   ),
 616
 617	    TP_printk("c=%08x %s",
 618		      __entry->call,
 619		      __entry->service_id == 2501 ?
 620		      __print_symbolic(__entry->op, yfs_cm_operations) :
 621		      __print_symbolic(__entry->op, afs_cm_operations))
 622	    );
 623
 624TRACE_EVENT(afs_call,
 625	    TP_PROTO(unsigned int call_debug_id, enum afs_call_trace op,
 626		     int ref, int outstanding, const void *where),
 627
 628	    TP_ARGS(call_debug_id, op, ref, outstanding, where),
 629
 630	    TP_STRUCT__entry(
 631		    __field(unsigned int,		call)
 632		    __field(int,			op)
 633		    __field(int,			ref)
 634		    __field(int,			outstanding)
 635		    __field(const void *,		where)
 636			     ),
 637
 638	    TP_fast_assign(
 639		    __entry->call = call_debug_id;
 640		    __entry->op = op;
 641		    __entry->ref = ref;
 642		    __entry->outstanding = outstanding;
 643		    __entry->where = where;
 644			   ),
 645
 646	    TP_printk("c=%08x %s r=%d o=%d sp=%pSR",
 647		      __entry->call,
 648		      __print_symbolic(__entry->op, afs_call_traces),
 649		      __entry->ref,
 650		      __entry->outstanding,
 651		      __entry->where)
 652	    );
 653
 654TRACE_EVENT(afs_make_fs_call,
 655	    TP_PROTO(struct afs_call *call, const struct afs_fid *fid),
 656
 657	    TP_ARGS(call, fid),
 658
 659	    TP_STRUCT__entry(
 660		    __field(unsigned int,		call)
 661		    __field(enum afs_fs_operation,	op)
 662		    __field_struct(struct afs_fid,	fid)
 663			     ),
 664
 665	    TP_fast_assign(
 666		    __entry->call = call->debug_id;
 667		    __entry->op = call->operation_ID;
 668		    if (fid) {
 669			    __entry->fid = *fid;
 670		    } else {
 671			    __entry->fid.vid = 0;
 672			    __entry->fid.vnode = 0;
 673			    __entry->fid.unique = 0;
 674		    }
 675			   ),
 676
 677	    TP_printk("c=%08x %06llx:%06llx:%06x %s",
 678		      __entry->call,
 679		      __entry->fid.vid,
 680		      __entry->fid.vnode,
 681		      __entry->fid.unique,
 682		      __print_symbolic(__entry->op, afs_fs_operations))
 683	    );
 684
 685TRACE_EVENT(afs_make_fs_calli,
 686	    TP_PROTO(struct afs_call *call, const struct afs_fid *fid,
 687		     unsigned int i),
 688
 689	    TP_ARGS(call, fid, i),
 690
 691	    TP_STRUCT__entry(
 692		    __field(unsigned int,		call)
 693		    __field(unsigned int,		i)
 694		    __field(enum afs_fs_operation,	op)
 695		    __field_struct(struct afs_fid,	fid)
 696			     ),
 697
 698	    TP_fast_assign(
 699		    __entry->call = call->debug_id;
 700		    __entry->i = i;
 701		    __entry->op = call->operation_ID;
 702		    if (fid) {
 703			    __entry->fid = *fid;
 704		    } else {
 705			    __entry->fid.vid = 0;
 706			    __entry->fid.vnode = 0;
 707			    __entry->fid.unique = 0;
 708		    }
 709			   ),
 710
 711	    TP_printk("c=%08x %06llx:%06llx:%06x %s i=%u",
 712		      __entry->call,
 713		      __entry->fid.vid,
 714		      __entry->fid.vnode,
 715		      __entry->fid.unique,
 716		      __print_symbolic(__entry->op, afs_fs_operations),
 717		      __entry->i)
 718	    );
 719
 720TRACE_EVENT(afs_make_fs_call1,
 721	    TP_PROTO(struct afs_call *call, const struct afs_fid *fid,
 722		     const struct qstr *name),
 723
 724	    TP_ARGS(call, fid, name),
 725
 726	    TP_STRUCT__entry(
 727		    __field(unsigned int,		call)
 728		    __field(enum afs_fs_operation,	op)
 729		    __field_struct(struct afs_fid,	fid)
 730		    __array(char,			name, 24)
 731			     ),
 732
 733	    TP_fast_assign(
 734		    unsigned int __len = min_t(unsigned int, name->len, 23);
 
 735		    __entry->call = call->debug_id;
 736		    __entry->op = call->operation_ID;
 737		    if (fid) {
 738			    __entry->fid = *fid;
 739		    } else {
 740			    __entry->fid.vid = 0;
 741			    __entry->fid.vnode = 0;
 742			    __entry->fid.unique = 0;
 743		    }
 744		    memcpy(__entry->name, name->name, __len);
 745		    __entry->name[__len] = 0;
 746			   ),
 747
 748	    TP_printk("c=%08x %06llx:%06llx:%06x %s \"%s\"",
 749		      __entry->call,
 750		      __entry->fid.vid,
 751		      __entry->fid.vnode,
 752		      __entry->fid.unique,
 753		      __print_symbolic(__entry->op, afs_fs_operations),
 754		      __entry->name)
 755	    );
 756
 757TRACE_EVENT(afs_make_fs_call2,
 758	    TP_PROTO(struct afs_call *call, const struct afs_fid *fid,
 759		     const struct qstr *name, const struct qstr *name2),
 760
 761	    TP_ARGS(call, fid, name, name2),
 762
 763	    TP_STRUCT__entry(
 764		    __field(unsigned int,		call)
 765		    __field(enum afs_fs_operation,	op)
 766		    __field_struct(struct afs_fid,	fid)
 767		    __array(char,			name, 24)
 768		    __array(char,			name2, 24)
 769			     ),
 770
 771	    TP_fast_assign(
 772		    unsigned int __len = min_t(unsigned int, name->len, 23);
 773		    unsigned int __len2 = min_t(unsigned int, name2->len, 23);
 
 
 774		    __entry->call = call->debug_id;
 775		    __entry->op = call->operation_ID;
 776		    if (fid) {
 777			    __entry->fid = *fid;
 778		    } else {
 779			    __entry->fid.vid = 0;
 780			    __entry->fid.vnode = 0;
 781			    __entry->fid.unique = 0;
 782		    }
 783		    memcpy(__entry->name, name->name, __len);
 784		    __entry->name[__len] = 0;
 785		    memcpy(__entry->name2, name2->name, __len2);
 786		    __entry->name2[__len2] = 0;
 787			   ),
 788
 789	    TP_printk("c=%08x %06llx:%06llx:%06x %s \"%s\" \"%s\"",
 790		      __entry->call,
 791		      __entry->fid.vid,
 792		      __entry->fid.vnode,
 793		      __entry->fid.unique,
 794		      __print_symbolic(__entry->op, afs_fs_operations),
 795		      __entry->name,
 796		      __entry->name2)
 797	    );
 798
 799TRACE_EVENT(afs_make_vl_call,
 800	    TP_PROTO(struct afs_call *call),
 801
 802	    TP_ARGS(call),
 803
 804	    TP_STRUCT__entry(
 805		    __field(unsigned int,		call)
 806		    __field(enum afs_vl_operation,	op)
 807			     ),
 808
 809	    TP_fast_assign(
 810		    __entry->call = call->debug_id;
 811		    __entry->op = call->operation_ID;
 812			   ),
 813
 814	    TP_printk("c=%08x %s",
 815		      __entry->call,
 816		      __print_symbolic(__entry->op, afs_vl_operations))
 817	    );
 818
 819TRACE_EVENT(afs_call_done,
 820	    TP_PROTO(struct afs_call *call),
 821
 822	    TP_ARGS(call),
 823
 824	    TP_STRUCT__entry(
 825		    __field(unsigned int,		call)
 826		    __field(struct rxrpc_call *,	rx_call)
 827		    __field(int,			ret)
 828		    __field(u32,			abort_code)
 829			     ),
 830
 831	    TP_fast_assign(
 832		    __entry->call = call->debug_id;
 833		    __entry->rx_call = call->rxcall;
 834		    __entry->ret = call->error;
 835		    __entry->abort_code = call->abort_code;
 836			   ),
 837
 838	    TP_printk("   c=%08x ret=%d ab=%d [%p]",
 839		      __entry->call,
 840		      __entry->ret,
 841		      __entry->abort_code,
 842		      __entry->rx_call)
 843	    );
 844
 845TRACE_EVENT(afs_send_data,
 846	    TP_PROTO(struct afs_call *call, struct msghdr *msg),
 847
 848	    TP_ARGS(call, msg),
 
 849
 850	    TP_STRUCT__entry(
 851		    __field(unsigned int,		call)
 852		    __field(unsigned int,		flags)
 853		    __field(loff_t,			offset)
 854		    __field(loff_t,			count)
 
 
 
 855			     ),
 856
 857	    TP_fast_assign(
 858		    __entry->call = call->debug_id;
 
 
 
 
 
 859		    __entry->flags = msg->msg_flags;
 860		    __entry->offset = msg->msg_iter.xarray_start + msg->msg_iter.iov_offset;
 861		    __entry->count = iov_iter_count(&msg->msg_iter);
 862			   ),
 863
 864	    TP_printk(" c=%08x o=%llx n=%llx f=%x",
 865		      __entry->call, __entry->offset, __entry->count,
 
 
 866		      __entry->flags)
 867	    );
 868
 869TRACE_EVENT(afs_sent_data,
 870	    TP_PROTO(struct afs_call *call, struct msghdr *msg, int ret),
 871
 872	    TP_ARGS(call, msg, ret),
 
 873
 874	    TP_STRUCT__entry(
 875		    __field(unsigned int,		call)
 876		    __field(int,			ret)
 877		    __field(loff_t,			offset)
 878		    __field(loff_t,			count)
 
 879			     ),
 880
 881	    TP_fast_assign(
 882		    __entry->call = call->debug_id;
 
 
 
 883		    __entry->ret = ret;
 884		    __entry->offset = msg->msg_iter.xarray_start + msg->msg_iter.iov_offset;
 885		    __entry->count = iov_iter_count(&msg->msg_iter);
 886			   ),
 887
 888	    TP_printk(" c=%08x o=%llx n=%llx r=%x",
 889		      __entry->call, __entry->offset, __entry->count,
 890		      __entry->ret)
 
 891	    );
 892
 893TRACE_EVENT(afs_dir_check_failed,
 894	    TP_PROTO(struct afs_vnode *vnode, loff_t off, loff_t i_size),
 895
 896	    TP_ARGS(vnode, off, i_size),
 897
 898	    TP_STRUCT__entry(
 899		    __field(struct afs_vnode *,		vnode)
 900		    __field(loff_t,			off)
 901		    __field(loff_t,			i_size)
 902			     ),
 903
 904	    TP_fast_assign(
 905		    __entry->vnode = vnode;
 906		    __entry->off = off;
 907		    __entry->i_size = i_size;
 908			   ),
 909
 910	    TP_printk("vn=%p %llx/%llx",
 911		      __entry->vnode, __entry->off, __entry->i_size)
 912	    );
 913
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 914TRACE_EVENT(afs_call_state,
 915	    TP_PROTO(struct afs_call *call,
 916		     enum afs_call_state from,
 917		     enum afs_call_state to,
 918		     int ret, u32 remote_abort),
 919
 920	    TP_ARGS(call, from, to, ret, remote_abort),
 921
 922	    TP_STRUCT__entry(
 923		    __field(unsigned int,		call)
 924		    __field(enum afs_call_state,	from)
 925		    __field(enum afs_call_state,	to)
 926		    __field(int,			ret)
 927		    __field(u32,			abort)
 928			     ),
 929
 930	    TP_fast_assign(
 931		    __entry->call = call->debug_id;
 932		    __entry->from = from;
 933		    __entry->to = to;
 934		    __entry->ret = ret;
 935		    __entry->abort = remote_abort;
 936			   ),
 937
 938	    TP_printk("c=%08x %u->%u r=%d ab=%d",
 939		      __entry->call,
 940		      __entry->from, __entry->to,
 941		      __entry->ret, __entry->abort)
 942	    );
 943
 944TRACE_EVENT(afs_lookup,
 945	    TP_PROTO(struct afs_vnode *dvnode, const struct qstr *name,
 946		     struct afs_fid *fid),
 947
 948	    TP_ARGS(dvnode, name, fid),
 949
 950	    TP_STRUCT__entry(
 951		    __field_struct(struct afs_fid,	dfid)
 952		    __field_struct(struct afs_fid,	fid)
 953		    __array(char,			name, 24)
 954			     ),
 955
 956	    TP_fast_assign(
 957		    int __len = min_t(int, name->len, 23);
 958		    __entry->dfid = dvnode->fid;
 959		    __entry->fid = *fid;
 
 
 
 
 
 
 960		    memcpy(__entry->name, name->name, __len);
 961		    __entry->name[__len] = 0;
 962			   ),
 963
 964	    TP_printk("d=%llx:%llx:%x \"%s\" f=%llx:%x",
 965		      __entry->dfid.vid, __entry->dfid.vnode, __entry->dfid.unique,
 966		      __entry->name,
 967		      __entry->fid.vnode, __entry->fid.unique)
 968	    );
 969
 970TRACE_EVENT(afs_edit_dir,
 971	    TP_PROTO(struct afs_vnode *dvnode,
 972		     enum afs_edit_dir_reason why,
 973		     enum afs_edit_dir_op op,
 974		     unsigned int block,
 975		     unsigned int slot,
 976		     unsigned int f_vnode,
 977		     unsigned int f_unique,
 978		     const char *name),
 979
 980	    TP_ARGS(dvnode, why, op, block, slot, f_vnode, f_unique, name),
 981
 982	    TP_STRUCT__entry(
 983		    __field(unsigned int,		vnode)
 984		    __field(unsigned int,		unique)
 985		    __field(enum afs_edit_dir_reason,	why)
 986		    __field(enum afs_edit_dir_op,	op)
 987		    __field(unsigned int,		block)
 988		    __field(unsigned short,		slot)
 989		    __field(unsigned int,		f_vnode)
 990		    __field(unsigned int,		f_unique)
 991		    __array(char,			name, 24)
 992			     ),
 993
 994	    TP_fast_assign(
 995		    int __len = strlen(name);
 996		    __len = min(__len, 23);
 997		    __entry->vnode	= dvnode->fid.vnode;
 998		    __entry->unique	= dvnode->fid.unique;
 999		    __entry->why	= why;
1000		    __entry->op		= op;
1001		    __entry->block	= block;
1002		    __entry->slot	= slot;
1003		    __entry->f_vnode	= f_vnode;
1004		    __entry->f_unique	= f_unique;
1005		    memcpy(__entry->name, name, __len);
1006		    __entry->name[__len] = 0;
1007			   ),
1008
1009	    TP_printk("d=%x:%x %s %s %u[%u] f=%x:%x \"%s\"",
1010		      __entry->vnode, __entry->unique,
1011		      __print_symbolic(__entry->why, afs_edit_dir_reasons),
1012		      __print_symbolic(__entry->op, afs_edit_dir_ops),
1013		      __entry->block, __entry->slot,
1014		      __entry->f_vnode, __entry->f_unique,
1015		      __entry->name)
1016	    );
1017
1018TRACE_EVENT(afs_protocol_error,
1019	    TP_PROTO(struct afs_call *call, enum afs_eproto_cause cause),
1020
1021	    TP_ARGS(call, cause),
1022
1023	    TP_STRUCT__entry(
1024		    __field(unsigned int,		call)
1025		    __field(enum afs_eproto_cause,	cause)
 
1026			     ),
1027
1028	    TP_fast_assign(
1029		    __entry->call = call ? call->debug_id : 0;
 
1030		    __entry->cause = cause;
1031			   ),
1032
1033	    TP_printk("c=%08x %s",
1034		      __entry->call,
1035		      __print_symbolic(__entry->cause, afs_eproto_causes))
1036	    );
1037
1038TRACE_EVENT(afs_io_error,
1039	    TP_PROTO(unsigned int call, int error, enum afs_io_error where),
1040
1041	    TP_ARGS(call, error, where),
1042
1043	    TP_STRUCT__entry(
1044		    __field(unsigned int,	call)
1045		    __field(int,		error)
1046		    __field(enum afs_io_error,	where)
1047			     ),
1048
1049	    TP_fast_assign(
1050		    __entry->call = call;
1051		    __entry->error = error;
1052		    __entry->where = where;
1053			   ),
1054
1055	    TP_printk("c=%08x r=%d %s",
1056		      __entry->call, __entry->error,
1057		      __print_symbolic(__entry->where, afs_io_errors))
1058	    );
1059
1060TRACE_EVENT(afs_file_error,
1061	    TP_PROTO(struct afs_vnode *vnode, int error, enum afs_file_error where),
1062
1063	    TP_ARGS(vnode, error, where),
1064
1065	    TP_STRUCT__entry(
1066		    __field_struct(struct afs_fid,	fid)
1067		    __field(int,			error)
1068		    __field(enum afs_file_error,	where)
1069			     ),
1070
1071	    TP_fast_assign(
1072		    __entry->fid = vnode->fid;
1073		    __entry->error = error;
1074		    __entry->where = where;
1075			   ),
1076
1077	    TP_printk("%llx:%llx:%x r=%d %s",
1078		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1079		      __entry->error,
1080		      __print_symbolic(__entry->where, afs_file_errors))
1081	    );
1082
1083TRACE_EVENT(afs_bulkstat_error,
1084	    TP_PROTO(struct afs_operation *op, struct afs_fid *fid, unsigned int index, s32 abort),
1085
1086	    TP_ARGS(op, fid, index, abort),
1087
1088	    TP_STRUCT__entry(
1089		    __field_struct(struct afs_fid,	fid)
1090		    __field(unsigned int,		op)
1091		    __field(unsigned int,		index)
1092		    __field(s32,			abort)
1093			     ),
1094
1095	    TP_fast_assign(
1096		    __entry->op = op->debug_id;
1097		    __entry->fid = *fid;
1098		    __entry->index = index;
1099		    __entry->abort = abort;
1100			   ),
1101
1102	    TP_printk("OP=%08x[%02x] %llx:%llx:%x a=%d",
1103		      __entry->op, __entry->index,
1104		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1105		      __entry->abort)
1106	    );
1107
1108TRACE_EVENT(afs_cm_no_server,
1109	    TP_PROTO(struct afs_call *call, struct sockaddr_rxrpc *srx),
1110
1111	    TP_ARGS(call, srx),
1112
1113	    TP_STRUCT__entry(
1114		    __field(unsigned int,			call)
1115		    __field(unsigned int,			op_id)
1116		    __field_struct(struct sockaddr_rxrpc,	srx)
1117			     ),
1118
1119	    TP_fast_assign(
1120		    __entry->call = call->debug_id;
1121		    __entry->op_id = call->operation_ID;
1122		    memcpy(&__entry->srx, srx, sizeof(__entry->srx));
1123			   ),
1124
1125	    TP_printk("c=%08x op=%u %pISpc",
1126		      __entry->call, __entry->op_id, &__entry->srx.transport)
1127	    );
1128
1129TRACE_EVENT(afs_cm_no_server_u,
1130	    TP_PROTO(struct afs_call *call, const uuid_t *uuid),
1131
1132	    TP_ARGS(call, uuid),
1133
1134	    TP_STRUCT__entry(
1135		    __field(unsigned int,			call)
1136		    __field(unsigned int,			op_id)
1137		    __field_struct(uuid_t,			uuid)
1138			     ),
1139
1140	    TP_fast_assign(
1141		    __entry->call = call->debug_id;
1142		    __entry->op_id = call->operation_ID;
1143		    memcpy(&__entry->uuid, uuid, sizeof(__entry->uuid));
1144			   ),
1145
1146	    TP_printk("c=%08x op=%u %pU",
1147		      __entry->call, __entry->op_id, &__entry->uuid)
1148	    );
1149
1150TRACE_EVENT(afs_flock_ev,
1151	    TP_PROTO(struct afs_vnode *vnode, struct file_lock *fl,
1152		     enum afs_flock_event event, int error),
1153
1154	    TP_ARGS(vnode, fl, event, error),
1155
1156	    TP_STRUCT__entry(
1157		    __field_struct(struct afs_fid,	fid)
1158		    __field(enum afs_flock_event,	event)
1159		    __field(enum afs_lock_state,	state)
1160		    __field(int,			error)
1161		    __field(unsigned int,		debug_id)
1162			     ),
1163
1164	    TP_fast_assign(
1165		    __entry->fid = vnode->fid;
1166		    __entry->event = event;
1167		    __entry->state = vnode->lock_state;
1168		    __entry->error = error;
1169		    __entry->debug_id = fl ? fl->fl_u.afs.debug_id : 0;
1170			   ),
1171
1172	    TP_printk("%llx:%llx:%x %04x %s s=%s e=%d",
1173		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1174		      __entry->debug_id,
1175		      __print_symbolic(__entry->event, afs_flock_events),
1176		      __print_symbolic(__entry->state, afs_flock_states),
1177		      __entry->error)
1178	    );
1179
1180TRACE_EVENT(afs_flock_op,
1181	    TP_PROTO(struct afs_vnode *vnode, struct file_lock *fl,
1182		     enum afs_flock_operation op),
1183
1184	    TP_ARGS(vnode, fl, op),
1185
1186	    TP_STRUCT__entry(
1187		    __field_struct(struct afs_fid,	fid)
1188		    __field(loff_t,			from)
1189		    __field(loff_t,			len)
1190		    __field(enum afs_flock_operation,	op)
1191		    __field(unsigned char,		type)
1192		    __field(unsigned int,		flags)
1193		    __field(unsigned int,		debug_id)
1194			     ),
1195
1196	    TP_fast_assign(
1197		    __entry->fid = vnode->fid;
1198		    __entry->from = fl->fl_start;
1199		    __entry->len = fl->fl_end - fl->fl_start + 1;
1200		    __entry->op = op;
1201		    __entry->type = fl->c.flc_type;
1202		    __entry->flags = fl->c.flc_flags;
1203		    __entry->debug_id = fl->fl_u.afs.debug_id;
1204			   ),
1205
1206	    TP_printk("%llx:%llx:%x %04x %s t=%s R=%llx/%llx f=%x",
1207		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1208		      __entry->debug_id,
1209		      __print_symbolic(__entry->op, afs_flock_operations),
1210		      __print_symbolic(__entry->type, afs_flock_types),
1211		      __entry->from, __entry->len, __entry->flags)
1212	    );
1213
1214TRACE_EVENT(afs_reload_dir,
1215	    TP_PROTO(struct afs_vnode *vnode),
1216
1217	    TP_ARGS(vnode),
1218
1219	    TP_STRUCT__entry(
1220		    __field_struct(struct afs_fid,	fid)
1221			     ),
1222
1223	    TP_fast_assign(
1224		    __entry->fid = vnode->fid;
1225			   ),
1226
1227	    TP_printk("%llx:%llx:%x",
1228		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique)
1229	    );
1230
1231TRACE_EVENT(afs_silly_rename,
1232	    TP_PROTO(struct afs_vnode *vnode, bool done),
1233
1234	    TP_ARGS(vnode, done),
1235
1236	    TP_STRUCT__entry(
1237		    __field_struct(struct afs_fid,	fid)
1238		    __field(bool,			done)
1239			     ),
1240
1241	    TP_fast_assign(
1242		    __entry->fid = vnode->fid;
1243		    __entry->done = done;
1244			   ),
1245
1246	    TP_printk("%llx:%llx:%x done=%u",
1247		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1248		      __entry->done)
1249	    );
1250
1251TRACE_EVENT(afs_get_tree,
1252	    TP_PROTO(struct afs_cell *cell, struct afs_volume *volume),
1253
1254	    TP_ARGS(cell, volume),
1255
1256	    TP_STRUCT__entry(
1257		    __field(u64,			vid)
1258		    __array(char,			cell, 24)
1259		    __array(char,			volume, 24)
1260			     ),
1261
1262	    TP_fast_assign(
1263		    int __len;
1264		    __entry->vid = volume->vid;
1265		    __len = min_t(int, cell->name_len, 23);
1266		    memcpy(__entry->cell, cell->name, __len);
1267		    __entry->cell[__len] = 0;
1268		    __len = min_t(int, volume->name_len, 23);
1269		    memcpy(__entry->volume, volume->name, __len);
1270		    __entry->volume[__len] = 0;
1271			   ),
1272
1273	    TP_printk("--- MOUNT %s:%s %llx",
1274		      __entry->cell, __entry->volume, __entry->vid)
1275	    );
1276
1277TRACE_EVENT(afs_cb_v_break,
1278	    TP_PROTO(afs_volid_t vid, unsigned int cb_v_break,
1279		     enum afs_cb_break_reason reason),
1280
1281	    TP_ARGS(vid, cb_v_break, reason),
1282
1283	    TP_STRUCT__entry(
1284		    __field(afs_volid_t,		vid)
1285		    __field(unsigned int,		cb_v_break)
1286		    __field(enum afs_cb_break_reason,	reason)
1287			     ),
1288
1289	    TP_fast_assign(
1290		    __entry->vid	= vid;
1291		    __entry->cb_v_break	= cb_v_break;
1292		    __entry->reason	= reason;
1293			   ),
1294
1295	    TP_printk("%llx vb=%x %s",
1296		      __entry->vid,
1297		      __entry->cb_v_break,
1298		      __print_symbolic(__entry->reason, afs_cb_break_reasons))
1299	    );
1300
1301TRACE_EVENT(afs_cb_break,
1302	    TP_PROTO(struct afs_fid *fid, unsigned int cb_break,
1303		     enum afs_cb_break_reason reason, bool skipped),
1304
1305	    TP_ARGS(fid, cb_break, reason, skipped),
1306
1307	    TP_STRUCT__entry(
1308		    __field_struct(struct afs_fid,	fid)
1309		    __field(unsigned int,		cb_break)
1310		    __field(enum afs_cb_break_reason,	reason)
1311		    __field(bool,			skipped)
1312			     ),
1313
1314	    TP_fast_assign(
1315		    __entry->fid	= *fid;
1316		    __entry->cb_break	= cb_break;
1317		    __entry->reason	= reason;
1318		    __entry->skipped	= skipped;
1319			   ),
1320
1321	    TP_printk("%llx:%llx:%x b=%x s=%u %s",
1322		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1323		      __entry->cb_break,
1324		      __entry->skipped,
1325		      __print_symbolic(__entry->reason, afs_cb_break_reasons))
1326	    );
1327
1328TRACE_EVENT(afs_cb_miss,
1329	    TP_PROTO(struct afs_fid *fid, enum afs_cb_break_reason reason),
1330
1331	    TP_ARGS(fid, reason),
1332
1333	    TP_STRUCT__entry(
1334		    __field_struct(struct afs_fid,	fid)
1335		    __field(enum afs_cb_break_reason,	reason)
1336			     ),
1337
1338	    TP_fast_assign(
1339		    __entry->fid	= *fid;
1340		    __entry->reason	= reason;
1341			   ),
1342
1343	    TP_printk(" %llx:%llx:%x %s",
1344		      __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1345		      __print_symbolic(__entry->reason, afs_cb_break_reasons))
1346	    );
1347
1348TRACE_EVENT(afs_server,
1349	    TP_PROTO(unsigned int server_debug_id, int ref, int active,
1350		     enum afs_server_trace reason),
1351
1352	    TP_ARGS(server_debug_id, ref, active, reason),
1353
1354	    TP_STRUCT__entry(
1355		    __field(unsigned int,		server)
1356		    __field(int,			ref)
1357		    __field(int,			active)
1358		    __field(int,			reason)
1359			     ),
1360
1361	    TP_fast_assign(
1362		    __entry->server = server_debug_id;
1363		    __entry->ref = ref;
1364		    __entry->active = active;
1365		    __entry->reason = reason;
1366			   ),
1367
1368	    TP_printk("s=%08x %s u=%d a=%d",
1369		      __entry->server,
1370		      __print_symbolic(__entry->reason, afs_server_traces),
1371		      __entry->ref,
1372		      __entry->active)
1373	    );
1374
1375TRACE_EVENT(afs_volume,
1376	    TP_PROTO(afs_volid_t vid, int ref, enum afs_volume_trace reason),
1377
1378	    TP_ARGS(vid, ref, reason),
1379
1380	    TP_STRUCT__entry(
1381		    __field(afs_volid_t,		vid)
1382		    __field(int,			ref)
1383		    __field(enum afs_volume_trace,	reason)
1384			     ),
1385
1386	    TP_fast_assign(
1387		    __entry->vid = vid;
1388		    __entry->ref = ref;
1389		    __entry->reason = reason;
1390			   ),
1391
1392	    TP_printk("V=%llx %s ur=%d",
1393		      __entry->vid,
1394		      __print_symbolic(__entry->reason, afs_volume_traces),
1395		      __entry->ref)
1396	    );
1397
1398TRACE_EVENT(afs_cell,
1399	    TP_PROTO(unsigned int cell_debug_id, int ref, int active,
1400		     enum afs_cell_trace reason),
1401
1402	    TP_ARGS(cell_debug_id, ref, active, reason),
1403
1404	    TP_STRUCT__entry(
1405		    __field(unsigned int,		cell)
1406		    __field(int,			ref)
1407		    __field(int,			active)
1408		    __field(int,			reason)
1409			     ),
1410
1411	    TP_fast_assign(
1412		    __entry->cell = cell_debug_id;
1413		    __entry->ref = ref;
1414		    __entry->active = active;
1415		    __entry->reason = reason;
1416			   ),
1417
1418	    TP_printk("L=%08x %s r=%d a=%d",
1419		      __entry->cell,
1420		      __print_symbolic(__entry->reason, afs_cell_traces),
1421		      __entry->ref,
1422		      __entry->active)
1423	    );
1424
1425TRACE_EVENT(afs_alist,
1426	    TP_PROTO(unsigned int alist_debug_id, int ref, enum afs_alist_trace reason),
1427
1428	    TP_ARGS(alist_debug_id, ref, reason),
1429
1430	    TP_STRUCT__entry(
1431		    __field(unsigned int,		alist)
1432		    __field(int,			ref)
1433		    __field(int,			active)
1434		    __field(int,			reason)
1435			     ),
1436
1437	    TP_fast_assign(
1438		    __entry->alist = alist_debug_id;
1439		    __entry->ref = ref;
1440		    __entry->reason = reason;
1441			   ),
1442
1443	    TP_printk("AL=%08x %s r=%d",
1444		      __entry->alist,
1445		      __print_symbolic(__entry->reason, afs_alist_traces),
1446		      __entry->ref)
1447	    );
1448
1449TRACE_EVENT(afs_estate,
1450	    TP_PROTO(unsigned int server_debug_id, unsigned int estate_debug_id,
1451		     int ref, enum afs_estate_trace reason),
1452
1453	    TP_ARGS(server_debug_id, estate_debug_id, ref, reason),
1454
1455	    TP_STRUCT__entry(
1456		    __field(unsigned int,		server)
1457		    __field(unsigned int,		estate)
1458		    __field(int,			ref)
1459		    __field(int,			active)
1460		    __field(int,			reason)
1461			     ),
1462
1463	    TP_fast_assign(
1464		    __entry->server = server_debug_id;
1465		    __entry->estate = estate_debug_id;
1466		    __entry->ref = ref;
1467		    __entry->reason = reason;
1468			   ),
1469
1470	    TP_printk("ES=%08x[%x] %s r=%d",
1471		      __entry->server,
1472		      __entry->estate,
1473		      __print_symbolic(__entry->reason, afs_estate_traces),
1474		      __entry->ref)
1475	    );
1476
1477TRACE_EVENT(afs_fs_probe,
1478	    TP_PROTO(struct afs_server *server, bool tx, struct afs_endpoint_state *estate,
1479		     unsigned int addr_index, int error, s32 abort_code, unsigned int rtt_us),
1480
1481	    TP_ARGS(server, tx, estate, addr_index, error, abort_code, rtt_us),
1482
1483	    TP_STRUCT__entry(
1484		    __field(unsigned int,		server)
1485		    __field(unsigned int,		estate)
1486		    __field(bool,			tx)
1487		    __field(u16,			addr_index)
1488		    __field(short,			error)
1489		    __field(s32,			abort_code)
1490		    __field(unsigned int,		rtt_us)
1491		    __field_struct(struct sockaddr_rxrpc, srx)
1492			     ),
1493
1494	    TP_fast_assign(
1495		    struct afs_addr_list *alist = estate->addresses;
1496		    __entry->server = server->debug_id;
1497		    __entry->estate = estate->probe_seq;
1498		    __entry->tx = tx;
1499		    __entry->addr_index = addr_index;
1500		    __entry->error = error;
1501		    __entry->abort_code = abort_code;
1502		    __entry->rtt_us = rtt_us;
1503		    memcpy(&__entry->srx, rxrpc_kernel_remote_srx(alist->addrs[addr_index].peer),
1504			   sizeof(__entry->srx));
1505			   ),
1506
1507	    TP_printk("s=%08x %s pq=%x ax=%u e=%d ac=%d rtt=%d %pISpc",
1508		      __entry->server, __entry->tx ? "tx" : "rx", __entry->estate,
1509		      __entry->addr_index, __entry->error, __entry->abort_code, __entry->rtt_us,
1510		      &__entry->srx.transport)
1511	    );
1512
1513TRACE_EVENT(afs_vl_probe,
1514	    TP_PROTO(struct afs_vlserver *server, bool tx, struct afs_addr_list *alist,
1515		     unsigned int addr_index, int error, s32 abort_code, unsigned int rtt_us),
1516
1517	    TP_ARGS(server, tx, alist, addr_index, error, abort_code, rtt_us),
1518
1519	    TP_STRUCT__entry(
1520		    __field(unsigned int,		server)
1521		    __field(bool,			tx)
1522		    __field(unsigned short,		flags)
1523		    __field(u16,			addr_index)
1524		    __field(short,			error)
1525		    __field(s32,			abort_code)
1526		    __field(unsigned int,		rtt_us)
1527		    __field_struct(struct sockaddr_rxrpc, srx)
1528			     ),
1529
1530	    TP_fast_assign(
1531		    __entry->server = server->debug_id;
1532		    __entry->tx = tx;
1533		    __entry->addr_index = addr_index;
1534		    __entry->error = error;
1535		    __entry->abort_code = abort_code;
1536		    __entry->rtt_us = rtt_us;
1537		    memcpy(&__entry->srx, rxrpc_kernel_remote_srx(alist->addrs[addr_index].peer),
1538			   sizeof(__entry->srx));
1539			   ),
1540
1541	    TP_printk("vl=%08x %s ax=%u e=%d ac=%d rtt=%d %pISpc",
1542		      __entry->server, __entry->tx ? "tx" : "rx", __entry->addr_index,
1543		      __entry->error, __entry->abort_code, __entry->rtt_us,
1544		      &__entry->srx.transport)
1545	    );
1546
1547TRACE_EVENT(afs_rotate,
1548	    TP_PROTO(struct afs_operation *op, enum afs_rotate_trace reason, unsigned int extra),
1549
1550	    TP_ARGS(op, reason, extra),
1551
1552	    TP_STRUCT__entry(
1553		    __field(unsigned int,		op)
1554		    __field(unsigned int,		flags)
1555		    __field(unsigned int,		extra)
1556		    __field(unsigned short,		iteration)
1557		    __field(short,			server_index)
1558		    __field(short,			addr_index)
1559		    __field(enum afs_rotate_trace,	reason)
1560			     ),
1561
1562	    TP_fast_assign(
1563		    __entry->op = op->debug_id;
1564		    __entry->flags = op->flags;
1565		    __entry->iteration = op->nr_iterations;
1566		    __entry->server_index = op->server_index;
1567		    __entry->addr_index = op->addr_index;
1568		    __entry->reason = reason;
1569		    __entry->extra = extra;
1570			   ),
1571
1572	    TP_printk("OP=%08x it=%02x %s fl=%x sx=%d ax=%d ext=%d",
1573		      __entry->op,
1574		      __entry->iteration,
1575		      __print_symbolic(__entry->reason, afs_rotate_traces),
1576		      __entry->flags,
1577		      __entry->server_index,
1578		      __entry->addr_index,
1579		      __entry->extra)
1580	    );
1581
1582TRACE_EVENT(afs_make_call,
1583	    TP_PROTO(struct afs_call *call),
1584
1585	    TP_ARGS(call),
1586
1587	    TP_STRUCT__entry(
1588		    __field(unsigned int,		call)
1589		    __field(bool,			is_vl)
1590		    __field(enum afs_fs_operation,	op)
1591		    __field_struct(struct afs_fid,	fid)
1592		    __field_struct(struct sockaddr_rxrpc, srx)
1593			     ),
1594
1595	    TP_fast_assign(
1596		    __entry->call = call->debug_id;
1597		    __entry->op = call->operation_ID;
1598		    __entry->fid = call->fid;
1599		    memcpy(&__entry->srx, rxrpc_kernel_remote_srx(call->peer),
1600			   sizeof(__entry->srx));
1601		    __entry->srx.srx_service = call->service_id;
1602		    __entry->is_vl = (__entry->srx.srx_service == VL_SERVICE ||
1603				      __entry->srx.srx_service == YFS_VL_SERVICE);
1604			   ),
1605
1606	    TP_printk("c=%08x %pISpc+%u %s %llx:%llx:%x",
1607		      __entry->call,
1608		      &__entry->srx.transport,
1609		      __entry->srx.srx_service,
1610		      __entry->is_vl ?
1611		      __print_symbolic(__entry->op, afs_vl_operations) :
1612		      __print_symbolic(__entry->op, afs_fs_operations),
1613		      __entry->fid.vid,
1614		      __entry->fid.vnode,
1615		      __entry->fid.unique)
1616	    );
1617
1618#endif /* _TRACE_AFS_H */
1619
1620/* This part must be outside protection */
1621#include <trace/define_trace.h>