fs/nfsd/trace.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Copyright (c) 2014 Christoph Hellwig.
   4  */
   5 #undef TRACE_SYSTEM
   6 #define TRACE_SYSTEM nfsd
   7
   8 #if !defined(_NFSD_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
   9 #define _NFSD_TRACE_H
  10
  11 #include <linux/tracepoint.h>
  12 #include <linux/sunrpc/clnt.h>
  13 #include <linux/sunrpc/xprt.h>
  14 #include <trace/misc/nfs.h>
  15 #include <trace/misc/sunrpc.h>
  16
  17 #include "export.h"
  18 #include "nfsfh.h"
  19 #include "xdr4.h"
  20
  21 #define NFSD_TRACE_PROC_RES_FIELDS \
  22                 __field(unsigned int, netns_ino) \
  23                 __field(u32, xid) \
  24                 __field(unsigned long, status) \
  25                 __array(unsigned char, server, sizeof(struct sockaddr_in6)) \
  26                 __array(unsigned char, client, sizeof(struct sockaddr_in6))
  27
  28 #define NFSD_TRACE_PROC_RES_ASSIGNMENTS(error) \
  29                 do { \
  30                         __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \
  31                         __entry->xid = be32_to_cpu(rqstp->rq_xid); \
  32                         __entry->status = be32_to_cpu(error); \
  33                         memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \
  34                                rqstp->rq_xprt->xpt_locallen); \
  35                         memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \
  36                                rqstp->rq_xprt->xpt_remotelen); \
  37                 } while (0);
  38
  39 DECLARE_EVENT_CLASS(nfsd_xdr_err_class,
  40         TP_PROTO(
  41                 const struct svc_rqst *rqstp
  42         ),
  43         TP_ARGS(rqstp),
  44         TP_STRUCT__entry(
  45                 __field(unsigned int, netns_ino)
  46                 __field(u32, xid)
  47                 __field(u32, vers)
  48                 __field(u32, proc)
  49                 __sockaddr(server, rqstp->rq_xprt->xpt_locallen)
  50                 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
  51         ),
  52         TP_fast_assign(
  53                 const struct svc_xprt *xprt = rqstp->rq_xprt;
  54
  55                 __entry->netns_ino = xprt->xpt_net->ns.inum;
  56                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
  57                 __entry->vers = rqstp->rq_vers;
  58                 __entry->proc = rqstp->rq_proc;
  59                 __assign_sockaddr(server, &xprt->xpt_local, xprt->xpt_locallen);
  60                 __assign_sockaddr(client, &xprt->xpt_remote, xprt->xpt_remotelen);
  61         ),
  62         TP_printk("xid=0x%08x vers=%u proc=%u",
  63                 __entry->xid, __entry->vers, __entry->proc
  64         )
  65 );
  66
  67 #define DEFINE_NFSD_XDR_ERR_EVENT(name) \
  68 DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \
  69         TP_PROTO(const struct svc_rqst *rqstp), \
  70         TP_ARGS(rqstp))
  71
  72 DEFINE_NFSD_XDR_ERR_EVENT(garbage_args);
  73 DEFINE_NFSD_XDR_ERR_EVENT(cant_encode);
  74
  75 #define show_nfsd_may_flags(x)                                          \
  76         __print_flags(x, "|",                                           \
  77                 { NFSD_MAY_EXEC,                "EXEC" },               \
  78                 { NFSD_MAY_WRITE,               "WRITE" },              \
  79                 { NFSD_MAY_READ,                "READ" },               \
  80                 { NFSD_MAY_SATTR,               "SATTR" },              \
  81                 { NFSD_MAY_TRUNC,               "TRUNC" },              \
  82                 { NFSD_MAY_LOCK,                "LOCK" },               \
  83                 { NFSD_MAY_OWNER_OVERRIDE,      "OWNER_OVERRIDE" },     \
  84                 { NFSD_MAY_LOCAL_ACCESS,        "LOCAL_ACCESS" },       \
  85                 { NFSD_MAY_BYPASS_GSS_ON_ROOT,  "BYPASS_GSS_ON_ROOT" }, \
  86                 { NFSD_MAY_NOT_BREAK_LEASE,     "NOT_BREAK_LEASE" },    \
  87                 { NFSD_MAY_BYPASS_GSS,          "BYPASS_GSS" },         \
  88                 { NFSD_MAY_READ_IF_EXEC,        "READ_IF_EXEC" },       \
  89                 { NFSD_MAY_64BIT_COOKIE,        "64BIT_COOKIE" })
  90
  91 TRACE_EVENT(nfsd_compound,
  92         TP_PROTO(
  93                 const struct svc_rqst *rqst,
  94                 const char *tag,
  95                 u32 taglen,
  96                 u32 opcnt
  97         ),
  98         TP_ARGS(rqst, tag, taglen, opcnt),
  99         TP_STRUCT__entry(
 100                 __field(u32, xid)
 101                 __field(u32, opcnt)
 102                 __string_len(tag, tag, taglen)
 103         ),
 104         TP_fast_assign(
 105                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 106                 __entry->opcnt = opcnt;
 107                 __assign_str(tag, tag);
 108         ),
 109         TP_printk("xid=0x%08x opcnt=%u tag=%s",
 110                 __entry->xid, __entry->opcnt, __get_str(tag)
 111         )
 112 )
 113
 114 TRACE_EVENT(nfsd_compound_status,
 115         TP_PROTO(u32 args_opcnt,
 116                  u32 resp_opcnt,
 117                  __be32 status,
 118                  const char *name),
 119         TP_ARGS(args_opcnt, resp_opcnt, status, name),
 120         TP_STRUCT__entry(
 121                 __field(u32, args_opcnt)
 122                 __field(u32, resp_opcnt)
 123                 __field(int, status)
 124                 __string(name, name)
 125         ),
 126         TP_fast_assign(
 127                 __entry->args_opcnt = args_opcnt;
 128                 __entry->resp_opcnt = resp_opcnt;
 129                 __entry->status = be32_to_cpu(status);
 130                 __assign_str(name, name);
 131         ),
 132         TP_printk("op=%u/%u %s status=%d",
 133                 __entry->resp_opcnt, __entry->args_opcnt,
 134                 __get_str(name), __entry->status)
 135 )
 136
 137 TRACE_EVENT(nfsd_compound_decode_err,
 138         TP_PROTO(
 139                 const struct svc_rqst *rqstp,
 140                 u32 args_opcnt,
 141                 u32 resp_opcnt,
 142                 u32 opnum,
 143                 __be32 status
 144         ),
 145         TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status),
 146         TP_STRUCT__entry(
 147                 NFSD_TRACE_PROC_RES_FIELDS
 148
 149                 __field(u32, args_opcnt)
 150                 __field(u32, resp_opcnt)
 151                 __field(u32, opnum)
 152         ),
 153         TP_fast_assign(
 154                 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status)
 155
 156                 __entry->args_opcnt = args_opcnt;
 157                 __entry->resp_opcnt = resp_opcnt;
 158                 __entry->opnum = opnum;
 159         ),
 160         TP_printk("op=%u/%u opnum=%u status=%lu",
 161                 __entry->resp_opcnt, __entry->args_opcnt,
 162                 __entry->opnum, __entry->status)
 163 );
 164
 165 TRACE_EVENT(nfsd_compound_encode_err,
 166         TP_PROTO(
 167                 const struct svc_rqst *rqstp,
 168                 u32 opnum,
 169                 __be32 status
 170         ),
 171         TP_ARGS(rqstp, opnum, status),
 172         TP_STRUCT__entry(
 173                 NFSD_TRACE_PROC_RES_FIELDS
 174
 175                 __field(u32, opnum)
 176         ),
 177         TP_fast_assign(
 178                 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status)
 179
 180                 __entry->opnum = opnum;
 181         ),
 182         TP_printk("opnum=%u status=%lu",
 183                 __entry->opnum, __entry->status)
 184 );
 185
 186 #define show_fs_file_type(x) \
 187         __print_symbolic(x, \
 188                 { S_IFLNK,              "LNK" }, \
 189                 { S_IFREG,              "REG" }, \
 190                 { S_IFDIR,              "DIR" }, \
 191                 { S_IFCHR,              "CHR" }, \
 192                 { S_IFBLK,              "BLK" }, \
 193                 { S_IFIFO,              "FIFO" }, \
 194                 { S_IFSOCK,             "SOCK" })
 195
 196 TRACE_EVENT(nfsd_fh_verify,
 197         TP_PROTO(
 198                 const struct svc_rqst *rqstp,
 199                 const struct svc_fh *fhp,
 200                 umode_t type,
 201                 int access
 202         ),
 203         TP_ARGS(rqstp, fhp, type, access),
 204         TP_STRUCT__entry(
 205                 __field(unsigned int, netns_ino)
 206                 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen)
 207                 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
 208                 __field(u32, xid)
 209                 __field(u32, fh_hash)
 210                 __field(const void *, inode)
 211                 __field(unsigned long, type)
 212                 __field(unsigned long, access)
 213         ),
 214         TP_fast_assign(
 215                 __entry->netns_ino = SVC_NET(rqstp)->ns.inum;
 216                 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local,
 217                        rqstp->rq_xprt->xpt_locallen);
 218                 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote,
 219                                   rqstp->rq_xprt->xpt_remotelen);
 220                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
 221                 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
 222                 __entry->inode = d_inode(fhp->fh_dentry);
 223                 __entry->type = type;
 224                 __entry->access = access;
 225         ),
 226         TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s",
 227                 __entry->xid, __entry->fh_hash,
 228                 show_fs_file_type(__entry->type),
 229                 show_nfsd_may_flags(__entry->access)
 230         )
 231 );
 232
 233 TRACE_EVENT_CONDITION(nfsd_fh_verify_err,
 234         TP_PROTO(
 235                 const struct svc_rqst *rqstp,
 236                 const struct svc_fh *fhp,
 237                 umode_t type,
 238                 int access,
 239                 __be32 error
 240         ),
 241         TP_ARGS(rqstp, fhp, type, access, error),
 242         TP_CONDITION(error),
 243         TP_STRUCT__entry(
 244                 __field(unsigned int, netns_ino)
 245                 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen)
 246                 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
 247                 __field(u32, xid)
 248                 __field(u32, fh_hash)
 249                 __field(const void *, inode)
 250                 __field(unsigned long, type)
 251                 __field(unsigned long, access)
 252                 __field(int, error)
 253         ),
 254         TP_fast_assign(
 255                 __entry->netns_ino = SVC_NET(rqstp)->ns.inum;
 256                 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local,
 257                        rqstp->rq_xprt->xpt_locallen);
 258                 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote,
 259                                   rqstp->rq_xprt->xpt_remotelen);
 260                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
 261                 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
 262                 if (fhp->fh_dentry)
 263                         __entry->inode = d_inode(fhp->fh_dentry);
 264                 else
 265                         __entry->inode = NULL;
 266                 __entry->type = type;
 267                 __entry->access = access;
 268                 __entry->error = be32_to_cpu(error);
 269         ),
 270         TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s error=%d",
 271                 __entry->xid, __entry->fh_hash,
 272                 show_fs_file_type(__entry->type),
 273                 show_nfsd_may_flags(__entry->access),
 274                 __entry->error
 275         )
 276 );
 277
 278 DECLARE_EVENT_CLASS(nfsd_fh_err_class,
 279         TP_PROTO(struct svc_rqst *rqstp,
 280                  struct svc_fh  *fhp,
 281                  int            status),
 282         TP_ARGS(rqstp, fhp, status),
 283         TP_STRUCT__entry(
 284                 __field(u32, xid)
 285                 __field(u32, fh_hash)
 286                 __field(int, status)
 287         ),
 288         TP_fast_assign(
 289                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
 290                 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
 291                 __entry->status = status;
 292         ),
 293         TP_printk("xid=0x%08x fh_hash=0x%08x status=%d",
 294                   __entry->xid, __entry->fh_hash,
 295                   __entry->status)
 296 )
 297
 298 #define DEFINE_NFSD_FH_ERR_EVENT(name)          \
 299 DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name,    \
 300         TP_PROTO(struct svc_rqst *rqstp,        \
 301                  struct svc_fh  *fhp,           \
 302                  int            status),        \
 303         TP_ARGS(rqstp, fhp, status))
 304
 305 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport);
 306 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle);
 307
 308 TRACE_EVENT(nfsd_exp_find_key,
 309         TP_PROTO(const struct svc_expkey *key,
 310                  int status),
 311         TP_ARGS(key, status),
 312         TP_STRUCT__entry(
 313                 __field(int, fsidtype)
 314                 __array(u32, fsid, 6)
 315                 __string(auth_domain, key->ek_client->name)
 316                 __field(int, status)
 317         ),
 318         TP_fast_assign(
 319                 __entry->fsidtype = key->ek_fsidtype;
 320                 memcpy(__entry->fsid, key->ek_fsid, 4*6);
 321                 __assign_str(auth_domain, key->ek_client->name);
 322                 __entry->status = status;
 323         ),
 324         TP_printk("fsid=%x::%s domain=%s status=%d",
 325                 __entry->fsidtype,
 326                 __print_array(__entry->fsid, 6, 4),
 327                 __get_str(auth_domain),
 328                 __entry->status
 329         )
 330 );
 331
 332 TRACE_EVENT(nfsd_expkey_update,
 333         TP_PROTO(const struct svc_expkey *key, const char *exp_path),
 334         TP_ARGS(key, exp_path),
 335         TP_STRUCT__entry(
 336                 __field(int, fsidtype)
 337                 __array(u32, fsid, 6)
 338                 __string(auth_domain, key->ek_client->name)
 339                 __string(path, exp_path)
 340                 __field(bool, cache)
 341         ),
 342         TP_fast_assign(
 343                 __entry->fsidtype = key->ek_fsidtype;
 344                 memcpy(__entry->fsid, key->ek_fsid, 4*6);
 345                 __assign_str(auth_domain, key->ek_client->name);
 346                 __assign_str(path, exp_path);
 347                 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags);
 348         ),
 349         TP_printk("fsid=%x::%s domain=%s path=%s cache=%s",
 350                 __entry->fsidtype,
 351                 __print_array(__entry->fsid, 6, 4),
 352                 __get_str(auth_domain),
 353                 __get_str(path),
 354                 __entry->cache ? "pos" : "neg"
 355         )
 356 );
 357
 358 TRACE_EVENT(nfsd_exp_get_by_name,
 359         TP_PROTO(const struct svc_export *key,
 360                  int status),
 361         TP_ARGS(key, status),
 362         TP_STRUCT__entry(
 363                 __string(path, key->ex_path.dentry->d_name.name)
 364                 __string(auth_domain, key->ex_client->name)
 365                 __field(int, status)
 366         ),
 367         TP_fast_assign(
 368                 __assign_str(path, key->ex_path.dentry->d_name.name);
 369                 __assign_str(auth_domain, key->ex_client->name);
 370                 __entry->status = status;
 371         ),
 372         TP_printk("path=%s domain=%s status=%d",
 373                 __get_str(path),
 374                 __get_str(auth_domain),
 375                 __entry->status
 376         )
 377 );
 378
 379 TRACE_EVENT(nfsd_export_update,
 380         TP_PROTO(const struct svc_export *key),
 381         TP_ARGS(key),
 382         TP_STRUCT__entry(
 383                 __string(path, key->ex_path.dentry->d_name.name)
 384                 __string(auth_domain, key->ex_client->name)
 385                 __field(bool, cache)
 386         ),
 387         TP_fast_assign(
 388                 __assign_str(path, key->ex_path.dentry->d_name.name);
 389                 __assign_str(auth_domain, key->ex_client->name);
 390                 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags);
 391         ),
 392         TP_printk("path=%s domain=%s cache=%s",
 393                 __get_str(path),
 394                 __get_str(auth_domain),
 395                 __entry->cache ? "pos" : "neg"
 396         )
 397 );
 398
 399 DECLARE_EVENT_CLASS(nfsd_io_class,
 400         TP_PROTO(struct svc_rqst *rqstp,
 401                  struct svc_fh  *fhp,
 402                  u64            offset,
 403                  u32            len),
 404         TP_ARGS(rqstp, fhp, offset, len),
 405         TP_STRUCT__entry(
 406                 __field(u32, xid)
 407                 __field(u32, fh_hash)
 408                 __field(u64, offset)
 409                 __field(u32, len)
 410         ),
 411         TP_fast_assign(
 412                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
 413                 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
 414                 __entry->offset = offset;
 415                 __entry->len = len;
 416         ),
 417         TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u",
 418                   __entry->xid, __entry->fh_hash,
 419                   __entry->offset, __entry->len)
 420 )
 421
 422 #define DEFINE_NFSD_IO_EVENT(name)              \
 423 DEFINE_EVENT(nfsd_io_class, nfsd_##name,        \
 424         TP_PROTO(struct svc_rqst *rqstp,        \
 425                  struct svc_fh  *fhp,           \
 426                  u64            offset,         \
 427                  u32            len),           \
 428         TP_ARGS(rqstp, fhp, offset, len))
 429
 430 DEFINE_NFSD_IO_EVENT(read_start);
 431 DEFINE_NFSD_IO_EVENT(read_splice);
 432 DEFINE_NFSD_IO_EVENT(read_vector);
 433 DEFINE_NFSD_IO_EVENT(read_io_done);
 434 DEFINE_NFSD_IO_EVENT(read_done);
 435 DEFINE_NFSD_IO_EVENT(write_start);
 436 DEFINE_NFSD_IO_EVENT(write_opened);
 437 DEFINE_NFSD_IO_EVENT(write_io_done);
 438 DEFINE_NFSD_IO_EVENT(write_done);
 439
 440 DECLARE_EVENT_CLASS(nfsd_err_class,
 441         TP_PROTO(struct svc_rqst *rqstp,
 442                  struct svc_fh  *fhp,
 443                  loff_t         offset,
 444                  int            status),
 445         TP_ARGS(rqstp, fhp, offset, status),
 446         TP_STRUCT__entry(
 447                 __field(u32, xid)
 448                 __field(u32, fh_hash)
 449                 __field(loff_t, offset)
 450                 __field(int, status)
 451         ),
 452         TP_fast_assign(
 453                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
 454                 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
 455                 __entry->offset = offset;
 456                 __entry->status = status;
 457         ),
 458         TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d",
 459                   __entry->xid, __entry->fh_hash,
 460                   __entry->offset, __entry->status)
 461 )
 462
 463 #define DEFINE_NFSD_ERR_EVENT(name)             \
 464 DEFINE_EVENT(nfsd_err_class, nfsd_##name,       \
 465         TP_PROTO(struct svc_rqst *rqstp,        \
 466                  struct svc_fh  *fhp,           \
 467                  loff_t         offset,         \
 468                  int            len),           \
 469         TP_ARGS(rqstp, fhp, offset, len))
 470
 471 DEFINE_NFSD_ERR_EVENT(read_err);
 472 DEFINE_NFSD_ERR_EVENT(write_err);
 473
 474 TRACE_EVENT(nfsd_dirent,
 475         TP_PROTO(struct svc_fh *fhp,
 476                  u64 ino,
 477                  const char *name,
 478                  int namlen),
 479         TP_ARGS(fhp, ino, name, namlen),
 480         TP_STRUCT__entry(
 481                 __field(u32, fh_hash)
 482                 __field(u64, ino)
 483                 __string_len(name, name, namlen)
 484         ),
 485         TP_fast_assign(
 486                 __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0;
 487                 __entry->ino = ino;
 488                 __assign_str(name, name);
 489         ),
 490         TP_printk("fh_hash=0x%08x ino=%llu name=%s",
 491                 __entry->fh_hash, __entry->ino, __get_str(name)
 492         )
 493 )
 494
 495 DECLARE_EVENT_CLASS(nfsd_copy_err_class,
 496         TP_PROTO(struct svc_rqst *rqstp,
 497                  struct svc_fh  *src_fhp,
 498                  loff_t         src_offset,
 499                  struct svc_fh  *dst_fhp,
 500                  loff_t         dst_offset,
 501                  u64            count,
 502                  int            status),
 503         TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status),
 504         TP_STRUCT__entry(
 505                 __field(u32, xid)
 506                 __field(u32, src_fh_hash)
 507                 __field(loff_t, src_offset)
 508                 __field(u32, dst_fh_hash)
 509                 __field(loff_t, dst_offset)
 510                 __field(u64, count)
 511                 __field(int, status)
 512         ),
 513         TP_fast_assign(
 514                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
 515                 __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle);
 516                 __entry->src_offset = src_offset;
 517                 __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle);
 518                 __entry->dst_offset = dst_offset;
 519                 __entry->count = count;
 520                 __entry->status = status;
 521         ),
 522         TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld "
 523                         "dst_fh_hash=0x%08x dst_offset=%lld "
 524                         "count=%llu status=%d",
 525                   __entry->xid, __entry->src_fh_hash, __entry->src_offset,
 526                   __entry->dst_fh_hash, __entry->dst_offset,
 527                   (unsigned long long)__entry->count,
 528                   __entry->status)
 529 )
 530
 531 #define DEFINE_NFSD_COPY_ERR_EVENT(name)                \
 532 DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name,          \
 533         TP_PROTO(struct svc_rqst        *rqstp,         \
 534                  struct svc_fh          *src_fhp,       \
 535                  loff_t                 src_offset,     \
 536                  struct svc_fh          *dst_fhp,       \
 537                  loff_t                 dst_offset,     \
 538                  u64                    count,          \
 539                  int                    status),        \
 540         TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \
 541                 count, status))
 542
 543 DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err);
 544
 545 #include "state.h"
 546 #include "filecache.h"
 547 #include "vfs.h"
 548
 549 TRACE_EVENT(nfsd_delegret_wakeup,
 550         TP_PROTO(
 551                 const struct svc_rqst *rqstp,
 552                 const struct inode *inode,
 553                 long timeo
 554         ),
 555         TP_ARGS(rqstp, inode, timeo),
 556         TP_STRUCT__entry(
 557                 __field(u32, xid)
 558                 __field(const void *, inode)
 559                 __field(long, timeo)
 560         ),
 561         TP_fast_assign(
 562                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
 563                 __entry->inode = inode;
 564                 __entry->timeo = timeo;
 565         ),
 566         TP_printk("xid=0x%08x inode=%p%s",
 567                   __entry->xid, __entry->inode,
 568                   __entry->timeo == 0 ? " (timed out)" : ""
 569         )
 570 );
 571
 572 DECLARE_EVENT_CLASS(nfsd_stateid_class,
 573         TP_PROTO(stateid_t *stp),
 574         TP_ARGS(stp),
 575         TP_STRUCT__entry(
 576                 __field(u32, cl_boot)
 577                 __field(u32, cl_id)
 578                 __field(u32, si_id)
 579                 __field(u32, si_generation)
 580         ),
 581         TP_fast_assign(
 582                 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
 583                 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
 584                 __entry->si_id = stp->si_opaque.so_id;
 585                 __entry->si_generation = stp->si_generation;
 586         ),
 587         TP_printk("client %08x:%08x stateid %08x:%08x",
 588                 __entry->cl_boot,
 589                 __entry->cl_id,
 590                 __entry->si_id,
 591                 __entry->si_generation)
 592 )
 593
 594 #define DEFINE_STATEID_EVENT(name) \
 595 DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \
 596         TP_PROTO(stateid_t *stp), \
 597         TP_ARGS(stp))
 598
 599 DEFINE_STATEID_EVENT(layoutstate_alloc);
 600 DEFINE_STATEID_EVENT(layoutstate_unhash);
 601 DEFINE_STATEID_EVENT(layoutstate_free);
 602 DEFINE_STATEID_EVENT(layout_get_lookup_fail);
 603 DEFINE_STATEID_EVENT(layout_commit_lookup_fail);
 604 DEFINE_STATEID_EVENT(layout_return_lookup_fail);
 605 DEFINE_STATEID_EVENT(layout_recall);
 606 DEFINE_STATEID_EVENT(layout_recall_done);
 607 DEFINE_STATEID_EVENT(layout_recall_fail);
 608 DEFINE_STATEID_EVENT(layout_recall_release);
 609
 610 DEFINE_STATEID_EVENT(open);
 611 DEFINE_STATEID_EVENT(deleg_read);
 612 DEFINE_STATEID_EVENT(deleg_write);
 613 DEFINE_STATEID_EVENT(deleg_return);
 614 DEFINE_STATEID_EVENT(deleg_recall);
 615
 616 DECLARE_EVENT_CLASS(nfsd_stateseqid_class,
 617         TP_PROTO(u32 seqid, const stateid_t *stp),
 618         TP_ARGS(seqid, stp),
 619         TP_STRUCT__entry(
 620                 __field(u32, seqid)
 621                 __field(u32, cl_boot)
 622                 __field(u32, cl_id)
 623                 __field(u32, si_id)
 624                 __field(u32, si_generation)
 625         ),
 626         TP_fast_assign(
 627                 __entry->seqid = seqid;
 628                 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
 629                 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
 630                 __entry->si_id = stp->si_opaque.so_id;
 631                 __entry->si_generation = stp->si_generation;
 632         ),
 633         TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x",
 634                 __entry->seqid, __entry->cl_boot, __entry->cl_id,
 635                 __entry->si_id, __entry->si_generation)
 636 )
 637
 638 #define DEFINE_STATESEQID_EVENT(name) \
 639 DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \
 640         TP_PROTO(u32 seqid, const stateid_t *stp), \
 641         TP_ARGS(seqid, stp))
 642
 643 DEFINE_STATESEQID_EVENT(preprocess);
 644 DEFINE_STATESEQID_EVENT(open_confirm);
 645
 646 #define show_stid_type(x)                                               \
 647         __print_flags(x, "|",                                           \
 648                 { SC_TYPE_OPEN,         "OPEN" },               \
 649                 { SC_TYPE_LOCK,         "LOCK" },               \
 650                 { SC_TYPE_DELEG,                "DELEG" },              \
 651                 { SC_TYPE_LAYOUT,               "LAYOUT" })
 652
 653 #define show_stid_status(x)                                             \
 654         __print_flags(x, "|",                                           \
 655                 { SC_STATUS_CLOSED,             "CLOSED" },             \
 656                 { SC_STATUS_REVOKED,            "REVOKED" },            \
 657                 { SC_STATUS_ADMIN_REVOKED,      "ADMIN_REVOKED" })
 658
 659 DECLARE_EVENT_CLASS(nfsd_stid_class,
 660         TP_PROTO(
 661                 const struct nfs4_stid *stid
 662         ),
 663         TP_ARGS(stid),
 664         TP_STRUCT__entry(
 665                 __field(unsigned long, sc_type)
 666                 __field(unsigned long, sc_status)
 667                 __field(int, sc_count)
 668                 __field(u32, cl_boot)
 669                 __field(u32, cl_id)
 670                 __field(u32, si_id)
 671                 __field(u32, si_generation)
 672         ),
 673         TP_fast_assign(
 674                 const stateid_t *stp = &stid->sc_stateid;
 675
 676                 __entry->sc_type = stid->sc_type;
 677                 __entry->sc_status = stid->sc_status;
 678                 __entry->sc_count = refcount_read(&stid->sc_count);
 679                 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
 680                 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
 681                 __entry->si_id = stp->si_opaque.so_id;
 682                 __entry->si_generation = stp->si_generation;
 683         ),
 684         TP_printk("client %08x:%08x stateid %08x:%08x ref=%d type=%s state=%s",
 685                 __entry->cl_boot, __entry->cl_id,
 686                 __entry->si_id, __entry->si_generation,
 687                 __entry->sc_count, show_stid_type(__entry->sc_type),
 688                 show_stid_status(__entry->sc_status)
 689         )
 690 );
 691
 692 #define DEFINE_STID_EVENT(name)                                 \
 693 DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name,                 \
 694         TP_PROTO(const struct nfs4_stid *stid),                 \
 695         TP_ARGS(stid))
 696
 697 DEFINE_STID_EVENT(revoke);
 698
 699 TRACE_EVENT(nfsd_stateowner_replay,
 700         TP_PROTO(
 701                 u32 opnum,
 702                 const struct nfs4_replay *rp
 703         ),
 704         TP_ARGS(opnum, rp),
 705         TP_STRUCT__entry(
 706                 __field(unsigned long, status)
 707                 __field(u32, opnum)
 708         ),
 709         TP_fast_assign(
 710                 __entry->status = be32_to_cpu(rp->rp_status);
 711                 __entry->opnum = opnum;
 712         ),
 713         TP_printk("opnum=%u status=%lu",
 714                 __entry->opnum, __entry->status)
 715 );
 716
 717 TRACE_EVENT_CONDITION(nfsd_seq4_status,
 718         TP_PROTO(
 719                 const struct svc_rqst *rqstp,
 720                 const struct nfsd4_sequence *sequence
 721         ),
 722         TP_ARGS(rqstp, sequence),
 723         TP_CONDITION(sequence->status_flags),
 724         TP_STRUCT__entry(
 725                 __field(unsigned int, netns_ino)
 726                 __field(u32, xid)
 727                 __field(u32, cl_boot)
 728                 __field(u32, cl_id)
 729                 __field(u32, seqno)
 730                 __field(u32, reserved)
 731                 __field(unsigned long, status_flags)
 732         ),
 733         TP_fast_assign(
 734                 const struct nfsd4_sessionid *sid =
 735                         (struct nfsd4_sessionid *)&sequence->sessionid;
 736
 737                 __entry->netns_ino = SVC_NET(rqstp)->ns.inum;
 738                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
 739                 __entry->cl_boot = sid->clientid.cl_boot;
 740                 __entry->cl_id = sid->clientid.cl_id;
 741                 __entry->seqno = sid->sequence;
 742                 __entry->reserved = sid->reserved;
 743                 __entry->status_flags = sequence->status_flags;
 744         ),
 745         TP_printk("xid=0x%08x sessionid=%08x:%08x:%08x:%08x status_flags=%s",
 746                 __entry->xid, __entry->cl_boot, __entry->cl_id,
 747                 __entry->seqno, __entry->reserved,
 748                 show_nfs4_seq4_status(__entry->status_flags)
 749         )
 750 );
 751
 752 DECLARE_EVENT_CLASS(nfsd_clientid_class,
 753         TP_PROTO(const clientid_t *clid),
 754         TP_ARGS(clid),
 755         TP_STRUCT__entry(
 756                 __field(u32, cl_boot)
 757                 __field(u32, cl_id)
 758         ),
 759         TP_fast_assign(
 760                 __entry->cl_boot = clid->cl_boot;
 761                 __entry->cl_id = clid->cl_id;
 762         ),
 763         TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
 764 )
 765
 766 #define DEFINE_CLIENTID_EVENT(name) \
 767 DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \
 768         TP_PROTO(const clientid_t *clid), \
 769         TP_ARGS(clid))
 770
 771 DEFINE_CLIENTID_EVENT(expire_unconf);
 772 DEFINE_CLIENTID_EVENT(reclaim_complete);
 773 DEFINE_CLIENTID_EVENT(confirmed);
 774 DEFINE_CLIENTID_EVENT(destroyed);
 775 DEFINE_CLIENTID_EVENT(admin_expired);
 776 DEFINE_CLIENTID_EVENT(replaced);
 777 DEFINE_CLIENTID_EVENT(purged);
 778 DEFINE_CLIENTID_EVENT(renew);
 779 DEFINE_CLIENTID_EVENT(stale);
 780
 781 DECLARE_EVENT_CLASS(nfsd_net_class,
 782         TP_PROTO(const struct nfsd_net *nn),
 783         TP_ARGS(nn),
 784         TP_STRUCT__entry(
 785                 __field(unsigned long long, boot_time)
 786         ),
 787         TP_fast_assign(
 788                 __entry->boot_time = nn->boot_time;
 789         ),
 790         TP_printk("boot_time=%16llx", __entry->boot_time)
 791 )
 792
 793 #define DEFINE_NET_EVENT(name) \
 794 DEFINE_EVENT(nfsd_net_class, nfsd_##name, \
 795         TP_PROTO(const struct nfsd_net *nn), \
 796         TP_ARGS(nn))
 797
 798 DEFINE_NET_EVENT(grace_start);
 799 DEFINE_NET_EVENT(grace_complete);
 800
 801 TRACE_EVENT(nfsd_writeverf_reset,
 802         TP_PROTO(
 803                 const struct nfsd_net *nn,
 804                 const struct svc_rqst *rqstp,
 805                 int error
 806         ),
 807         TP_ARGS(nn, rqstp, error),
 808         TP_STRUCT__entry(
 809                 __field(unsigned long long, boot_time)
 810                 __field(u32, xid)
 811                 __field(int, error)
 812                 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
 813         ),
 814         TP_fast_assign(
 815                 __entry->boot_time = nn->boot_time;
 816                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
 817                 __entry->error = error;
 818
 819                 /* avoid seqlock inside TP_fast_assign */
 820                 memcpy(__entry->verifier, nn->writeverf,
 821                        NFS4_VERIFIER_SIZE);
 822         ),
 823         TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s",
 824                 __entry->boot_time, __entry->xid, __entry->error,
 825                 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE)
 826         )
 827 );
 828
 829 TRACE_EVENT(nfsd_clid_cred_mismatch,
 830         TP_PROTO(
 831                 const struct nfs4_client *clp,
 832                 const struct svc_rqst *rqstp
 833         ),
 834         TP_ARGS(clp, rqstp),
 835         TP_STRUCT__entry(
 836                 __field(u32, cl_boot)
 837                 __field(u32, cl_id)
 838                 __field(unsigned long, cl_flavor)
 839                 __field(unsigned long, new_flavor)
 840                 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
 841         ),
 842         TP_fast_assign(
 843                 __entry->cl_boot = clp->cl_clientid.cl_boot;
 844                 __entry->cl_id = clp->cl_clientid.cl_id;
 845                 __entry->cl_flavor = clp->cl_cred.cr_flavor;
 846                 __entry->new_flavor = rqstp->rq_cred.cr_flavor;
 847                 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
 848                                   rqstp->rq_xprt->xpt_remotelen);
 849         ),
 850         TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc",
 851                 __entry->cl_boot, __entry->cl_id,
 852                 show_nfsd_authflavor(__entry->cl_flavor),
 853                 show_nfsd_authflavor(__entry->new_flavor),
 854                 __get_sockaddr(addr)
 855         )
 856 )
 857
 858 TRACE_EVENT(nfsd_clid_verf_mismatch,
 859         TP_PROTO(
 860                 const struct nfs4_client *clp,
 861                 const struct svc_rqst *rqstp,
 862                 const nfs4_verifier *verf
 863         ),
 864         TP_ARGS(clp, rqstp, verf),
 865         TP_STRUCT__entry(
 866                 __field(u32, cl_boot)
 867                 __field(u32, cl_id)
 868                 __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE)
 869                 __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE)
 870                 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
 871         ),
 872         TP_fast_assign(
 873                 __entry->cl_boot = clp->cl_clientid.cl_boot;
 874                 __entry->cl_id = clp->cl_clientid.cl_id;
 875                 memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier,
 876                        NFS4_VERIFIER_SIZE);
 877                 memcpy(__entry->new_verifier, (void *)verf,
 878                        NFS4_VERIFIER_SIZE);
 879                 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
 880                                   rqstp->rq_xprt->xpt_remotelen);
 881         ),
 882         TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc",
 883                 __entry->cl_boot, __entry->cl_id,
 884                 __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE),
 885                 __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE),
 886                 __get_sockaddr(addr)
 887         )
 888 );
 889
 890 DECLARE_EVENT_CLASS(nfsd_clid_class,
 891         TP_PROTO(const struct nfs4_client *clp),
 892         TP_ARGS(clp),
 893         TP_STRUCT__entry(
 894                 __field(u32, cl_boot)
 895                 __field(u32, cl_id)
 896                 __array(unsigned char, addr, sizeof(struct sockaddr_in6))
 897                 __field(unsigned long, flavor)
 898                 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
 899                 __string_len(name, clp->cl_name.data, clp->cl_name.len)
 900         ),
 901         TP_fast_assign(
 902                 __entry->cl_boot = clp->cl_clientid.cl_boot;
 903                 __entry->cl_id = clp->cl_clientid.cl_id;
 904                 memcpy(__entry->addr, &clp->cl_addr,
 905                         sizeof(struct sockaddr_in6));
 906                 __entry->flavor = clp->cl_cred.cr_flavor;
 907                 memcpy(__entry->verifier, (void *)&clp->cl_verifier,
 908                        NFS4_VERIFIER_SIZE);
 909                 __assign_str(name, clp->cl_name.data);
 910         ),
 911         TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x",
 912                 __entry->addr, __get_str(name),
 913                 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE),
 914                 show_nfsd_authflavor(__entry->flavor),
 915                 __entry->cl_boot, __entry->cl_id)
 916 );
 917
 918 #define DEFINE_CLID_EVENT(name) \
 919 DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \
 920         TP_PROTO(const struct nfs4_client *clp), \
 921         TP_ARGS(clp))
 922
 923 DEFINE_CLID_EVENT(fresh);
 924 DEFINE_CLID_EVENT(confirmed_r);
 925
 926 /*
 927  * from fs/nfsd/filecache.h
 928  */
 929 #define show_nf_flags(val)                                              \
 930         __print_flags(val, "|",                                         \
 931                 { 1 << NFSD_FILE_HASHED,        "HASHED" },             \
 932                 { 1 << NFSD_FILE_PENDING,       "PENDING" },            \
 933                 { 1 << NFSD_FILE_REFERENCED,    "REFERENCED" },         \
 934                 { 1 << NFSD_FILE_GC,            "GC" })
 935
 936 DECLARE_EVENT_CLASS(nfsd_file_class,
 937         TP_PROTO(struct nfsd_file *nf),
 938         TP_ARGS(nf),
 939         TP_STRUCT__entry(
 940                 __field(void *, nf_inode)
 941                 __field(int, nf_ref)
 942                 __field(unsigned long, nf_flags)
 943                 __field(unsigned char, nf_may)
 944                 __field(struct file *, nf_file)
 945         ),
 946         TP_fast_assign(
 947                 __entry->nf_inode = nf->nf_inode;
 948                 __entry->nf_ref = refcount_read(&nf->nf_ref);
 949                 __entry->nf_flags = nf->nf_flags;
 950                 __entry->nf_may = nf->nf_may;
 951                 __entry->nf_file = nf->nf_file;
 952         ),
 953         TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p",
 954                 __entry->nf_inode,
 955                 __entry->nf_ref,
 956                 show_nf_flags(__entry->nf_flags),
 957                 show_nfsd_may_flags(__entry->nf_may),
 958                 __entry->nf_file)
 959 )
 960
 961 #define DEFINE_NFSD_FILE_EVENT(name) \
 962 DEFINE_EVENT(nfsd_file_class, name, \
 963         TP_PROTO(struct nfsd_file *nf), \
 964         TP_ARGS(nf))
 965
 966 DEFINE_NFSD_FILE_EVENT(nfsd_file_free);
 967 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash);
 968 DEFINE_NFSD_FILE_EVENT(nfsd_file_put);
 969 DEFINE_NFSD_FILE_EVENT(nfsd_file_closing);
 970 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue);
 971
 972 TRACE_EVENT(nfsd_file_alloc,
 973         TP_PROTO(
 974                 const struct nfsd_file *nf
 975         ),
 976         TP_ARGS(nf),
 977         TP_STRUCT__entry(
 978                 __field(const void *, nf_inode)
 979                 __field(unsigned long, nf_flags)
 980                 __field(unsigned long, nf_may)
 981                 __field(unsigned int, nf_ref)
 982         ),
 983         TP_fast_assign(
 984                 __entry->nf_inode = nf->nf_inode;
 985                 __entry->nf_flags = nf->nf_flags;
 986                 __entry->nf_ref = refcount_read(&nf->nf_ref);
 987                 __entry->nf_may = nf->nf_may;
 988         ),
 989         TP_printk("inode=%p ref=%u flags=%s may=%s",
 990                 __entry->nf_inode, __entry->nf_ref,
 991                 show_nf_flags(__entry->nf_flags),
 992                 show_nfsd_may_flags(__entry->nf_may)
 993         )
 994 );
 995
 996 TRACE_EVENT(nfsd_file_acquire,
 997         TP_PROTO(
 998                 const struct svc_rqst *rqstp,
 999                 const struct inode *inode,
1000                 unsigned int may_flags,
1001                 const struct nfsd_file *nf,
1002                 __be32 status
1003         ),
1004
1005         TP_ARGS(rqstp, inode, may_flags, nf, status),
1006
1007         TP_STRUCT__entry(
1008                 __field(u32, xid)
1009                 __field(const void *, inode)
1010                 __field(unsigned long, may_flags)
1011                 __field(unsigned int, nf_ref)
1012                 __field(unsigned long, nf_flags)
1013                 __field(unsigned long, nf_may)
1014                 __field(const void *, nf_file)
1015                 __field(u32, status)
1016         ),
1017
1018         TP_fast_assign(
1019                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1020                 __entry->inode = inode;
1021                 __entry->may_flags = may_flags;
1022                 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0;
1023                 __entry->nf_flags = nf ? nf->nf_flags : 0;
1024                 __entry->nf_may = nf ? nf->nf_may : 0;
1025                 __entry->nf_file = nf ? nf->nf_file : NULL;
1026                 __entry->status = be32_to_cpu(status);
1027         ),
1028
1029         TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u",
1030                         __entry->xid, __entry->inode,
1031                         show_nfsd_may_flags(__entry->may_flags),
1032                         __entry->nf_ref, show_nf_flags(__entry->nf_flags),
1033                         show_nfsd_may_flags(__entry->nf_may),
1034                         __entry->nf_file, __entry->status
1035         )
1036 );
1037
1038 TRACE_EVENT(nfsd_file_insert_err,
1039         TP_PROTO(
1040                 const struct svc_rqst *rqstp,
1041                 const struct inode *inode,
1042                 unsigned int may_flags,
1043                 long error
1044         ),
1045         TP_ARGS(rqstp, inode, may_flags, error),
1046         TP_STRUCT__entry(
1047                 __field(u32, xid)
1048                 __field(const void *, inode)
1049                 __field(unsigned long, may_flags)
1050                 __field(long, error)
1051         ),
1052         TP_fast_assign(
1053                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1054                 __entry->inode = inode;
1055                 __entry->may_flags = may_flags;
1056                 __entry->error = error;
1057         ),
1058         TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld",
1059                 __entry->xid, __entry->inode,
1060                 show_nfsd_may_flags(__entry->may_flags),
1061                 __entry->error
1062         )
1063 );
1064
1065 TRACE_EVENT(nfsd_file_cons_err,
1066         TP_PROTO(
1067                 const struct svc_rqst *rqstp,
1068                 const struct inode *inode,
1069                 unsigned int may_flags,
1070                 const struct nfsd_file *nf
1071         ),
1072         TP_ARGS(rqstp, inode, may_flags, nf),
1073         TP_STRUCT__entry(
1074                 __field(u32, xid)
1075                 __field(const void *, inode)
1076                 __field(unsigned long, may_flags)
1077                 __field(unsigned int, nf_ref)
1078                 __field(unsigned long, nf_flags)
1079                 __field(unsigned long, nf_may)
1080                 __field(const void *, nf_file)
1081         ),
1082         TP_fast_assign(
1083                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1084                 __entry->inode = inode;
1085                 __entry->may_flags = may_flags;
1086                 __entry->nf_ref = refcount_read(&nf->nf_ref);
1087                 __entry->nf_flags = nf->nf_flags;
1088                 __entry->nf_may = nf->nf_may;
1089                 __entry->nf_file = nf->nf_file;
1090         ),
1091         TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p",
1092                 __entry->xid, __entry->inode,
1093                 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref,
1094                 show_nf_flags(__entry->nf_flags),
1095                 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file
1096         )
1097 );
1098
1099 DECLARE_EVENT_CLASS(nfsd_file_open_class,
1100         TP_PROTO(const struct nfsd_file *nf, __be32 status),
1101         TP_ARGS(nf, status),
1102         TP_STRUCT__entry(
1103                 __field(void *, nf_inode)       /* cannot be dereferenced */
1104                 __field(int, nf_ref)
1105                 __field(unsigned long, nf_flags)
1106                 __field(unsigned long, nf_may)
1107                 __field(void *, nf_file)        /* cannot be dereferenced */
1108         ),
1109         TP_fast_assign(
1110                 __entry->nf_inode = nf->nf_inode;
1111                 __entry->nf_ref = refcount_read(&nf->nf_ref);
1112                 __entry->nf_flags = nf->nf_flags;
1113                 __entry->nf_may = nf->nf_may;
1114                 __entry->nf_file = nf->nf_file;
1115         ),
1116         TP_printk("inode=%p ref=%d flags=%s may=%s file=%p",
1117                 __entry->nf_inode,
1118                 __entry->nf_ref,
1119                 show_nf_flags(__entry->nf_flags),
1120                 show_nfsd_may_flags(__entry->nf_may),
1121                 __entry->nf_file)
1122 )
1123
1124 #define DEFINE_NFSD_FILE_OPEN_EVENT(name)                                       \
1125 DEFINE_EVENT(nfsd_file_open_class, name,                                        \
1126         TP_PROTO(                                                       \
1127                 const struct nfsd_file *nf,                             \
1128                 __be32 status                                           \
1129         ),                                                              \
1130         TP_ARGS(nf, status))
1131
1132 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open);
1133 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened);
1134
1135 TRACE_EVENT(nfsd_file_is_cached,
1136         TP_PROTO(
1137                 const struct inode *inode,
1138                 int found
1139         ),
1140         TP_ARGS(inode, found),
1141         TP_STRUCT__entry(
1142                 __field(const struct inode *, inode)
1143                 __field(int, found)
1144         ),
1145         TP_fast_assign(
1146                 __entry->inode = inode;
1147                 __entry->found = found;
1148         ),
1149         TP_printk("inode=%p is %scached",
1150                 __entry->inode,
1151                 __entry->found ? "" : "not "
1152         )
1153 );
1154
1155 TRACE_EVENT(nfsd_file_fsnotify_handle_event,
1156         TP_PROTO(struct inode *inode, u32 mask),
1157         TP_ARGS(inode, mask),
1158         TP_STRUCT__entry(
1159                 __field(struct inode *, inode)
1160                 __field(unsigned int, nlink)
1161                 __field(umode_t, mode)
1162                 __field(u32, mask)
1163         ),
1164         TP_fast_assign(
1165                 __entry->inode = inode;
1166                 __entry->nlink = inode->i_nlink;
1167                 __entry->mode = inode->i_mode;
1168                 __entry->mask = mask;
1169         ),
1170         TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode,
1171                         __entry->nlink, __entry->mode, __entry->mask)
1172 );
1173
1174 DECLARE_EVENT_CLASS(nfsd_file_gc_class,
1175         TP_PROTO(
1176                 const struct nfsd_file *nf
1177         ),
1178         TP_ARGS(nf),
1179         TP_STRUCT__entry(
1180                 __field(void *, nf_inode)
1181                 __field(void *, nf_file)
1182                 __field(int, nf_ref)
1183                 __field(unsigned long, nf_flags)
1184         ),
1185         TP_fast_assign(
1186                 __entry->nf_inode = nf->nf_inode;
1187                 __entry->nf_file = nf->nf_file;
1188                 __entry->nf_ref = refcount_read(&nf->nf_ref);
1189                 __entry->nf_flags = nf->nf_flags;
1190         ),
1191         TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p",
1192                 __entry->nf_inode, __entry->nf_ref,
1193                 show_nf_flags(__entry->nf_flags),
1194                 __entry->nf_file
1195         )
1196 );
1197
1198 #define DEFINE_NFSD_FILE_GC_EVENT(name)                                 \
1199 DEFINE_EVENT(nfsd_file_gc_class, name,                                  \
1200         TP_PROTO(                                                       \
1201                 const struct nfsd_file *nf                              \
1202         ),                                                              \
1203         TP_ARGS(nf))
1204
1205 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add);
1206 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed);
1207 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del);
1208 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed);
1209 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use);
1210 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback);
1211 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced);
1212 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed);
1213
1214 DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class,
1215         TP_PROTO(
1216                 unsigned long removed,
1217                 unsigned long remaining
1218         ),
1219         TP_ARGS(removed, remaining),
1220         TP_STRUCT__entry(
1221                 __field(unsigned long, removed)
1222                 __field(unsigned long, remaining)
1223         ),
1224         TP_fast_assign(
1225                 __entry->removed = removed;
1226                 __entry->remaining = remaining;
1227         ),
1228         TP_printk("%lu entries removed, %lu remaining",
1229                 __entry->removed, __entry->remaining)
1230 );
1231
1232 #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name)                            \
1233 DEFINE_EVENT(nfsd_file_lruwalk_class, name,                             \
1234         TP_PROTO(                                                       \
1235                 unsigned long removed,                                  \
1236                 unsigned long remaining                                 \
1237         ),                                                              \
1238         TP_ARGS(removed, remaining))
1239
1240 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed);
1241 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed);
1242
1243 TRACE_EVENT(nfsd_file_close,
1244         TP_PROTO(
1245                 const struct inode *inode
1246         ),
1247         TP_ARGS(inode),
1248         TP_STRUCT__entry(
1249                 __field(const void *, inode)
1250         ),
1251         TP_fast_assign(
1252                 __entry->inode = inode;
1253         ),
1254         TP_printk("inode=%p",
1255                 __entry->inode
1256         )
1257 );
1258
1259 #include "cache.h"
1260
1261 TRACE_DEFINE_ENUM(RC_DROPIT);
1262 TRACE_DEFINE_ENUM(RC_REPLY);
1263 TRACE_DEFINE_ENUM(RC_DOIT);
1264
1265 #define show_drc_retval(x)                                              \
1266         __print_symbolic(x,                                             \
1267                 { RC_DROPIT, "DROPIT" },                                \
1268                 { RC_REPLY, "REPLY" },                                  \
1269                 { RC_DOIT, "DOIT" })
1270
1271 TRACE_EVENT(nfsd_drc_found,
1272         TP_PROTO(
1273                 const struct nfsd_net *nn,
1274                 const struct svc_rqst *rqstp,
1275                 int result
1276         ),
1277         TP_ARGS(nn, rqstp, result),
1278         TP_STRUCT__entry(
1279                 __field(unsigned long long, boot_time)
1280                 __field(unsigned long, result)
1281                 __field(u32, xid)
1282         ),
1283         TP_fast_assign(
1284                 __entry->boot_time = nn->boot_time;
1285                 __entry->result = result;
1286                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1287         ),
1288         TP_printk("boot_time=%16llx xid=0x%08x result=%s",
1289                 __entry->boot_time, __entry->xid,
1290                 show_drc_retval(__entry->result))
1291
1292 );
1293
1294 TRACE_EVENT(nfsd_drc_mismatch,
1295         TP_PROTO(
1296                 const struct nfsd_net *nn,
1297                 const struct nfsd_cacherep *key,
1298                 const struct nfsd_cacherep *rp
1299         ),
1300         TP_ARGS(nn, key, rp),
1301         TP_STRUCT__entry(
1302                 __field(unsigned long long, boot_time)
1303                 __field(u32, xid)
1304                 __field(u32, cached)
1305                 __field(u32, ingress)
1306         ),
1307         TP_fast_assign(
1308                 __entry->boot_time = nn->boot_time;
1309                 __entry->xid = be32_to_cpu(key->c_key.k_xid);
1310                 __entry->cached = (__force u32)key->c_key.k_csum;
1311                 __entry->ingress = (__force u32)rp->c_key.k_csum;
1312         ),
1313         TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x",
1314                 __entry->boot_time, __entry->xid, __entry->cached,
1315                 __entry->ingress)
1316 );
1317
1318 TRACE_EVENT(nfsd_cb_args,
1319         TP_PROTO(
1320                 const struct nfs4_client *clp,
1321                 const struct nfs4_cb_conn *conn
1322         ),
1323         TP_ARGS(clp, conn),
1324         TP_STRUCT__entry(
1325                 __field(u32, cl_boot)
1326                 __field(u32, cl_id)
1327                 __field(u32, prog)
1328                 __field(u32, ident)
1329                 __sockaddr(addr, conn->cb_addrlen)
1330         ),
1331         TP_fast_assign(
1332                 __entry->cl_boot = clp->cl_clientid.cl_boot;
1333                 __entry->cl_id = clp->cl_clientid.cl_id;
1334                 __entry->prog = conn->cb_prog;
1335                 __entry->ident = conn->cb_ident;
1336                 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen);
1337         ),
1338         TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u",
1339                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1340                 __entry->prog, __entry->ident)
1341 );
1342
1343 TRACE_EVENT(nfsd_cb_nodelegs,
1344         TP_PROTO(const struct nfs4_client *clp),
1345         TP_ARGS(clp),
1346         TP_STRUCT__entry(
1347                 __field(u32, cl_boot)
1348                 __field(u32, cl_id)
1349         ),
1350         TP_fast_assign(
1351                 __entry->cl_boot = clp->cl_clientid.cl_boot;
1352                 __entry->cl_id = clp->cl_clientid.cl_id;
1353         ),
1354         TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
1355 )
1356
1357 #define show_cb_state(val)                                              \
1358         __print_symbolic(val,                                           \
1359                 { NFSD4_CB_UP,          "UP" },                         \
1360                 { NFSD4_CB_UNKNOWN,     "UNKNOWN" },                    \
1361                 { NFSD4_CB_DOWN,        "DOWN" },                       \
1362                 { NFSD4_CB_FAULT,       "FAULT"})
1363
1364 DECLARE_EVENT_CLASS(nfsd_cb_class,
1365         TP_PROTO(const struct nfs4_client *clp),
1366         TP_ARGS(clp),
1367         TP_STRUCT__entry(
1368                 __field(unsigned long, state)
1369                 __field(u32, cl_boot)
1370                 __field(u32, cl_id)
1371                 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1372         ),
1373         TP_fast_assign(
1374                 __entry->state = clp->cl_cb_state;
1375                 __entry->cl_boot = clp->cl_clientid.cl_boot;
1376                 __entry->cl_id = clp->cl_clientid.cl_id;
1377                 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1378                                   clp->cl_cb_conn.cb_addrlen)
1379         ),
1380         TP_printk("addr=%pISpc client %08x:%08x state=%s",
1381                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1382                 show_cb_state(__entry->state))
1383 );
1384
1385 #define DEFINE_NFSD_CB_EVENT(name)                      \
1386 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name,             \
1387         TP_PROTO(const struct nfs4_client *clp),        \
1388         TP_ARGS(clp))
1389
1390 DEFINE_NFSD_CB_EVENT(start);
1391 DEFINE_NFSD_CB_EVENT(new_state);
1392 DEFINE_NFSD_CB_EVENT(probe);
1393 DEFINE_NFSD_CB_EVENT(lost);
1394 DEFINE_NFSD_CB_EVENT(shutdown);
1395
1396 TRACE_DEFINE_ENUM(RPC_AUTH_NULL);
1397 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX);
1398 TRACE_DEFINE_ENUM(RPC_AUTH_GSS);
1399 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5);
1400 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I);
1401 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P);
1402
1403 #define show_nfsd_authflavor(val)                                       \
1404         __print_symbolic(val,                                           \
1405                 { RPC_AUTH_NULL,                "none" },               \
1406                 { RPC_AUTH_UNIX,                "sys" },                \
1407                 { RPC_AUTH_GSS,                 "gss" },                \
1408                 { RPC_AUTH_GSS_KRB5,            "krb5" },               \
1409                 { RPC_AUTH_GSS_KRB5I,           "krb5i" },              \
1410                 { RPC_AUTH_GSS_KRB5P,           "krb5p" })
1411
1412 TRACE_EVENT(nfsd_cb_setup,
1413         TP_PROTO(const struct nfs4_client *clp,
1414                  const char *netid,
1415                  rpc_authflavor_t authflavor
1416         ),
1417         TP_ARGS(clp, netid, authflavor),
1418         TP_STRUCT__entry(
1419                 __field(u32, cl_boot)
1420                 __field(u32, cl_id)
1421                 __field(unsigned long, authflavor)
1422                 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1423                 __string(netid, netid)
1424         ),
1425         TP_fast_assign(
1426                 __entry->cl_boot = clp->cl_clientid.cl_boot;
1427                 __entry->cl_id = clp->cl_clientid.cl_id;
1428                 __assign_str(netid, netid);
1429                 __entry->authflavor = authflavor;
1430                 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1431                                   clp->cl_cb_conn.cb_addrlen)
1432         ),
1433         TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s",
1434                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1435                 __get_str(netid), show_nfsd_authflavor(__entry->authflavor))
1436 );
1437
1438 TRACE_EVENT(nfsd_cb_setup_err,
1439         TP_PROTO(
1440                 const struct nfs4_client *clp,
1441                 long error
1442         ),
1443         TP_ARGS(clp, error),
1444         TP_STRUCT__entry(
1445                 __field(long, error)
1446                 __field(u32, cl_boot)
1447                 __field(u32, cl_id)
1448                 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1449         ),
1450         TP_fast_assign(
1451                 __entry->error = error;
1452                 __entry->cl_boot = clp->cl_clientid.cl_boot;
1453                 __entry->cl_id = clp->cl_clientid.cl_id;
1454                 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1455                                   clp->cl_cb_conn.cb_addrlen)
1456         ),
1457         TP_printk("addr=%pISpc client %08x:%08x error=%ld",
1458                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1459                 __entry->error)
1460 );
1461
1462 DECLARE_EVENT_CLASS(nfsd_cb_lifetime_class,
1463         TP_PROTO(
1464                 const struct nfs4_client *clp,
1465                 const struct nfsd4_callback *cb
1466         ),
1467         TP_ARGS(clp, cb),
1468         TP_STRUCT__entry(
1469                 __field(u32, cl_boot)
1470                 __field(u32, cl_id)
1471                 __field(const void *, cb)
1472                 __field(bool, need_restart)
1473                 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1474         ),
1475         TP_fast_assign(
1476                 __entry->cl_boot = clp->cl_clientid.cl_boot;
1477                 __entry->cl_id = clp->cl_clientid.cl_id;
1478                 __entry->cb = cb;
1479                 __entry->need_restart = cb->cb_need_restart;
1480                 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1481                                   clp->cl_cb_conn.cb_addrlen)
1482         ),
1483         TP_printk("addr=%pISpc client %08x:%08x cb=%p%s",
1484                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1485                 __entry->cb, __entry->need_restart ?
1486                         " (need restart)" : " (first try)"
1487         )
1488 );
1489
1490 #define DEFINE_NFSD_CB_LIFETIME_EVENT(name)             \
1491 DEFINE_EVENT(nfsd_cb_lifetime_class, nfsd_cb_##name,    \
1492         TP_PROTO(                                       \
1493                 const struct nfs4_client *clp,          \
1494                 const struct nfsd4_callback *cb         \
1495         ),                                              \
1496         TP_ARGS(clp, cb))
1497
1498 DEFINE_NFSD_CB_LIFETIME_EVENT(queue);
1499 DEFINE_NFSD_CB_LIFETIME_EVENT(destroy);
1500 DEFINE_NFSD_CB_LIFETIME_EVENT(restart);
1501 DEFINE_NFSD_CB_LIFETIME_EVENT(bc_update);
1502 DEFINE_NFSD_CB_LIFETIME_EVENT(bc_shutdown);
1503
1504 TRACE_EVENT(nfsd_cb_seq_status,
1505         TP_PROTO(
1506                 const struct rpc_task *task,
1507                 const struct nfsd4_callback *cb
1508         ),
1509         TP_ARGS(task, cb),
1510         TP_STRUCT__entry(
1511                 __field(unsigned int, task_id)
1512                 __field(unsigned int, client_id)
1513                 __field(u32, cl_boot)
1514                 __field(u32, cl_id)
1515                 __field(u32, seqno)
1516                 __field(u32, reserved)
1517                 __field(int, tk_status)
1518                 __field(int, seq_status)
1519         ),
1520         TP_fast_assign(
1521                 const struct nfs4_client *clp = cb->cb_clp;
1522                 const struct nfsd4_session *session = clp->cl_cb_session;
1523                 const struct nfsd4_sessionid *sid =
1524                         (struct nfsd4_sessionid *)&session->se_sessionid;
1525
1526                 __entry->task_id = task->tk_pid;
1527                 __entry->client_id = task->tk_client ?
1528                                      task->tk_client->cl_clid : -1;
1529                 __entry->cl_boot = sid->clientid.cl_boot;
1530                 __entry->cl_id = sid->clientid.cl_id;
1531                 __entry->seqno = sid->sequence;
1532                 __entry->reserved = sid->reserved;
1533                 __entry->tk_status = task->tk_status;
1534                 __entry->seq_status = cb->cb_seq_status;
1535         ),
1536         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1537                 " sessionid=%08x:%08x:%08x:%08x tk_status=%d seq_status=%d\n",
1538                 __entry->task_id, __entry->client_id,
1539                 __entry->cl_boot, __entry->cl_id,
1540                 __entry->seqno, __entry->reserved,
1541                 __entry->tk_status, __entry->seq_status
1542         )
1543 );
1544
1545 TRACE_EVENT(nfsd_cb_free_slot,
1546         TP_PROTO(
1547                 const struct rpc_task *task,
1548                 const struct nfsd4_callback *cb
1549         ),
1550         TP_ARGS(task, cb),
1551         TP_STRUCT__entry(
1552                 __field(unsigned int, task_id)
1553                 __field(unsigned int, client_id)
1554                 __field(u32, cl_boot)
1555                 __field(u32, cl_id)
1556                 __field(u32, seqno)
1557                 __field(u32, reserved)
1558                 __field(u32, slot_seqno)
1559         ),
1560         TP_fast_assign(
1561                 const struct nfs4_client *clp = cb->cb_clp;
1562                 const struct nfsd4_session *session = clp->cl_cb_session;
1563                 const struct nfsd4_sessionid *sid =
1564                         (struct nfsd4_sessionid *)&session->se_sessionid;
1565
1566                 __entry->task_id = task->tk_pid;
1567                 __entry->client_id = task->tk_client ?
1568                                      task->tk_client->cl_clid : -1;
1569                 __entry->cl_boot = sid->clientid.cl_boot;
1570                 __entry->cl_id = sid->clientid.cl_id;
1571                 __entry->seqno = sid->sequence;
1572                 __entry->reserved = sid->reserved;
1573                 __entry->slot_seqno = session->se_cb_seq_nr;
1574         ),
1575         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1576                 " sessionid=%08x:%08x:%08x:%08x new slot seqno=%u\n",
1577                 __entry->task_id, __entry->client_id,
1578                 __entry->cl_boot, __entry->cl_id,
1579                 __entry->seqno, __entry->reserved,
1580                 __entry->slot_seqno
1581         )
1582 );
1583
1584 TRACE_EVENT_CONDITION(nfsd_cb_recall,
1585         TP_PROTO(
1586                 const struct nfs4_stid *stid
1587         ),
1588         TP_ARGS(stid),
1589         TP_CONDITION(stid->sc_client),
1590         TP_STRUCT__entry(
1591                 __field(u32, cl_boot)
1592                 __field(u32, cl_id)
1593                 __field(u32, si_id)
1594                 __field(u32, si_generation)
1595                 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen)
1596         ),
1597         TP_fast_assign(
1598                 const stateid_t *stp = &stid->sc_stateid;
1599                 const struct nfs4_client *clp = stid->sc_client;
1600
1601                 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1602                 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1603                 __entry->si_id = stp->si_opaque.so_id;
1604                 __entry->si_generation = stp->si_generation;
1605                 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1606                                   clp->cl_cb_conn.cb_addrlen)
1607         ),
1608         TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x",
1609                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1610                 __entry->si_id, __entry->si_generation)
1611 );
1612
1613 TRACE_EVENT(nfsd_cb_notify_lock,
1614         TP_PROTO(
1615                 const struct nfs4_lockowner *lo,
1616                 const struct nfsd4_blocked_lock *nbl
1617         ),
1618         TP_ARGS(lo, nbl),
1619         TP_STRUCT__entry(
1620                 __field(u32, cl_boot)
1621                 __field(u32, cl_id)
1622                 __field(u32, fh_hash)
1623                 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen)
1624         ),
1625         TP_fast_assign(
1626                 const struct nfs4_client *clp = lo->lo_owner.so_client;
1627
1628                 __entry->cl_boot = clp->cl_clientid.cl_boot;
1629                 __entry->cl_id = clp->cl_clientid.cl_id;
1630                 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh);
1631                 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1632                                   clp->cl_cb_conn.cb_addrlen)
1633         ),
1634         TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x",
1635                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1636                 __entry->fh_hash)
1637 );
1638
1639 TRACE_EVENT(nfsd_cb_offload,
1640         TP_PROTO(
1641                 const struct nfs4_client *clp,
1642                 const stateid_t *stp,
1643                 const struct knfsd_fh *fh,
1644                 u64 count,
1645                 __be32 status
1646         ),
1647         TP_ARGS(clp, stp, fh, count, status),
1648         TP_STRUCT__entry(
1649                 __field(u32, cl_boot)
1650                 __field(u32, cl_id)
1651                 __field(u32, si_id)
1652                 __field(u32, si_generation)
1653                 __field(u32, fh_hash)
1654                 __field(int, status)
1655                 __field(u64, count)
1656                 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1657         ),
1658         TP_fast_assign(
1659                 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1660                 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1661                 __entry->si_id = stp->si_opaque.so_id;
1662                 __entry->si_generation = stp->si_generation;
1663                 __entry->fh_hash = knfsd_fh_hash(fh);
1664                 __entry->status = be32_to_cpu(status);
1665                 __entry->count = count;
1666                 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1667                                   clp->cl_cb_conn.cb_addrlen)
1668         ),
1669         TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d",
1670                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1671                 __entry->si_id, __entry->si_generation,
1672                 __entry->fh_hash, __entry->count, __entry->status)
1673 );
1674
1675 TRACE_EVENT(nfsd_cb_recall_any,
1676         TP_PROTO(
1677                 const struct nfsd4_cb_recall_any *ra
1678         ),
1679         TP_ARGS(ra),
1680         TP_STRUCT__entry(
1681                 __field(u32, cl_boot)
1682                 __field(u32, cl_id)
1683                 __field(u32, keep)
1684                 __field(unsigned long, bmval0)
1685                 __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen)
1686         ),
1687         TP_fast_assign(
1688                 __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot;
1689                 __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id;
1690                 __entry->keep = ra->ra_keep;
1691                 __entry->bmval0 = ra->ra_bmval[0];
1692                 __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr,
1693                                   ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen);
1694         ),
1695         TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s",
1696                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1697                 __entry->keep, show_rca_mask(__entry->bmval0)
1698         )
1699 );
1700
1701 DECLARE_EVENT_CLASS(nfsd_cb_done_class,
1702         TP_PROTO(
1703                 const stateid_t *stp,
1704                 const struct rpc_task *task
1705         ),
1706         TP_ARGS(stp, task),
1707         TP_STRUCT__entry(
1708                 __field(u32, cl_boot)
1709                 __field(u32, cl_id)
1710                 __field(u32, si_id)
1711                 __field(u32, si_generation)
1712                 __field(int, status)
1713         ),
1714         TP_fast_assign(
1715                 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1716                 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1717                 __entry->si_id = stp->si_opaque.so_id;
1718                 __entry->si_generation = stp->si_generation;
1719                 __entry->status = task->tk_status;
1720         ),
1721         TP_printk("client %08x:%08x stateid %08x:%08x status=%d",
1722                 __entry->cl_boot, __entry->cl_id, __entry->si_id,
1723                 __entry->si_generation, __entry->status
1724         )
1725 );
1726
1727 #define DEFINE_NFSD_CB_DONE_EVENT(name)                 \
1728 DEFINE_EVENT(nfsd_cb_done_class, name,                  \
1729         TP_PROTO(                                       \
1730                 const stateid_t *stp,                   \
1731                 const struct rpc_task *task             \
1732         ),                                              \
1733         TP_ARGS(stp, task))
1734
1735 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done);
1736 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done);
1737 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done);
1738 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done);
1739
1740 TRACE_EVENT(nfsd_cb_recall_any_done,
1741         TP_PROTO(
1742                 const struct nfsd4_callback *cb,
1743                 const struct rpc_task *task
1744         ),
1745         TP_ARGS(cb, task),
1746         TP_STRUCT__entry(
1747                 __field(u32, cl_boot)
1748                 __field(u32, cl_id)
1749                 __field(int, status)
1750         ),
1751         TP_fast_assign(
1752                 __entry->status = task->tk_status;
1753                 __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot;
1754                 __entry->cl_id = cb->cb_clp->cl_clientid.cl_id;
1755         ),
1756         TP_printk("client %08x:%08x status=%d",
1757                 __entry->cl_boot, __entry->cl_id, __entry->status
1758         )
1759 );
1760
1761 TRACE_EVENT(nfsd_ctl_unlock_ip,
1762         TP_PROTO(
1763                 const struct net *net,
1764                 const char *address
1765         ),
1766         TP_ARGS(net, address),
1767         TP_STRUCT__entry(
1768                 __field(unsigned int, netns_ino)
1769                 __string(address, address)
1770         ),
1771         TP_fast_assign(
1772                 __entry->netns_ino = net->ns.inum;
1773                 __assign_str(address, address);
1774         ),
1775         TP_printk("address=%s",
1776                 __get_str(address)
1777         )
1778 );
1779
1780 TRACE_EVENT(nfsd_ctl_unlock_fs,
1781         TP_PROTO(
1782                 const struct net *net,
1783                 const char *path
1784         ),
1785         TP_ARGS(net, path),
1786         TP_STRUCT__entry(
1787                 __field(unsigned int, netns_ino)
1788                 __string(path, path)
1789         ),
1790         TP_fast_assign(
1791                 __entry->netns_ino = net->ns.inum;
1792                 __assign_str(path, path);
1793         ),
1794         TP_printk("path=%s",
1795                 __get_str(path)
1796         )
1797 );
1798
1799 TRACE_EVENT(nfsd_ctl_filehandle,
1800         TP_PROTO(
1801                 const struct net *net,
1802                 const char *domain,
1803                 const char *path,
1804                 int maxsize
1805         ),
1806         TP_ARGS(net, domain, path, maxsize),
1807         TP_STRUCT__entry(
1808                 __field(unsigned int, netns_ino)
1809                 __field(int, maxsize)
1810                 __string(domain, domain)
1811                 __string(path, path)
1812         ),
1813         TP_fast_assign(
1814                 __entry->netns_ino = net->ns.inum;
1815                 __entry->maxsize = maxsize;
1816                 __assign_str(domain, domain);
1817                 __assign_str(path, path);
1818         ),
1819         TP_printk("domain=%s path=%s maxsize=%d",
1820                 __get_str(domain), __get_str(path), __entry->maxsize
1821         )
1822 );
1823
1824 TRACE_EVENT(nfsd_ctl_threads,
1825         TP_PROTO(
1826                 const struct net *net,
1827                 int newthreads
1828         ),
1829         TP_ARGS(net, newthreads),
1830         TP_STRUCT__entry(
1831                 __field(unsigned int, netns_ino)
1832                 __field(int, newthreads)
1833         ),
1834         TP_fast_assign(
1835                 __entry->netns_ino = net->ns.inum;
1836                 __entry->newthreads = newthreads;
1837         ),
1838         TP_printk("newthreads=%d",
1839                 __entry->newthreads
1840         )
1841 );
1842
1843 TRACE_EVENT(nfsd_ctl_pool_threads,
1844         TP_PROTO(
1845                 const struct net *net,
1846                 int pool,
1847                 int nrthreads
1848         ),
1849         TP_ARGS(net, pool, nrthreads),
1850         TP_STRUCT__entry(
1851                 __field(unsigned int, netns_ino)
1852                 __field(int, pool)
1853                 __field(int, nrthreads)
1854         ),
1855         TP_fast_assign(
1856                 __entry->netns_ino = net->ns.inum;
1857                 __entry->pool = pool;
1858                 __entry->nrthreads = nrthreads;
1859         ),
1860         TP_printk("pool=%d nrthreads=%d",
1861                 __entry->pool, __entry->nrthreads
1862         )
1863 );
1864
1865 TRACE_EVENT(nfsd_ctl_version,
1866         TP_PROTO(
1867                 const struct net *net,
1868                 const char *mesg
1869         ),
1870         TP_ARGS(net, mesg),
1871         TP_STRUCT__entry(
1872                 __field(unsigned int, netns_ino)
1873                 __string(mesg, mesg)
1874         ),
1875         TP_fast_assign(
1876                 __entry->netns_ino = net->ns.inum;
1877                 __assign_str(mesg, mesg);
1878         ),
1879         TP_printk("%s",
1880                 __get_str(mesg)
1881         )
1882 );
1883
1884 TRACE_EVENT(nfsd_ctl_ports_addfd,
1885         TP_PROTO(
1886                 const struct net *net,
1887                 int fd
1888         ),
1889         TP_ARGS(net, fd),
1890         TP_STRUCT__entry(
1891                 __field(unsigned int, netns_ino)
1892                 __field(int, fd)
1893         ),
1894         TP_fast_assign(
1895                 __entry->netns_ino = net->ns.inum;
1896                 __entry->fd = fd;
1897         ),
1898         TP_printk("fd=%d",
1899                 __entry->fd
1900         )
1901 );
1902
1903 TRACE_EVENT(nfsd_ctl_ports_addxprt,
1904         TP_PROTO(
1905                 const struct net *net,
1906                 const char *transport,
1907                 int port
1908         ),
1909         TP_ARGS(net, transport, port),
1910         TP_STRUCT__entry(
1911                 __field(unsigned int, netns_ino)
1912                 __field(int, port)
1913                 __string(transport, transport)
1914         ),
1915         TP_fast_assign(
1916                 __entry->netns_ino = net->ns.inum;
1917                 __entry->port = port;
1918                 __assign_str(transport, transport);
1919         ),
1920         TP_printk("transport=%s port=%d",
1921                 __get_str(transport), __entry->port
1922         )
1923 );
1924
1925 TRACE_EVENT(nfsd_ctl_maxblksize,
1926         TP_PROTO(
1927                 const struct net *net,
1928                 int bsize
1929         ),
1930         TP_ARGS(net, bsize),
1931         TP_STRUCT__entry(
1932                 __field(unsigned int, netns_ino)
1933                 __field(int, bsize)
1934         ),
1935         TP_fast_assign(
1936                 __entry->netns_ino = net->ns.inum;
1937                 __entry->bsize = bsize;
1938         ),
1939         TP_printk("bsize=%d",
1940                 __entry->bsize
1941         )
1942 );
1943
1944 TRACE_EVENT(nfsd_ctl_maxconn,
1945         TP_PROTO(
1946                 const struct net *net,
1947                 int maxconn
1948         ),
1949         TP_ARGS(net, maxconn),
1950         TP_STRUCT__entry(
1951                 __field(unsigned int, netns_ino)
1952                 __field(int, maxconn)
1953         ),
1954         TP_fast_assign(
1955                 __entry->netns_ino = net->ns.inum;
1956                 __entry->maxconn = maxconn;
1957         ),
1958         TP_printk("maxconn=%d",
1959                 __entry->maxconn
1960         )
1961 );
1962
1963 TRACE_EVENT(nfsd_ctl_time,
1964         TP_PROTO(
1965                 const struct net *net,
1966                 const char *name,
1967                 size_t namelen,
1968                 int time
1969         ),
1970         TP_ARGS(net, name, namelen, time),
1971         TP_STRUCT__entry(
1972                 __field(unsigned int, netns_ino)
1973                 __field(int, time)
1974                 __string_len(name, name, namelen)
1975         ),
1976         TP_fast_assign(
1977                 __entry->netns_ino = net->ns.inum;
1978                 __entry->time = time;
1979                 __assign_str(name, name);
1980         ),
1981         TP_printk("file=%s time=%d\n",
1982                 __get_str(name), __entry->time
1983         )
1984 );
1985
1986 TRACE_EVENT(nfsd_ctl_recoverydir,
1987         TP_PROTO(
1988                 const struct net *net,
1989                 const char *recdir
1990         ),
1991         TP_ARGS(net, recdir),
1992         TP_STRUCT__entry(
1993                 __field(unsigned int, netns_ino)
1994                 __string(recdir, recdir)
1995         ),
1996         TP_fast_assign(
1997                 __entry->netns_ino = net->ns.inum;
1998                 __assign_str(recdir, recdir);
1999         ),
2000         TP_printk("recdir=%s",
2001                 __get_str(recdir)
2002         )
2003 );
2004
2005 TRACE_EVENT(nfsd_end_grace,
2006         TP_PROTO(
2007                 const struct net *net
2008         ),
2009         TP_ARGS(net),
2010         TP_STRUCT__entry(
2011                 __field(unsigned int, netns_ino)
2012         ),
2013         TP_fast_assign(
2014                 __entry->netns_ino = net->ns.inum;
2015         ),
2016         TP_printk("nn=%d", __entry->netns_ino
2017         )
2018 );
2019
2020 DECLARE_EVENT_CLASS(nfsd_copy_class,
2021         TP_PROTO(
2022                 const struct nfsd4_copy *copy
2023         ),
2024         TP_ARGS(copy),
2025         TP_STRUCT__entry(
2026                 __field(bool, intra)
2027                 __field(bool, async)
2028                 __field(u32, src_cl_boot)
2029                 __field(u32, src_cl_id)
2030                 __field(u32, src_so_id)
2031                 __field(u32, src_si_generation)
2032                 __field(u32, dst_cl_boot)
2033                 __field(u32, dst_cl_id)
2034                 __field(u32, dst_so_id)
2035                 __field(u32, dst_si_generation)
2036                 __field(u64, src_cp_pos)
2037                 __field(u64, dst_cp_pos)
2038                 __field(u64, cp_count)
2039                 __sockaddr(addr, sizeof(struct sockaddr_in6))
2040         ),
2041         TP_fast_assign(
2042                 const stateid_t *src_stp = &copy->cp_src_stateid;
2043                 const stateid_t *dst_stp = &copy->cp_dst_stateid;
2044
2045                 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, &copy->cp_flags);
2046                 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, &copy->cp_flags);
2047                 __entry->src_cl_boot = src_stp->si_opaque.so_clid.cl_boot;
2048                 __entry->src_cl_id = src_stp->si_opaque.so_clid.cl_id;
2049                 __entry->src_so_id = src_stp->si_opaque.so_id;
2050                 __entry->src_si_generation = src_stp->si_generation;
2051                 __entry->dst_cl_boot = dst_stp->si_opaque.so_clid.cl_boot;
2052                 __entry->dst_cl_id = dst_stp->si_opaque.so_clid.cl_id;
2053                 __entry->dst_so_id = dst_stp->si_opaque.so_id;
2054                 __entry->dst_si_generation = dst_stp->si_generation;
2055                 __entry->src_cp_pos = copy->cp_src_pos;
2056                 __entry->dst_cp_pos = copy->cp_dst_pos;
2057                 __entry->cp_count = copy->cp_count;
2058                 __assign_sockaddr(addr, &copy->cp_clp->cl_addr,
2059                                 sizeof(struct sockaddr_in6));
2060         ),
2061         TP_printk("client=%pISpc intra=%d async=%d "
2062                 "src_stateid[si_generation:0x%x cl_boot:0x%x cl_id:0x%x so_id:0x%x] "
2063                 "dst_stateid[si_generation:0x%x cl_boot:0x%x cl_id:0x%x so_id:0x%x] "
2064                 "cp_src_pos=%llu cp_dst_pos=%llu cp_count=%llu",
2065                 __get_sockaddr(addr), __entry->intra, __entry->async,
2066                 __entry->src_si_generation, __entry->src_cl_boot,
2067                 __entry->src_cl_id, __entry->src_so_id,
2068                 __entry->dst_si_generation, __entry->dst_cl_boot,
2069                 __entry->dst_cl_id, __entry->dst_so_id,
2070                 __entry->src_cp_pos, __entry->dst_cp_pos, __entry->cp_count
2071         )
2072 );
2073
2074 #define DEFINE_COPY_EVENT(name)                         \
2075 DEFINE_EVENT(nfsd_copy_class, nfsd_copy_##name, \
2076         TP_PROTO(const struct nfsd4_copy *copy),        \
2077         TP_ARGS(copy))
2078
2079 DEFINE_COPY_EVENT(inter);
2080 DEFINE_COPY_EVENT(intra);
2081 DEFINE_COPY_EVENT(do_async);
2082
2083 TRACE_EVENT(nfsd_copy_done,
2084         TP_PROTO(
2085                 const struct nfsd4_copy *copy,
2086                 __be32 status
2087         ),
2088         TP_ARGS(copy, status),
2089         TP_STRUCT__entry(
2090                 __field(int, status)
2091                 __field(bool, intra)
2092                 __field(bool, async)
2093                 __sockaddr(addr, sizeof(struct sockaddr_in6))
2094         ),
2095         TP_fast_assign(
2096                 __entry->status = be32_to_cpu(status);
2097                 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, &copy->cp_flags);
2098                 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, &copy->cp_flags);
2099                 __assign_sockaddr(addr, &copy->cp_clp->cl_addr,
2100                                 sizeof(struct sockaddr_in6));
2101         ),
2102         TP_printk("addr=%pISpc status=%d intra=%d async=%d ",
2103                 __get_sockaddr(addr), __entry->status, __entry->intra, __entry->async
2104         )
2105 );
2106
2107 #endif /* _NFSD_TRACE_H */
2108
2109 #undef TRACE_INCLUDE_PATH
2110 #define TRACE_INCLUDE_PATH .
2111 #define TRACE_INCLUDE_FILE trace
2112 #include <trace/define_trace.h>