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_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_cell_insert, "GET cell-insrt") \ 157 EM(afs_volume_trace_get_new_op, "GET op-new ") \ 158 EM(afs_volume_trace_get_query_alias, "GET cell-alias") \ 159 EM(afs_volume_trace_put_cell_dup, "PUT cell-dup ") \ 160 EM(afs_volume_trace_put_cell_root, "PUT cell-root ") \ 161 EM(afs_volume_trace_put_destroy_sbi, "PUT sbi-destry") \ 162 EM(afs_volume_trace_put_free_fc, "PUT fc-free ") \ 163 EM(afs_volume_trace_put_put_op, "PUT op-put ") \ 164 EM(afs_volume_trace_put_query_alias, "PUT cell-alias") \ 165 EM(afs_volume_trace_put_validate_fc, "PUT fc-validat") \ 166 E_(afs_volume_trace_remove, "REMOVE ") 167 168 #define afs_cell_traces \ 169 EM(afs_cell_trace_alloc, "ALLOC ") \ 170 EM(afs_cell_trace_free, "FREE ") \ 171 EM(afs_cell_trace_get_queue_dns, "GET q-dns ") \ 172 EM(afs_cell_trace_get_queue_manage, "GET q-mng ") \ 173 EM(afs_cell_trace_get_queue_new, "GET q-new ") \ 174 EM(afs_cell_trace_get_vol, "GET vol ") \ 175 EM(afs_cell_trace_insert, "INSERT ") \ 176 EM(afs_cell_trace_manage, "MANAGE ") \ 177 EM(afs_cell_trace_put_candidate, "PUT candid") \ 178 EM(afs_cell_trace_put_destroy, "PUT destry") \ 179 EM(afs_cell_trace_put_queue_work, "PUT q-work") \ 180 EM(afs_cell_trace_put_queue_fail, "PUT q-fail") \ 181 EM(afs_cell_trace_put_vol, "PUT vol ") \ 182 EM(afs_cell_trace_see_source, "SEE source") \ 183 EM(afs_cell_trace_see_ws, "SEE ws ") \ 184 EM(afs_cell_trace_unuse_alias, "UNU alias ") \ 185 EM(afs_cell_trace_unuse_check_alias, "UNU chk-al") \ 186 EM(afs_cell_trace_unuse_delete, "UNU delete") \ 187 EM(afs_cell_trace_unuse_fc, "UNU fc ") \ 188 EM(afs_cell_trace_unuse_lookup, "UNU lookup") \ 189 EM(afs_cell_trace_unuse_mntpt, "UNU mntpt ") \ 190 EM(afs_cell_trace_unuse_no_pin, "UNU no-pin") \ 191 EM(afs_cell_trace_unuse_parse, "UNU parse ") \ 192 EM(afs_cell_trace_unuse_pin, "UNU pin ") \ 193 EM(afs_cell_trace_unuse_probe, "UNU probe ") \ 194 EM(afs_cell_trace_unuse_sbi, "UNU sbi ") \ 195 EM(afs_cell_trace_unuse_ws, "UNU ws ") \ 196 EM(afs_cell_trace_use_alias, "USE alias ") \ 197 EM(afs_cell_trace_use_check_alias, "USE chk-al") \ 198 EM(afs_cell_trace_use_fc, "USE fc ") \ 199 EM(afs_cell_trace_use_fc_alias, "USE fc-al ") \ 200 EM(afs_cell_trace_use_lookup, "USE lookup") \ 201 EM(afs_cell_trace_use_mntpt, "USE mntpt ") \ 202 EM(afs_cell_trace_use_pin, "USE pin ") \ 203 EM(afs_cell_trace_use_probe, "USE probe ") \ 204 EM(afs_cell_trace_use_sbi, "USE sbi ") \ 205 E_(afs_cell_trace_wait, "WAIT ") 206 207 #define afs_fs_operations \ 208 EM(afs_FS_FetchData, "FS.FetchData") \ 209 EM(afs_FS_FetchStatus, "FS.FetchStatus") \ 210 EM(afs_FS_StoreData, "FS.StoreData") \ 211 EM(afs_FS_StoreStatus, "FS.StoreStatus") \ 212 EM(afs_FS_RemoveFile, "FS.RemoveFile") \ 213 EM(afs_FS_CreateFile, "FS.CreateFile") \ 214 EM(afs_FS_Rename, "FS.Rename") \ 215 EM(afs_FS_Symlink, "FS.Symlink") \ 216 EM(afs_FS_Link, "FS.Link") \ 217 EM(afs_FS_MakeDir, "FS.MakeDir") \ 218 EM(afs_FS_RemoveDir, "FS.RemoveDir") \ 219 EM(afs_FS_GetVolumeInfo, "FS.GetVolumeInfo") \ 220 EM(afs_FS_GetVolumeStatus, "FS.GetVolumeStatus") \ 221 EM(afs_FS_GetRootVolume, "FS.GetRootVolume") \ 222 EM(afs_FS_SetLock, "FS.SetLock") \ 223 EM(afs_FS_ExtendLock, "FS.ExtendLock") \ 224 EM(afs_FS_ReleaseLock, "FS.ReleaseLock") \ 225 EM(afs_FS_Lookup, "FS.Lookup") \ 226 EM(afs_FS_InlineBulkStatus, "FS.InlineBulkStatus") \ 227 EM(afs_FS_FetchData64, "FS.FetchData64") \ 228 EM(afs_FS_StoreData64, "FS.StoreData64") \ 229 EM(afs_FS_GiveUpAllCallBacks, "FS.GiveUpAllCallBacks") \ 230 EM(afs_FS_GetCapabilities, "FS.GetCapabilities") \ 231 EM(yfs_FS_FetchACL, "YFS.FetchACL") \ 232 EM(yfs_FS_FetchStatus, "YFS.FetchStatus") \ 233 EM(yfs_FS_StoreACL, "YFS.StoreACL") \ 234 EM(yfs_FS_StoreStatus, "YFS.StoreStatus") \ 235 EM(yfs_FS_RemoveFile, "YFS.RemoveFile") \ 236 EM(yfs_FS_CreateFile, "YFS.CreateFile") \ 237 EM(yfs_FS_Rename, "YFS.Rename") \ 238 EM(yfs_FS_Symlink, "YFS.Symlink") \ 239 EM(yfs_FS_Link, "YFS.Link") \ 240 EM(yfs_FS_MakeDir, "YFS.MakeDir") \ 241 EM(yfs_FS_RemoveDir, "YFS.RemoveDir") \ 242 EM(yfs_FS_GetVolumeStatus, "YFS.GetVolumeStatus") \ 243 EM(yfs_FS_SetVolumeStatus, "YFS.SetVolumeStatus") \ 244 EM(yfs_FS_SetLock, "YFS.SetLock") \ 245 EM(yfs_FS_ExtendLock, "YFS.ExtendLock") \ 246 EM(yfs_FS_ReleaseLock, "YFS.ReleaseLock") \ 247 EM(yfs_FS_Lookup, "YFS.Lookup") \ 248 EM(yfs_FS_FlushCPS, "YFS.FlushCPS") \ 249 EM(yfs_FS_FetchOpaqueACL, "YFS.FetchOpaqueACL") \ 250 EM(yfs_FS_WhoAmI, "YFS.WhoAmI") \ 251 EM(yfs_FS_RemoveACL, "YFS.RemoveACL") \ 252 EM(yfs_FS_RemoveFile2, "YFS.RemoveFile2") \ 253 EM(yfs_FS_StoreOpaqueACL2, "YFS.StoreOpaqueACL2") \ 254 EM(yfs_FS_InlineBulkStatus, "YFS.InlineBulkStatus") \ 255 EM(yfs_FS_FetchData64, "YFS.FetchData64") \ 256 EM(yfs_FS_StoreData64, "YFS.StoreData64") \ 257 E_(yfs_FS_UpdateSymlink, "YFS.UpdateSymlink") 258 259 #define afs_vl_operations \ 260 EM(afs_VL_GetEntryByNameU, "VL.GetEntryByNameU") \ 261 EM(afs_VL_GetAddrsU, "VL.GetAddrsU") \ 262 EM(afs_YFSVL_GetEndpoints, "YFSVL.GetEndpoints") \ 263 EM(afs_YFSVL_GetCellName, "YFSVL.GetCellName") \ 264 E_(afs_VL_GetCapabilities, "VL.GetCapabilities") 265 266 #define afs_cm_operations \ 267 EM(afs_CB_CallBack, "CB.CallBack") \ 268 EM(afs_CB_InitCallBackState, "CB.InitCallBackState") \ 269 EM(afs_CB_Probe, "CB.Probe") \ 270 EM(afs_CB_GetLock, "CB.GetLock") \ 271 EM(afs_CB_GetCE, "CB.GetCE") \ 272 EM(afs_CB_GetXStatsVersion, "CB.GetXStatsVersion") \ 273 EM(afs_CB_GetXStats, "CB.GetXStats") \ 274 EM(afs_CB_InitCallBackState3, "CB.InitCallBackState3") \ 275 E_(afs_CB_ProbeUuid, "CB.ProbeUuid") 276 277 #define yfs_cm_operations \ 278 EM(yfs_CB_Probe, "YFSCB.Probe") \ 279 EM(yfs_CB_GetLock, "YFSCB.GetLock") \ 280 EM(yfs_CB_XStatsVersion, "YFSCB.XStatsVersion") \ 281 EM(yfs_CB_GetXStats, "YFSCB.GetXStats") \ 282 EM(yfs_CB_InitCallBackState3, "YFSCB.InitCallBackState3") \ 283 EM(yfs_CB_ProbeUuid, "YFSCB.ProbeUuid") \ 284 EM(yfs_CB_GetServerPrefs, "YFSCB.GetServerPrefs") \ 285 EM(yfs_CB_GetCellServDV, "YFSCB.GetCellServDV") \ 286 EM(yfs_CB_GetLocalCell, "YFSCB.GetLocalCell") \ 287 EM(yfs_CB_GetCacheConfig, "YFSCB.GetCacheConfig") \ 288 EM(yfs_CB_GetCellByNum, "YFSCB.GetCellByNum") \ 289 EM(yfs_CB_TellMeAboutYourself, "YFSCB.TellMeAboutYourself") \ 290 E_(yfs_CB_CallBack, "YFSCB.CallBack") 291 292 #define afs_edit_dir_ops \ 293 EM(afs_edit_dir_create, "create") \ 294 EM(afs_edit_dir_create_error, "c_fail") \ 295 EM(afs_edit_dir_create_inval, "c_invl") \ 296 EM(afs_edit_dir_create_nospc, "c_nspc") \ 297 EM(afs_edit_dir_delete, "delete") \ 298 EM(afs_edit_dir_delete_error, "d_err ") \ 299 EM(afs_edit_dir_delete_inval, "d_invl") \ 300 EM(afs_edit_dir_delete_noent, "d_nent") \ 301 EM(afs_edit_dir_update_dd, "u_ddot") \ 302 EM(afs_edit_dir_update_error, "u_fail") \ 303 EM(afs_edit_dir_update_inval, "u_invl") \ 304 E_(afs_edit_dir_update_nodd, "u_nodd") 305 306 #define afs_edit_dir_reasons \ 307 EM(afs_edit_dir_for_create, "Create") \ 308 EM(afs_edit_dir_for_link, "Link ") \ 309 EM(afs_edit_dir_for_mkdir, "MkDir ") \ 310 EM(afs_edit_dir_for_rename_0, "Renam0") \ 311 EM(afs_edit_dir_for_rename_1, "Renam1") \ 312 EM(afs_edit_dir_for_rename_2, "Renam2") \ 313 EM(afs_edit_dir_for_rename_sub, "RnmSub") \ 314 EM(afs_edit_dir_for_rmdir, "RmDir ") \ 315 EM(afs_edit_dir_for_silly_0, "S_Ren0") \ 316 EM(afs_edit_dir_for_silly_1, "S_Ren1") \ 317 EM(afs_edit_dir_for_symlink, "Symlnk") \ 318 E_(afs_edit_dir_for_unlink, "Unlink") 319 320 #define afs_eproto_causes \ 321 EM(afs_eproto_bad_status, "BadStatus") \ 322 EM(afs_eproto_cb_count, "CbCount") \ 323 EM(afs_eproto_cb_fid_count, "CbFidCount") \ 324 EM(afs_eproto_cellname_len, "CellNameLen") \ 325 EM(afs_eproto_file_type, "FileTYpe") \ 326 EM(afs_eproto_ibulkst_cb_count, "IBS.CbCount") \ 327 EM(afs_eproto_ibulkst_count, "IBS.FidCount") \ 328 EM(afs_eproto_motd_len, "MotdLen") \ 329 EM(afs_eproto_offline_msg_len, "OfflineMsgLen") \ 330 EM(afs_eproto_volname_len, "VolNameLen") \ 331 EM(afs_eproto_yvl_fsendpt4_len, "YVL.FsEnd4Len") \ 332 EM(afs_eproto_yvl_fsendpt6_len, "YVL.FsEnd6Len") \ 333 EM(afs_eproto_yvl_fsendpt_num, "YVL.FsEndCount") \ 334 EM(afs_eproto_yvl_fsendpt_type, "YVL.FsEndType") \ 335 EM(afs_eproto_yvl_vlendpt4_len, "YVL.VlEnd4Len") \ 336 EM(afs_eproto_yvl_vlendpt6_len, "YVL.VlEnd6Len") \ 337 E_(afs_eproto_yvl_vlendpt_type, "YVL.VlEndType") 338 339 #define afs_io_errors \ 340 EM(afs_io_error_cm_reply, "CM_REPLY") \ 341 EM(afs_io_error_extract, "EXTRACT") \ 342 EM(afs_io_error_fs_probe_fail, "FS_PROBE_FAIL") \ 343 EM(afs_io_error_vl_lookup_fail, "VL_LOOKUP_FAIL") \ 344 E_(afs_io_error_vl_probe_fail, "VL_PROBE_FAIL") 345 346 #define afs_file_errors \ 347 EM(afs_file_error_dir_bad_magic, "DIR_BAD_MAGIC") \ 348 EM(afs_file_error_dir_big, "DIR_BIG") \ 349 EM(afs_file_error_dir_missing_page, "DIR_MISSING_PAGE") \ 350 EM(afs_file_error_dir_name_too_long, "DIR_NAME_TOO_LONG") \ 351 EM(afs_file_error_dir_over_end, "DIR_ENT_OVER_END") \ 352 EM(afs_file_error_dir_small, "DIR_SMALL") \ 353 EM(afs_file_error_dir_unmarked_ext, "DIR_UNMARKED_EXT") \ 354 EM(afs_file_error_mntpt, "MNTPT_READ_FAILED") \ 355 E_(afs_file_error_writeback_fail, "WRITEBACK_FAILED") 356 357 #define afs_flock_types \ 358 EM(F_RDLCK, "RDLCK") \ 359 EM(F_WRLCK, "WRLCK") \ 360 E_(F_UNLCK, "UNLCK") 361 362 #define afs_flock_states \ 363 EM(AFS_VNODE_LOCK_NONE, "NONE") \ 364 EM(AFS_VNODE_LOCK_WAITING_FOR_CB, "WAIT_FOR_CB") \ 365 EM(AFS_VNODE_LOCK_SETTING, "SETTING") \ 366 EM(AFS_VNODE_LOCK_GRANTED, "GRANTED") \ 367 EM(AFS_VNODE_LOCK_EXTENDING, "EXTENDING") \ 368 EM(AFS_VNODE_LOCK_NEED_UNLOCK, "NEED_UNLOCK") \ 369 EM(AFS_VNODE_LOCK_UNLOCKING, "UNLOCKING") \ 370 E_(AFS_VNODE_LOCK_DELETED, "DELETED") 371 372 #define afs_flock_events \ 373 EM(afs_flock_acquired, "Acquired") \ 374 EM(afs_flock_callback_break, "Callback") \ 375 EM(afs_flock_defer_unlock, "D-Unlock") \ 376 EM(afs_flock_extend_fail, "Ext_Fail") \ 377 EM(afs_flock_fail_other, "ErrOther") \ 378 EM(afs_flock_fail_perm, "ErrPerm ") \ 379 EM(afs_flock_no_lockers, "NoLocker") \ 380 EM(afs_flock_release_fail, "Rel_Fail") \ 381 EM(afs_flock_silly_delete, "SillyDel") \ 382 EM(afs_flock_timestamp, "Timestmp") \ 383 EM(afs_flock_try_to_lock, "TryToLck") \ 384 EM(afs_flock_vfs_lock, "VFSLock ") \ 385 EM(afs_flock_vfs_locking, "VFSLking") \ 386 EM(afs_flock_waited, "Waited ") \ 387 EM(afs_flock_waiting, "Waiting ") \ 388 EM(afs_flock_work_extending, "Extendng") \ 389 EM(afs_flock_work_retry, "Retry ") \ 390 EM(afs_flock_work_unlocking, "Unlcking") \ 391 E_(afs_flock_would_block, "EWOULDBL") 392 393 #define afs_flock_operations \ 394 EM(afs_flock_op_copy_lock, "COPY ") \ 395 EM(afs_flock_op_flock, "->flock ") \ 396 EM(afs_flock_op_grant, "GRANT ") \ 397 EM(afs_flock_op_lock, "->lock ") \ 398 EM(afs_flock_op_release_lock, "RELEASE ") \ 399 EM(afs_flock_op_return_ok, "<-OK ") \ 400 EM(afs_flock_op_return_edeadlk, "<-EDEADL") \ 401 EM(afs_flock_op_return_eagain, "<-EAGAIN") \ 402 EM(afs_flock_op_return_error, "<-ERROR ") \ 403 EM(afs_flock_op_set_lock, "SET ") \ 404 EM(afs_flock_op_unlock, "UNLOCK ") \ 405 E_(afs_flock_op_wake, "WAKE ") 406 407 #define afs_cb_break_reasons \ 408 EM(afs_cb_break_no_break, "no-break") \ 409 EM(afs_cb_break_no_promise, "no-promise") \ 410 EM(afs_cb_break_for_callback, "break-cb") \ 411 EM(afs_cb_break_for_deleted, "break-del") \ 412 EM(afs_cb_break_for_lapsed, "break-lapsed") \ 413 EM(afs_cb_break_for_s_reinit, "s-reinit") \ 414 EM(afs_cb_break_for_unlink, "break-unlink") \ 415 EM(afs_cb_break_for_v_break, "break-v") \ 416 EM(afs_cb_break_for_volume_callback, "break-v-cb") \ 417 E_(afs_cb_break_for_zap, "break-zap") 418 419 /* 420 * Generate enums for tracing information. 421 */ 422 #ifndef __AFS_GENERATE_TRACE_ENUMS_ONCE_ONLY 423 #define __AFS_GENERATE_TRACE_ENUMS_ONCE_ONLY 424 425 #undef EM 426 #undef E_ 427 #define EM(a, b) a, 428 #define E_(a, b) a 429 430 enum afs_call_trace { afs_call_traces } __mode(byte); 431 enum afs_cb_break_reason { afs_cb_break_reasons } __mode(byte); 432 enum afs_cell_trace { afs_cell_traces } __mode(byte); 433 enum afs_edit_dir_op { afs_edit_dir_ops } __mode(byte); 434 enum afs_edit_dir_reason { afs_edit_dir_reasons } __mode(byte); 435 enum afs_eproto_cause { afs_eproto_causes } __mode(byte); 436 enum afs_file_error { afs_file_errors } __mode(byte); 437 enum afs_flock_event { afs_flock_events } __mode(byte); 438 enum afs_flock_operation { afs_flock_operations } __mode(byte); 439 enum afs_io_error { afs_io_errors } __mode(byte); 440 enum afs_server_trace { afs_server_traces } __mode(byte); 441 enum afs_volume_trace { afs_volume_traces } __mode(byte); 442 443 #endif /* end __AFS_GENERATE_TRACE_ENUMS_ONCE_ONLY */ 444 445 /* 446 * Export enum symbols via userspace. 447 */ 448 #undef EM 449 #undef E_ 450 #define EM(a, b) TRACE_DEFINE_ENUM(a); 451 #define E_(a, b) TRACE_DEFINE_ENUM(a); 452 453 afs_call_traces; 454 afs_server_traces; 455 afs_cell_traces; 456 afs_fs_operations; 457 afs_vl_operations; 458 afs_cm_operations; 459 yfs_cm_operations; 460 afs_edit_dir_ops; 461 afs_edit_dir_reasons; 462 afs_eproto_causes; 463 afs_io_errors; 464 afs_file_errors; 465 afs_flock_types; 466 afs_flock_operations; 467 afs_cb_break_reasons; 468 469 /* 470 * Now redefine the EM() and E_() macros to map the enums to the strings that 471 * will be printed in the output. 472 */ 473 #undef EM 474 #undef E_ 475 #define EM(a, b) { a, b }, 476 #define E_(a, b) { a, b } 477 478 TRACE_EVENT(afs_receive_data, 479 TP_PROTO(struct afs_call *call, struct iov_iter *iter, 480 bool want_more, int ret), 481 482 TP_ARGS(call, iter, want_more, ret), 483 484 TP_STRUCT__entry( 485 __field(loff_t, remain ) 486 __field(unsigned int, call ) 487 __field(enum afs_call_state, state ) 488 __field(unsigned short, unmarshall ) 489 __field(bool, want_more ) 490 __field(int, ret ) 491 ), 492 493 TP_fast_assign( 494 __entry->call = call->debug_id; 495 __entry->state = call->state; 496 __entry->unmarshall = call->unmarshall; 497 __entry->remain = iov_iter_count(iter); 498 __entry->want_more = want_more; 499 __entry->ret = ret; 500 ), 501 502 TP_printk("c=%08x r=%llu u=%u w=%u s=%u ret=%d", 503 __entry->call, 504 __entry->remain, 505 __entry->unmarshall, 506 __entry->want_more, 507 __entry->state, 508 __entry->ret) 509 ); 510 511 TRACE_EVENT(afs_notify_call, 512 TP_PROTO(struct rxrpc_call *rxcall, struct afs_call *call), 513 514 TP_ARGS(rxcall, call), 515 516 TP_STRUCT__entry( 517 __field(unsigned int, call ) 518 __field(enum afs_call_state, state ) 519 __field(unsigned short, unmarshall ) 520 ), 521 522 TP_fast_assign( 523 __entry->call = call->debug_id; 524 __entry->state = call->state; 525 __entry->unmarshall = call->unmarshall; 526 ), 527 528 TP_printk("c=%08x s=%u u=%u", 529 __entry->call, 530 __entry->state, __entry->unmarshall) 531 ); 532 533 TRACE_EVENT(afs_cb_call, 534 TP_PROTO(struct afs_call *call), 535 536 TP_ARGS(call), 537 538 TP_STRUCT__entry( 539 __field(unsigned int, call ) 540 __field(u32, op ) 541 __field(u16, service_id ) 542 ), 543 544 TP_fast_assign( 545 __entry->call = call->debug_id; 546 __entry->op = call->operation_ID; 547 __entry->service_id = call->service_id; 548 ), 549 550 TP_printk("c=%08x %s", 551 __entry->call, 552 __entry->service_id == 2501 ? 553 __print_symbolic(__entry->op, yfs_cm_operations) : 554 __print_symbolic(__entry->op, afs_cm_operations)) 555 ); 556 557 TRACE_EVENT(afs_call, 558 TP_PROTO(unsigned int call_debug_id, enum afs_call_trace op, 559 int ref, int outstanding, const void *where), 560 561 TP_ARGS(call_debug_id, op, ref, outstanding, where), 562 563 TP_STRUCT__entry( 564 __field(unsigned int, call ) 565 __field(int, op ) 566 __field(int, ref ) 567 __field(int, outstanding ) 568 __field(const void *, where ) 569 ), 570 571 TP_fast_assign( 572 __entry->call = call_debug_id; 573 __entry->op = op; 574 __entry->ref = ref; 575 __entry->outstanding = outstanding; 576 __entry->where = where; 577 ), 578 579 TP_printk("c=%08x %s r=%d o=%d sp=%pSR", 580 __entry->call, 581 __print_symbolic(__entry->op, afs_call_traces), 582 __entry->ref, 583 __entry->outstanding, 584 __entry->where) 585 ); 586 587 TRACE_EVENT(afs_make_fs_call, 588 TP_PROTO(struct afs_call *call, const struct afs_fid *fid), 589 590 TP_ARGS(call, fid), 591 592 TP_STRUCT__entry( 593 __field(unsigned int, call ) 594 __field(enum afs_fs_operation, op ) 595 __field_struct(struct afs_fid, fid ) 596 ), 597 598 TP_fast_assign( 599 __entry->call = call->debug_id; 600 __entry->op = call->operation_ID; 601 if (fid) { 602 __entry->fid = *fid; 603 } else { 604 __entry->fid.vid = 0; 605 __entry->fid.vnode = 0; 606 __entry->fid.unique = 0; 607 } 608 ), 609 610 TP_printk("c=%08x %06llx:%06llx:%06x %s", 611 __entry->call, 612 __entry->fid.vid, 613 __entry->fid.vnode, 614 __entry->fid.unique, 615 __print_symbolic(__entry->op, afs_fs_operations)) 616 ); 617 618 TRACE_EVENT(afs_make_fs_calli, 619 TP_PROTO(struct afs_call *call, const struct afs_fid *fid, 620 unsigned int i), 621 622 TP_ARGS(call, fid, i), 623 624 TP_STRUCT__entry( 625 __field(unsigned int, call ) 626 __field(unsigned int, i ) 627 __field(enum afs_fs_operation, op ) 628 __field_struct(struct afs_fid, fid ) 629 ), 630 631 TP_fast_assign( 632 __entry->call = call->debug_id; 633 __entry->i = i; 634 __entry->op = call->operation_ID; 635 if (fid) { 636 __entry->fid = *fid; 637 } else { 638 __entry->fid.vid = 0; 639 __entry->fid.vnode = 0; 640 __entry->fid.unique = 0; 641 } 642 ), 643 644 TP_printk("c=%08x %06llx:%06llx:%06x %s i=%u", 645 __entry->call, 646 __entry->fid.vid, 647 __entry->fid.vnode, 648 __entry->fid.unique, 649 __print_symbolic(__entry->op, afs_fs_operations), 650 __entry->i) 651 ); 652 653 TRACE_EVENT(afs_make_fs_call1, 654 TP_PROTO(struct afs_call *call, const struct afs_fid *fid, 655 const struct qstr *name), 656 657 TP_ARGS(call, fid, name), 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 __array(char, name, 24 ) 664 ), 665 666 TP_fast_assign( 667 unsigned int __len = min_t(unsigned int, name->len, 23); 668 __entry->call = call->debug_id; 669 __entry->op = call->operation_ID; 670 if (fid) { 671 __entry->fid = *fid; 672 } else { 673 __entry->fid.vid = 0; 674 __entry->fid.vnode = 0; 675 __entry->fid.unique = 0; 676 } 677 memcpy(__entry->name, name->name, __len); 678 __entry->name[__len] = 0; 679 ), 680 681 TP_printk("c=%08x %06llx:%06llx:%06x %s \"%s\"", 682 __entry->call, 683 __entry->fid.vid, 684 __entry->fid.vnode, 685 __entry->fid.unique, 686 __print_symbolic(__entry->op, afs_fs_operations), 687 __entry->name) 688 ); 689 690 TRACE_EVENT(afs_make_fs_call2, 691 TP_PROTO(struct afs_call *call, const struct afs_fid *fid, 692 const struct qstr *name, const struct qstr *name2), 693 694 TP_ARGS(call, fid, name, name2), 695 696 TP_STRUCT__entry( 697 __field(unsigned int, call ) 698 __field(enum afs_fs_operation, op ) 699 __field_struct(struct afs_fid, fid ) 700 __array(char, name, 24 ) 701 __array(char, name2, 24 ) 702 ), 703 704 TP_fast_assign( 705 unsigned int __len = min_t(unsigned int, name->len, 23); 706 unsigned int __len2 = min_t(unsigned int, name2->len, 23); 707 __entry->call = call->debug_id; 708 __entry->op = call->operation_ID; 709 if (fid) { 710 __entry->fid = *fid; 711 } else { 712 __entry->fid.vid = 0; 713 __entry->fid.vnode = 0; 714 __entry->fid.unique = 0; 715 } 716 memcpy(__entry->name, name->name, __len); 717 __entry->name[__len] = 0; 718 memcpy(__entry->name2, name2->name, __len2); 719 __entry->name2[__len2] = 0; 720 ), 721 722 TP_printk("c=%08x %06llx:%06llx:%06x %s \"%s\" \"%s\"", 723 __entry->call, 724 __entry->fid.vid, 725 __entry->fid.vnode, 726 __entry->fid.unique, 727 __print_symbolic(__entry->op, afs_fs_operations), 728 __entry->name, 729 __entry->name2) 730 ); 731 732 TRACE_EVENT(afs_make_vl_call, 733 TP_PROTO(struct afs_call *call), 734 735 TP_ARGS(call), 736 737 TP_STRUCT__entry( 738 __field(unsigned int, call ) 739 __field(enum afs_vl_operation, op ) 740 ), 741 742 TP_fast_assign( 743 __entry->call = call->debug_id; 744 __entry->op = call->operation_ID; 745 ), 746 747 TP_printk("c=%08x %s", 748 __entry->call, 749 __print_symbolic(__entry->op, afs_vl_operations)) 750 ); 751 752 TRACE_EVENT(afs_call_done, 753 TP_PROTO(struct afs_call *call), 754 755 TP_ARGS(call), 756 757 TP_STRUCT__entry( 758 __field(unsigned int, call ) 759 __field(struct rxrpc_call *, rx_call ) 760 __field(int, ret ) 761 __field(u32, abort_code ) 762 ), 763 764 TP_fast_assign( 765 __entry->call = call->debug_id; 766 __entry->rx_call = call->rxcall; 767 __entry->ret = call->error; 768 __entry->abort_code = call->abort_code; 769 ), 770 771 TP_printk(" c=%08x ret=%d ab=%d [%p]", 772 __entry->call, 773 __entry->ret, 774 __entry->abort_code, 775 __entry->rx_call) 776 ); 777 778 TRACE_EVENT(afs_send_data, 779 TP_PROTO(struct afs_call *call, struct msghdr *msg), 780 781 TP_ARGS(call, msg), 782 783 TP_STRUCT__entry( 784 __field(unsigned int, call ) 785 __field(unsigned int, flags ) 786 __field(loff_t, offset ) 787 __field(loff_t, count ) 788 ), 789 790 TP_fast_assign( 791 __entry->call = call->debug_id; 792 __entry->flags = msg->msg_flags; 793 __entry->offset = msg->msg_iter.xarray_start + msg->msg_iter.iov_offset; 794 __entry->count = iov_iter_count(&msg->msg_iter); 795 ), 796 797 TP_printk(" c=%08x o=%llx n=%llx f=%x", 798 __entry->call, __entry->offset, __entry->count, 799 __entry->flags) 800 ); 801 802 TRACE_EVENT(afs_sent_data, 803 TP_PROTO(struct afs_call *call, struct msghdr *msg, int ret), 804 805 TP_ARGS(call, msg, ret), 806 807 TP_STRUCT__entry( 808 __field(unsigned int, call ) 809 __field(int, ret ) 810 __field(loff_t, offset ) 811 __field(loff_t, count ) 812 ), 813 814 TP_fast_assign( 815 __entry->call = call->debug_id; 816 __entry->ret = ret; 817 __entry->offset = msg->msg_iter.xarray_start + msg->msg_iter.iov_offset; 818 __entry->count = iov_iter_count(&msg->msg_iter); 819 ), 820 821 TP_printk(" c=%08x o=%llx n=%llx r=%x", 822 __entry->call, __entry->offset, __entry->count, 823 __entry->ret) 824 ); 825 826 TRACE_EVENT(afs_dir_check_failed, 827 TP_PROTO(struct afs_vnode *vnode, loff_t off, loff_t i_size), 828 829 TP_ARGS(vnode, off, i_size), 830 831 TP_STRUCT__entry( 832 __field(struct afs_vnode *, vnode ) 833 __field(loff_t, off ) 834 __field(loff_t, i_size ) 835 ), 836 837 TP_fast_assign( 838 __entry->vnode = vnode; 839 __entry->off = off; 840 __entry->i_size = i_size; 841 ), 842 843 TP_printk("vn=%p %llx/%llx", 844 __entry->vnode, __entry->off, __entry->i_size) 845 ); 846 847 TRACE_EVENT(afs_folio_dirty, 848 TP_PROTO(struct afs_vnode *vnode, const char *where, struct folio *folio), 849 850 TP_ARGS(vnode, where, folio), 851 852 TP_STRUCT__entry( 853 __field(struct afs_vnode *, vnode ) 854 __field(const char *, where ) 855 __field(pgoff_t, index ) 856 __field(unsigned long, from ) 857 __field(unsigned long, to ) 858 ), 859 860 TP_fast_assign( 861 unsigned long priv = (unsigned long)folio_get_private(folio); 862 __entry->vnode = vnode; 863 __entry->where = where; 864 __entry->index = folio_index(folio); 865 __entry->from = afs_folio_dirty_from(folio, priv); 866 __entry->to = afs_folio_dirty_to(folio, priv); 867 __entry->to |= (afs_is_folio_dirty_mmapped(priv) ? 868 (1UL << (BITS_PER_LONG - 1)) : 0); 869 ), 870 871 TP_printk("vn=%p %lx %s %lx-%lx%s", 872 __entry->vnode, __entry->index, __entry->where, 873 __entry->from, 874 __entry->to & ~(1UL << (BITS_PER_LONG - 1)), 875 __entry->to & (1UL << (BITS_PER_LONG - 1)) ? " M" : "") 876 ); 877 878 TRACE_EVENT(afs_call_state, 879 TP_PROTO(struct afs_call *call, 880 enum afs_call_state from, 881 enum afs_call_state to, 882 int ret, u32 remote_abort), 883 884 TP_ARGS(call, from, to, ret, remote_abort), 885 886 TP_STRUCT__entry( 887 __field(unsigned int, call ) 888 __field(enum afs_call_state, from ) 889 __field(enum afs_call_state, to ) 890 __field(int, ret ) 891 __field(u32, abort ) 892 ), 893 894 TP_fast_assign( 895 __entry->call = call->debug_id; 896 __entry->from = from; 897 __entry->to = to; 898 __entry->ret = ret; 899 __entry->abort = remote_abort; 900 ), 901 902 TP_printk("c=%08x %u->%u r=%d ab=%d", 903 __entry->call, 904 __entry->from, __entry->to, 905 __entry->ret, __entry->abort) 906 ); 907 908 TRACE_EVENT(afs_lookup, 909 TP_PROTO(struct afs_vnode *dvnode, const struct qstr *name, 910 struct afs_fid *fid), 911 912 TP_ARGS(dvnode, name, fid), 913 914 TP_STRUCT__entry( 915 __field_struct(struct afs_fid, dfid ) 916 __field_struct(struct afs_fid, fid ) 917 __array(char, name, 24 ) 918 ), 919 920 TP_fast_assign( 921 int __len = min_t(int, name->len, 23); 922 __entry->dfid = dvnode->fid; 923 __entry->fid = *fid; 924 memcpy(__entry->name, name->name, __len); 925 __entry->name[__len] = 0; 926 ), 927 928 TP_printk("d=%llx:%llx:%x \"%s\" f=%llx:%x", 929 __entry->dfid.vid, __entry->dfid.vnode, __entry->dfid.unique, 930 __entry->name, 931 __entry->fid.vnode, __entry->fid.unique) 932 ); 933 934 TRACE_EVENT(afs_edit_dir, 935 TP_PROTO(struct afs_vnode *dvnode, 936 enum afs_edit_dir_reason why, 937 enum afs_edit_dir_op op, 938 unsigned int block, 939 unsigned int slot, 940 unsigned int f_vnode, 941 unsigned int f_unique, 942 const char *name), 943 944 TP_ARGS(dvnode, why, op, block, slot, f_vnode, f_unique, name), 945 946 TP_STRUCT__entry( 947 __field(unsigned int, vnode ) 948 __field(unsigned int, unique ) 949 __field(enum afs_edit_dir_reason, why ) 950 __field(enum afs_edit_dir_op, op ) 951 __field(unsigned int, block ) 952 __field(unsigned short, slot ) 953 __field(unsigned int, f_vnode ) 954 __field(unsigned int, f_unique ) 955 __array(char, name, 24 ) 956 ), 957 958 TP_fast_assign( 959 int __len = strlen(name); 960 __len = min(__len, 23); 961 __entry->vnode = dvnode->fid.vnode; 962 __entry->unique = dvnode->fid.unique; 963 __entry->why = why; 964 __entry->op = op; 965 __entry->block = block; 966 __entry->slot = slot; 967 __entry->f_vnode = f_vnode; 968 __entry->f_unique = f_unique; 969 memcpy(__entry->name, name, __len); 970 __entry->name[__len] = 0; 971 ), 972 973 TP_printk("d=%x:%x %s %s %u[%u] f=%x:%x \"%s\"", 974 __entry->vnode, __entry->unique, 975 __print_symbolic(__entry->why, afs_edit_dir_reasons), 976 __print_symbolic(__entry->op, afs_edit_dir_ops), 977 __entry->block, __entry->slot, 978 __entry->f_vnode, __entry->f_unique, 979 __entry->name) 980 ); 981 982 TRACE_EVENT(afs_protocol_error, 983 TP_PROTO(struct afs_call *call, enum afs_eproto_cause cause), 984 985 TP_ARGS(call, cause), 986 987 TP_STRUCT__entry( 988 __field(unsigned int, call ) 989 __field(enum afs_eproto_cause, cause ) 990 ), 991 992 TP_fast_assign( 993 __entry->call = call ? call->debug_id : 0; 994 __entry->cause = cause; 995 ), 996 997 TP_printk("c=%08x %s", 998 __entry->call, 999 __print_symbolic(__entry->cause, afs_eproto_causes)) 1000 ); 1001 1002 TRACE_EVENT(afs_io_error, 1003 TP_PROTO(unsigned int call, int error, enum afs_io_error where), 1004 1005 TP_ARGS(call, error, where), 1006 1007 TP_STRUCT__entry( 1008 __field(unsigned int, call ) 1009 __field(int, error ) 1010 __field(enum afs_io_error, where ) 1011 ), 1012 1013 TP_fast_assign( 1014 __entry->call = call; 1015 __entry->error = error; 1016 __entry->where = where; 1017 ), 1018 1019 TP_printk("c=%08x r=%d %s", 1020 __entry->call, __entry->error, 1021 __print_symbolic(__entry->where, afs_io_errors)) 1022 ); 1023 1024 TRACE_EVENT(afs_file_error, 1025 TP_PROTO(struct afs_vnode *vnode, int error, enum afs_file_error where), 1026 1027 TP_ARGS(vnode, error, where), 1028 1029 TP_STRUCT__entry( 1030 __field_struct(struct afs_fid, fid ) 1031 __field(int, error ) 1032 __field(enum afs_file_error, where ) 1033 ), 1034 1035 TP_fast_assign( 1036 __entry->fid = vnode->fid; 1037 __entry->error = error; 1038 __entry->where = where; 1039 ), 1040 1041 TP_printk("%llx:%llx:%x r=%d %s", 1042 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique, 1043 __entry->error, 1044 __print_symbolic(__entry->where, afs_file_errors)) 1045 ); 1046 1047 TRACE_EVENT(afs_cm_no_server, 1048 TP_PROTO(struct afs_call *call, struct sockaddr_rxrpc *srx), 1049 1050 TP_ARGS(call, srx), 1051 1052 TP_STRUCT__entry( 1053 __field(unsigned int, call ) 1054 __field(unsigned int, op_id ) 1055 __field_struct(struct sockaddr_rxrpc, srx ) 1056 ), 1057 1058 TP_fast_assign( 1059 __entry->call = call->debug_id; 1060 __entry->op_id = call->operation_ID; 1061 memcpy(&__entry->srx, srx, sizeof(__entry->srx)); 1062 ), 1063 1064 TP_printk("c=%08x op=%u %pISpc", 1065 __entry->call, __entry->op_id, &__entry->srx.transport) 1066 ); 1067 1068 TRACE_EVENT(afs_cm_no_server_u, 1069 TP_PROTO(struct afs_call *call, const uuid_t *uuid), 1070 1071 TP_ARGS(call, uuid), 1072 1073 TP_STRUCT__entry( 1074 __field(unsigned int, call ) 1075 __field(unsigned int, op_id ) 1076 __field_struct(uuid_t, uuid ) 1077 ), 1078 1079 TP_fast_assign( 1080 __entry->call = call->debug_id; 1081 __entry->op_id = call->operation_ID; 1082 memcpy(&__entry->uuid, uuid, sizeof(__entry->uuid)); 1083 ), 1084 1085 TP_printk("c=%08x op=%u %pU", 1086 __entry->call, __entry->op_id, &__entry->uuid) 1087 ); 1088 1089 TRACE_EVENT(afs_flock_ev, 1090 TP_PROTO(struct afs_vnode *vnode, struct file_lock *fl, 1091 enum afs_flock_event event, int error), 1092 1093 TP_ARGS(vnode, fl, event, error), 1094 1095 TP_STRUCT__entry( 1096 __field_struct(struct afs_fid, fid ) 1097 __field(enum afs_flock_event, event ) 1098 __field(enum afs_lock_state, state ) 1099 __field(int, error ) 1100 __field(unsigned int, debug_id ) 1101 ), 1102 1103 TP_fast_assign( 1104 __entry->fid = vnode->fid; 1105 __entry->event = event; 1106 __entry->state = vnode->lock_state; 1107 __entry->error = error; 1108 __entry->debug_id = fl ? fl->fl_u.afs.debug_id : 0; 1109 ), 1110 1111 TP_printk("%llx:%llx:%x %04x %s s=%s e=%d", 1112 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique, 1113 __entry->debug_id, 1114 __print_symbolic(__entry->event, afs_flock_events), 1115 __print_symbolic(__entry->state, afs_flock_states), 1116 __entry->error) 1117 ); 1118 1119 TRACE_EVENT(afs_flock_op, 1120 TP_PROTO(struct afs_vnode *vnode, struct file_lock *fl, 1121 enum afs_flock_operation op), 1122 1123 TP_ARGS(vnode, fl, op), 1124 1125 TP_STRUCT__entry( 1126 __field_struct(struct afs_fid, fid ) 1127 __field(loff_t, from ) 1128 __field(loff_t, len ) 1129 __field(enum afs_flock_operation, op ) 1130 __field(unsigned char, type ) 1131 __field(unsigned int, flags ) 1132 __field(unsigned int, debug_id ) 1133 ), 1134 1135 TP_fast_assign( 1136 __entry->fid = vnode->fid; 1137 __entry->from = fl->fl_start; 1138 __entry->len = fl->fl_end - fl->fl_start + 1; 1139 __entry->op = op; 1140 __entry->type = fl->fl_type; 1141 __entry->flags = fl->fl_flags; 1142 __entry->debug_id = fl->fl_u.afs.debug_id; 1143 ), 1144 1145 TP_printk("%llx:%llx:%x %04x %s t=%s R=%llx/%llx f=%x", 1146 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique, 1147 __entry->debug_id, 1148 __print_symbolic(__entry->op, afs_flock_operations), 1149 __print_symbolic(__entry->type, afs_flock_types), 1150 __entry->from, __entry->len, __entry->flags) 1151 ); 1152 1153 TRACE_EVENT(afs_reload_dir, 1154 TP_PROTO(struct afs_vnode *vnode), 1155 1156 TP_ARGS(vnode), 1157 1158 TP_STRUCT__entry( 1159 __field_struct(struct afs_fid, fid ) 1160 ), 1161 1162 TP_fast_assign( 1163 __entry->fid = vnode->fid; 1164 ), 1165 1166 TP_printk("%llx:%llx:%x", 1167 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique) 1168 ); 1169 1170 TRACE_EVENT(afs_silly_rename, 1171 TP_PROTO(struct afs_vnode *vnode, bool done), 1172 1173 TP_ARGS(vnode, done), 1174 1175 TP_STRUCT__entry( 1176 __field_struct(struct afs_fid, fid ) 1177 __field(bool, done ) 1178 ), 1179 1180 TP_fast_assign( 1181 __entry->fid = vnode->fid; 1182 __entry->done = done; 1183 ), 1184 1185 TP_printk("%llx:%llx:%x done=%u", 1186 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique, 1187 __entry->done) 1188 ); 1189 1190 TRACE_EVENT(afs_get_tree, 1191 TP_PROTO(struct afs_cell *cell, struct afs_volume *volume), 1192 1193 TP_ARGS(cell, volume), 1194 1195 TP_STRUCT__entry( 1196 __field(u64, vid ) 1197 __array(char, cell, 24 ) 1198 __array(char, volume, 24 ) 1199 ), 1200 1201 TP_fast_assign( 1202 int __len; 1203 __entry->vid = volume->vid; 1204 __len = min_t(int, cell->name_len, 23); 1205 memcpy(__entry->cell, cell->name, __len); 1206 __entry->cell[__len] = 0; 1207 __len = min_t(int, volume->name_len, 23); 1208 memcpy(__entry->volume, volume->name, __len); 1209 __entry->volume[__len] = 0; 1210 ), 1211 1212 TP_printk("--- MOUNT %s:%s %llx", 1213 __entry->cell, __entry->volume, __entry->vid) 1214 ); 1215 1216 TRACE_EVENT(afs_cb_break, 1217 TP_PROTO(struct afs_fid *fid, unsigned int cb_break, 1218 enum afs_cb_break_reason reason, bool skipped), 1219 1220 TP_ARGS(fid, cb_break, reason, skipped), 1221 1222 TP_STRUCT__entry( 1223 __field_struct(struct afs_fid, fid ) 1224 __field(unsigned int, cb_break ) 1225 __field(enum afs_cb_break_reason, reason ) 1226 __field(bool, skipped ) 1227 ), 1228 1229 TP_fast_assign( 1230 __entry->fid = *fid; 1231 __entry->cb_break = cb_break; 1232 __entry->reason = reason; 1233 __entry->skipped = skipped; 1234 ), 1235 1236 TP_printk("%llx:%llx:%x b=%x s=%u %s", 1237 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique, 1238 __entry->cb_break, 1239 __entry->skipped, 1240 __print_symbolic(__entry->reason, afs_cb_break_reasons)) 1241 ); 1242 1243 TRACE_EVENT(afs_cb_miss, 1244 TP_PROTO(struct afs_fid *fid, enum afs_cb_break_reason reason), 1245 1246 TP_ARGS(fid, reason), 1247 1248 TP_STRUCT__entry( 1249 __field_struct(struct afs_fid, fid ) 1250 __field(enum afs_cb_break_reason, reason ) 1251 ), 1252 1253 TP_fast_assign( 1254 __entry->fid = *fid; 1255 __entry->reason = reason; 1256 ), 1257 1258 TP_printk(" %llx:%llx:%x %s", 1259 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique, 1260 __print_symbolic(__entry->reason, afs_cb_break_reasons)) 1261 ); 1262 1263 TRACE_EVENT(afs_server, 1264 TP_PROTO(unsigned int server_debug_id, int ref, int active, 1265 enum afs_server_trace reason), 1266 1267 TP_ARGS(server_debug_id, ref, active, reason), 1268 1269 TP_STRUCT__entry( 1270 __field(unsigned int, server ) 1271 __field(int, ref ) 1272 __field(int, active ) 1273 __field(int, reason ) 1274 ), 1275 1276 TP_fast_assign( 1277 __entry->server = server_debug_id; 1278 __entry->ref = ref; 1279 __entry->active = active; 1280 __entry->reason = reason; 1281 ), 1282 1283 TP_printk("s=%08x %s u=%d a=%d", 1284 __entry->server, 1285 __print_symbolic(__entry->reason, afs_server_traces), 1286 __entry->ref, 1287 __entry->active) 1288 ); 1289 1290 TRACE_EVENT(afs_volume, 1291 TP_PROTO(afs_volid_t vid, int ref, enum afs_volume_trace reason), 1292 1293 TP_ARGS(vid, ref, reason), 1294 1295 TP_STRUCT__entry( 1296 __field(afs_volid_t, vid ) 1297 __field(int, ref ) 1298 __field(enum afs_volume_trace, reason ) 1299 ), 1300 1301 TP_fast_assign( 1302 __entry->vid = vid; 1303 __entry->ref = ref; 1304 __entry->reason = reason; 1305 ), 1306 1307 TP_printk("V=%llx %s ur=%d", 1308 __entry->vid, 1309 __print_symbolic(__entry->reason, afs_volume_traces), 1310 __entry->ref) 1311 ); 1312 1313 TRACE_EVENT(afs_cell, 1314 TP_PROTO(unsigned int cell_debug_id, int ref, int active, 1315 enum afs_cell_trace reason), 1316 1317 TP_ARGS(cell_debug_id, ref, active, reason), 1318 1319 TP_STRUCT__entry( 1320 __field(unsigned int, cell ) 1321 __field(int, ref ) 1322 __field(int, active ) 1323 __field(int, reason ) 1324 ), 1325 1326 TP_fast_assign( 1327 __entry->cell = cell_debug_id; 1328 __entry->ref = ref; 1329 __entry->active = active; 1330 __entry->reason = reason; 1331 ), 1332 1333 TP_printk("L=%08x %s r=%d a=%d", 1334 __entry->cell, 1335 __print_symbolic(__entry->reason, afs_cell_traces), 1336 __entry->ref, 1337 __entry->active) 1338 ); 1339 1340 #endif /* _TRACE_AFS_H */ 1341 1342 /* This part must be outside protection */ 1343 #include <trace/define_trace.h> 1344