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