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