include/trace/events/afs.h

   1 /* AFS tracepoints
   2  *
   3  * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public Licence
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the Licence, or (at your option) any later version.
  10  */
  11 #undef TRACE_SYSTEM
  12 #define TRACE_SYSTEM afs
  13
  14 #if !defined(_TRACE_AFS_H) || defined(TRACE_HEADER_MULTI_READ)
  15 #define _TRACE_AFS_H
  16
  17 #include <linux/tracepoint.h>
  18
  19 /*
  20  * Define enums for tracing information.
  21  */
  22 #ifndef __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
  23 #define __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
  24
  25 enum afs_call_trace {
  26         afs_call_trace_alloc,
  27         afs_call_trace_free,
  28         afs_call_trace_put,
  29         afs_call_trace_wake,
  30         afs_call_trace_work,
  31 };
  32
  33 enum afs_fs_operation {
  34         afs_FS_FetchData                = 130,  /* AFS Fetch file data */
  35         afs_FS_FetchStatus              = 132,  /* AFS Fetch file status */
  36         afs_FS_StoreData                = 133,  /* AFS Store file data */
  37         afs_FS_StoreStatus              = 135,  /* AFS Store file status */
  38         afs_FS_RemoveFile               = 136,  /* AFS Remove a file */
  39         afs_FS_CreateFile               = 137,  /* AFS Create a file */
  40         afs_FS_Rename                   = 138,  /* AFS Rename or move a file or directory */
  41         afs_FS_Symlink                  = 139,  /* AFS Create a symbolic link */
  42         afs_FS_Link                     = 140,  /* AFS Create a hard link */
  43         afs_FS_MakeDir                  = 141,  /* AFS Create a directory */
  44         afs_FS_RemoveDir                = 142,  /* AFS Remove a directory */
  45         afs_FS_GetVolumeInfo            = 148,  /* AFS Get information about a volume */
  46         afs_FS_GetVolumeStatus          = 149,  /* AFS Get volume status information */
  47         afs_FS_GetRootVolume            = 151,  /* AFS Get root volume name */
  48         afs_FS_SetLock                  = 156,  /* AFS Request a file lock */
  49         afs_FS_ExtendLock               = 157,  /* AFS Extend a file lock */
  50         afs_FS_ReleaseLock              = 158,  /* AFS Release a file lock */
  51         afs_FS_Lookup                   = 161,  /* AFS lookup file in directory */
  52         afs_FS_InlineBulkStatus         = 65536, /* AFS Fetch multiple file statuses with errors */
  53         afs_FS_FetchData64              = 65537, /* AFS Fetch file data */
  54         afs_FS_StoreData64              = 65538, /* AFS Store file data */
  55         afs_FS_GiveUpAllCallBacks       = 65539, /* AFS Give up all our callbacks on a server */
  56         afs_FS_GetCapabilities          = 65540, /* AFS Get FS server capabilities */
  57 };
  58
  59 enum afs_vl_operation {
  60         afs_VL_GetEntryByNameU  = 527,          /* AFS Get Vol Entry By Name operation ID */
  61         afs_VL_GetAddrsU        = 533,          /* AFS Get FS server addresses */
  62         afs_YFSVL_GetEndpoints  = 64002,        /* YFS Get FS & Vol server addresses */
  63         afs_VL_GetCapabilities  = 65537,        /* AFS Get VL server capabilities */
  64 };
  65
  66 enum afs_edit_dir_op {
  67         afs_edit_dir_create,
  68         afs_edit_dir_create_error,
  69         afs_edit_dir_create_inval,
  70         afs_edit_dir_create_nospc,
  71         afs_edit_dir_delete,
  72         afs_edit_dir_delete_error,
  73         afs_edit_dir_delete_inval,
  74         afs_edit_dir_delete_noent,
  75 };
  76
  77 enum afs_edit_dir_reason {
  78         afs_edit_dir_for_create,
  79         afs_edit_dir_for_link,
  80         afs_edit_dir_for_mkdir,
  81         afs_edit_dir_for_rename,
  82         afs_edit_dir_for_rmdir,
  83         afs_edit_dir_for_symlink,
  84         afs_edit_dir_for_unlink,
  85 };
  86
  87 #endif /* end __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY */
  88
  89 /*
  90  * Declare tracing information enums and their string mappings for display.
  91  */
  92 #define afs_call_traces \
  93         EM(afs_call_trace_alloc,                "ALLOC") \
  94         EM(afs_call_trace_free,                 "FREE ") \
  95         EM(afs_call_trace_put,                  "PUT  ") \
  96         EM(afs_call_trace_wake,                 "WAKE ") \
  97         E_(afs_call_trace_work,                 "QUEUE")
  98
  99 #define afs_fs_operations \
 100         EM(afs_FS_FetchData,                    "FS.FetchData") \
 101         EM(afs_FS_FetchStatus,                  "FS.FetchStatus") \
 102         EM(afs_FS_StoreData,                    "FS.StoreData") \
 103         EM(afs_FS_StoreStatus,                  "FS.StoreStatus") \
 104         EM(afs_FS_RemoveFile,                   "FS.RemoveFile") \
 105         EM(afs_FS_CreateFile,                   "FS.CreateFile") \
 106         EM(afs_FS_Rename,                       "FS.Rename") \
 107         EM(afs_FS_Symlink,                      "FS.Symlink") \
 108         EM(afs_FS_Link,                         "FS.Link") \
 109         EM(afs_FS_MakeDir,                      "FS.MakeDir") \
 110         EM(afs_FS_RemoveDir,                    "FS.RemoveDir") \
 111         EM(afs_FS_GetVolumeInfo,                "FS.GetVolumeInfo") \
 112         EM(afs_FS_GetVolumeStatus,              "FS.GetVolumeStatus") \
 113         EM(afs_FS_GetRootVolume,                "FS.GetRootVolume") \
 114         EM(afs_FS_SetLock,                      "FS.SetLock") \
 115         EM(afs_FS_ExtendLock,                   "FS.ExtendLock") \
 116         EM(afs_FS_ReleaseLock,                  "FS.ReleaseLock") \
 117         EM(afs_FS_Lookup,                       "FS.Lookup") \
 118         EM(afs_FS_InlineBulkStatus,             "FS.InlineBulkStatus") \
 119         EM(afs_FS_FetchData64,                  "FS.FetchData64") \
 120         EM(afs_FS_StoreData64,                  "FS.StoreData64") \
 121         EM(afs_FS_GiveUpAllCallBacks,           "FS.GiveUpAllCallBacks") \
 122         E_(afs_FS_GetCapabilities,              "FS.GetCapabilities")
 123
 124 #define afs_vl_operations \
 125         EM(afs_VL_GetEntryByNameU,              "VL.GetEntryByNameU") \
 126         EM(afs_VL_GetAddrsU,                    "VL.GetAddrsU") \
 127         EM(afs_YFSVL_GetEndpoints,              "YFSVL.GetEndpoints") \
 128         E_(afs_VL_GetCapabilities,              "VL.GetCapabilities")
 129
 130 #define afs_edit_dir_ops                                  \
 131         EM(afs_edit_dir_create,                 "create") \
 132         EM(afs_edit_dir_create_error,           "c_fail") \
 133         EM(afs_edit_dir_create_inval,           "c_invl") \
 134         EM(afs_edit_dir_create_nospc,           "c_nspc") \
 135         EM(afs_edit_dir_delete,                 "delete") \
 136         EM(afs_edit_dir_delete_error,           "d_err ") \
 137         EM(afs_edit_dir_delete_inval,           "d_invl") \
 138         E_(afs_edit_dir_delete_noent,           "d_nent")
 139
 140 #define afs_edit_dir_reasons                              \
 141         EM(afs_edit_dir_for_create,             "Create") \
 142         EM(afs_edit_dir_for_link,               "Link  ") \
 143         EM(afs_edit_dir_for_mkdir,              "MkDir ") \
 144         EM(afs_edit_dir_for_rename,             "Rename") \
 145         EM(afs_edit_dir_for_rmdir,              "RmDir ") \
 146         EM(afs_edit_dir_for_symlink,            "Symlnk") \
 147         E_(afs_edit_dir_for_unlink,             "Unlink")
 148
 149
 150 /*
 151  * Export enum symbols via userspace.
 152  */
 153 #undef EM
 154 #undef E_
 155 #define EM(a, b) TRACE_DEFINE_ENUM(a);
 156 #define E_(a, b) TRACE_DEFINE_ENUM(a);
 157
 158 afs_call_traces;
 159 afs_fs_operations;
 160 afs_vl_operations;
 161 afs_edit_dir_ops;
 162 afs_edit_dir_reasons;
 163
 164 /*
 165  * Now redefine the EM() and E_() macros to map the enums to the strings that
 166  * will be printed in the output.
 167  */
 168 #undef EM
 169 #undef E_
 170 #define EM(a, b)        { a, b },
 171 #define E_(a, b)        { a, b }
 172
 173 TRACE_EVENT(afs_recv_data,
 174             TP_PROTO(struct afs_call *call, unsigned count, unsigned offset,
 175                      bool want_more, int ret),
 176
 177             TP_ARGS(call, count, offset, want_more, ret),
 178
 179             TP_STRUCT__entry(
 180                     __field(unsigned int,               call            )
 181                     __field(enum afs_call_state,        state           )
 182                     __field(unsigned int,               count           )
 183                     __field(unsigned int,               offset          )
 184                     __field(unsigned short,             unmarshall      )
 185                     __field(bool,                       want_more       )
 186                     __field(int,                        ret             )
 187                              ),
 188
 189             TP_fast_assign(
 190                     __entry->call       = call->debug_id;
 191                     __entry->state      = call->state;
 192                     __entry->unmarshall = call->unmarshall;
 193                     __entry->count      = count;
 194                     __entry->offset     = offset;
 195                     __entry->want_more  = want_more;
 196                     __entry->ret        = ret;
 197                            ),
 198
 199             TP_printk("c=%08x s=%u u=%u %u/%u wm=%u ret=%d",
 200                       __entry->call,
 201                       __entry->state, __entry->unmarshall,
 202                       __entry->offset, __entry->count,
 203                       __entry->want_more, __entry->ret)
 204             );
 205
 206 TRACE_EVENT(afs_notify_call,
 207             TP_PROTO(struct rxrpc_call *rxcall, struct afs_call *call),
 208
 209             TP_ARGS(rxcall, call),
 210
 211             TP_STRUCT__entry(
 212                     __field(unsigned int,               call            )
 213                     __field(enum afs_call_state,        state           )
 214                     __field(unsigned short,             unmarshall      )
 215                              ),
 216
 217             TP_fast_assign(
 218                     __entry->call       = call->debug_id;
 219                     __entry->state      = call->state;
 220                     __entry->unmarshall = call->unmarshall;
 221                            ),
 222
 223             TP_printk("c=%08x s=%u u=%u",
 224                       __entry->call,
 225                       __entry->state, __entry->unmarshall)
 226             );
 227
 228 TRACE_EVENT(afs_cb_call,
 229             TP_PROTO(struct afs_call *call),
 230
 231             TP_ARGS(call),
 232
 233             TP_STRUCT__entry(
 234                     __field(unsigned int,               call            )
 235                     __field(const char *,               name            )
 236                     __field(u32,                        op              )
 237                              ),
 238
 239             TP_fast_assign(
 240                     __entry->call       = call->debug_id;
 241                     __entry->name       = call->type->name;
 242                     __entry->op         = call->operation_ID;
 243                            ),
 244
 245             TP_printk("c=%08x %s o=%u",
 246                       __entry->call,
 247                       __entry->name,
 248                       __entry->op)
 249             );
 250
 251 TRACE_EVENT(afs_call,
 252             TP_PROTO(struct afs_call *call, enum afs_call_trace op,
 253                      int usage, int outstanding, const void *where),
 254
 255             TP_ARGS(call, op, usage, outstanding, where),
 256
 257             TP_STRUCT__entry(
 258                     __field(unsigned int,               call            )
 259                     __field(int,                        op              )
 260                     __field(int,                        usage           )
 261                     __field(int,                        outstanding     )
 262                     __field(const void *,               where           )
 263                              ),
 264
 265             TP_fast_assign(
 266                     __entry->call = call->debug_id;
 267                     __entry->op = op;
 268                     __entry->usage = usage;
 269                     __entry->outstanding = outstanding;
 270                     __entry->where = where;
 271                            ),
 272
 273             TP_printk("c=%08x %s u=%d o=%d sp=%pSR",
 274                       __entry->call,
 275                       __print_symbolic(__entry->op, afs_call_traces),
 276                       __entry->usage,
 277                       __entry->outstanding,
 278                       __entry->where)
 279             );
 280
 281 TRACE_EVENT(afs_make_fs_call,
 282             TP_PROTO(struct afs_call *call, const struct afs_fid *fid),
 283
 284             TP_ARGS(call, fid),
 285
 286             TP_STRUCT__entry(
 287                     __field(unsigned int,               call            )
 288                     __field(enum afs_fs_operation,      op              )
 289                     __field_struct(struct afs_fid,      fid             )
 290                              ),
 291
 292             TP_fast_assign(
 293                     __entry->call = call->debug_id;
 294                     __entry->op = call->operation_ID;
 295                     if (fid) {
 296                             __entry->fid = *fid;
 297                     } else {
 298                             __entry->fid.vid = 0;
 299                             __entry->fid.vnode = 0;
 300                             __entry->fid.unique = 0;
 301                     }
 302                            ),
 303
 304             TP_printk("c=%08x %06x:%06x:%06x %s",
 305                       __entry->call,
 306                       __entry->fid.vid,
 307                       __entry->fid.vnode,
 308                       __entry->fid.unique,
 309                       __print_symbolic(__entry->op, afs_fs_operations))
 310             );
 311
 312 TRACE_EVENT(afs_make_vl_call,
 313             TP_PROTO(struct afs_call *call),
 314
 315             TP_ARGS(call),
 316
 317             TP_STRUCT__entry(
 318                     __field(unsigned int,               call            )
 319                     __field(enum afs_vl_operation,      op              )
 320                              ),
 321
 322             TP_fast_assign(
 323                     __entry->call = call->debug_id;
 324                     __entry->op = call->operation_ID;
 325                            ),
 326
 327             TP_printk("c=%08x %s",
 328                       __entry->call,
 329                       __print_symbolic(__entry->op, afs_vl_operations))
 330             );
 331
 332 TRACE_EVENT(afs_call_done,
 333             TP_PROTO(struct afs_call *call),
 334
 335             TP_ARGS(call),
 336
 337             TP_STRUCT__entry(
 338                     __field(unsigned int,               call            )
 339                     __field(struct rxrpc_call *,        rx_call         )
 340                     __field(int,                        ret             )
 341                     __field(u32,                        abort_code      )
 342                              ),
 343
 344             TP_fast_assign(
 345                     __entry->call = call->debug_id;
 346                     __entry->rx_call = call->rxcall;
 347                     __entry->ret = call->error;
 348                     __entry->abort_code = call->abort_code;
 349                            ),
 350
 351             TP_printk("   c=%08x ret=%d ab=%d [%p]",
 352                       __entry->call,
 353                       __entry->ret,
 354                       __entry->abort_code,
 355                       __entry->rx_call)
 356             );
 357
 358 TRACE_EVENT(afs_send_pages,
 359             TP_PROTO(struct afs_call *call, struct msghdr *msg,
 360                      pgoff_t first, pgoff_t last, unsigned int offset),
 361
 362             TP_ARGS(call, msg, first, last, offset),
 363
 364             TP_STRUCT__entry(
 365                     __field(unsigned int,               call            )
 366                     __field(pgoff_t,                    first           )
 367                     __field(pgoff_t,                    last            )
 368                     __field(unsigned int,               nr              )
 369                     __field(unsigned int,               bytes           )
 370                     __field(unsigned int,               offset          )
 371                     __field(unsigned int,               flags           )
 372                              ),
 373
 374             TP_fast_assign(
 375                     __entry->call = call->debug_id;
 376                     __entry->first = first;
 377                     __entry->last = last;
 378                     __entry->nr = msg->msg_iter.nr_segs;
 379                     __entry->bytes = msg->msg_iter.count;
 380                     __entry->offset = offset;
 381                     __entry->flags = msg->msg_flags;
 382                            ),
 383
 384             TP_printk(" c=%08x %lx-%lx-%lx b=%x o=%x f=%x",
 385                       __entry->call,
 386                       __entry->first, __entry->first + __entry->nr - 1, __entry->last,
 387                       __entry->bytes, __entry->offset,
 388                       __entry->flags)
 389             );
 390
 391 TRACE_EVENT(afs_sent_pages,
 392             TP_PROTO(struct afs_call *call, pgoff_t first, pgoff_t last,
 393                      pgoff_t cursor, int ret),
 394
 395             TP_ARGS(call, first, last, cursor, ret),
 396
 397             TP_STRUCT__entry(
 398                     __field(unsigned int,               call            )
 399                     __field(pgoff_t,                    first           )
 400                     __field(pgoff_t,                    last            )
 401                     __field(pgoff_t,                    cursor          )
 402                     __field(int,                        ret             )
 403                              ),
 404
 405             TP_fast_assign(
 406                     __entry->call = call->debug_id;
 407                     __entry->first = first;
 408                     __entry->last = last;
 409                     __entry->cursor = cursor;
 410                     __entry->ret = ret;
 411                            ),
 412
 413             TP_printk(" c=%08x %lx-%lx c=%lx r=%d",
 414                       __entry->call,
 415                       __entry->first, __entry->last,
 416                       __entry->cursor, __entry->ret)
 417             );
 418
 419 TRACE_EVENT(afs_dir_check_failed,
 420             TP_PROTO(struct afs_vnode *vnode, loff_t off, loff_t i_size),
 421
 422             TP_ARGS(vnode, off, i_size),
 423
 424             TP_STRUCT__entry(
 425                     __field(struct afs_vnode *,         vnode           )
 426                     __field(loff_t,                     off             )
 427                     __field(loff_t,                     i_size          )
 428                              ),
 429
 430             TP_fast_assign(
 431                     __entry->vnode = vnode;
 432                     __entry->off = off;
 433                     __entry->i_size = i_size;
 434                            ),
 435
 436             TP_printk("vn=%p %llx/%llx",
 437                       __entry->vnode, __entry->off, __entry->i_size)
 438             );
 439
 440 /*
 441  * We use page->private to hold the amount of the page that we've written to,
 442  * splitting the field into two parts.  However, we need to represent a range
 443  * 0...PAGE_SIZE inclusive, so we can't support 64K pages on a 32-bit system.
 444  */
 445 #if PAGE_SIZE > 32768
 446 #define AFS_PRIV_MAX    0xffffffff
 447 #define AFS_PRIV_SHIFT  32
 448 #else
 449 #define AFS_PRIV_MAX    0xffff
 450 #define AFS_PRIV_SHIFT  16
 451 #endif
 452
 453 TRACE_EVENT(afs_page_dirty,
 454             TP_PROTO(struct afs_vnode *vnode, const char *where,
 455                      pgoff_t page, unsigned long priv),
 456
 457             TP_ARGS(vnode, where, page, priv),
 458
 459             TP_STRUCT__entry(
 460                     __field(struct afs_vnode *,         vnode           )
 461                     __field(const char *,               where           )
 462                     __field(pgoff_t,                    page            )
 463                     __field(unsigned long,              priv            )
 464                              ),
 465
 466             TP_fast_assign(
 467                     __entry->vnode = vnode;
 468                     __entry->where = where;
 469                     __entry->page = page;
 470                     __entry->priv = priv;
 471                            ),
 472
 473             TP_printk("vn=%p %lx %s %lu-%lu",
 474                       __entry->vnode, __entry->page, __entry->where,
 475                       __entry->priv & AFS_PRIV_MAX,
 476                       __entry->priv >> AFS_PRIV_SHIFT)
 477             );
 478
 479 TRACE_EVENT(afs_call_state,
 480             TP_PROTO(struct afs_call *call,
 481                      enum afs_call_state from,
 482                      enum afs_call_state to,
 483                      int ret, u32 remote_abort),
 484
 485             TP_ARGS(call, from, to, ret, remote_abort),
 486
 487             TP_STRUCT__entry(
 488                     __field(unsigned int,               call            )
 489                     __field(enum afs_call_state,        from            )
 490                     __field(enum afs_call_state,        to              )
 491                     __field(int,                        ret             )
 492                     __field(u32,                        abort           )
 493                              ),
 494
 495             TP_fast_assign(
 496                     __entry->call = call->debug_id;
 497                     __entry->from = from;
 498                     __entry->to = to;
 499                     __entry->ret = ret;
 500                     __entry->abort = remote_abort;
 501                            ),
 502
 503             TP_printk("c=%08x %u->%u r=%d ab=%d",
 504                       __entry->call,
 505                       __entry->from, __entry->to,
 506                       __entry->ret, __entry->abort)
 507             );
 508
 509 TRACE_EVENT(afs_edit_dir,
 510             TP_PROTO(struct afs_vnode *dvnode,
 511                      enum afs_edit_dir_reason why,
 512                      enum afs_edit_dir_op op,
 513                      unsigned int block,
 514                      unsigned int slot,
 515                      unsigned int f_vnode,
 516                      unsigned int f_unique,
 517                      const char *name),
 518
 519             TP_ARGS(dvnode, why, op, block, slot, f_vnode, f_unique, name),
 520
 521             TP_STRUCT__entry(
 522                     __field(unsigned int,               vnode           )
 523                     __field(unsigned int,               unique          )
 524                     __field(enum afs_edit_dir_reason,   why             )
 525                     __field(enum afs_edit_dir_op,       op              )
 526                     __field(unsigned int,               block           )
 527                     __field(unsigned short,             slot            )
 528                     __field(unsigned int,               f_vnode         )
 529                     __field(unsigned int,               f_unique        )
 530                     __array(char,                       name, 18        )
 531                              ),
 532
 533             TP_fast_assign(
 534                     int __len = strlen(name);
 535                     __len = min(__len, 17);
 536                     __entry->vnode      = dvnode->fid.vnode;
 537                     __entry->unique     = dvnode->fid.unique;
 538                     __entry->why        = why;
 539                     __entry->op         = op;
 540                     __entry->block      = block;
 541                     __entry->slot       = slot;
 542                     __entry->f_vnode    = f_vnode;
 543                     __entry->f_unique   = f_unique;
 544                     memcpy(__entry->name, name, __len);
 545                     __entry->name[__len] = 0;
 546                            ),
 547
 548             TP_printk("d=%x:%x %s %s %u[%u] f=%x:%x %s",
 549                       __entry->vnode, __entry->unique,
 550                       __print_symbolic(__entry->why, afs_edit_dir_reasons),
 551                       __print_symbolic(__entry->op, afs_edit_dir_ops),
 552                       __entry->block, __entry->slot,
 553                       __entry->f_vnode, __entry->f_unique,
 554                       __entry->name)
 555             );
 556
 557 TRACE_EVENT(afs_protocol_error,
 558             TP_PROTO(struct afs_call *call, int error, const void *where),
 559
 560             TP_ARGS(call, error, where),
 561
 562             TP_STRUCT__entry(
 563                     __field(unsigned int,       call            )
 564                     __field(int,                error           )
 565                     __field(const void *,       where           )
 566                              ),
 567
 568             TP_fast_assign(
 569                     __entry->call = call ? call->debug_id : 0;
 570                     __entry->error = error;
 571                     __entry->where = where;
 572                            ),
 573
 574             TP_printk("c=%08x r=%d sp=%pSR",
 575                       __entry->call, __entry->error, __entry->where)
 576             );
 577
 578 TRACE_EVENT(afs_cm_no_server,
 579             TP_PROTO(struct afs_call *call, struct sockaddr_rxrpc *srx),
 580
 581             TP_ARGS(call, srx),
 582
 583             TP_STRUCT__entry(
 584                     __field(unsigned int,                       call    )
 585                     __field(unsigned int,                       op_id   )
 586                     __field_struct(struct sockaddr_rxrpc,       srx     )
 587                              ),
 588
 589             TP_fast_assign(
 590                     __entry->call = call->debug_id;
 591                     __entry->op_id = call->operation_ID;
 592                     memcpy(&__entry->srx, srx, sizeof(__entry->srx));
 593                            ),
 594
 595             TP_printk("c=%08x op=%u %pISpc",
 596                       __entry->call, __entry->op_id, &__entry->srx.transport)
 597             );
 598
 599 TRACE_EVENT(afs_cm_no_server_u,
 600             TP_PROTO(struct afs_call *call, const uuid_t *uuid),
 601
 602             TP_ARGS(call, uuid),
 603
 604             TP_STRUCT__entry(
 605                     __field(unsigned int,                       call    )
 606                     __field(unsigned int,                       op_id   )
 607                     __field_struct(uuid_t,                      uuid    )
 608                              ),
 609
 610             TP_fast_assign(
 611                     __entry->call = call->debug_id;
 612                     __entry->op_id = call->operation_ID;
 613                     memcpy(&__entry->uuid, uuid, sizeof(__entry->uuid));
 614                            ),
 615
 616             TP_printk("c=%08x op=%u %pU",
 617                       __entry->call, __entry->op_id, &__entry->uuid)
 618             );
 619
 620 #endif /* _TRACE_AFS_H */
 621
 622 /* This part must be outside protection */
 623 #include <trace/define_trace.h>