include/trace/events/afs.h

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