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