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_return);
 611 DEFINE_STATEID_EVENT(deleg_recall);
 612
 613 DECLARE_EVENT_CLASS(nfsd_stateseqid_class,
 614         TP_PROTO(u32 seqid, const stateid_t *stp),
 615         TP_ARGS(seqid, stp),
 616         TP_STRUCT__entry(
 617                 __field(u32, seqid)
 618                 __field(u32, cl_boot)
 619                 __field(u32, cl_id)
 620                 __field(u32, si_id)
 621                 __field(u32, si_generation)
 622         ),
 623         TP_fast_assign(
 624                 __entry->seqid = seqid;
 625                 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
 626                 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
 627                 __entry->si_id = stp->si_opaque.so_id;
 628                 __entry->si_generation = stp->si_generation;
 629         ),
 630         TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x",
 631                 __entry->seqid, __entry->cl_boot, __entry->cl_id,
 632                 __entry->si_id, __entry->si_generation)
 633 )
 634
 635 #define DEFINE_STATESEQID_EVENT(name) \
 636 DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \
 637         TP_PROTO(u32 seqid, const stateid_t *stp), \
 638         TP_ARGS(seqid, stp))
 639
 640 DEFINE_STATESEQID_EVENT(preprocess);
 641 DEFINE_STATESEQID_EVENT(open_confirm);
 642
 643 TRACE_DEFINE_ENUM(NFS4_OPEN_STID);
 644 TRACE_DEFINE_ENUM(NFS4_LOCK_STID);
 645 TRACE_DEFINE_ENUM(NFS4_DELEG_STID);
 646 TRACE_DEFINE_ENUM(NFS4_CLOSED_STID);
 647 TRACE_DEFINE_ENUM(NFS4_REVOKED_DELEG_STID);
 648 TRACE_DEFINE_ENUM(NFS4_CLOSED_DELEG_STID);
 649 TRACE_DEFINE_ENUM(NFS4_LAYOUT_STID);
 650
 651 #define show_stid_type(x)                                               \
 652         __print_flags(x, "|",                                           \
 653                 { NFS4_OPEN_STID,               "OPEN" },               \
 654                 { NFS4_LOCK_STID,               "LOCK" },               \
 655                 { NFS4_DELEG_STID,              "DELEG" },              \
 656                 { NFS4_CLOSED_STID,             "CLOSED" },             \
 657                 { NFS4_REVOKED_DELEG_STID,      "REVOKED" },            \
 658                 { NFS4_CLOSED_DELEG_STID,       "CLOSED_DELEG" },       \
 659                 { NFS4_LAYOUT_STID,             "LAYOUT" })
 660
 661 DECLARE_EVENT_CLASS(nfsd_stid_class,
 662         TP_PROTO(
 663                 const struct nfs4_stid *stid
 664         ),
 665         TP_ARGS(stid),
 666         TP_STRUCT__entry(
 667                 __field(unsigned long, sc_type)
 668                 __field(int, sc_count)
 669                 __field(u32, cl_boot)
 670                 __field(u32, cl_id)
 671                 __field(u32, si_id)
 672                 __field(u32, si_generation)
 673         ),
 674         TP_fast_assign(
 675                 const stateid_t *stp = &stid->sc_stateid;
 676
 677                 __entry->sc_type = stid->sc_type;
 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",
 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         )
 689 );
 690
 691 #define DEFINE_STID_EVENT(name)                                 \
 692 DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name,                 \
 693         TP_PROTO(const struct nfs4_stid *stid),                 \
 694         TP_ARGS(stid))
 695
 696 DEFINE_STID_EVENT(revoke);
 697
 698 DECLARE_EVENT_CLASS(nfsd_clientid_class,
 699         TP_PROTO(const clientid_t *clid),
 700         TP_ARGS(clid),
 701         TP_STRUCT__entry(
 702                 __field(u32, cl_boot)
 703                 __field(u32, cl_id)
 704         ),
 705         TP_fast_assign(
 706                 __entry->cl_boot = clid->cl_boot;
 707                 __entry->cl_id = clid->cl_id;
 708         ),
 709         TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
 710 )
 711
 712 #define DEFINE_CLIENTID_EVENT(name) \
 713 DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \
 714         TP_PROTO(const clientid_t *clid), \
 715         TP_ARGS(clid))
 716
 717 DEFINE_CLIENTID_EVENT(expire_unconf);
 718 DEFINE_CLIENTID_EVENT(reclaim_complete);
 719 DEFINE_CLIENTID_EVENT(confirmed);
 720 DEFINE_CLIENTID_EVENT(destroyed);
 721 DEFINE_CLIENTID_EVENT(admin_expired);
 722 DEFINE_CLIENTID_EVENT(replaced);
 723 DEFINE_CLIENTID_EVENT(purged);
 724 DEFINE_CLIENTID_EVENT(renew);
 725 DEFINE_CLIENTID_EVENT(stale);
 726
 727 DECLARE_EVENT_CLASS(nfsd_net_class,
 728         TP_PROTO(const struct nfsd_net *nn),
 729         TP_ARGS(nn),
 730         TP_STRUCT__entry(
 731                 __field(unsigned long long, boot_time)
 732         ),
 733         TP_fast_assign(
 734                 __entry->boot_time = nn->boot_time;
 735         ),
 736         TP_printk("boot_time=%16llx", __entry->boot_time)
 737 )
 738
 739 #define DEFINE_NET_EVENT(name) \
 740 DEFINE_EVENT(nfsd_net_class, nfsd_##name, \
 741         TP_PROTO(const struct nfsd_net *nn), \
 742         TP_ARGS(nn))
 743
 744 DEFINE_NET_EVENT(grace_start);
 745 DEFINE_NET_EVENT(grace_complete);
 746
 747 TRACE_EVENT(nfsd_writeverf_reset,
 748         TP_PROTO(
 749                 const struct nfsd_net *nn,
 750                 const struct svc_rqst *rqstp,
 751                 int error
 752         ),
 753         TP_ARGS(nn, rqstp, error),
 754         TP_STRUCT__entry(
 755                 __field(unsigned long long, boot_time)
 756                 __field(u32, xid)
 757                 __field(int, error)
 758                 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
 759         ),
 760         TP_fast_assign(
 761                 __entry->boot_time = nn->boot_time;
 762                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
 763                 __entry->error = error;
 764
 765                 /* avoid seqlock inside TP_fast_assign */
 766                 memcpy(__entry->verifier, nn->writeverf,
 767                        NFS4_VERIFIER_SIZE);
 768         ),
 769         TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s",
 770                 __entry->boot_time, __entry->xid, __entry->error,
 771                 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE)
 772         )
 773 );
 774
 775 TRACE_EVENT(nfsd_clid_cred_mismatch,
 776         TP_PROTO(
 777                 const struct nfs4_client *clp,
 778                 const struct svc_rqst *rqstp
 779         ),
 780         TP_ARGS(clp, rqstp),
 781         TP_STRUCT__entry(
 782                 __field(u32, cl_boot)
 783                 __field(u32, cl_id)
 784                 __field(unsigned long, cl_flavor)
 785                 __field(unsigned long, new_flavor)
 786                 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
 787         ),
 788         TP_fast_assign(
 789                 __entry->cl_boot = clp->cl_clientid.cl_boot;
 790                 __entry->cl_id = clp->cl_clientid.cl_id;
 791                 __entry->cl_flavor = clp->cl_cred.cr_flavor;
 792                 __entry->new_flavor = rqstp->rq_cred.cr_flavor;
 793                 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
 794                                   rqstp->rq_xprt->xpt_remotelen);
 795         ),
 796         TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc",
 797                 __entry->cl_boot, __entry->cl_id,
 798                 show_nfsd_authflavor(__entry->cl_flavor),
 799                 show_nfsd_authflavor(__entry->new_flavor),
 800                 __get_sockaddr(addr)
 801         )
 802 )
 803
 804 TRACE_EVENT(nfsd_clid_verf_mismatch,
 805         TP_PROTO(
 806                 const struct nfs4_client *clp,
 807                 const struct svc_rqst *rqstp,
 808                 const nfs4_verifier *verf
 809         ),
 810         TP_ARGS(clp, rqstp, verf),
 811         TP_STRUCT__entry(
 812                 __field(u32, cl_boot)
 813                 __field(u32, cl_id)
 814                 __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE)
 815                 __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE)
 816                 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
 817         ),
 818         TP_fast_assign(
 819                 __entry->cl_boot = clp->cl_clientid.cl_boot;
 820                 __entry->cl_id = clp->cl_clientid.cl_id;
 821                 memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier,
 822                        NFS4_VERIFIER_SIZE);
 823                 memcpy(__entry->new_verifier, (void *)verf,
 824                        NFS4_VERIFIER_SIZE);
 825                 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
 826                                   rqstp->rq_xprt->xpt_remotelen);
 827         ),
 828         TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc",
 829                 __entry->cl_boot, __entry->cl_id,
 830                 __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE),
 831                 __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE),
 832                 __get_sockaddr(addr)
 833         )
 834 );
 835
 836 DECLARE_EVENT_CLASS(nfsd_clid_class,
 837         TP_PROTO(const struct nfs4_client *clp),
 838         TP_ARGS(clp),
 839         TP_STRUCT__entry(
 840                 __field(u32, cl_boot)
 841                 __field(u32, cl_id)
 842                 __array(unsigned char, addr, sizeof(struct sockaddr_in6))
 843                 __field(unsigned long, flavor)
 844                 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
 845                 __string_len(name, clp->cl_name.data, clp->cl_name.len)
 846         ),
 847         TP_fast_assign(
 848                 __entry->cl_boot = clp->cl_clientid.cl_boot;
 849                 __entry->cl_id = clp->cl_clientid.cl_id;
 850                 memcpy(__entry->addr, &clp->cl_addr,
 851                         sizeof(struct sockaddr_in6));
 852                 __entry->flavor = clp->cl_cred.cr_flavor;
 853                 memcpy(__entry->verifier, (void *)&clp->cl_verifier,
 854                        NFS4_VERIFIER_SIZE);
 855                 __assign_str_len(name, clp->cl_name.data, clp->cl_name.len);
 856         ),
 857         TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x",
 858                 __entry->addr, __get_str(name),
 859                 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE),
 860                 show_nfsd_authflavor(__entry->flavor),
 861                 __entry->cl_boot, __entry->cl_id)
 862 );
 863
 864 #define DEFINE_CLID_EVENT(name) \
 865 DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \
 866         TP_PROTO(const struct nfs4_client *clp), \
 867         TP_ARGS(clp))
 868
 869 DEFINE_CLID_EVENT(fresh);
 870 DEFINE_CLID_EVENT(confirmed_r);
 871
 872 /*
 873  * from fs/nfsd/filecache.h
 874  */
 875 #define show_nf_flags(val)                                              \
 876         __print_flags(val, "|",                                         \
 877                 { 1 << NFSD_FILE_HASHED,        "HASHED" },             \
 878                 { 1 << NFSD_FILE_PENDING,       "PENDING" },            \
 879                 { 1 << NFSD_FILE_REFERENCED,    "REFERENCED" },         \
 880                 { 1 << NFSD_FILE_GC,            "GC" })
 881
 882 DECLARE_EVENT_CLASS(nfsd_file_class,
 883         TP_PROTO(struct nfsd_file *nf),
 884         TP_ARGS(nf),
 885         TP_STRUCT__entry(
 886                 __field(void *, nf_inode)
 887                 __field(int, nf_ref)
 888                 __field(unsigned long, nf_flags)
 889                 __field(unsigned char, nf_may)
 890                 __field(struct file *, nf_file)
 891         ),
 892         TP_fast_assign(
 893                 __entry->nf_inode = nf->nf_inode;
 894                 __entry->nf_ref = refcount_read(&nf->nf_ref);
 895                 __entry->nf_flags = nf->nf_flags;
 896                 __entry->nf_may = nf->nf_may;
 897                 __entry->nf_file = nf->nf_file;
 898         ),
 899         TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p",
 900                 __entry->nf_inode,
 901                 __entry->nf_ref,
 902                 show_nf_flags(__entry->nf_flags),
 903                 show_nfsd_may_flags(__entry->nf_may),
 904                 __entry->nf_file)
 905 )
 906
 907 #define DEFINE_NFSD_FILE_EVENT(name) \
 908 DEFINE_EVENT(nfsd_file_class, name, \
 909         TP_PROTO(struct nfsd_file *nf), \
 910         TP_ARGS(nf))
 911
 912 DEFINE_NFSD_FILE_EVENT(nfsd_file_free);
 913 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash);
 914 DEFINE_NFSD_FILE_EVENT(nfsd_file_put);
 915 DEFINE_NFSD_FILE_EVENT(nfsd_file_closing);
 916 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue);
 917
 918 TRACE_EVENT(nfsd_file_alloc,
 919         TP_PROTO(
 920                 const struct nfsd_file *nf
 921         ),
 922         TP_ARGS(nf),
 923         TP_STRUCT__entry(
 924                 __field(const void *, nf_inode)
 925                 __field(unsigned long, nf_flags)
 926                 __field(unsigned long, nf_may)
 927                 __field(unsigned int, nf_ref)
 928         ),
 929         TP_fast_assign(
 930                 __entry->nf_inode = nf->nf_inode;
 931                 __entry->nf_flags = nf->nf_flags;
 932                 __entry->nf_ref = refcount_read(&nf->nf_ref);
 933                 __entry->nf_may = nf->nf_may;
 934         ),
 935         TP_printk("inode=%p ref=%u flags=%s may=%s",
 936                 __entry->nf_inode, __entry->nf_ref,
 937                 show_nf_flags(__entry->nf_flags),
 938                 show_nfsd_may_flags(__entry->nf_may)
 939         )
 940 );
 941
 942 TRACE_EVENT(nfsd_file_acquire,
 943         TP_PROTO(
 944                 const struct svc_rqst *rqstp,
 945                 const struct inode *inode,
 946                 unsigned int may_flags,
 947                 const struct nfsd_file *nf,
 948                 __be32 status
 949         ),
 950
 951         TP_ARGS(rqstp, inode, may_flags, nf, status),
 952
 953         TP_STRUCT__entry(
 954                 __field(u32, xid)
 955                 __field(const void *, inode)
 956                 __field(unsigned long, may_flags)
 957                 __field(unsigned int, nf_ref)
 958                 __field(unsigned long, nf_flags)
 959                 __field(unsigned long, nf_may)
 960                 __field(const void *, nf_file)
 961                 __field(u32, status)
 962         ),
 963
 964         TP_fast_assign(
 965                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
 966                 __entry->inode = inode;
 967                 __entry->may_flags = may_flags;
 968                 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0;
 969                 __entry->nf_flags = nf ? nf->nf_flags : 0;
 970                 __entry->nf_may = nf ? nf->nf_may : 0;
 971                 __entry->nf_file = nf ? nf->nf_file : NULL;
 972                 __entry->status = be32_to_cpu(status);
 973         ),
 974
 975         TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u",
 976                         __entry->xid, __entry->inode,
 977                         show_nfsd_may_flags(__entry->may_flags),
 978                         __entry->nf_ref, show_nf_flags(__entry->nf_flags),
 979                         show_nfsd_may_flags(__entry->nf_may),
 980                         __entry->nf_file, __entry->status
 981         )
 982 );
 983
 984 TRACE_EVENT(nfsd_file_insert_err,
 985         TP_PROTO(
 986                 const struct svc_rqst *rqstp,
 987                 const struct inode *inode,
 988                 unsigned int may_flags,
 989                 long error
 990         ),
 991         TP_ARGS(rqstp, inode, may_flags, error),
 992         TP_STRUCT__entry(
 993                 __field(u32, xid)
 994                 __field(const void *, inode)
 995                 __field(unsigned long, may_flags)
 996                 __field(long, error)
 997         ),
 998         TP_fast_assign(
 999                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1000                 __entry->inode = inode;
1001                 __entry->may_flags = may_flags;
1002                 __entry->error = error;
1003         ),
1004         TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld",
1005                 __entry->xid, __entry->inode,
1006                 show_nfsd_may_flags(__entry->may_flags),
1007                 __entry->error
1008         )
1009 );
1010
1011 TRACE_EVENT(nfsd_file_cons_err,
1012         TP_PROTO(
1013                 const struct svc_rqst *rqstp,
1014                 const struct inode *inode,
1015                 unsigned int may_flags,
1016                 const struct nfsd_file *nf
1017         ),
1018         TP_ARGS(rqstp, inode, may_flags, nf),
1019         TP_STRUCT__entry(
1020                 __field(u32, xid)
1021                 __field(const void *, inode)
1022                 __field(unsigned long, may_flags)
1023                 __field(unsigned int, nf_ref)
1024                 __field(unsigned long, nf_flags)
1025                 __field(unsigned long, nf_may)
1026                 __field(const void *, nf_file)
1027         ),
1028         TP_fast_assign(
1029                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1030                 __entry->inode = inode;
1031                 __entry->may_flags = may_flags;
1032                 __entry->nf_ref = refcount_read(&nf->nf_ref);
1033                 __entry->nf_flags = nf->nf_flags;
1034                 __entry->nf_may = nf->nf_may;
1035                 __entry->nf_file = nf->nf_file;
1036         ),
1037         TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p",
1038                 __entry->xid, __entry->inode,
1039                 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref,
1040                 show_nf_flags(__entry->nf_flags),
1041                 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file
1042         )
1043 );
1044
1045 DECLARE_EVENT_CLASS(nfsd_file_open_class,
1046         TP_PROTO(const struct nfsd_file *nf, __be32 status),
1047         TP_ARGS(nf, status),
1048         TP_STRUCT__entry(
1049                 __field(void *, nf_inode)       /* cannot be dereferenced */
1050                 __field(int, nf_ref)
1051                 __field(unsigned long, nf_flags)
1052                 __field(unsigned long, nf_may)
1053                 __field(void *, nf_file)        /* cannot be dereferenced */
1054         ),
1055         TP_fast_assign(
1056                 __entry->nf_inode = nf->nf_inode;
1057                 __entry->nf_ref = refcount_read(&nf->nf_ref);
1058                 __entry->nf_flags = nf->nf_flags;
1059                 __entry->nf_may = nf->nf_may;
1060                 __entry->nf_file = nf->nf_file;
1061         ),
1062         TP_printk("inode=%p ref=%d flags=%s may=%s file=%p",
1063                 __entry->nf_inode,
1064                 __entry->nf_ref,
1065                 show_nf_flags(__entry->nf_flags),
1066                 show_nfsd_may_flags(__entry->nf_may),
1067                 __entry->nf_file)
1068 )
1069
1070 #define DEFINE_NFSD_FILE_OPEN_EVENT(name)                                       \
1071 DEFINE_EVENT(nfsd_file_open_class, name,                                        \
1072         TP_PROTO(                                                       \
1073                 const struct nfsd_file *nf,                             \
1074                 __be32 status                                           \
1075         ),                                                              \
1076         TP_ARGS(nf, status))
1077
1078 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open);
1079 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened);
1080
1081 TRACE_EVENT(nfsd_file_is_cached,
1082         TP_PROTO(
1083                 const struct inode *inode,
1084                 int found
1085         ),
1086         TP_ARGS(inode, found),
1087         TP_STRUCT__entry(
1088                 __field(const struct inode *, inode)
1089                 __field(int, found)
1090         ),
1091         TP_fast_assign(
1092                 __entry->inode = inode;
1093                 __entry->found = found;
1094         ),
1095         TP_printk("inode=%p is %scached",
1096                 __entry->inode,
1097                 __entry->found ? "" : "not "
1098         )
1099 );
1100
1101 TRACE_EVENT(nfsd_file_fsnotify_handle_event,
1102         TP_PROTO(struct inode *inode, u32 mask),
1103         TP_ARGS(inode, mask),
1104         TP_STRUCT__entry(
1105                 __field(struct inode *, inode)
1106                 __field(unsigned int, nlink)
1107                 __field(umode_t, mode)
1108                 __field(u32, mask)
1109         ),
1110         TP_fast_assign(
1111                 __entry->inode = inode;
1112                 __entry->nlink = inode->i_nlink;
1113                 __entry->mode = inode->i_mode;
1114                 __entry->mask = mask;
1115         ),
1116         TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode,
1117                         __entry->nlink, __entry->mode, __entry->mask)
1118 );
1119
1120 DECLARE_EVENT_CLASS(nfsd_file_gc_class,
1121         TP_PROTO(
1122                 const struct nfsd_file *nf
1123         ),
1124         TP_ARGS(nf),
1125         TP_STRUCT__entry(
1126                 __field(void *, nf_inode)
1127                 __field(void *, nf_file)
1128                 __field(int, nf_ref)
1129                 __field(unsigned long, nf_flags)
1130         ),
1131         TP_fast_assign(
1132                 __entry->nf_inode = nf->nf_inode;
1133                 __entry->nf_file = nf->nf_file;
1134                 __entry->nf_ref = refcount_read(&nf->nf_ref);
1135                 __entry->nf_flags = nf->nf_flags;
1136         ),
1137         TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p",
1138                 __entry->nf_inode, __entry->nf_ref,
1139                 show_nf_flags(__entry->nf_flags),
1140                 __entry->nf_file
1141         )
1142 );
1143
1144 #define DEFINE_NFSD_FILE_GC_EVENT(name)                                 \
1145 DEFINE_EVENT(nfsd_file_gc_class, name,                                  \
1146         TP_PROTO(                                                       \
1147                 const struct nfsd_file *nf                              \
1148         ),                                                              \
1149         TP_ARGS(nf))
1150
1151 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add);
1152 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed);
1153 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del);
1154 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed);
1155 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use);
1156 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback);
1157 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced);
1158 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed);
1159
1160 DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class,
1161         TP_PROTO(
1162                 unsigned long removed,
1163                 unsigned long remaining
1164         ),
1165         TP_ARGS(removed, remaining),
1166         TP_STRUCT__entry(
1167                 __field(unsigned long, removed)
1168                 __field(unsigned long, remaining)
1169         ),
1170         TP_fast_assign(
1171                 __entry->removed = removed;
1172                 __entry->remaining = remaining;
1173         ),
1174         TP_printk("%lu entries removed, %lu remaining",
1175                 __entry->removed, __entry->remaining)
1176 );
1177
1178 #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name)                            \
1179 DEFINE_EVENT(nfsd_file_lruwalk_class, name,                             \
1180         TP_PROTO(                                                       \
1181                 unsigned long removed,                                  \
1182                 unsigned long remaining                                 \
1183         ),                                                              \
1184         TP_ARGS(removed, remaining))
1185
1186 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed);
1187 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed);
1188
1189 TRACE_EVENT(nfsd_file_close,
1190         TP_PROTO(
1191                 const struct inode *inode
1192         ),
1193         TP_ARGS(inode),
1194         TP_STRUCT__entry(
1195                 __field(const void *, inode)
1196         ),
1197         TP_fast_assign(
1198                 __entry->inode = inode;
1199         ),
1200         TP_printk("inode=%p",
1201                 __entry->inode
1202         )
1203 );
1204
1205 #include "cache.h"
1206
1207 TRACE_DEFINE_ENUM(RC_DROPIT);
1208 TRACE_DEFINE_ENUM(RC_REPLY);
1209 TRACE_DEFINE_ENUM(RC_DOIT);
1210
1211 #define show_drc_retval(x)                                              \
1212         __print_symbolic(x,                                             \
1213                 { RC_DROPIT, "DROPIT" },                                \
1214                 { RC_REPLY, "REPLY" },                                  \
1215                 { RC_DOIT, "DOIT" })
1216
1217 TRACE_EVENT(nfsd_drc_found,
1218         TP_PROTO(
1219                 const struct nfsd_net *nn,
1220                 const struct svc_rqst *rqstp,
1221                 int result
1222         ),
1223         TP_ARGS(nn, rqstp, result),
1224         TP_STRUCT__entry(
1225                 __field(unsigned long long, boot_time)
1226                 __field(unsigned long, result)
1227                 __field(u32, xid)
1228         ),
1229         TP_fast_assign(
1230                 __entry->boot_time = nn->boot_time;
1231                 __entry->result = result;
1232                 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1233         ),
1234         TP_printk("boot_time=%16llx xid=0x%08x result=%s",
1235                 __entry->boot_time, __entry->xid,
1236                 show_drc_retval(__entry->result))
1237
1238 );
1239
1240 TRACE_EVENT(nfsd_drc_mismatch,
1241         TP_PROTO(
1242                 const struct nfsd_net *nn,
1243                 const struct svc_cacherep *key,
1244                 const struct svc_cacherep *rp
1245         ),
1246         TP_ARGS(nn, key, rp),
1247         TP_STRUCT__entry(
1248                 __field(unsigned long long, boot_time)
1249                 __field(u32, xid)
1250                 __field(u32, cached)
1251                 __field(u32, ingress)
1252         ),
1253         TP_fast_assign(
1254                 __entry->boot_time = nn->boot_time;
1255                 __entry->xid = be32_to_cpu(key->c_key.k_xid);
1256                 __entry->cached = (__force u32)key->c_key.k_csum;
1257                 __entry->ingress = (__force u32)rp->c_key.k_csum;
1258         ),
1259         TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x",
1260                 __entry->boot_time, __entry->xid, __entry->cached,
1261                 __entry->ingress)
1262 );
1263
1264 TRACE_EVENT(nfsd_cb_args,
1265         TP_PROTO(
1266                 const struct nfs4_client *clp,
1267                 const struct nfs4_cb_conn *conn
1268         ),
1269         TP_ARGS(clp, conn),
1270         TP_STRUCT__entry(
1271                 __field(u32, cl_boot)
1272                 __field(u32, cl_id)
1273                 __field(u32, prog)
1274                 __field(u32, ident)
1275                 __sockaddr(addr, conn->cb_addrlen)
1276         ),
1277         TP_fast_assign(
1278                 __entry->cl_boot = clp->cl_clientid.cl_boot;
1279                 __entry->cl_id = clp->cl_clientid.cl_id;
1280                 __entry->prog = conn->cb_prog;
1281                 __entry->ident = conn->cb_ident;
1282                 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen);
1283         ),
1284         TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u",
1285                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1286                 __entry->prog, __entry->ident)
1287 );
1288
1289 TRACE_EVENT(nfsd_cb_nodelegs,
1290         TP_PROTO(const struct nfs4_client *clp),
1291         TP_ARGS(clp),
1292         TP_STRUCT__entry(
1293                 __field(u32, cl_boot)
1294                 __field(u32, cl_id)
1295         ),
1296         TP_fast_assign(
1297                 __entry->cl_boot = clp->cl_clientid.cl_boot;
1298                 __entry->cl_id = clp->cl_clientid.cl_id;
1299         ),
1300         TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
1301 )
1302
1303 #define show_cb_state(val)                                              \
1304         __print_symbolic(val,                                           \
1305                 { NFSD4_CB_UP,          "UP" },                         \
1306                 { NFSD4_CB_UNKNOWN,     "UNKNOWN" },                    \
1307                 { NFSD4_CB_DOWN,        "DOWN" },                       \
1308                 { NFSD4_CB_FAULT,       "FAULT"})
1309
1310 DECLARE_EVENT_CLASS(nfsd_cb_class,
1311         TP_PROTO(const struct nfs4_client *clp),
1312         TP_ARGS(clp),
1313         TP_STRUCT__entry(
1314                 __field(unsigned long, state)
1315                 __field(u32, cl_boot)
1316                 __field(u32, cl_id)
1317                 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1318         ),
1319         TP_fast_assign(
1320                 __entry->state = clp->cl_cb_state;
1321                 __entry->cl_boot = clp->cl_clientid.cl_boot;
1322                 __entry->cl_id = clp->cl_clientid.cl_id;
1323                 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1324                                   clp->cl_cb_conn.cb_addrlen)
1325         ),
1326         TP_printk("addr=%pISpc client %08x:%08x state=%s",
1327                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1328                 show_cb_state(__entry->state))
1329 );
1330
1331 #define DEFINE_NFSD_CB_EVENT(name)                      \
1332 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name,             \
1333         TP_PROTO(const struct nfs4_client *clp),        \
1334         TP_ARGS(clp))
1335
1336 DEFINE_NFSD_CB_EVENT(state);
1337 DEFINE_NFSD_CB_EVENT(probe);
1338 DEFINE_NFSD_CB_EVENT(lost);
1339 DEFINE_NFSD_CB_EVENT(shutdown);
1340
1341 TRACE_DEFINE_ENUM(RPC_AUTH_NULL);
1342 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX);
1343 TRACE_DEFINE_ENUM(RPC_AUTH_GSS);
1344 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5);
1345 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I);
1346 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P);
1347
1348 #define show_nfsd_authflavor(val)                                       \
1349         __print_symbolic(val,                                           \
1350                 { RPC_AUTH_NULL,                "none" },               \
1351                 { RPC_AUTH_UNIX,                "sys" },                \
1352                 { RPC_AUTH_GSS,                 "gss" },                \
1353                 { RPC_AUTH_GSS_KRB5,            "krb5" },               \
1354                 { RPC_AUTH_GSS_KRB5I,           "krb5i" },              \
1355                 { RPC_AUTH_GSS_KRB5P,           "krb5p" })
1356
1357 TRACE_EVENT(nfsd_cb_setup,
1358         TP_PROTO(const struct nfs4_client *clp,
1359                  const char *netid,
1360                  rpc_authflavor_t authflavor
1361         ),
1362         TP_ARGS(clp, netid, authflavor),
1363         TP_STRUCT__entry(
1364                 __field(u32, cl_boot)
1365                 __field(u32, cl_id)
1366                 __field(unsigned long, authflavor)
1367                 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1368                 __array(unsigned char, netid, 8)
1369         ),
1370         TP_fast_assign(
1371                 __entry->cl_boot = clp->cl_clientid.cl_boot;
1372                 __entry->cl_id = clp->cl_clientid.cl_id;
1373                 strlcpy(__entry->netid, netid, sizeof(__entry->netid));
1374                 __entry->authflavor = authflavor;
1375                 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1376                                   clp->cl_cb_conn.cb_addrlen)
1377         ),
1378         TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s",
1379                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1380                 __entry->netid, show_nfsd_authflavor(__entry->authflavor))
1381 );
1382
1383 TRACE_EVENT(nfsd_cb_setup_err,
1384         TP_PROTO(
1385                 const struct nfs4_client *clp,
1386                 long error
1387         ),
1388         TP_ARGS(clp, error),
1389         TP_STRUCT__entry(
1390                 __field(long, error)
1391                 __field(u32, cl_boot)
1392                 __field(u32, cl_id)
1393                 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1394         ),
1395         TP_fast_assign(
1396                 __entry->error = error;
1397                 __entry->cl_boot = clp->cl_clientid.cl_boot;
1398                 __entry->cl_id = clp->cl_clientid.cl_id;
1399                 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1400                                   clp->cl_cb_conn.cb_addrlen)
1401         ),
1402         TP_printk("addr=%pISpc client %08x:%08x error=%ld",
1403                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1404                 __entry->error)
1405 );
1406
1407 TRACE_EVENT_CONDITION(nfsd_cb_recall,
1408         TP_PROTO(
1409                 const struct nfs4_stid *stid
1410         ),
1411         TP_ARGS(stid),
1412         TP_CONDITION(stid->sc_client),
1413         TP_STRUCT__entry(
1414                 __field(u32, cl_boot)
1415                 __field(u32, cl_id)
1416                 __field(u32, si_id)
1417                 __field(u32, si_generation)
1418                 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen)
1419         ),
1420         TP_fast_assign(
1421                 const stateid_t *stp = &stid->sc_stateid;
1422                 const struct nfs4_client *clp = stid->sc_client;
1423
1424                 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1425                 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1426                 __entry->si_id = stp->si_opaque.so_id;
1427                 __entry->si_generation = stp->si_generation;
1428                 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1429                                   clp->cl_cb_conn.cb_addrlen)
1430         ),
1431         TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x",
1432                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1433                 __entry->si_id, __entry->si_generation)
1434 );
1435
1436 TRACE_EVENT(nfsd_cb_notify_lock,
1437         TP_PROTO(
1438                 const struct nfs4_lockowner *lo,
1439                 const struct nfsd4_blocked_lock *nbl
1440         ),
1441         TP_ARGS(lo, nbl),
1442         TP_STRUCT__entry(
1443                 __field(u32, cl_boot)
1444                 __field(u32, cl_id)
1445                 __field(u32, fh_hash)
1446                 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen)
1447         ),
1448         TP_fast_assign(
1449                 const struct nfs4_client *clp = lo->lo_owner.so_client;
1450
1451                 __entry->cl_boot = clp->cl_clientid.cl_boot;
1452                 __entry->cl_id = clp->cl_clientid.cl_id;
1453                 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh);
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 fh_hash=0x%08x",
1458                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1459                 __entry->fh_hash)
1460 );
1461
1462 TRACE_EVENT(nfsd_cb_offload,
1463         TP_PROTO(
1464                 const struct nfs4_client *clp,
1465                 const stateid_t *stp,
1466                 const struct knfsd_fh *fh,
1467                 u64 count,
1468                 __be32 status
1469         ),
1470         TP_ARGS(clp, stp, fh, count, status),
1471         TP_STRUCT__entry(
1472                 __field(u32, cl_boot)
1473                 __field(u32, cl_id)
1474                 __field(u32, si_id)
1475                 __field(u32, si_generation)
1476                 __field(u32, fh_hash)
1477                 __field(int, status)
1478                 __field(u64, count)
1479                 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1480         ),
1481         TP_fast_assign(
1482                 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1483                 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1484                 __entry->si_id = stp->si_opaque.so_id;
1485                 __entry->si_generation = stp->si_generation;
1486                 __entry->fh_hash = knfsd_fh_hash(fh);
1487                 __entry->status = be32_to_cpu(status);
1488                 __entry->count = count;
1489                 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1490                                   clp->cl_cb_conn.cb_addrlen)
1491         ),
1492         TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d",
1493                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1494                 __entry->si_id, __entry->si_generation,
1495                 __entry->fh_hash, __entry->count, __entry->status)
1496 );
1497
1498 TRACE_EVENT(nfsd_cb_recall_any,
1499         TP_PROTO(
1500                 const struct nfsd4_cb_recall_any *ra
1501         ),
1502         TP_ARGS(ra),
1503         TP_STRUCT__entry(
1504                 __field(u32, cl_boot)
1505                 __field(u32, cl_id)
1506                 __field(u32, keep)
1507                 __field(unsigned long, bmval0)
1508                 __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen)
1509         ),
1510         TP_fast_assign(
1511                 __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot;
1512                 __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id;
1513                 __entry->keep = ra->ra_keep;
1514                 __entry->bmval0 = ra->ra_bmval[0];
1515                 __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr,
1516                                   ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen);
1517         ),
1518         TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s",
1519                 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1520                 __entry->keep, show_rca_mask(__entry->bmval0)
1521         )
1522 );
1523
1524 DECLARE_EVENT_CLASS(nfsd_cb_done_class,
1525         TP_PROTO(
1526                 const stateid_t *stp,
1527                 const struct rpc_task *task
1528         ),
1529         TP_ARGS(stp, task),
1530         TP_STRUCT__entry(
1531                 __field(u32, cl_boot)
1532                 __field(u32, cl_id)
1533                 __field(u32, si_id)
1534                 __field(u32, si_generation)
1535                 __field(int, status)
1536         ),
1537         TP_fast_assign(
1538                 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1539                 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1540                 __entry->si_id = stp->si_opaque.so_id;
1541                 __entry->si_generation = stp->si_generation;
1542                 __entry->status = task->tk_status;
1543         ),
1544         TP_printk("client %08x:%08x stateid %08x:%08x status=%d",
1545                 __entry->cl_boot, __entry->cl_id, __entry->si_id,
1546                 __entry->si_generation, __entry->status
1547         )
1548 );
1549
1550 #define DEFINE_NFSD_CB_DONE_EVENT(name)                 \
1551 DEFINE_EVENT(nfsd_cb_done_class, name,                  \
1552         TP_PROTO(                                       \
1553                 const stateid_t *stp,                   \
1554                 const struct rpc_task *task             \
1555         ),                                              \
1556         TP_ARGS(stp, task))
1557
1558 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done);
1559 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done);
1560 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done);
1561 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done);
1562
1563 TRACE_EVENT(nfsd_cb_recall_any_done,
1564         TP_PROTO(
1565                 const struct nfsd4_callback *cb,
1566                 const struct rpc_task *task
1567         ),
1568         TP_ARGS(cb, task),
1569         TP_STRUCT__entry(
1570                 __field(u32, cl_boot)
1571                 __field(u32, cl_id)
1572                 __field(int, status)
1573         ),
1574         TP_fast_assign(
1575                 __entry->status = task->tk_status;
1576                 __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot;
1577                 __entry->cl_id = cb->cb_clp->cl_clientid.cl_id;
1578         ),
1579         TP_printk("client %08x:%08x status=%d",
1580                 __entry->cl_boot, __entry->cl_id, __entry->status
1581         )
1582 );
1583
1584 #endif /* _NFSD_TRACE_H */
1585
1586 #undef TRACE_INCLUDE_PATH
1587 #define TRACE_INCLUDE_PATH .
1588 #define TRACE_INCLUDE_FILE trace
1589 #include <trace/define_trace.h>