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