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