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_call_trace { 22 afs_call_trace_alloc, 23 afs_call_trace_free, 24 afs_call_trace_get, 25 afs_call_trace_put, 26 afs_call_trace_wake, 27 afs_call_trace_work, 28 }; 29 30 enum afs_server_trace { 31 afs_server_trace_alloc, 32 afs_server_trace_callback, 33 afs_server_trace_destroy, 34 afs_server_trace_free, 35 afs_server_trace_gc, 36 afs_server_trace_get_by_uuid, 37 afs_server_trace_get_caps, 38 afs_server_trace_get_install, 39 afs_server_trace_get_new_cbi, 40 afs_server_trace_give_up_cb, 41 afs_server_trace_put_call, 42 afs_server_trace_put_cbi, 43 afs_server_trace_put_find_rsq, 44 afs_server_trace_put_slist, 45 afs_server_trace_put_slist_isort, 46 afs_server_trace_put_uuid_rsq, 47 afs_server_trace_update, 48 }; 49 50 enum afs_fs_operation { 51 afs_FS_FetchData = 130, /* AFS Fetch file data */ 52 afs_FS_FetchACL = 131, /* AFS Fetch file ACL */ 53 afs_FS_FetchStatus = 132, /* AFS Fetch file status */ 54 afs_FS_StoreData = 133, /* AFS Store file data */ 55 afs_FS_StoreACL = 134, /* AFS Store file ACL */ 56 afs_FS_StoreStatus = 135, /* AFS Store file status */ 57 afs_FS_RemoveFile = 136, /* AFS Remove a file */ 58 afs_FS_CreateFile = 137, /* AFS Create a file */ 59 afs_FS_Rename = 138, /* AFS Rename or move a file or directory */ 60 afs_FS_Symlink = 139, /* AFS Create a symbolic link */ 61 afs_FS_Link = 140, /* AFS Create a hard link */ 62 afs_FS_MakeDir = 141, /* AFS Create a directory */ 63 afs_FS_RemoveDir = 142, /* AFS Remove a directory */ 64 afs_FS_GetVolumeInfo = 148, /* AFS Get information about a volume */ 65 afs_FS_GetVolumeStatus = 149, /* AFS Get volume status information */ 66 afs_FS_GetRootVolume = 151, /* AFS Get root volume name */ 67 afs_FS_SetLock = 156, /* AFS Request a file lock */ 68 afs_FS_ExtendLock = 157, /* AFS Extend a file lock */ 69 afs_FS_ReleaseLock = 158, /* AFS Release a file lock */ 70 afs_FS_Lookup = 161, /* AFS lookup file in directory */ 71 afs_FS_InlineBulkStatus = 65536, /* AFS Fetch multiple file statuses with errors */ 72 afs_FS_FetchData64 = 65537, /* AFS Fetch file data */ 73 afs_FS_StoreData64 = 65538, /* AFS Store file data */ 74 afs_FS_GiveUpAllCallBacks = 65539, /* AFS Give up all our callbacks on a server */ 75 afs_FS_GetCapabilities = 65540, /* AFS Get FS server capabilities */ 76 77 yfs_FS_FetchData = 130, /* YFS Fetch file data */ 78 yfs_FS_FetchACL = 64131, /* YFS Fetch file ACL */ 79 yfs_FS_FetchStatus = 64132, /* YFS Fetch file status */ 80 yfs_FS_StoreACL = 64134, /* YFS Store file ACL */ 81 yfs_FS_StoreStatus = 64135, /* YFS Store file status */ 82 yfs_FS_RemoveFile = 64136, /* YFS Remove a file */ 83 yfs_FS_CreateFile = 64137, /* YFS Create a file */ 84 yfs_FS_Rename = 64138, /* YFS Rename or move a file or directory */ 85 yfs_FS_Symlink = 64139, /* YFS Create a symbolic link */ 86 yfs_FS_Link = 64140, /* YFS Create a hard link */ 87 yfs_FS_MakeDir = 64141, /* YFS Create a directory */ 88 yfs_FS_RemoveDir = 64142, /* YFS Remove a directory */ 89 yfs_FS_GetVolumeStatus = 64149, /* YFS Get volume status information */ 90 yfs_FS_SetVolumeStatus = 64150, /* YFS Set volume status information */ 91 yfs_FS_SetLock = 64156, /* YFS Request a file lock */ 92 yfs_FS_ExtendLock = 64157, /* YFS Extend a file lock */ 93 yfs_FS_ReleaseLock = 64158, /* YFS Release a file lock */ 94 yfs_FS_Lookup = 64161, /* YFS lookup file in directory */ 95 yfs_FS_FlushCPS = 64165, 96 yfs_FS_FetchOpaqueACL = 64168, 97 yfs_FS_WhoAmI = 64170, 98 yfs_FS_RemoveACL = 64171, 99 yfs_FS_RemoveFile2 = 64173, 100 yfs_FS_StoreOpaqueACL2 = 64174, 101 yfs_FS_InlineBulkStatus = 64536, /* YFS Fetch multiple file statuses with errors */ 102 yfs_FS_FetchData64 = 64537, /* YFS Fetch file data */ 103 yfs_FS_StoreData64 = 64538, /* YFS Store file data */ 104 yfs_FS_UpdateSymlink = 64540, 105 }; 106 107 enum afs_vl_operation { 108 afs_VL_GetEntryByNameU = 527, /* AFS Get Vol Entry By Name operation ID */ 109 afs_VL_GetAddrsU = 533, /* AFS Get FS server addresses */ 110 afs_YFSVL_GetEndpoints = 64002, /* YFS Get FS & Vol server addresses */ 111 afs_VL_GetCapabilities = 65537, /* AFS Get VL server capabilities */ 112 }; 113 114 enum afs_cm_operation { 115 afs_CB_CallBack = 204, /* AFS break callback promises */ 116 afs_CB_InitCallBackState = 205, /* AFS initialise callback state */ 117 afs_CB_Probe = 206, /* AFS probe client */ 118 afs_CB_GetLock = 207, /* AFS get contents of CM lock table */ 119 afs_CB_GetCE = 208, /* AFS get cache file description */ 120 afs_CB_GetXStatsVersion = 209, /* AFS get version of extended statistics */ 121 afs_CB_GetXStats = 210, /* AFS get contents of extended statistics data */ 122 afs_CB_InitCallBackState3 = 213, /* AFS initialise callback state, version 3 */ 123 afs_CB_ProbeUuid = 214, /* AFS check the client hasn't rebooted */ 124 }; 125 126 enum yfs_cm_operation { 127 yfs_CB_Probe = 206, /* YFS probe client */ 128 yfs_CB_GetLock = 207, /* YFS get contents of CM lock table */ 129 yfs_CB_XStatsVersion = 209, /* YFS get version of extended statistics */ 130 yfs_CB_GetXStats = 210, /* YFS get contents of extended statistics data */ 131 yfs_CB_InitCallBackState3 = 213, /* YFS initialise callback state, version 3 */ 132 yfs_CB_ProbeUuid = 214, /* YFS check the client hasn't rebooted */ 133 yfs_CB_GetServerPrefs = 215, 134 yfs_CB_GetCellServDV = 216, 135 yfs_CB_GetLocalCell = 217, 136 yfs_CB_GetCacheConfig = 218, 137 yfs_CB_GetCellByNum = 65537, 138 yfs_CB_TellMeAboutYourself = 65538, /* get client capabilities */ 139 yfs_CB_CallBack = 64204, 140 }; 141 142 enum afs_edit_dir_op { 143 afs_edit_dir_create, 144 afs_edit_dir_create_error, 145 afs_edit_dir_create_inval, 146 afs_edit_dir_create_nospc, 147 afs_edit_dir_delete, 148 afs_edit_dir_delete_error, 149 afs_edit_dir_delete_inval, 150 afs_edit_dir_delete_noent, 151 }; 152 153 enum afs_edit_dir_reason { 154 afs_edit_dir_for_create, 155 afs_edit_dir_for_link, 156 afs_edit_dir_for_mkdir, 157 afs_edit_dir_for_rename_0, 158 afs_edit_dir_for_rename_1, 159 afs_edit_dir_for_rename_2, 160 afs_edit_dir_for_rmdir, 161 afs_edit_dir_for_silly_0, 162 afs_edit_dir_for_silly_1, 163 afs_edit_dir_for_symlink, 164 afs_edit_dir_for_unlink, 165 }; 166 167 enum afs_eproto_cause { 168 afs_eproto_bad_status, 169 afs_eproto_cb_count, 170 afs_eproto_cb_fid_count, 171 afs_eproto_file_type, 172 afs_eproto_ibulkst_cb_count, 173 afs_eproto_ibulkst_count, 174 afs_eproto_motd_len, 175 afs_eproto_offline_msg_len, 176 afs_eproto_volname_len, 177 afs_eproto_yvl_fsendpt4_len, 178 afs_eproto_yvl_fsendpt6_len, 179 afs_eproto_yvl_fsendpt_num, 180 afs_eproto_yvl_fsendpt_type, 181 afs_eproto_yvl_vlendpt4_len, 182 afs_eproto_yvl_vlendpt6_len, 183 afs_eproto_yvl_vlendpt_type, 184 }; 185 186 enum afs_io_error { 187 afs_io_error_cm_reply, 188 afs_io_error_extract, 189 afs_io_error_fs_probe_fail, 190 afs_io_error_vl_lookup_fail, 191 afs_io_error_vl_probe_fail, 192 }; 193 194 enum afs_file_error { 195 afs_file_error_dir_bad_magic, 196 afs_file_error_dir_big, 197 afs_file_error_dir_missing_page, 198 afs_file_error_dir_over_end, 199 afs_file_error_dir_small, 200 afs_file_error_dir_unmarked_ext, 201 afs_file_error_mntpt, 202 afs_file_error_writeback_fail, 203 }; 204 205 enum afs_flock_event { 206 afs_flock_acquired, 207 afs_flock_callback_break, 208 afs_flock_defer_unlock, 209 afs_flock_extend_fail, 210 afs_flock_fail_other, 211 afs_flock_fail_perm, 212 afs_flock_no_lockers, 213 afs_flock_release_fail, 214 afs_flock_silly_delete, 215 afs_flock_timestamp, 216 afs_flock_try_to_lock, 217 afs_flock_vfs_lock, 218 afs_flock_vfs_locking, 219 afs_flock_waited, 220 afs_flock_waiting, 221 afs_flock_work_extending, 222 afs_flock_work_retry, 223 afs_flock_work_unlocking, 224 afs_flock_would_block, 225 }; 226 227 enum afs_flock_operation { 228 afs_flock_op_copy_lock, 229 afs_flock_op_flock, 230 afs_flock_op_grant, 231 afs_flock_op_lock, 232 afs_flock_op_release_lock, 233 afs_flock_op_return_ok, 234 afs_flock_op_return_eagain, 235 afs_flock_op_return_edeadlk, 236 afs_flock_op_return_error, 237 afs_flock_op_set_lock, 238 afs_flock_op_unlock, 239 afs_flock_op_wake, 240 }; 241 242 enum afs_cb_break_reason { 243 afs_cb_break_no_break, 244 afs_cb_break_for_callback, 245 afs_cb_break_for_deleted, 246 afs_cb_break_for_lapsed, 247 afs_cb_break_for_unlink, 248 afs_cb_break_for_vsbreak, 249 afs_cb_break_for_volume_callback, 250 afs_cb_break_for_zap, 251 }; 252 253 #endif /* end __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY */ 254 255 /* 256 * Declare tracing information enums and their string mappings for display. 257 */ 258 #define afs_call_traces \ 259 EM(afs_call_trace_alloc, "ALLOC") \ 260 EM(afs_call_trace_free, "FREE ") \ 261 EM(afs_call_trace_get, "GET ") \ 262 EM(afs_call_trace_put, "PUT ") \ 263 EM(afs_call_trace_wake, "WAKE ") \ 264 E_(afs_call_trace_work, "QUEUE") 265 266 #define afs_server_traces \ 267 EM(afs_server_trace_alloc, "ALLOC ") \ 268 EM(afs_server_trace_callback, "CALLBACK ") \ 269 EM(afs_server_trace_destroy, "DESTROY ") \ 270 EM(afs_server_trace_free, "FREE ") \ 271 EM(afs_server_trace_gc, "GC ") \ 272 EM(afs_server_trace_get_by_uuid, "GET uuid ") \ 273 EM(afs_server_trace_get_caps, "GET caps ") \ 274 EM(afs_server_trace_get_install, "GET inst ") \ 275 EM(afs_server_trace_get_new_cbi, "GET cbi ") \ 276 EM(afs_server_trace_give_up_cb, "giveup-cb") \ 277 EM(afs_server_trace_put_call, "PUT call ") \ 278 EM(afs_server_trace_put_cbi, "PUT cbi ") \ 279 EM(afs_server_trace_put_find_rsq, "PUT f-rsq") \ 280 EM(afs_server_trace_put_slist, "PUT slist") \ 281 EM(afs_server_trace_put_slist_isort, "PUT isort") \ 282 EM(afs_server_trace_put_uuid_rsq, "PUT u-req") \ 283 E_(afs_server_trace_update, "UPDATE") 284 285 #define afs_fs_operations \ 286 EM(afs_FS_FetchData, "FS.FetchData") \ 287 EM(afs_FS_FetchStatus, "FS.FetchStatus") \ 288 EM(afs_FS_StoreData, "FS.StoreData") \ 289 EM(afs_FS_StoreStatus, "FS.StoreStatus") \ 290 EM(afs_FS_RemoveFile, "FS.RemoveFile") \ 291 EM(afs_FS_CreateFile, "FS.CreateFile") \ 292 EM(afs_FS_Rename, "FS.Rename") \ 293 EM(afs_FS_Symlink, "FS.Symlink") \ 294 EM(afs_FS_Link, "FS.Link") \ 295 EM(afs_FS_MakeDir, "FS.MakeDir") \ 296 EM(afs_FS_RemoveDir, "FS.RemoveDir") \ 297 EM(afs_FS_GetVolumeInfo, "FS.GetVolumeInfo") \ 298 EM(afs_FS_GetVolumeStatus, "FS.GetVolumeStatus") \ 299 EM(afs_FS_GetRootVolume, "FS.GetRootVolume") \ 300 EM(afs_FS_SetLock, "FS.SetLock") \ 301 EM(afs_FS_ExtendLock, "FS.ExtendLock") \ 302 EM(afs_FS_ReleaseLock, "FS.ReleaseLock") \ 303 EM(afs_FS_Lookup, "FS.Lookup") \ 304 EM(afs_FS_InlineBulkStatus, "FS.InlineBulkStatus") \ 305 EM(afs_FS_FetchData64, "FS.FetchData64") \ 306 EM(afs_FS_StoreData64, "FS.StoreData64") \ 307 EM(afs_FS_GiveUpAllCallBacks, "FS.GiveUpAllCallBacks") \ 308 EM(afs_FS_GetCapabilities, "FS.GetCapabilities") \ 309 EM(yfs_FS_FetchACL, "YFS.FetchACL") \ 310 EM(yfs_FS_FetchStatus, "YFS.FetchStatus") \ 311 EM(yfs_FS_StoreACL, "YFS.StoreACL") \ 312 EM(yfs_FS_StoreStatus, "YFS.StoreStatus") \ 313 EM(yfs_FS_RemoveFile, "YFS.RemoveFile") \ 314 EM(yfs_FS_CreateFile, "YFS.CreateFile") \ 315 EM(yfs_FS_Rename, "YFS.Rename") \ 316 EM(yfs_FS_Symlink, "YFS.Symlink") \ 317 EM(yfs_FS_Link, "YFS.Link") \ 318 EM(yfs_FS_MakeDir, "YFS.MakeDir") \ 319 EM(yfs_FS_RemoveDir, "YFS.RemoveDir") \ 320 EM(yfs_FS_GetVolumeStatus, "YFS.GetVolumeStatus") \ 321 EM(yfs_FS_SetVolumeStatus, "YFS.SetVolumeStatus") \ 322 EM(yfs_FS_SetLock, "YFS.SetLock") \ 323 EM(yfs_FS_ExtendLock, "YFS.ExtendLock") \ 324 EM(yfs_FS_ReleaseLock, "YFS.ReleaseLock") \ 325 EM(yfs_FS_Lookup, "YFS.Lookup") \ 326 EM(yfs_FS_FlushCPS, "YFS.FlushCPS") \ 327 EM(yfs_FS_FetchOpaqueACL, "YFS.FetchOpaqueACL") \ 328 EM(yfs_FS_WhoAmI, "YFS.WhoAmI") \ 329 EM(yfs_FS_RemoveACL, "YFS.RemoveACL") \ 330 EM(yfs_FS_RemoveFile2, "YFS.RemoveFile2") \ 331 EM(yfs_FS_StoreOpaqueACL2, "YFS.StoreOpaqueACL2") \ 332 EM(yfs_FS_InlineBulkStatus, "YFS.InlineBulkStatus") \ 333 EM(yfs_FS_FetchData64, "YFS.FetchData64") \ 334 EM(yfs_FS_StoreData64, "YFS.StoreData64") \ 335 E_(yfs_FS_UpdateSymlink, "YFS.UpdateSymlink") 336 337 #define afs_vl_operations \ 338 EM(afs_VL_GetEntryByNameU, "VL.GetEntryByNameU") \ 339 EM(afs_VL_GetAddrsU, "VL.GetAddrsU") \ 340 EM(afs_YFSVL_GetEndpoints, "YFSVL.GetEndpoints") \ 341 E_(afs_VL_GetCapabilities, "VL.GetCapabilities") 342 343 #define afs_cm_operations \ 344 EM(afs_CB_CallBack, "CB.CallBack") \ 345 EM(afs_CB_InitCallBackState, "CB.InitCallBackState") \ 346 EM(afs_CB_Probe, "CB.Probe") \ 347 EM(afs_CB_GetLock, "CB.GetLock") \ 348 EM(afs_CB_GetCE, "CB.GetCE") \ 349 EM(afs_CB_GetXStatsVersion, "CB.GetXStatsVersion") \ 350 EM(afs_CB_GetXStats, "CB.GetXStats") \ 351 EM(afs_CB_InitCallBackState3, "CB.InitCallBackState3") \ 352 E_(afs_CB_ProbeUuid, "CB.ProbeUuid") 353 354 #define yfs_cm_operations \ 355 EM(yfs_CB_Probe, "YFSCB.Probe") \ 356 EM(yfs_CB_GetLock, "YFSCB.GetLock") \ 357 EM(yfs_CB_XStatsVersion, "YFSCB.XStatsVersion") \ 358 EM(yfs_CB_GetXStats, "YFSCB.GetXStats") \ 359 EM(yfs_CB_InitCallBackState3, "YFSCB.InitCallBackState3") \ 360 EM(yfs_CB_ProbeUuid, "YFSCB.ProbeUuid") \ 361 EM(yfs_CB_GetServerPrefs, "YFSCB.GetServerPrefs") \ 362 EM(yfs_CB_GetCellServDV, "YFSCB.GetCellServDV") \ 363 EM(yfs_CB_GetLocalCell, "YFSCB.GetLocalCell") \ 364 EM(yfs_CB_GetCacheConfig, "YFSCB.GetCacheConfig") \ 365 EM(yfs_CB_GetCellByNum, "YFSCB.GetCellByNum") \ 366 EM(yfs_CB_TellMeAboutYourself, "YFSCB.TellMeAboutYourself") \ 367 E_(yfs_CB_CallBack, "YFSCB.CallBack") 368 369 #define afs_edit_dir_ops \ 370 EM(afs_edit_dir_create, "create") \ 371 EM(afs_edit_dir_create_error, "c_fail") \ 372 EM(afs_edit_dir_create_inval, "c_invl") \ 373 EM(afs_edit_dir_create_nospc, "c_nspc") \ 374 EM(afs_edit_dir_delete, "delete") \ 375 EM(afs_edit_dir_delete_error, "d_err ") \ 376 EM(afs_edit_dir_delete_inval, "d_invl") \ 377 E_(afs_edit_dir_delete_noent, "d_nent") 378 379 #define afs_edit_dir_reasons \ 380 EM(afs_edit_dir_for_create, "Create") \ 381 EM(afs_edit_dir_for_link, "Link ") \ 382 EM(afs_edit_dir_for_mkdir, "MkDir ") \ 383 EM(afs_edit_dir_for_rename_0, "Renam0") \ 384 EM(afs_edit_dir_for_rename_1, "Renam1") \ 385 EM(afs_edit_dir_for_rename_2, "Renam2") \ 386 EM(afs_edit_dir_for_rmdir, "RmDir ") \ 387 EM(afs_edit_dir_for_silly_0, "S_Ren0") \ 388 EM(afs_edit_dir_for_silly_1, "S_Ren1") \ 389 EM(afs_edit_dir_for_symlink, "Symlnk") \ 390 E_(afs_edit_dir_for_unlink, "Unlink") 391 392 #define afs_eproto_causes \ 393 EM(afs_eproto_bad_status, "BadStatus") \ 394 EM(afs_eproto_cb_count, "CbCount") \ 395 EM(afs_eproto_cb_fid_count, "CbFidCount") \ 396 EM(afs_eproto_file_type, "FileTYpe") \ 397 EM(afs_eproto_ibulkst_cb_count, "IBS.CbCount") \ 398 EM(afs_eproto_ibulkst_count, "IBS.FidCount") \ 399 EM(afs_eproto_motd_len, "MotdLen") \ 400 EM(afs_eproto_offline_msg_len, "OfflineMsgLen") \ 401 EM(afs_eproto_volname_len, "VolNameLen") \ 402 EM(afs_eproto_yvl_fsendpt4_len, "YVL.FsEnd4Len") \ 403 EM(afs_eproto_yvl_fsendpt6_len, "YVL.FsEnd6Len") \ 404 EM(afs_eproto_yvl_fsendpt_num, "YVL.FsEndCount") \ 405 EM(afs_eproto_yvl_fsendpt_type, "YVL.FsEndType") \ 406 EM(afs_eproto_yvl_vlendpt4_len, "YVL.VlEnd4Len") \ 407 EM(afs_eproto_yvl_vlendpt6_len, "YVL.VlEnd6Len") \ 408 E_(afs_eproto_yvl_vlendpt_type, "YVL.VlEndType") 409 410 #define afs_io_errors \ 411 EM(afs_io_error_cm_reply, "CM_REPLY") \ 412 EM(afs_io_error_extract, "EXTRACT") \ 413 EM(afs_io_error_fs_probe_fail, "FS_PROBE_FAIL") \ 414 EM(afs_io_error_vl_lookup_fail, "VL_LOOKUP_FAIL") \ 415 E_(afs_io_error_vl_probe_fail, "VL_PROBE_FAIL") 416 417 #define afs_file_errors \ 418 EM(afs_file_error_dir_bad_magic, "DIR_BAD_MAGIC") \ 419 EM(afs_file_error_dir_big, "DIR_BIG") \ 420 EM(afs_file_error_dir_missing_page, "DIR_MISSING_PAGE") \ 421 EM(afs_file_error_dir_over_end, "DIR_ENT_OVER_END") \ 422 EM(afs_file_error_dir_small, "DIR_SMALL") \ 423 EM(afs_file_error_dir_unmarked_ext, "DIR_UNMARKED_EXT") \ 424 EM(afs_file_error_mntpt, "MNTPT_READ_FAILED") \ 425 E_(afs_file_error_writeback_fail, "WRITEBACK_FAILED") 426 427 #define afs_flock_types \ 428 EM(F_RDLCK, "RDLCK") \ 429 EM(F_WRLCK, "WRLCK") \ 430 E_(F_UNLCK, "UNLCK") 431 432 #define afs_flock_states \ 433 EM(AFS_VNODE_LOCK_NONE, "NONE") \ 434 EM(AFS_VNODE_LOCK_WAITING_FOR_CB, "WAIT_FOR_CB") \ 435 EM(AFS_VNODE_LOCK_SETTING, "SETTING") \ 436 EM(AFS_VNODE_LOCK_GRANTED, "GRANTED") \ 437 EM(AFS_VNODE_LOCK_EXTENDING, "EXTENDING") \ 438 EM(AFS_VNODE_LOCK_NEED_UNLOCK, "NEED_UNLOCK") \ 439 EM(AFS_VNODE_LOCK_UNLOCKING, "UNLOCKING") \ 440 E_(AFS_VNODE_LOCK_DELETED, "DELETED") 441 442 #define afs_flock_events \ 443 EM(afs_flock_acquired, "Acquired") \ 444 EM(afs_flock_callback_break, "Callback") \ 445 EM(afs_flock_defer_unlock, "D-Unlock") \ 446 EM(afs_flock_extend_fail, "Ext_Fail") \ 447 EM(afs_flock_fail_other, "ErrOther") \ 448 EM(afs_flock_fail_perm, "ErrPerm ") \ 449 EM(afs_flock_no_lockers, "NoLocker") \ 450 EM(afs_flock_release_fail, "Rel_Fail") \ 451 EM(afs_flock_silly_delete, "SillyDel") \ 452 EM(afs_flock_timestamp, "Timestmp") \ 453 EM(afs_flock_try_to_lock, "TryToLck") \ 454 EM(afs_flock_vfs_lock, "VFSLock ") \ 455 EM(afs_flock_vfs_locking, "VFSLking") \ 456 EM(afs_flock_waited, "Waited ") \ 457 EM(afs_flock_waiting, "Waiting ") \ 458 EM(afs_flock_work_extending, "Extendng") \ 459 EM(afs_flock_work_retry, "Retry ") \ 460 EM(afs_flock_work_unlocking, "Unlcking") \ 461 E_(afs_flock_would_block, "EWOULDBL") 462 463 #define afs_flock_operations \ 464 EM(afs_flock_op_copy_lock, "COPY ") \ 465 EM(afs_flock_op_flock, "->flock ") \ 466 EM(afs_flock_op_grant, "GRANT ") \ 467 EM(afs_flock_op_lock, "->lock ") \ 468 EM(afs_flock_op_release_lock, "RELEASE ") \ 469 EM(afs_flock_op_return_ok, "<-OK ") \ 470 EM(afs_flock_op_return_edeadlk, "<-EDEADL") \ 471 EM(afs_flock_op_return_eagain, "<-EAGAIN") \ 472 EM(afs_flock_op_return_error, "<-ERROR ") \ 473 EM(afs_flock_op_set_lock, "SET ") \ 474 EM(afs_flock_op_unlock, "UNLOCK ") \ 475 E_(afs_flock_op_wake, "WAKE ") 476 477 #define afs_cb_break_reasons \ 478 EM(afs_cb_break_no_break, "no-break") \ 479 EM(afs_cb_break_for_callback, "break-cb") \ 480 EM(afs_cb_break_for_deleted, "break-del") \ 481 EM(afs_cb_break_for_lapsed, "break-lapsed") \ 482 EM(afs_cb_break_for_unlink, "break-unlink") \ 483 EM(afs_cb_break_for_vsbreak, "break-vs") \ 484 EM(afs_cb_break_for_volume_callback, "break-v-cb") \ 485 E_(afs_cb_break_for_zap, "break-zap") 486 487 /* 488 * Export enum symbols via userspace. 489 */ 490 #undef EM 491 #undef E_ 492 #define EM(a, b) TRACE_DEFINE_ENUM(a); 493 #define E_(a, b) TRACE_DEFINE_ENUM(a); 494 495 afs_call_traces; 496 afs_server_traces; 497 afs_fs_operations; 498 afs_vl_operations; 499 afs_cm_operations; 500 yfs_cm_operations; 501 afs_edit_dir_ops; 502 afs_edit_dir_reasons; 503 afs_eproto_causes; 504 afs_io_errors; 505 afs_file_errors; 506 afs_flock_types; 507 afs_flock_operations; 508 afs_cb_break_reasons; 509 510 /* 511 * Now redefine the EM() and E_() macros to map the enums to the strings that 512 * will be printed in the output. 513 */ 514 #undef EM 515 #undef E_ 516 #define EM(a, b) { a, b }, 517 #define E_(a, b) { a, b } 518 519 TRACE_EVENT(afs_receive_data, 520 TP_PROTO(struct afs_call *call, struct iov_iter *iter, 521 bool want_more, int ret), 522 523 TP_ARGS(call, iter, want_more, ret), 524 525 TP_STRUCT__entry( 526 __field(loff_t, remain ) 527 __field(unsigned int, call ) 528 __field(enum afs_call_state, state ) 529 __field(unsigned short, unmarshall ) 530 __field(bool, want_more ) 531 __field(int, ret ) 532 ), 533 534 TP_fast_assign( 535 __entry->call = call->debug_id; 536 __entry->state = call->state; 537 __entry->unmarshall = call->unmarshall; 538 __entry->remain = iov_iter_count(iter); 539 __entry->want_more = want_more; 540 __entry->ret = ret; 541 ), 542 543 TP_printk("c=%08x r=%llu u=%u w=%u s=%u ret=%d", 544 __entry->call, 545 __entry->remain, 546 __entry->unmarshall, 547 __entry->want_more, 548 __entry->state, 549 __entry->ret) 550 ); 551 552 TRACE_EVENT(afs_notify_call, 553 TP_PROTO(struct rxrpc_call *rxcall, struct afs_call *call), 554 555 TP_ARGS(rxcall, call), 556 557 TP_STRUCT__entry( 558 __field(unsigned int, call ) 559 __field(enum afs_call_state, state ) 560 __field(unsigned short, unmarshall ) 561 ), 562 563 TP_fast_assign( 564 __entry->call = call->debug_id; 565 __entry->state = call->state; 566 __entry->unmarshall = call->unmarshall; 567 ), 568 569 TP_printk("c=%08x s=%u u=%u", 570 __entry->call, 571 __entry->state, __entry->unmarshall) 572 ); 573 574 TRACE_EVENT(afs_cb_call, 575 TP_PROTO(struct afs_call *call), 576 577 TP_ARGS(call), 578 579 TP_STRUCT__entry( 580 __field(unsigned int, call ) 581 __field(u32, op ) 582 __field(u16, service_id ) 583 ), 584 585 TP_fast_assign( 586 __entry->call = call->debug_id; 587 __entry->op = call->operation_ID; 588 __entry->service_id = call->service_id; 589 ), 590 591 TP_printk("c=%08x %s", 592 __entry->call, 593 __entry->service_id == 2501 ? 594 __print_symbolic(__entry->op, yfs_cm_operations) : 595 __print_symbolic(__entry->op, afs_cm_operations)) 596 ); 597 598 TRACE_EVENT(afs_call, 599 TP_PROTO(struct afs_call *call, enum afs_call_trace op, 600 int usage, int outstanding, const void *where), 601 602 TP_ARGS(call, op, usage, outstanding, where), 603 604 TP_STRUCT__entry( 605 __field(unsigned int, call ) 606 __field(int, op ) 607 __field(int, usage ) 608 __field(int, outstanding ) 609 __field(const void *, where ) 610 ), 611 612 TP_fast_assign( 613 __entry->call = call->debug_id; 614 __entry->op = op; 615 __entry->usage = usage; 616 __entry->outstanding = outstanding; 617 __entry->where = where; 618 ), 619 620 TP_printk("c=%08x %s u=%d o=%d sp=%pSR", 621 __entry->call, 622 __print_symbolic(__entry->op, afs_call_traces), 623 __entry->usage, 624 __entry->outstanding, 625 __entry->where) 626 ); 627 628 TRACE_EVENT(afs_make_fs_call, 629 TP_PROTO(struct afs_call *call, const struct afs_fid *fid), 630 631 TP_ARGS(call, fid), 632 633 TP_STRUCT__entry( 634 __field(unsigned int, call ) 635 __field(enum afs_fs_operation, op ) 636 __field_struct(struct afs_fid, fid ) 637 ), 638 639 TP_fast_assign( 640 __entry->call = call->debug_id; 641 __entry->op = call->operation_ID; 642 if (fid) { 643 __entry->fid = *fid; 644 } else { 645 __entry->fid.vid = 0; 646 __entry->fid.vnode = 0; 647 __entry->fid.unique = 0; 648 } 649 ), 650 651 TP_printk("c=%08x %06llx:%06llx:%06x %s", 652 __entry->call, 653 __entry->fid.vid, 654 __entry->fid.vnode, 655 __entry->fid.unique, 656 __print_symbolic(__entry->op, afs_fs_operations)) 657 ); 658 659 TRACE_EVENT(afs_make_fs_calli, 660 TP_PROTO(struct afs_call *call, const struct afs_fid *fid, 661 unsigned int i), 662 663 TP_ARGS(call, fid, i), 664 665 TP_STRUCT__entry( 666 __field(unsigned int, call ) 667 __field(unsigned int, i ) 668 __field(enum afs_fs_operation, op ) 669 __field_struct(struct afs_fid, fid ) 670 ), 671 672 TP_fast_assign( 673 __entry->call = call->debug_id; 674 __entry->i = i; 675 __entry->op = call->operation_ID; 676 if (fid) { 677 __entry->fid = *fid; 678 } else { 679 __entry->fid.vid = 0; 680 __entry->fid.vnode = 0; 681 __entry->fid.unique = 0; 682 } 683 ), 684 685 TP_printk("c=%08x %06llx:%06llx:%06x %s i=%u", 686 __entry->call, 687 __entry->fid.vid, 688 __entry->fid.vnode, 689 __entry->fid.unique, 690 __print_symbolic(__entry->op, afs_fs_operations), 691 __entry->i) 692 ); 693 694 TRACE_EVENT(afs_make_fs_call1, 695 TP_PROTO(struct afs_call *call, const struct afs_fid *fid, 696 const char *name), 697 698 TP_ARGS(call, fid, name), 699 700 TP_STRUCT__entry( 701 __field(unsigned int, call ) 702 __field(enum afs_fs_operation, op ) 703 __field_struct(struct afs_fid, fid ) 704 __array(char, name, 24 ) 705 ), 706 707 TP_fast_assign( 708 int __len = strlen(name); 709 __len = min(__len, 23); 710 __entry->call = call->debug_id; 711 __entry->op = call->operation_ID; 712 if (fid) { 713 __entry->fid = *fid; 714 } else { 715 __entry->fid.vid = 0; 716 __entry->fid.vnode = 0; 717 __entry->fid.unique = 0; 718 } 719 memcpy(__entry->name, name, __len); 720 __entry->name[__len] = 0; 721 ), 722 723 TP_printk("c=%08x %06llx:%06llx:%06x %s \"%s\"", 724 __entry->call, 725 __entry->fid.vid, 726 __entry->fid.vnode, 727 __entry->fid.unique, 728 __print_symbolic(__entry->op, afs_fs_operations), 729 __entry->name) 730 ); 731 732 TRACE_EVENT(afs_make_fs_call2, 733 TP_PROTO(struct afs_call *call, const struct afs_fid *fid, 734 const char *name, const char *name2), 735 736 TP_ARGS(call, fid, name, name2), 737 738 TP_STRUCT__entry( 739 __field(unsigned int, call ) 740 __field(enum afs_fs_operation, op ) 741 __field_struct(struct afs_fid, fid ) 742 __array(char, name, 24 ) 743 __array(char, name2, 24 ) 744 ), 745 746 TP_fast_assign( 747 int __len = strlen(name); 748 int __len2 = strlen(name2); 749 __len = min(__len, 23); 750 __len2 = min(__len2, 23); 751 __entry->call = call->debug_id; 752 __entry->op = call->operation_ID; 753 if (fid) { 754 __entry->fid = *fid; 755 } else { 756 __entry->fid.vid = 0; 757 __entry->fid.vnode = 0; 758 __entry->fid.unique = 0; 759 } 760 memcpy(__entry->name, name, __len); 761 __entry->name[__len] = 0; 762 memcpy(__entry->name2, name2, __len2); 763 __entry->name2[__len2] = 0; 764 ), 765 766 TP_printk("c=%08x %06llx:%06llx:%06x %s \"%s\" \"%s\"", 767 __entry->call, 768 __entry->fid.vid, 769 __entry->fid.vnode, 770 __entry->fid.unique, 771 __print_symbolic(__entry->op, afs_fs_operations), 772 __entry->name, 773 __entry->name2) 774 ); 775 776 TRACE_EVENT(afs_make_vl_call, 777 TP_PROTO(struct afs_call *call), 778 779 TP_ARGS(call), 780 781 TP_STRUCT__entry( 782 __field(unsigned int, call ) 783 __field(enum afs_vl_operation, op ) 784 ), 785 786 TP_fast_assign( 787 __entry->call = call->debug_id; 788 __entry->op = call->operation_ID; 789 ), 790 791 TP_printk("c=%08x %s", 792 __entry->call, 793 __print_symbolic(__entry->op, afs_vl_operations)) 794 ); 795 796 TRACE_EVENT(afs_call_done, 797 TP_PROTO(struct afs_call *call), 798 799 TP_ARGS(call), 800 801 TP_STRUCT__entry( 802 __field(unsigned int, call ) 803 __field(struct rxrpc_call *, rx_call ) 804 __field(int, ret ) 805 __field(u32, abort_code ) 806 ), 807 808 TP_fast_assign( 809 __entry->call = call->debug_id; 810 __entry->rx_call = call->rxcall; 811 __entry->ret = call->error; 812 __entry->abort_code = call->abort_code; 813 ), 814 815 TP_printk(" c=%08x ret=%d ab=%d [%p]", 816 __entry->call, 817 __entry->ret, 818 __entry->abort_code, 819 __entry->rx_call) 820 ); 821 822 TRACE_EVENT(afs_send_pages, 823 TP_PROTO(struct afs_call *call, struct msghdr *msg, 824 pgoff_t first, pgoff_t last, unsigned int offset), 825 826 TP_ARGS(call, msg, first, last, offset), 827 828 TP_STRUCT__entry( 829 __field(unsigned int, call ) 830 __field(pgoff_t, first ) 831 __field(pgoff_t, last ) 832 __field(unsigned int, nr ) 833 __field(unsigned int, bytes ) 834 __field(unsigned int, offset ) 835 __field(unsigned int, flags ) 836 ), 837 838 TP_fast_assign( 839 __entry->call = call->debug_id; 840 __entry->first = first; 841 __entry->last = last; 842 __entry->nr = msg->msg_iter.nr_segs; 843 __entry->bytes = msg->msg_iter.count; 844 __entry->offset = offset; 845 __entry->flags = msg->msg_flags; 846 ), 847 848 TP_printk(" c=%08x %lx-%lx-%lx b=%x o=%x f=%x", 849 __entry->call, 850 __entry->first, __entry->first + __entry->nr - 1, __entry->last, 851 __entry->bytes, __entry->offset, 852 __entry->flags) 853 ); 854 855 TRACE_EVENT(afs_sent_pages, 856 TP_PROTO(struct afs_call *call, pgoff_t first, pgoff_t last, 857 pgoff_t cursor, int ret), 858 859 TP_ARGS(call, first, last, cursor, ret), 860 861 TP_STRUCT__entry( 862 __field(unsigned int, call ) 863 __field(pgoff_t, first ) 864 __field(pgoff_t, last ) 865 __field(pgoff_t, cursor ) 866 __field(int, ret ) 867 ), 868 869 TP_fast_assign( 870 __entry->call = call->debug_id; 871 __entry->first = first; 872 __entry->last = last; 873 __entry->cursor = cursor; 874 __entry->ret = ret; 875 ), 876 877 TP_printk(" c=%08x %lx-%lx c=%lx r=%d", 878 __entry->call, 879 __entry->first, __entry->last, 880 __entry->cursor, __entry->ret) 881 ); 882 883 TRACE_EVENT(afs_dir_check_failed, 884 TP_PROTO(struct afs_vnode *vnode, loff_t off, loff_t i_size), 885 886 TP_ARGS(vnode, off, i_size), 887 888 TP_STRUCT__entry( 889 __field(struct afs_vnode *, vnode ) 890 __field(loff_t, off ) 891 __field(loff_t, i_size ) 892 ), 893 894 TP_fast_assign( 895 __entry->vnode = vnode; 896 __entry->off = off; 897 __entry->i_size = i_size; 898 ), 899 900 TP_printk("vn=%p %llx/%llx", 901 __entry->vnode, __entry->off, __entry->i_size) 902 ); 903 904 /* 905 * We use page->private to hold the amount of the page that we've written to, 906 * splitting the field into two parts. However, we need to represent a range 907 * 0...PAGE_SIZE inclusive, so we can't support 64K pages on a 32-bit system. 908 */ 909 #if PAGE_SIZE > 32768 910 #define AFS_PRIV_MAX 0xffffffff 911 #define AFS_PRIV_SHIFT 32 912 #else 913 #define AFS_PRIV_MAX 0xffff 914 #define AFS_PRIV_SHIFT 16 915 #endif 916 917 TRACE_EVENT(afs_page_dirty, 918 TP_PROTO(struct afs_vnode *vnode, const char *where, 919 pgoff_t page, unsigned long priv), 920 921 TP_ARGS(vnode, where, page, priv), 922 923 TP_STRUCT__entry( 924 __field(struct afs_vnode *, vnode ) 925 __field(const char *, where ) 926 __field(pgoff_t, page ) 927 __field(unsigned long, priv ) 928 ), 929 930 TP_fast_assign( 931 __entry->vnode = vnode; 932 __entry->where = where; 933 __entry->page = page; 934 __entry->priv = priv; 935 ), 936 937 TP_printk("vn=%p %lx %s %lu-%lu", 938 __entry->vnode, __entry->page, __entry->where, 939 __entry->priv & AFS_PRIV_MAX, 940 __entry->priv >> AFS_PRIV_SHIFT) 941 ); 942 943 TRACE_EVENT(afs_call_state, 944 TP_PROTO(struct afs_call *call, 945 enum afs_call_state from, 946 enum afs_call_state to, 947 int ret, u32 remote_abort), 948 949 TP_ARGS(call, from, to, ret, remote_abort), 950 951 TP_STRUCT__entry( 952 __field(unsigned int, call ) 953 __field(enum afs_call_state, from ) 954 __field(enum afs_call_state, to ) 955 __field(int, ret ) 956 __field(u32, abort ) 957 ), 958 959 TP_fast_assign( 960 __entry->call = call->debug_id; 961 __entry->from = from; 962 __entry->to = to; 963 __entry->ret = ret; 964 __entry->abort = remote_abort; 965 ), 966 967 TP_printk("c=%08x %u->%u r=%d ab=%d", 968 __entry->call, 969 __entry->from, __entry->to, 970 __entry->ret, __entry->abort) 971 ); 972 973 TRACE_EVENT(afs_lookup, 974 TP_PROTO(struct afs_vnode *dvnode, const struct qstr *name, 975 struct afs_fid *fid), 976 977 TP_ARGS(dvnode, name, fid), 978 979 TP_STRUCT__entry( 980 __field_struct(struct afs_fid, dfid ) 981 __field_struct(struct afs_fid, fid ) 982 __array(char, name, 24 ) 983 ), 984 985 TP_fast_assign( 986 int __len = min_t(int, name->len, 23); 987 __entry->dfid = dvnode->fid; 988 __entry->fid = *fid; 989 memcpy(__entry->name, name->name, __len); 990 __entry->name[__len] = 0; 991 ), 992 993 TP_printk("d=%llx:%llx:%x \"%s\" f=%llx:%x", 994 __entry->dfid.vid, __entry->dfid.vnode, __entry->dfid.unique, 995 __entry->name, 996 __entry->fid.vnode, __entry->fid.unique) 997 ); 998 999 TRACE_EVENT(afs_edit_dir, 1000 TP_PROTO(struct afs_vnode *dvnode, 1001 enum afs_edit_dir_reason why, 1002 enum afs_edit_dir_op op, 1003 unsigned int block, 1004 unsigned int slot, 1005 unsigned int f_vnode, 1006 unsigned int f_unique, 1007 const char *name), 1008 1009 TP_ARGS(dvnode, why, op, block, slot, f_vnode, f_unique, name), 1010 1011 TP_STRUCT__entry( 1012 __field(unsigned int, vnode ) 1013 __field(unsigned int, unique ) 1014 __field(enum afs_edit_dir_reason, why ) 1015 __field(enum afs_edit_dir_op, op ) 1016 __field(unsigned int, block ) 1017 __field(unsigned short, slot ) 1018 __field(unsigned int, f_vnode ) 1019 __field(unsigned int, f_unique ) 1020 __array(char, name, 24 ) 1021 ), 1022 1023 TP_fast_assign( 1024 int __len = strlen(name); 1025 __len = min(__len, 23); 1026 __entry->vnode = dvnode->fid.vnode; 1027 __entry->unique = dvnode->fid.unique; 1028 __entry->why = why; 1029 __entry->op = op; 1030 __entry->block = block; 1031 __entry->slot = slot; 1032 __entry->f_vnode = f_vnode; 1033 __entry->f_unique = f_unique; 1034 memcpy(__entry->name, name, __len); 1035 __entry->name[__len] = 0; 1036 ), 1037 1038 TP_printk("d=%x:%x %s %s %u[%u] f=%x:%x \"%s\"", 1039 __entry->vnode, __entry->unique, 1040 __print_symbolic(__entry->why, afs_edit_dir_reasons), 1041 __print_symbolic(__entry->op, afs_edit_dir_ops), 1042 __entry->block, __entry->slot, 1043 __entry->f_vnode, __entry->f_unique, 1044 __entry->name) 1045 ); 1046 1047 TRACE_EVENT(afs_protocol_error, 1048 TP_PROTO(struct afs_call *call, int error, enum afs_eproto_cause cause), 1049 1050 TP_ARGS(call, error, cause), 1051 1052 TP_STRUCT__entry( 1053 __field(unsigned int, call ) 1054 __field(int, error ) 1055 __field(enum afs_eproto_cause, cause ) 1056 ), 1057 1058 TP_fast_assign( 1059 __entry->call = call ? call->debug_id : 0; 1060 __entry->error = error; 1061 __entry->cause = cause; 1062 ), 1063 1064 TP_printk("c=%08x r=%d %s", 1065 __entry->call, __entry->error, 1066 __print_symbolic(__entry->cause, afs_eproto_causes)) 1067 ); 1068 1069 TRACE_EVENT(afs_io_error, 1070 TP_PROTO(unsigned int call, int error, enum afs_io_error where), 1071 1072 TP_ARGS(call, error, where), 1073 1074 TP_STRUCT__entry( 1075 __field(unsigned int, call ) 1076 __field(int, error ) 1077 __field(enum afs_io_error, where ) 1078 ), 1079 1080 TP_fast_assign( 1081 __entry->call = call; 1082 __entry->error = error; 1083 __entry->where = where; 1084 ), 1085 1086 TP_printk("c=%08x r=%d %s", 1087 __entry->call, __entry->error, 1088 __print_symbolic(__entry->where, afs_io_errors)) 1089 ); 1090 1091 TRACE_EVENT(afs_file_error, 1092 TP_PROTO(struct afs_vnode *vnode, int error, enum afs_file_error where), 1093 1094 TP_ARGS(vnode, error, where), 1095 1096 TP_STRUCT__entry( 1097 __field_struct(struct afs_fid, fid ) 1098 __field(int, error ) 1099 __field(enum afs_file_error, where ) 1100 ), 1101 1102 TP_fast_assign( 1103 __entry->fid = vnode->fid; 1104 __entry->error = error; 1105 __entry->where = where; 1106 ), 1107 1108 TP_printk("%llx:%llx:%x r=%d %s", 1109 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique, 1110 __entry->error, 1111 __print_symbolic(__entry->where, afs_file_errors)) 1112 ); 1113 1114 TRACE_EVENT(afs_cm_no_server, 1115 TP_PROTO(struct afs_call *call, struct sockaddr_rxrpc *srx), 1116 1117 TP_ARGS(call, srx), 1118 1119 TP_STRUCT__entry( 1120 __field(unsigned int, call ) 1121 __field(unsigned int, op_id ) 1122 __field_struct(struct sockaddr_rxrpc, srx ) 1123 ), 1124 1125 TP_fast_assign( 1126 __entry->call = call->debug_id; 1127 __entry->op_id = call->operation_ID; 1128 memcpy(&__entry->srx, srx, sizeof(__entry->srx)); 1129 ), 1130 1131 TP_printk("c=%08x op=%u %pISpc", 1132 __entry->call, __entry->op_id, &__entry->srx.transport) 1133 ); 1134 1135 TRACE_EVENT(afs_cm_no_server_u, 1136 TP_PROTO(struct afs_call *call, const uuid_t *uuid), 1137 1138 TP_ARGS(call, uuid), 1139 1140 TP_STRUCT__entry( 1141 __field(unsigned int, call ) 1142 __field(unsigned int, op_id ) 1143 __field_struct(uuid_t, uuid ) 1144 ), 1145 1146 TP_fast_assign( 1147 __entry->call = call->debug_id; 1148 __entry->op_id = call->operation_ID; 1149 memcpy(&__entry->uuid, uuid, sizeof(__entry->uuid)); 1150 ), 1151 1152 TP_printk("c=%08x op=%u %pU", 1153 __entry->call, __entry->op_id, &__entry->uuid) 1154 ); 1155 1156 TRACE_EVENT(afs_flock_ev, 1157 TP_PROTO(struct afs_vnode *vnode, struct file_lock *fl, 1158 enum afs_flock_event event, int error), 1159 1160 TP_ARGS(vnode, fl, event, error), 1161 1162 TP_STRUCT__entry( 1163 __field_struct(struct afs_fid, fid ) 1164 __field(enum afs_flock_event, event ) 1165 __field(enum afs_lock_state, state ) 1166 __field(int, error ) 1167 __field(unsigned int, debug_id ) 1168 ), 1169 1170 TP_fast_assign( 1171 __entry->fid = vnode->fid; 1172 __entry->event = event; 1173 __entry->state = vnode->lock_state; 1174 __entry->error = error; 1175 __entry->debug_id = fl ? fl->fl_u.afs.debug_id : 0; 1176 ), 1177 1178 TP_printk("%llx:%llx:%x %04x %s s=%s e=%d", 1179 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique, 1180 __entry->debug_id, 1181 __print_symbolic(__entry->event, afs_flock_events), 1182 __print_symbolic(__entry->state, afs_flock_states), 1183 __entry->error) 1184 ); 1185 1186 TRACE_EVENT(afs_flock_op, 1187 TP_PROTO(struct afs_vnode *vnode, struct file_lock *fl, 1188 enum afs_flock_operation op), 1189 1190 TP_ARGS(vnode, fl, op), 1191 1192 TP_STRUCT__entry( 1193 __field_struct(struct afs_fid, fid ) 1194 __field(loff_t, from ) 1195 __field(loff_t, len ) 1196 __field(enum afs_flock_operation, op ) 1197 __field(unsigned char, type ) 1198 __field(unsigned int, flags ) 1199 __field(unsigned int, debug_id ) 1200 ), 1201 1202 TP_fast_assign( 1203 __entry->fid = vnode->fid; 1204 __entry->from = fl->fl_start; 1205 __entry->len = fl->fl_end - fl->fl_start + 1; 1206 __entry->op = op; 1207 __entry->type = fl->fl_type; 1208 __entry->flags = fl->fl_flags; 1209 __entry->debug_id = fl->fl_u.afs.debug_id; 1210 ), 1211 1212 TP_printk("%llx:%llx:%x %04x %s t=%s R=%llx/%llx f=%x", 1213 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique, 1214 __entry->debug_id, 1215 __print_symbolic(__entry->op, afs_flock_operations), 1216 __print_symbolic(__entry->type, afs_flock_types), 1217 __entry->from, __entry->len, __entry->flags) 1218 ); 1219 1220 TRACE_EVENT(afs_reload_dir, 1221 TP_PROTO(struct afs_vnode *vnode), 1222 1223 TP_ARGS(vnode), 1224 1225 TP_STRUCT__entry( 1226 __field_struct(struct afs_fid, fid ) 1227 ), 1228 1229 TP_fast_assign( 1230 __entry->fid = vnode->fid; 1231 ), 1232 1233 TP_printk("%llx:%llx:%x", 1234 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique) 1235 ); 1236 1237 TRACE_EVENT(afs_silly_rename, 1238 TP_PROTO(struct afs_vnode *vnode, bool done), 1239 1240 TP_ARGS(vnode, done), 1241 1242 TP_STRUCT__entry( 1243 __field_struct(struct afs_fid, fid ) 1244 __field(bool, done ) 1245 ), 1246 1247 TP_fast_assign( 1248 __entry->fid = vnode->fid; 1249 __entry->done = done; 1250 ), 1251 1252 TP_printk("%llx:%llx:%x done=%u", 1253 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique, 1254 __entry->done) 1255 ); 1256 1257 TRACE_EVENT(afs_get_tree, 1258 TP_PROTO(struct afs_cell *cell, struct afs_volume *volume), 1259 1260 TP_ARGS(cell, volume), 1261 1262 TP_STRUCT__entry( 1263 __field(u64, vid ) 1264 __array(char, cell, 24 ) 1265 __array(char, volume, 24 ) 1266 ), 1267 1268 TP_fast_assign( 1269 int __len; 1270 __entry->vid = volume->vid; 1271 __len = min_t(int, cell->name_len, 23); 1272 memcpy(__entry->cell, cell->name, __len); 1273 __entry->cell[__len] = 0; 1274 __len = min_t(int, volume->name_len, 23); 1275 memcpy(__entry->volume, volume->name, __len); 1276 __entry->volume[__len] = 0; 1277 ), 1278 1279 TP_printk("--- MOUNT %s:%s %llx", 1280 __entry->cell, __entry->volume, __entry->vid) 1281 ); 1282 1283 TRACE_EVENT(afs_cb_break, 1284 TP_PROTO(struct afs_fid *fid, unsigned int cb_break, 1285 enum afs_cb_break_reason reason, bool skipped), 1286 1287 TP_ARGS(fid, cb_break, reason, skipped), 1288 1289 TP_STRUCT__entry( 1290 __field_struct(struct afs_fid, fid ) 1291 __field(unsigned int, cb_break ) 1292 __field(enum afs_cb_break_reason, reason ) 1293 __field(bool, skipped ) 1294 ), 1295 1296 TP_fast_assign( 1297 __entry->fid = *fid; 1298 __entry->cb_break = cb_break; 1299 __entry->reason = reason; 1300 __entry->skipped = skipped; 1301 ), 1302 1303 TP_printk("%llx:%llx:%x b=%x s=%u %s", 1304 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique, 1305 __entry->cb_break, 1306 __entry->skipped, 1307 __print_symbolic(__entry->reason, afs_cb_break_reasons)) 1308 ); 1309 1310 TRACE_EVENT(afs_cb_miss, 1311 TP_PROTO(struct afs_fid *fid, enum afs_cb_break_reason reason), 1312 1313 TP_ARGS(fid, reason), 1314 1315 TP_STRUCT__entry( 1316 __field_struct(struct afs_fid, fid ) 1317 __field(enum afs_cb_break_reason, reason ) 1318 ), 1319 1320 TP_fast_assign( 1321 __entry->fid = *fid; 1322 __entry->reason = reason; 1323 ), 1324 1325 TP_printk(" %llx:%llx:%x %s", 1326 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique, 1327 __print_symbolic(__entry->reason, afs_cb_break_reasons)) 1328 ); 1329 1330 TRACE_EVENT(afs_server, 1331 TP_PROTO(struct afs_server *server, int usage, enum afs_server_trace reason), 1332 1333 TP_ARGS(server, usage, reason), 1334 1335 TP_STRUCT__entry( 1336 __field(unsigned int, server ) 1337 __field(int, usage ) 1338 __field(int, reason ) 1339 ), 1340 1341 TP_fast_assign( 1342 __entry->server = server->debug_id; 1343 __entry->usage = usage; 1344 __entry->reason = reason; 1345 ), 1346 1347 TP_printk("s=%08x %s u=%d", 1348 __entry->server, 1349 __print_symbolic(__entry->reason, afs_server_traces), 1350 __entry->usage) 1351 ); 1352 1353 #endif /* _TRACE_AFS_H */ 1354 1355 /* This part must be outside protection */ 1356 #include <trace/define_trace.h> 1357