trace.h

   1/* SPDX-License-Identifier: GPL-2.0 */
   2/*
   3 * Copyright (c) 2014 Christoph Hellwig.
   4 */
   5#undef TRACE_SYSTEM
   6#define TRACE_SYSTEM nfsd
   7
   8#if !defined(_NFSD_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
   9#define _NFSD_TRACE_H
  10
  11#include <linux/tracepoint.h>
  12#include <linux/sunrpc/clnt.h>
  13#include <linux/sunrpc/xprt.h>
  14#include <trace/misc/fs.h>
  15#include <trace/misc/nfs.h>
  16#include <trace/misc/sunrpc.h>
  17
  18#include "export.h"
  19#include "nfsfh.h"
  20#include "xdr4.h"
  21
  22#define NFSD_TRACE_PROC_CALL_FIELDS(r) \
  23		__field(unsigned int, netns_ino) \
  24		__field(u32, xid) \
  25		__sockaddr(server, (r)->rq_xprt->xpt_locallen) \
  26		__sockaddr(client, (r)->rq_xprt->xpt_remotelen)
  27
  28#define NFSD_TRACE_PROC_CALL_ASSIGNMENTS(r) \
  29		do { \
  30			struct svc_xprt *xprt = (r)->rq_xprt; \
  31			__entry->netns_ino = SVC_NET(r)->ns.inum; \
  32			__entry->xid = be32_to_cpu((r)->rq_xid); \
  33			__assign_sockaddr(server, &xprt->xpt_local, \
  34					  xprt->xpt_locallen); \
  35			__assign_sockaddr(client, &xprt->xpt_remote, \
  36					  xprt->xpt_remotelen); \
  37		} while (0)
  38
  39#define NFSD_TRACE_PROC_RES_FIELDS(r) \
  40		__field(unsigned int, netns_ino) \
  41		__field(u32, xid) \
  42		__field(unsigned long, status) \
  43		__sockaddr(server, (r)->rq_xprt->xpt_locallen) \
  44		__sockaddr(client, (r)->rq_xprt->xpt_remotelen)
  45
  46#define NFSD_TRACE_PROC_RES_ASSIGNMENTS(r, error) \
  47		do { \
  48			struct svc_xprt *xprt = (r)->rq_xprt; \
  49			__entry->netns_ino = SVC_NET(r)->ns.inum; \
  50			__entry->xid = be32_to_cpu((r)->rq_xid); \
  51			__entry->status = be32_to_cpu(error); \
  52			__assign_sockaddr(server, &xprt->xpt_local, \
  53					  xprt->xpt_locallen); \
  54			__assign_sockaddr(client, &xprt->xpt_remote, \
  55					  xprt->xpt_remotelen); \
  56		} while (0);
  57
  58DECLARE_EVENT_CLASS(nfsd_xdr_err_class,
  59	TP_PROTO(
  60		const struct svc_rqst *rqstp
  61	),
  62	TP_ARGS(rqstp),
  63	TP_STRUCT__entry(
  64		__field(unsigned int, netns_ino)
  65		__field(u32, xid)
  66		__field(u32, vers)
  67		__field(u32, proc)
  68		__sockaddr(server, rqstp->rq_xprt->xpt_locallen)
  69		__sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
  70	),
  71	TP_fast_assign(
  72		const struct svc_xprt *xprt = rqstp->rq_xprt;
  73
  74		__entry->netns_ino = xprt->xpt_net->ns.inum;
  75		__entry->xid = be32_to_cpu(rqstp->rq_xid);
  76		__entry->vers = rqstp->rq_vers;
  77		__entry->proc = rqstp->rq_proc;
  78		__assign_sockaddr(server, &xprt->xpt_local, xprt->xpt_locallen);
  79		__assign_sockaddr(client, &xprt->xpt_remote, xprt->xpt_remotelen);
  80	),
  81	TP_printk("xid=0x%08x vers=%u proc=%u",
  82		__entry->xid, __entry->vers, __entry->proc
  83	)
  84);
  85
  86#define DEFINE_NFSD_XDR_ERR_EVENT(name) \
  87DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \
  88	TP_PROTO(const struct svc_rqst *rqstp), \
  89	TP_ARGS(rqstp))
  90
  91DEFINE_NFSD_XDR_ERR_EVENT(garbage_args);
  92DEFINE_NFSD_XDR_ERR_EVENT(cant_encode);
  93
  94#define show_nfsd_may_flags(x)						\
  95	__print_flags(x, "|",						\
  96		{ NFSD_MAY_EXEC,		"EXEC" },		\
  97		{ NFSD_MAY_WRITE,		"WRITE" },		\
  98		{ NFSD_MAY_READ,		"READ" },		\
  99		{ NFSD_MAY_SATTR,		"SATTR" },		\
 100		{ NFSD_MAY_TRUNC,		"TRUNC" },		\
 101		{ NFSD_MAY_NLM,			"NLM" },		\
 102		{ NFSD_MAY_OWNER_OVERRIDE,	"OWNER_OVERRIDE" },	\
 103		{ NFSD_MAY_LOCAL_ACCESS,	"LOCAL_ACCESS" },	\
 104		{ NFSD_MAY_BYPASS_GSS_ON_ROOT,	"BYPASS_GSS_ON_ROOT" },	\
 105		{ NFSD_MAY_NOT_BREAK_LEASE,	"NOT_BREAK_LEASE" },	\
 106		{ NFSD_MAY_BYPASS_GSS,		"BYPASS_GSS" },		\
 107		{ NFSD_MAY_READ_IF_EXEC,	"READ_IF_EXEC" },	\
 108		{ NFSD_MAY_64BIT_COOKIE,	"64BIT_COOKIE" },	\
 109		{ NFSD_MAY_LOCALIO,		"LOCALIO" })
 110
 111TRACE_EVENT(nfsd_compound,
 112	TP_PROTO(
 113		const struct svc_rqst *rqst,
 114		const char *tag,
 115		u32 taglen,
 116		u32 opcnt
 117	),
 118	TP_ARGS(rqst, tag, taglen, opcnt),
 119	TP_STRUCT__entry(
 120		__field(u32, xid)
 121		__field(u32, opcnt)
 122		__string_len(tag, tag, taglen)
 123	),
 124	TP_fast_assign(
 125		__entry->xid = be32_to_cpu(rqst->rq_xid);
 126		__entry->opcnt = opcnt;
 127		__assign_str(tag);
 128	),
 129	TP_printk("xid=0x%08x opcnt=%u tag=%s",
 130		__entry->xid, __entry->opcnt, __get_str(tag)
 131	)
 132)
 133
 134TRACE_EVENT(nfsd_compound_status,
 135	TP_PROTO(u32 args_opcnt,
 136		 u32 resp_opcnt,
 137		 __be32 status,
 138		 const char *name),
 139	TP_ARGS(args_opcnt, resp_opcnt, status, name),
 140	TP_STRUCT__entry(
 141		__field(u32, args_opcnt)
 142		__field(u32, resp_opcnt)
 143		__field(int, status)
 144		__string(name, name)
 145	),
 146	TP_fast_assign(
 147		__entry->args_opcnt = args_opcnt;
 148		__entry->resp_opcnt = resp_opcnt;
 149		__entry->status = be32_to_cpu(status);
 150		__assign_str(name);
 151	),
 152	TP_printk("op=%u/%u %s status=%d",
 153		__entry->resp_opcnt, __entry->args_opcnt,
 154		__get_str(name), __entry->status)
 155)
 156
 157TRACE_EVENT(nfsd_compound_decode_err,
 158	TP_PROTO(
 159		const struct svc_rqst *rqstp,
 160		u32 args_opcnt,
 161		u32 resp_opcnt,
 162		u32 opnum,
 163		__be32 status
 164	),
 165	TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status),
 166	TP_STRUCT__entry(
 167		NFSD_TRACE_PROC_RES_FIELDS(rqstp)
 168
 169		__field(u32, args_opcnt)
 170		__field(u32, resp_opcnt)
 171		__field(u32, opnum)
 172	),
 173	TP_fast_assign(
 174		NFSD_TRACE_PROC_RES_ASSIGNMENTS(rqstp, status)
 175
 176		__entry->args_opcnt = args_opcnt;
 177		__entry->resp_opcnt = resp_opcnt;
 178		__entry->opnum = opnum;
 179	),
 180	TP_printk("op=%u/%u opnum=%u status=%lu",
 181		__entry->resp_opcnt, __entry->args_opcnt,
 182		__entry->opnum, __entry->status)
 183);
 184
 185DECLARE_EVENT_CLASS(nfsd_compound_err_class,
 186	TP_PROTO(
 187		const struct svc_rqst *rqstp,
 188		u32 opnum,
 189		__be32 status
 190	),
 191	TP_ARGS(rqstp, opnum, status),
 192	TP_STRUCT__entry(
 193		NFSD_TRACE_PROC_RES_FIELDS(rqstp)
 194
 195		__field(u32, opnum)
 196	),
 197	TP_fast_assign(
 198		NFSD_TRACE_PROC_RES_ASSIGNMENTS(rqstp, status)
 199
 200		__entry->opnum = opnum;
 201	),
 202	TP_printk("opnum=%u status=%lu",
 203		__entry->opnum, __entry->status)
 204);
 205
 206#define DEFINE_NFSD_COMPOUND_ERR_EVENT(name)				\
 207DEFINE_EVENT(nfsd_compound_err_class, nfsd_compound_##name##_err,	\
 208	TP_PROTO(							\
 209		const struct svc_rqst *rqstp,				\
 210		u32 opnum,						\
 211		__be32 status						\
 212	),								\
 213	TP_ARGS(rqstp, opnum, status))
 214
 215DEFINE_NFSD_COMPOUND_ERR_EVENT(op);
 216DEFINE_NFSD_COMPOUND_ERR_EVENT(encode);
 217
 218#define show_fs_file_type(x) \
 219	__print_symbolic(x, \
 220		{ S_IFLNK,		"LNK" }, \
 221		{ S_IFREG,		"REG" }, \
 222		{ S_IFDIR,		"DIR" }, \
 223		{ S_IFCHR,		"CHR" }, \
 224		{ S_IFBLK,		"BLK" }, \
 225		{ S_IFIFO,		"FIFO" }, \
 226		{ S_IFSOCK,		"SOCK" })
 227
 228TRACE_EVENT_CONDITION(nfsd_fh_verify,
 229	TP_PROTO(
 230		const struct svc_rqst *rqstp,
 231		const struct svc_fh *fhp,
 232		umode_t type,
 233		int access
 234	),
 235	TP_ARGS(rqstp, fhp, type, access),
 236	TP_CONDITION(rqstp != NULL),
 237	TP_STRUCT__entry(
 238		__field(unsigned int, netns_ino)
 239		__sockaddr(server, rqstp->rq_xprt->xpt_remotelen)
 240		__sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
 241		__field(u32, xid)
 242		__field(u32, fh_hash)
 243		__field(const void *, inode)
 244		__field(unsigned long, type)
 245		__field(unsigned long, access)
 246	),
 247	TP_fast_assign(
 248		__entry->netns_ino = SVC_NET(rqstp)->ns.inum;
 249		__assign_sockaddr(server, &rqstp->rq_xprt->xpt_local,
 250		       rqstp->rq_xprt->xpt_locallen);
 251		__assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote,
 252				  rqstp->rq_xprt->xpt_remotelen);
 253		__entry->xid = be32_to_cpu(rqstp->rq_xid);
 254		__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
 255		__entry->inode = d_inode(fhp->fh_dentry);
 256		__entry->type = type;
 257		__entry->access = access;
 258	),
 259	TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s",
 260		__entry->xid, __entry->fh_hash,
 261		show_fs_file_type(__entry->type),
 262		show_nfsd_may_flags(__entry->access)
 263	)
 264);
 265
 266TRACE_EVENT_CONDITION(nfsd_fh_verify_err,
 267	TP_PROTO(
 268		const struct svc_rqst *rqstp,
 269		const struct svc_fh *fhp,
 270		umode_t type,
 271		int access,
 272		__be32 error
 273	),
 274	TP_ARGS(rqstp, fhp, type, access, error),
 275	TP_CONDITION(rqstp != NULL && error),
 276	TP_STRUCT__entry(
 277		__field(unsigned int, netns_ino)
 278		__sockaddr(server, rqstp->rq_xprt->xpt_remotelen)
 279		__sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
 280		__field(u32, xid)
 281		__field(u32, fh_hash)
 282		__field(const void *, inode)
 283		__field(unsigned long, type)
 284		__field(unsigned long, access)
 285		__field(int, error)
 286	),
 287	TP_fast_assign(
 288		__entry->netns_ino = SVC_NET(rqstp)->ns.inum;
 289		__assign_sockaddr(server, &rqstp->rq_xprt->xpt_local,
 290		       rqstp->rq_xprt->xpt_locallen);
 291		__assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote,
 292				  rqstp->rq_xprt->xpt_remotelen);
 293		__entry->xid = be32_to_cpu(rqstp->rq_xid);
 294		__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
 295		if (fhp->fh_dentry)
 296			__entry->inode = d_inode(fhp->fh_dentry);
 297		else
 298			__entry->inode = NULL;
 299		__entry->type = type;
 300		__entry->access = access;
 301		__entry->error = be32_to_cpu(error);
 302	),
 303	TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s error=%d",
 304		__entry->xid, __entry->fh_hash,
 305		show_fs_file_type(__entry->type),
 306		show_nfsd_may_flags(__entry->access),
 307		__entry->error
 308	)
 309);
 310
 311DECLARE_EVENT_CLASS(nfsd_fh_err_class,
 312	TP_PROTO(struct svc_rqst *rqstp,
 313		 struct svc_fh	*fhp,
 314		 int		status),
 315	TP_ARGS(rqstp, fhp, status),
 316	TP_STRUCT__entry(
 317		__field(u32, xid)
 318		__field(u32, fh_hash)
 319		__field(int, status)
 320	),
 321	TP_fast_assign(
 322		__entry->xid = be32_to_cpu(rqstp->rq_xid);
 323		__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
 324		__entry->status = status;
 325	),
 326	TP_printk("xid=0x%08x fh_hash=0x%08x status=%d",
 327		  __entry->xid, __entry->fh_hash,
 328		  __entry->status)
 329)
 330
 331#define DEFINE_NFSD_FH_ERR_EVENT(name)			\
 332DEFINE_EVENT_CONDITION(nfsd_fh_err_class, nfsd_##name,	\
 333	TP_PROTO(struct svc_rqst *rqstp,		\
 334		 struct svc_fh	*fhp,			\
 335		 int		status),		\
 336	TP_ARGS(rqstp, fhp, status),			\
 337	TP_CONDITION(rqstp != NULL))
 338
 339DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport);
 340DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle);
 341
 342TRACE_EVENT(nfsd_exp_find_key,
 343	TP_PROTO(const struct svc_expkey *key,
 344		 int status),
 345	TP_ARGS(key, status),
 346	TP_STRUCT__entry(
 347		__field(u8, fsidtype)
 348		__array(u32, fsid, 6)
 349		__string(auth_domain, key->ek_client->name)
 350		__field(int, status)
 351	),
 352	TP_fast_assign(
 353		__entry->fsidtype = key->ek_fsidtype;
 354		memcpy(__entry->fsid, key->ek_fsid, 4*6);
 355		__assign_str(auth_domain);
 356		__entry->status = status;
 357	),
 358	TP_printk("fsid=%x::%s domain=%s status=%d",
 359		__entry->fsidtype,
 360		__print_array(__entry->fsid, 6, 4),
 361		__get_str(auth_domain),
 362		__entry->status
 363	)
 364);
 365
 366TRACE_EVENT(nfsd_expkey_update,
 367	TP_PROTO(const struct svc_expkey *key, const char *exp_path),
 368	TP_ARGS(key, exp_path),
 369	TP_STRUCT__entry(
 370		__field(u8, fsidtype)
 371		__array(u32, fsid, 6)
 372		__string(auth_domain, key->ek_client->name)
 373		__string(path, exp_path)
 374		__field(bool, cache)
 375	),
 376	TP_fast_assign(
 377		__entry->fsidtype = key->ek_fsidtype;
 378		memcpy(__entry->fsid, key->ek_fsid, 4*6);
 379		__assign_str(auth_domain);
 380		__assign_str(path);
 381		__entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags);
 382	),
 383	TP_printk("fsid=%x::%s domain=%s path=%s cache=%s",
 384		__entry->fsidtype,
 385		__print_array(__entry->fsid, 6, 4),
 386		__get_str(auth_domain),
 387		__get_str(path),
 388		__entry->cache ? "pos" : "neg"
 389	)
 390);
 391
 392TRACE_EVENT(nfsd_exp_get_by_name,
 393	TP_PROTO(const struct svc_export *key,
 394		 int status),
 395	TP_ARGS(key, status),
 396	TP_STRUCT__entry(
 397		__string(path, key->ex_path.dentry->d_name.name)
 398		__string(auth_domain, key->ex_client->name)
 399		__field(int, status)
 400	),
 401	TP_fast_assign(
 402		__assign_str(path);
 403		__assign_str(auth_domain);
 404		__entry->status = status;
 405	),
 406	TP_printk("path=%s domain=%s status=%d",
 407		__get_str(path),
 408		__get_str(auth_domain),
 409		__entry->status
 410	)
 411);
 412
 413TRACE_EVENT(nfsd_export_update,
 414	TP_PROTO(const struct svc_export *key),
 415	TP_ARGS(key),
 416	TP_STRUCT__entry(
 417		__string(path, key->ex_path.dentry->d_name.name)
 418		__string(auth_domain, key->ex_client->name)
 419		__field(bool, cache)
 420	),
 421	TP_fast_assign(
 422		__assign_str(path);
 423		__assign_str(auth_domain);
 424		__entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags);
 425	),
 426	TP_printk("path=%s domain=%s cache=%s",
 427		__get_str(path),
 428		__get_str(auth_domain),
 429		__entry->cache ? "pos" : "neg"
 430	)
 431);
 432
 433DECLARE_EVENT_CLASS(nfsd_io_class,
 434	TP_PROTO(struct svc_rqst *rqstp,
 435		 struct svc_fh	*fhp,
 436		 u64		offset,
 437		 u32		len),
 438	TP_ARGS(rqstp, fhp, offset, len),
 439	TP_STRUCT__entry(
 440		__field(u32, xid)
 441		__field(u32, fh_hash)
 442		__field(u64, offset)
 443		__field(u32, len)
 444	),
 445	TP_fast_assign(
 446		__entry->xid = be32_to_cpu(rqstp->rq_xid);
 447		__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
 448		__entry->offset = offset;
 449		__entry->len = len;
 450	),
 451	TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u",
 452		  __entry->xid, __entry->fh_hash,
 453		  __entry->offset, __entry->len)
 454)
 455
 456#define DEFINE_NFSD_IO_EVENT(name)		\
 457DEFINE_EVENT(nfsd_io_class, nfsd_##name,	\
 458	TP_PROTO(struct svc_rqst *rqstp,	\
 459		 struct svc_fh	*fhp,		\
 460		 u64		offset,		\
 461		 u32		len),		\
 462	TP_ARGS(rqstp, fhp, offset, len))
 463
 464DEFINE_NFSD_IO_EVENT(read_start);
 465DEFINE_NFSD_IO_EVENT(read_splice);
 466DEFINE_NFSD_IO_EVENT(read_vector);
 467DEFINE_NFSD_IO_EVENT(read_direct);
 468DEFINE_NFSD_IO_EVENT(read_io_done);
 469DEFINE_NFSD_IO_EVENT(read_done);
 470DEFINE_NFSD_IO_EVENT(write_start);
 471DEFINE_NFSD_IO_EVENT(write_opened);
 472DEFINE_NFSD_IO_EVENT(write_direct);
 473DEFINE_NFSD_IO_EVENT(write_vector);
 474DEFINE_NFSD_IO_EVENT(write_io_done);
 475DEFINE_NFSD_IO_EVENT(write_done);
 476DEFINE_NFSD_IO_EVENT(commit_start);
 477DEFINE_NFSD_IO_EVENT(commit_done);
 478
 479DECLARE_EVENT_CLASS(nfsd_err_class,
 480	TP_PROTO(struct svc_rqst *rqstp,
 481		 struct svc_fh	*fhp,
 482		 loff_t		offset,
 483		 int		status),
 484	TP_ARGS(rqstp, fhp, offset, status),
 485	TP_STRUCT__entry(
 486		__field(u32, xid)
 487		__field(u32, fh_hash)
 488		__field(loff_t, offset)
 489		__field(int, status)
 490	),
 491	TP_fast_assign(
 492		__entry->xid = be32_to_cpu(rqstp->rq_xid);
 493		__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
 494		__entry->offset = offset;
 495		__entry->status = status;
 496	),
 497	TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d",
 498		  __entry->xid, __entry->fh_hash,
 499		  __entry->offset, __entry->status)
 500)
 501
 502#define DEFINE_NFSD_ERR_EVENT(name)		\
 503DEFINE_EVENT(nfsd_err_class, nfsd_##name,	\
 504	TP_PROTO(struct svc_rqst *rqstp,	\
 505		 struct svc_fh	*fhp,		\
 506		 loff_t		offset,		\
 507		 int		len),		\
 508	TP_ARGS(rqstp, fhp, offset, len))
 509
 510DEFINE_NFSD_ERR_EVENT(read_err);
 511DEFINE_NFSD_ERR_EVENT(write_err);
 512
 513TRACE_EVENT(nfsd_dirent,
 514	TP_PROTO(struct svc_fh *fhp,
 515		 u64 ino,
 516		 const char *name,
 517		 int namlen),
 518	TP_ARGS(fhp, ino, name, namlen),
 519	TP_STRUCT__entry(
 520		__field(u32, fh_hash)
 521		__field(u64, ino)
 522		__string_len(name, name, namlen)
 523	),
 524	TP_fast_assign(
 525		__entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0;
 526		__entry->ino = ino;
 527		__assign_str(name);
 528	),
 529	TP_printk("fh_hash=0x%08x ino=%llu name=%s",
 530		__entry->fh_hash, __entry->ino, __get_str(name)
 531	)
 532)
 533
 534DECLARE_EVENT_CLASS(nfsd_copy_err_class,
 535	TP_PROTO(struct svc_rqst *rqstp,
 536		 struct svc_fh	*src_fhp,
 537		 loff_t		src_offset,
 538		 struct svc_fh	*dst_fhp,
 539		 loff_t		dst_offset,
 540		 u64		count,
 541		 int		status),
 542	TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status),
 543	TP_STRUCT__entry(
 544		__field(u32, xid)
 545		__field(u32, src_fh_hash)
 546		__field(loff_t, src_offset)
 547		__field(u32, dst_fh_hash)
 548		__field(loff_t, dst_offset)
 549		__field(u64, count)
 550		__field(int, status)
 551	),
 552	TP_fast_assign(
 553		__entry->xid = be32_to_cpu(rqstp->rq_xid);
 554		__entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle);
 555		__entry->src_offset = src_offset;
 556		__entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle);
 557		__entry->dst_offset = dst_offset;
 558		__entry->count = count;
 559		__entry->status = status;
 560	),
 561	TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld "
 562			"dst_fh_hash=0x%08x dst_offset=%lld "
 563			"count=%llu status=%d",
 564		  __entry->xid, __entry->src_fh_hash, __entry->src_offset,
 565		  __entry->dst_fh_hash, __entry->dst_offset,
 566		  (unsigned long long)__entry->count,
 567		  __entry->status)
 568)
 569
 570#define DEFINE_NFSD_COPY_ERR_EVENT(name)		\
 571DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name,		\
 572	TP_PROTO(struct svc_rqst	*rqstp,		\
 573		 struct svc_fh		*src_fhp,	\
 574		 loff_t			src_offset,	\
 575		 struct svc_fh		*dst_fhp,	\
 576		 loff_t			dst_offset,	\
 577		 u64			count,		\
 578		 int			status),	\
 579	TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \
 580		count, status))
 581
 582DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err);
 583
 584#include "state.h"
 585#include "filecache.h"
 586#include "vfs.h"
 587
 588TRACE_EVENT(nfsd_delegret_wakeup,
 589	TP_PROTO(
 590		const struct svc_rqst *rqstp,
 591		const struct inode *inode,
 592		long timeo
 593	),
 594	TP_ARGS(rqstp, inode, timeo),
 595	TP_STRUCT__entry(
 596		__field(u32, xid)
 597		__field(const void *, inode)
 598		__field(long, timeo)
 599	),
 600	TP_fast_assign(
 601		__entry->xid = be32_to_cpu(rqstp->rq_xid);
 602		__entry->inode = inode;
 603		__entry->timeo = timeo;
 604	),
 605	TP_printk("xid=0x%08x inode=%p%s",
 606		  __entry->xid, __entry->inode,
 607		  __entry->timeo == 0 ? " (timed out)" : ""
 608	)
 609);
 610
 611DECLARE_EVENT_CLASS(nfsd_stateid_class,
 612	TP_PROTO(stateid_t *stp),
 613	TP_ARGS(stp),
 614	TP_STRUCT__entry(
 615		__field(u32, cl_boot)
 616		__field(u32, cl_id)
 617		__field(u32, si_id)
 618		__field(u32, si_generation)
 619	),
 620	TP_fast_assign(
 621		__entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
 622		__entry->cl_id = stp->si_opaque.so_clid.cl_id;
 623		__entry->si_id = stp->si_opaque.so_id;
 624		__entry->si_generation = stp->si_generation;
 625	),
 626	TP_printk("client %08x:%08x stateid %08x:%08x",
 627		__entry->cl_boot,
 628		__entry->cl_id,
 629		__entry->si_id,
 630		__entry->si_generation)
 631)
 632
 633#define DEFINE_STATEID_EVENT(name) \
 634DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \
 635	TP_PROTO(stateid_t *stp), \
 636	TP_ARGS(stp))
 637
 638DEFINE_STATEID_EVENT(layoutstate_alloc);
 639DEFINE_STATEID_EVENT(layoutstate_unhash);
 640DEFINE_STATEID_EVENT(layoutstate_free);
 641DEFINE_STATEID_EVENT(layout_get_lookup_fail);
 642DEFINE_STATEID_EVENT(layout_commit_lookup_fail);
 643DEFINE_STATEID_EVENT(layout_return_lookup_fail);
 644DEFINE_STATEID_EVENT(layout_recall);
 645DEFINE_STATEID_EVENT(layout_recall_done);
 646DEFINE_STATEID_EVENT(layout_recall_fail);
 647DEFINE_STATEID_EVENT(layout_recall_release);
 648
 649DEFINE_STATEID_EVENT(open);
 650DEFINE_STATEID_EVENT(deleg_read);
 651DEFINE_STATEID_EVENT(deleg_write);
 652DEFINE_STATEID_EVENT(deleg_return);
 653
 654DECLARE_EVENT_CLASS(nfsd_stateseqid_class,
 655	TP_PROTO(u32 seqid, const stateid_t *stp),
 656	TP_ARGS(seqid, stp),
 657	TP_STRUCT__entry(
 658		__field(u32, seqid)
 659		__field(u32, cl_boot)
 660		__field(u32, cl_id)
 661		__field(u32, si_id)
 662		__field(u32, si_generation)
 663	),
 664	TP_fast_assign(
 665		__entry->seqid = seqid;
 666		__entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
 667		__entry->cl_id = stp->si_opaque.so_clid.cl_id;
 668		__entry->si_id = stp->si_opaque.so_id;
 669		__entry->si_generation = stp->si_generation;
 670	),
 671	TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x",
 672		__entry->seqid, __entry->cl_boot, __entry->cl_id,
 673		__entry->si_id, __entry->si_generation)
 674)
 675
 676#define DEFINE_STATESEQID_EVENT(name) \
 677DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \
 678	TP_PROTO(u32 seqid, const stateid_t *stp), \
 679	TP_ARGS(seqid, stp))
 680
 681DEFINE_STATESEQID_EVENT(preprocess);
 682DEFINE_STATESEQID_EVENT(open_confirm);
 683
 684#define show_stid_type(x)						\
 685	__print_flags(x, "|",						\
 686		{ SC_TYPE_OPEN,		"OPEN" },		\
 687		{ SC_TYPE_LOCK,		"LOCK" },		\
 688		{ SC_TYPE_DELEG,		"DELEG" },		\
 689		{ SC_TYPE_LAYOUT,		"LAYOUT" })
 690
 691#define show_stid_status(x)						\
 692	__print_flags(x, "|",						\
 693		{ SC_STATUS_CLOSED,		"CLOSED" },		\
 694		{ SC_STATUS_REVOKED,		"REVOKED" },		\
 695		{ SC_STATUS_ADMIN_REVOKED,	"ADMIN_REVOKED" })
 696
 697DECLARE_EVENT_CLASS(nfsd_stid_class,
 698	TP_PROTO(
 699		const struct nfs4_stid *stid
 700	),
 701	TP_ARGS(stid),
 702	TP_STRUCT__entry(
 703		__field(unsigned long, sc_type)
 704		__field(unsigned long, sc_status)
 705		__field(int, sc_count)
 706		__field(u32, cl_boot)
 707		__field(u32, cl_id)
 708		__field(u32, si_id)
 709		__field(u32, si_generation)
 710	),
 711	TP_fast_assign(
 712		const stateid_t *stp = &stid->sc_stateid;
 713
 714		__entry->sc_type = stid->sc_type;
 715		__entry->sc_status = stid->sc_status;
 716		__entry->sc_count = refcount_read(&stid->sc_count);
 717		__entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
 718		__entry->cl_id = stp->si_opaque.so_clid.cl_id;
 719		__entry->si_id = stp->si_opaque.so_id;
 720		__entry->si_generation = stp->si_generation;
 721	),
 722	TP_printk("client %08x:%08x stateid %08x:%08x ref=%d type=%s state=%s",
 723		__entry->cl_boot, __entry->cl_id,
 724		__entry->si_id, __entry->si_generation,
 725		__entry->sc_count, show_stid_type(__entry->sc_type),
 726		show_stid_status(__entry->sc_status)
 727	)
 728);
 729
 730#define DEFINE_STID_EVENT(name)					\
 731DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name,			\
 732	TP_PROTO(const struct nfs4_stid *stid),			\
 733	TP_ARGS(stid))
 734
 735DEFINE_STID_EVENT(revoke);
 736
 737TRACE_EVENT(nfsd_stateowner_replay,
 738	TP_PROTO(
 739		u32 opnum,
 740		const struct nfs4_replay *rp
 741	),
 742	TP_ARGS(opnum, rp),
 743	TP_STRUCT__entry(
 744		__field(unsigned long, status)
 745		__field(u32, opnum)
 746	),
 747	TP_fast_assign(
 748		__entry->status = be32_to_cpu(rp->rp_status);
 749		__entry->opnum = opnum;
 750	),
 751	TP_printk("opnum=%u status=%lu",
 752		__entry->opnum, __entry->status)
 753);
 754
 755TRACE_EVENT_CONDITION(nfsd_seq4_status,
 756	TP_PROTO(
 757		const struct svc_rqst *rqstp,
 758		const struct nfsd4_sequence *sequence
 759	),
 760	TP_ARGS(rqstp, sequence),
 761	TP_CONDITION(sequence->status_flags),
 762	TP_STRUCT__entry(
 763		__field(unsigned int, netns_ino)
 764		__field(u32, xid)
 765		__field(u32, cl_boot)
 766		__field(u32, cl_id)
 767		__field(u32, seqno)
 768		__field(u32, reserved)
 769		__field(unsigned long, status_flags)
 770	),
 771	TP_fast_assign(
 772		const struct nfsd4_sessionid *sid =
 773			(struct nfsd4_sessionid *)&sequence->sessionid;
 774
 775		__entry->netns_ino = SVC_NET(rqstp)->ns.inum;
 776		__entry->xid = be32_to_cpu(rqstp->rq_xid);
 777		__entry->cl_boot = sid->clientid.cl_boot;
 778		__entry->cl_id = sid->clientid.cl_id;
 779		__entry->seqno = sid->sequence;
 780		__entry->reserved = sid->reserved;
 781		__entry->status_flags = sequence->status_flags;
 782	),
 783	TP_printk("xid=0x%08x sessionid=%08x:%08x:%08x:%08x status_flags=%s",
 784		__entry->xid, __entry->cl_boot, __entry->cl_id,
 785		__entry->seqno, __entry->reserved,
 786		show_nfs4_seq4_status(__entry->status_flags)
 787	)
 788);
 789
 790DECLARE_EVENT_CLASS(nfsd_cs_slot_class,
 791	TP_PROTO(
 792		const struct nfs4_client *clp,
 793		const struct nfsd4_create_session *cs
 794	),
 795	TP_ARGS(clp, cs),
 796	TP_STRUCT__entry(
 797		__field(u32, seqid)
 798		__field(u32, slot_seqid)
 799		__field(u32, cl_boot)
 800		__field(u32, cl_id)
 801		__sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
 802	),
 803	TP_fast_assign(
 804		const struct nfsd4_clid_slot *slot = &clp->cl_cs_slot;
 805
 806		__entry->cl_boot = clp->cl_clientid.cl_boot;
 807		__entry->cl_id = clp->cl_clientid.cl_id;
 808		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
 809				  clp->cl_cb_conn.cb_addrlen);
 810		__entry->seqid = cs->seqid;
 811		__entry->slot_seqid = slot->sl_seqid;
 812	),
 813	TP_printk("addr=%pISpc client %08x:%08x seqid=%u slot_seqid=%u",
 814		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
 815		__entry->seqid, __entry->slot_seqid
 816	)
 817);
 818
 819#define DEFINE_CS_SLOT_EVENT(name) \
 820DEFINE_EVENT(nfsd_cs_slot_class, nfsd_##name, \
 821	TP_PROTO( \
 822		const struct nfs4_client *clp, \
 823		const struct nfsd4_create_session *cs \
 824	), \
 825	TP_ARGS(clp, cs))
 826
 827DEFINE_CS_SLOT_EVENT(slot_seqid_conf);
 828DEFINE_CS_SLOT_EVENT(slot_seqid_unconf);
 829
 830#define show_nfs_slot_flags(val)					\
 831	__print_flags(val, "|",						\
 832		{ NFSD4_SLOT_INUSE,		"INUSE" },		\
 833		{ NFSD4_SLOT_CACHETHIS,		"CACHETHIS" },		\
 834		{ NFSD4_SLOT_INITIALIZED,	"INITIALIZED" },	\
 835		{ NFSD4_SLOT_CACHED,		"CACHED" },		\
 836		{ NFSD4_SLOT_REUSED,		"REUSED" })
 837
 838TRACE_EVENT(nfsd_slot_seqid_sequence,
 839	TP_PROTO(
 840		const struct nfs4_client *clp,
 841		const struct nfsd4_sequence *seq,
 842		const struct nfsd4_slot *slot
 843	),
 844	TP_ARGS(clp, seq, slot),
 845	TP_STRUCT__entry(
 846		__field(u32, seqid)
 847		__field(u32, slot_seqid)
 848		__field(u32, slot_index)
 849		__field(unsigned long, slot_flags)
 850		__field(u32, cl_boot)
 851		__field(u32, cl_id)
 852		__sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
 853	),
 854	TP_fast_assign(
 855		__entry->cl_boot = clp->cl_clientid.cl_boot;
 856		__entry->cl_id = clp->cl_clientid.cl_id;
 857		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
 858				  clp->cl_cb_conn.cb_addrlen);
 859		__entry->seqid = seq->seqid;
 860		__entry->slot_seqid = slot->sl_seqid;
 861		__entry->slot_index = seq->slotid;
 862		__entry->slot_flags = slot->sl_flags;
 863	),
 864	TP_printk("addr=%pISpc client %08x:%08x idx=%u seqid=%u slot_seqid=%u flags=%s",
 865		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
 866		__entry->slot_index, __entry->seqid, __entry->slot_seqid,
 867		show_nfs_slot_flags(__entry->slot_flags)
 868	)
 869);
 870
 871DECLARE_EVENT_CLASS(nfsd_clientid_class,
 872	TP_PROTO(const clientid_t *clid),
 873	TP_ARGS(clid),
 874	TP_STRUCT__entry(
 875		__field(u32, cl_boot)
 876		__field(u32, cl_id)
 877	),
 878	TP_fast_assign(
 879		__entry->cl_boot = clid->cl_boot;
 880		__entry->cl_id = clid->cl_id;
 881	),
 882	TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
 883)
 884
 885#define DEFINE_CLIENTID_EVENT(name) \
 886DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \
 887	TP_PROTO(const clientid_t *clid), \
 888	TP_ARGS(clid))
 889
 890DEFINE_CLIENTID_EVENT(expire_unconf);
 891DEFINE_CLIENTID_EVENT(reclaim_complete);
 892DEFINE_CLIENTID_EVENT(confirmed);
 893DEFINE_CLIENTID_EVENT(destroyed);
 894DEFINE_CLIENTID_EVENT(admin_expired);
 895DEFINE_CLIENTID_EVENT(replaced);
 896DEFINE_CLIENTID_EVENT(purged);
 897DEFINE_CLIENTID_EVENT(renew);
 898DEFINE_CLIENTID_EVENT(stale);
 899
 900TRACE_EVENT(nfsd_mark_client_expired,
 901	TP_PROTO(
 902		const struct nfs4_client *clp,
 903		int cl_rpc_users
 904	),
 905	TP_ARGS(clp, cl_rpc_users),
 906	TP_STRUCT__entry(
 907		__field(int, cl_rpc_users)
 908		__field(u32, cl_boot)
 909		__field(u32, cl_id)
 910		__sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
 911	),
 912	TP_fast_assign(
 913		__entry->cl_rpc_users = cl_rpc_users;
 914		__entry->cl_boot = clp->cl_clientid.cl_boot;
 915		__entry->cl_id = clp->cl_clientid.cl_id;
 916		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
 917				  clp->cl_cb_conn.cb_addrlen)
 918	),
 919	TP_printk("addr=%pISpc client %08x:%08x cl_rpc_users=%d",
 920		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
 921		__entry->cl_rpc_users)
 922);
 923
 924DECLARE_EVENT_CLASS(nfsd_net_class,
 925	TP_PROTO(const struct nfsd_net *nn),
 926	TP_ARGS(nn),
 927	TP_STRUCT__entry(
 928		__field(unsigned long long, boot_time)
 929	),
 930	TP_fast_assign(
 931		__entry->boot_time = nn->boot_time;
 932	),
 933	TP_printk("boot_time=%16llx", __entry->boot_time)
 934)
 935
 936#define DEFINE_NET_EVENT(name) \
 937DEFINE_EVENT(nfsd_net_class, nfsd_##name, \
 938	TP_PROTO(const struct nfsd_net *nn), \
 939	TP_ARGS(nn))
 940
 941DEFINE_NET_EVENT(grace_start);
 942DEFINE_NET_EVENT(grace_complete);
 943
 944TRACE_EVENT(nfsd_writeverf_reset,
 945	TP_PROTO(
 946		const struct nfsd_net *nn,
 947		const struct svc_rqst *rqstp,
 948		int error
 949	),
 950	TP_ARGS(nn, rqstp, error),
 951	TP_STRUCT__entry(
 952		__field(unsigned long long, boot_time)
 953		__field(u32, xid)
 954		__field(int, error)
 955		__array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
 956	),
 957	TP_fast_assign(
 958		__entry->boot_time = nn->boot_time;
 959		__entry->xid = be32_to_cpu(rqstp->rq_xid);
 960		__entry->error = error;
 961
 962		/* avoid seqlock inside TP_fast_assign */
 963		memcpy(__entry->verifier, nn->writeverf,
 964		       NFS4_VERIFIER_SIZE);
 965	),
 966	TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s",
 967		__entry->boot_time, __entry->xid, __entry->error,
 968		__print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE)
 969	)
 970);
 971
 972TRACE_EVENT(nfsd_clid_cred_mismatch,
 973	TP_PROTO(
 974		const struct nfs4_client *clp,
 975		const struct svc_rqst *rqstp
 976	),
 977	TP_ARGS(clp, rqstp),
 978	TP_STRUCT__entry(
 979		__field(u32, cl_boot)
 980		__field(u32, cl_id)
 981		__field(unsigned long, cl_flavor)
 982		__field(unsigned long, new_flavor)
 983		__sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
 984	),
 985	TP_fast_assign(
 986		__entry->cl_boot = clp->cl_clientid.cl_boot;
 987		__entry->cl_id = clp->cl_clientid.cl_id;
 988		__entry->cl_flavor = clp->cl_cred.cr_flavor;
 989		__entry->new_flavor = rqstp->rq_cred.cr_flavor;
 990		__assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
 991				  rqstp->rq_xprt->xpt_remotelen);
 992	),
 993	TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc",
 994		__entry->cl_boot, __entry->cl_id,
 995		show_nfsd_authflavor(__entry->cl_flavor),
 996		show_nfsd_authflavor(__entry->new_flavor),
 997		__get_sockaddr(addr)
 998	)
 999)
1000
1001TRACE_EVENT(nfsd_clid_verf_mismatch,
1002	TP_PROTO(
1003		const struct nfs4_client *clp,
1004		const struct svc_rqst *rqstp,
1005		const nfs4_verifier *verf
1006	),
1007	TP_ARGS(clp, rqstp, verf),
1008	TP_STRUCT__entry(
1009		__field(u32, cl_boot)
1010		__field(u32, cl_id)
1011		__array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE)
1012		__array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE)
1013		__sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
1014	),
1015	TP_fast_assign(
1016		__entry->cl_boot = clp->cl_clientid.cl_boot;
1017		__entry->cl_id = clp->cl_clientid.cl_id;
1018		memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier,
1019		       NFS4_VERIFIER_SIZE);
1020		memcpy(__entry->new_verifier, (void *)verf,
1021		       NFS4_VERIFIER_SIZE);
1022		__assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
1023				  rqstp->rq_xprt->xpt_remotelen);
1024	),
1025	TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc",
1026		__entry->cl_boot, __entry->cl_id,
1027		__print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE),
1028		__print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE),
1029		__get_sockaddr(addr)
1030	)
1031);
1032
1033DECLARE_EVENT_CLASS(nfsd_clid_class,
1034	TP_PROTO(const struct nfs4_client *clp),
1035	TP_ARGS(clp),
1036	TP_STRUCT__entry(
1037		__field(u32, cl_boot)
1038		__field(u32, cl_id)
1039		__array(unsigned char, addr, sizeof(struct sockaddr_in6))
1040		__field(unsigned long, flavor)
1041		__array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
1042		__string_len(name, clp->cl_name.data, clp->cl_name.len)
1043	),
1044	TP_fast_assign(
1045		__entry->cl_boot = clp->cl_clientid.cl_boot;
1046		__entry->cl_id = clp->cl_clientid.cl_id;
1047		memcpy(__entry->addr, &clp->cl_addr,
1048			sizeof(struct sockaddr_in6));
1049		__entry->flavor = clp->cl_cred.cr_flavor;
1050		memcpy(__entry->verifier, (void *)&clp->cl_verifier,
1051		       NFS4_VERIFIER_SIZE);
1052		__assign_str(name);
1053	),
1054	TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x",
1055		__entry->addr, __get_str(name),
1056		__print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE),
1057		show_nfsd_authflavor(__entry->flavor),
1058		__entry->cl_boot, __entry->cl_id)
1059);
1060
1061#define DEFINE_CLID_EVENT(name) \
1062DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \
1063	TP_PROTO(const struct nfs4_client *clp), \
1064	TP_ARGS(clp))
1065
1066DEFINE_CLID_EVENT(fresh);
1067DEFINE_CLID_EVENT(confirmed_r);
1068
1069/*
1070 * from fs/nfsd/filecache.h
1071 */
1072#define show_nf_flags(val)						\
1073	__print_flags(val, "|",						\
1074		{ 1 << NFSD_FILE_HASHED,	"HASHED" },		\
1075		{ 1 << NFSD_FILE_PENDING,	"PENDING" },		\
1076		{ 1 << NFSD_FILE_REFERENCED,	"REFERENCED" },		\
1077		{ 1 << NFSD_FILE_RECENT,	"RECENT" },		\
1078		{ 1 << NFSD_FILE_GC,		"GC" })
1079
1080DECLARE_EVENT_CLASS(nfsd_file_class,
1081	TP_PROTO(struct nfsd_file *nf),
1082	TP_ARGS(nf),
1083	TP_STRUCT__entry(
1084		__field(void *, nf_inode)
1085		__field(int, nf_ref)
1086		__field(unsigned long, nf_flags)
1087		__field(unsigned char, nf_may)
1088		__field(struct file *, nf_file)
1089	),
1090	TP_fast_assign(
1091		__entry->nf_inode = nf->nf_inode;
1092		__entry->nf_ref = refcount_read(&nf->nf_ref);
1093		__entry->nf_flags = nf->nf_flags;
1094		__entry->nf_may = nf->nf_may;
1095		__entry->nf_file = nf->nf_file;
1096	),
1097	TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p",
1098		__entry->nf_inode,
1099		__entry->nf_ref,
1100		show_nf_flags(__entry->nf_flags),
1101		show_nfsd_may_flags(__entry->nf_may),
1102		__entry->nf_file)
1103)
1104
1105#define DEFINE_NFSD_FILE_EVENT(name) \
1106DEFINE_EVENT(nfsd_file_class, name, \
1107	TP_PROTO(struct nfsd_file *nf), \
1108	TP_ARGS(nf))
1109
1110DEFINE_NFSD_FILE_EVENT(nfsd_file_free);
1111DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash);
1112DEFINE_NFSD_FILE_EVENT(nfsd_file_put);
1113DEFINE_NFSD_FILE_EVENT(nfsd_file_closing);
1114
1115TRACE_EVENT(nfsd_file_alloc,
1116	TP_PROTO(
1117		const struct nfsd_file *nf
1118	),
1119	TP_ARGS(nf),
1120	TP_STRUCT__entry(
1121		__field(const void *, nf_inode)
1122		__field(unsigned long, nf_flags)
1123		__field(unsigned long, nf_may)
1124		__field(unsigned int, nf_ref)
1125	),
1126	TP_fast_assign(
1127		__entry->nf_inode = nf->nf_inode;
1128		__entry->nf_flags = nf->nf_flags;
1129		__entry->nf_ref = refcount_read(&nf->nf_ref);
1130		__entry->nf_may = nf->nf_may;
1131	),
1132	TP_printk("inode=%p ref=%u flags=%s may=%s",
1133		__entry->nf_inode, __entry->nf_ref,
1134		show_nf_flags(__entry->nf_flags),
1135		show_nfsd_may_flags(__entry->nf_may)
1136	)
1137);
1138
1139TRACE_EVENT(nfsd_file_get_dio_attrs,
1140	TP_PROTO(
1141		const struct inode *inode,
1142		const struct kstat *stat
1143	),
1144	TP_ARGS(inode, stat),
1145	TP_STRUCT__entry(
1146		__field(const void *, inode)
1147		__field(unsigned long, mask)
1148		__field(u32, mem_align)
1149		__field(u32, offset_align)
1150		__field(u32, read_offset_align)
1151	),
1152	TP_fast_assign(
1153		__entry->inode = inode;
1154		__entry->mask = stat->result_mask;
1155		__entry->mem_align = stat->dio_mem_align;
1156		__entry->offset_align = stat->dio_offset_align;
1157		__entry->read_offset_align = stat->dio_read_offset_align;
1158	),
1159	TP_printk("inode=%p flags=%s mem_align=%u offset_align=%u read_offset_align=%u",
1160		__entry->inode, show_statx_mask(__entry->mask),
1161		__entry->mem_align, __entry->offset_align,
1162		__entry->read_offset_align
1163	)
1164);
1165
1166TRACE_EVENT(nfsd_file_acquire,
1167	TP_PROTO(
1168		const struct svc_rqst *rqstp,
1169		const struct inode *inode,
1170		unsigned int may_flags,
1171		const struct nfsd_file *nf,
1172		__be32 status
1173	),
1174
1175	TP_ARGS(rqstp, inode, may_flags, nf, status),
1176
1177	TP_STRUCT__entry(
1178		__field(u32, xid)
1179		__field(const void *, inode)
1180		__field(unsigned long, may_flags)
1181		__field(unsigned int, nf_ref)
1182		__field(unsigned long, nf_flags)
1183		__field(unsigned long, nf_may)
1184		__field(const void *, nf_file)
1185		__field(u32, status)
1186	),
1187
1188	TP_fast_assign(
1189		__entry->xid = rqstp ? be32_to_cpu(rqstp->rq_xid) : 0;
1190		__entry->inode = inode;
1191		__entry->may_flags = may_flags;
1192		__entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0;
1193		__entry->nf_flags = nf ? nf->nf_flags : 0;
1194		__entry->nf_may = nf ? nf->nf_may : 0;
1195		__entry->nf_file = nf ? nf->nf_file : NULL;
1196		__entry->status = be32_to_cpu(status);
1197	),
1198
1199	TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u",
1200			__entry->xid, __entry->inode,
1201			show_nfsd_may_flags(__entry->may_flags),
1202			__entry->nf_ref, show_nf_flags(__entry->nf_flags),
1203			show_nfsd_may_flags(__entry->nf_may),
1204			__entry->nf_file, __entry->status
1205	)
1206);
1207
1208TRACE_EVENT(nfsd_file_insert_err,
1209	TP_PROTO(
1210		const struct svc_rqst *rqstp,
1211		const struct inode *inode,
1212		unsigned int may_flags,
1213		long error
1214	),
1215	TP_ARGS(rqstp, inode, may_flags, error),
1216	TP_STRUCT__entry(
1217		__field(u32, xid)
1218		__field(const void *, inode)
1219		__field(unsigned long, may_flags)
1220		__field(long, error)
1221	),
1222	TP_fast_assign(
1223		__entry->xid = rqstp ? be32_to_cpu(rqstp->rq_xid) : 0;
1224		__entry->inode = inode;
1225		__entry->may_flags = may_flags;
1226		__entry->error = error;
1227	),
1228	TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld",
1229		__entry->xid, __entry->inode,
1230		show_nfsd_may_flags(__entry->may_flags),
1231		__entry->error
1232	)
1233);
1234
1235TRACE_EVENT(nfsd_file_cons_err,
1236	TP_PROTO(
1237		const struct svc_rqst *rqstp,
1238		const struct inode *inode,
1239		unsigned int may_flags,
1240		const struct nfsd_file *nf
1241	),
1242	TP_ARGS(rqstp, inode, may_flags, nf),
1243	TP_STRUCT__entry(
1244		__field(u32, xid)
1245		__field(const void *, inode)
1246		__field(unsigned long, may_flags)
1247		__field(unsigned int, nf_ref)
1248		__field(unsigned long, nf_flags)
1249		__field(unsigned long, nf_may)
1250		__field(const void *, nf_file)
1251	),
1252	TP_fast_assign(
1253		__entry->xid = rqstp ? be32_to_cpu(rqstp->rq_xid) : 0;
1254		__entry->inode = inode;
1255		__entry->may_flags = may_flags;
1256		__entry->nf_ref = refcount_read(&nf->nf_ref);
1257		__entry->nf_flags = nf->nf_flags;
1258		__entry->nf_may = nf->nf_may;
1259		__entry->nf_file = nf->nf_file;
1260	),
1261	TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p",
1262		__entry->xid, __entry->inode,
1263		show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref,
1264		show_nf_flags(__entry->nf_flags),
1265		show_nfsd_may_flags(__entry->nf_may), __entry->nf_file
1266	)
1267);
1268
1269DECLARE_EVENT_CLASS(nfsd_file_open_class,
1270	TP_PROTO(const struct nfsd_file *nf, __be32 status),
1271	TP_ARGS(nf, status),
1272	TP_STRUCT__entry(
1273		__field(void *, nf_inode)	/* cannot be dereferenced */
1274		__field(int, nf_ref)
1275		__field(unsigned long, nf_flags)
1276		__field(unsigned long, nf_may)
1277		__field(void *, nf_file)	/* cannot be dereferenced */
1278	),
1279	TP_fast_assign(
1280		__entry->nf_inode = nf->nf_inode;
1281		__entry->nf_ref = refcount_read(&nf->nf_ref);
1282		__entry->nf_flags = nf->nf_flags;
1283		__entry->nf_may = nf->nf_may;
1284		__entry->nf_file = nf->nf_file;
1285	),
1286	TP_printk("inode=%p ref=%d flags=%s may=%s file=%p",
1287		__entry->nf_inode,
1288		__entry->nf_ref,
1289		show_nf_flags(__entry->nf_flags),
1290		show_nfsd_may_flags(__entry->nf_may),
1291		__entry->nf_file)
1292)
1293
1294#define DEFINE_NFSD_FILE_OPEN_EVENT(name)					\
1295DEFINE_EVENT(nfsd_file_open_class, name,					\
1296	TP_PROTO(							\
1297		const struct nfsd_file *nf,				\
1298		__be32 status						\
1299	),								\
1300	TP_ARGS(nf, status))
1301
1302DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open);
1303DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened);
1304
1305TRACE_EVENT(nfsd_file_is_cached,
1306	TP_PROTO(
1307		const struct inode *inode,
1308		int found
1309	),
1310	TP_ARGS(inode, found),
1311	TP_STRUCT__entry(
1312		__field(const struct inode *, inode)
1313		__field(int, found)
1314	),
1315	TP_fast_assign(
1316		__entry->inode = inode;
1317		__entry->found = found;
1318	),
1319	TP_printk("inode=%p is %scached",
1320		__entry->inode,
1321		__entry->found ? "" : "not "
1322	)
1323);
1324
1325TRACE_EVENT(nfsd_file_fsnotify_handle_event,
1326	TP_PROTO(struct inode *inode, u32 mask),
1327	TP_ARGS(inode, mask),
1328	TP_STRUCT__entry(
1329		__field(struct inode *, inode)
1330		__field(unsigned int, nlink)
1331		__field(umode_t, mode)
1332		__field(u32, mask)
1333	),
1334	TP_fast_assign(
1335		__entry->inode = inode;
1336		__entry->nlink = inode->i_nlink;
1337		__entry->mode = inode->i_mode;
1338		__entry->mask = mask;
1339	),
1340	TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode,
1341			__entry->nlink, __entry->mode, __entry->mask)
1342);
1343
1344DECLARE_EVENT_CLASS(nfsd_file_gc_class,
1345	TP_PROTO(
1346		const struct nfsd_file *nf
1347	),
1348	TP_ARGS(nf),
1349	TP_STRUCT__entry(
1350		__field(void *, nf_inode)
1351		__field(void *, nf_file)
1352		__field(int, nf_ref)
1353		__field(unsigned long, nf_flags)
1354	),
1355	TP_fast_assign(
1356		__entry->nf_inode = nf->nf_inode;
1357		__entry->nf_file = nf->nf_file;
1358		__entry->nf_ref = refcount_read(&nf->nf_ref);
1359		__entry->nf_flags = nf->nf_flags;
1360	),
1361	TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p",
1362		__entry->nf_inode, __entry->nf_ref,
1363		show_nf_flags(__entry->nf_flags),
1364		__entry->nf_file
1365	)
1366);
1367
1368#define DEFINE_NFSD_FILE_GC_EVENT(name)					\
1369DEFINE_EVENT(nfsd_file_gc_class, name,					\
1370	TP_PROTO(							\
1371		const struct nfsd_file *nf				\
1372	),								\
1373	TP_ARGS(nf))
1374
1375DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add);
1376DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del);
1377DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use);
1378DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback);
1379DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced);
1380DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_aged);
1381DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed);
1382
1383DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class,
1384	TP_PROTO(
1385		unsigned long removed,
1386		unsigned long remaining
1387	),
1388	TP_ARGS(removed, remaining),
1389	TP_STRUCT__entry(
1390		__field(unsigned long, removed)
1391		__field(unsigned long, remaining)
1392	),
1393	TP_fast_assign(
1394		__entry->removed = removed;
1395		__entry->remaining = remaining;
1396	),
1397	TP_printk("%lu entries removed, %lu remaining",
1398		__entry->removed, __entry->remaining)
1399);
1400
1401#define DEFINE_NFSD_FILE_LRUWALK_EVENT(name)				\
1402DEFINE_EVENT(nfsd_file_lruwalk_class, name,				\
1403	TP_PROTO(							\
1404		unsigned long removed,					\
1405		unsigned long remaining					\
1406	),								\
1407	TP_ARGS(removed, remaining))
1408
1409DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed);
1410DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed);
1411
1412TRACE_EVENT(nfsd_file_close,
1413	TP_PROTO(
1414		const struct inode *inode
1415	),
1416	TP_ARGS(inode),
1417	TP_STRUCT__entry(
1418		__field(const void *, inode)
1419	),
1420	TP_fast_assign(
1421		__entry->inode = inode;
1422	),
1423	TP_printk("inode=%p",
1424		__entry->inode
1425	)
1426);
1427
1428#include "cache.h"
1429
1430TRACE_DEFINE_ENUM(RC_DROPIT);
1431TRACE_DEFINE_ENUM(RC_REPLY);
1432TRACE_DEFINE_ENUM(RC_DOIT);
1433
1434#define show_drc_retval(x)						\
1435	__print_symbolic(x,						\
1436		{ RC_DROPIT, "DROPIT" },				\
1437		{ RC_REPLY, "REPLY" },					\
1438		{ RC_DOIT, "DOIT" })
1439
1440TRACE_EVENT(nfsd_drc_found,
1441	TP_PROTO(
1442		const struct nfsd_net *nn,
1443		const struct svc_rqst *rqstp,
1444		int result
1445	),
1446	TP_ARGS(nn, rqstp, result),
1447	TP_STRUCT__entry(
1448		__field(unsigned long long, boot_time)
1449		__field(unsigned long, result)
1450		__field(u32, xid)
1451	),
1452	TP_fast_assign(
1453		__entry->boot_time = nn->boot_time;
1454		__entry->result = result;
1455		__entry->xid = be32_to_cpu(rqstp->rq_xid);
1456	),
1457	TP_printk("boot_time=%16llx xid=0x%08x result=%s",
1458		__entry->boot_time, __entry->xid,
1459		show_drc_retval(__entry->result))
1460
1461);
1462
1463TRACE_EVENT(nfsd_drc_mismatch,
1464	TP_PROTO(
1465		const struct nfsd_net *nn,
1466		const struct nfsd_cacherep *key,
1467		const struct nfsd_cacherep *rp
1468	),
1469	TP_ARGS(nn, key, rp),
1470	TP_STRUCT__entry(
1471		__field(unsigned long long, boot_time)
1472		__field(u32, xid)
1473		__field(u32, cached)
1474		__field(u32, ingress)
1475	),
1476	TP_fast_assign(
1477		__entry->boot_time = nn->boot_time;
1478		__entry->xid = be32_to_cpu(key->c_key.k_xid);
1479		__entry->cached = (__force u32)key->c_key.k_csum;
1480		__entry->ingress = (__force u32)rp->c_key.k_csum;
1481	),
1482	TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x",
1483		__entry->boot_time, __entry->xid, __entry->cached,
1484		__entry->ingress)
1485);
1486
1487TRACE_EVENT(nfsd_cb_args,
1488	TP_PROTO(
1489		const struct nfs4_client *clp,
1490		const struct nfs4_cb_conn *conn
1491	),
1492	TP_ARGS(clp, conn),
1493	TP_STRUCT__entry(
1494		__field(u32, cl_boot)
1495		__field(u32, cl_id)
1496		__field(u32, prog)
1497		__field(u32, ident)
1498		__sockaddr(addr, conn->cb_addrlen)
1499	),
1500	TP_fast_assign(
1501		__entry->cl_boot = clp->cl_clientid.cl_boot;
1502		__entry->cl_id = clp->cl_clientid.cl_id;
1503		__entry->prog = conn->cb_prog;
1504		__entry->ident = conn->cb_ident;
1505		__assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen);
1506	),
1507	TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u",
1508		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1509		__entry->prog, __entry->ident)
1510);
1511
1512TRACE_EVENT(nfsd_cb_nodelegs,
1513	TP_PROTO(const struct nfs4_client *clp),
1514	TP_ARGS(clp),
1515	TP_STRUCT__entry(
1516		__field(u32, cl_boot)
1517		__field(u32, cl_id)
1518	),
1519	TP_fast_assign(
1520		__entry->cl_boot = clp->cl_clientid.cl_boot;
1521		__entry->cl_id = clp->cl_clientid.cl_id;
1522	),
1523	TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
1524)
1525
1526#define show_cb_state(val)						\
1527	__print_symbolic(val,						\
1528		{ NFSD4_CB_UP,		"UP" },				\
1529		{ NFSD4_CB_UNKNOWN,	"UNKNOWN" },			\
1530		{ NFSD4_CB_DOWN,	"DOWN" },			\
1531		{ NFSD4_CB_FAULT,	"FAULT"})
1532
1533DECLARE_EVENT_CLASS(nfsd_cb_class,
1534	TP_PROTO(const struct nfs4_client *clp),
1535	TP_ARGS(clp),
1536	TP_STRUCT__entry(
1537		__field(unsigned long, state)
1538		__field(u32, cl_boot)
1539		__field(u32, cl_id)
1540		__sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1541	),
1542	TP_fast_assign(
1543		__entry->state = clp->cl_cb_state;
1544		__entry->cl_boot = clp->cl_clientid.cl_boot;
1545		__entry->cl_id = clp->cl_clientid.cl_id;
1546		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1547				  clp->cl_cb_conn.cb_addrlen)
1548	),
1549	TP_printk("addr=%pISpc client %08x:%08x state=%s",
1550		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1551		show_cb_state(__entry->state))
1552);
1553
1554#define DEFINE_NFSD_CB_EVENT(name)			\
1555DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name,		\
1556	TP_PROTO(const struct nfs4_client *clp),	\
1557	TP_ARGS(clp))
1558
1559DEFINE_NFSD_CB_EVENT(start);
1560DEFINE_NFSD_CB_EVENT(new_state);
1561DEFINE_NFSD_CB_EVENT(probe);
1562DEFINE_NFSD_CB_EVENT(lost);
1563DEFINE_NFSD_CB_EVENT(shutdown);
1564DEFINE_NFSD_CB_EVENT(rpc_prepare);
1565DEFINE_NFSD_CB_EVENT(rpc_done);
1566DEFINE_NFSD_CB_EVENT(rpc_release);
1567
1568TRACE_DEFINE_ENUM(RPC_AUTH_NULL);
1569TRACE_DEFINE_ENUM(RPC_AUTH_UNIX);
1570TRACE_DEFINE_ENUM(RPC_AUTH_GSS);
1571TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5);
1572TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I);
1573TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P);
1574
1575#define show_nfsd_authflavor(val)					\
1576	__print_symbolic(val,						\
1577		{ RPC_AUTH_NULL,		"none" },		\
1578		{ RPC_AUTH_UNIX,		"sys" },		\
1579		{ RPC_AUTH_GSS,			"gss" },		\
1580		{ RPC_AUTH_GSS_KRB5,		"krb5" },		\
1581		{ RPC_AUTH_GSS_KRB5I,		"krb5i" },		\
1582		{ RPC_AUTH_GSS_KRB5P,		"krb5p" })
1583
1584TRACE_EVENT(nfsd_cb_setup,
1585	TP_PROTO(const struct nfs4_client *clp,
1586		 const char *netid,
1587		 rpc_authflavor_t authflavor
1588	),
1589	TP_ARGS(clp, netid, authflavor),
1590	TP_STRUCT__entry(
1591		__field(u32, cl_boot)
1592		__field(u32, cl_id)
1593		__field(unsigned long, authflavor)
1594		__sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1595		__string(netid, netid)
1596	),
1597	TP_fast_assign(
1598		__entry->cl_boot = clp->cl_clientid.cl_boot;
1599		__entry->cl_id = clp->cl_clientid.cl_id;
1600		__assign_str(netid);
1601		__entry->authflavor = authflavor;
1602		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1603				  clp->cl_cb_conn.cb_addrlen)
1604	),
1605	TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s",
1606		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1607		__get_str(netid), show_nfsd_authflavor(__entry->authflavor))
1608);
1609
1610TRACE_EVENT(nfsd_cb_setup_err,
1611	TP_PROTO(
1612		const struct nfs4_client *clp,
1613		long error
1614	),
1615	TP_ARGS(clp, error),
1616	TP_STRUCT__entry(
1617		__field(long, error)
1618		__field(u32, cl_boot)
1619		__field(u32, cl_id)
1620		__sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1621	),
1622	TP_fast_assign(
1623		__entry->error = error;
1624		__entry->cl_boot = clp->cl_clientid.cl_boot;
1625		__entry->cl_id = clp->cl_clientid.cl_id;
1626		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1627				  clp->cl_cb_conn.cb_addrlen)
1628	),
1629	TP_printk("addr=%pISpc client %08x:%08x error=%ld",
1630		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1631		__entry->error)
1632);
1633
1634/* Not a real opcode, but there is no 0 operation. */
1635#define _CB_NULL	0
1636
1637#define show_nfsd_cb_opcode(val)					\
1638	__print_symbolic(val,						\
1639		{ _CB_NULL,			"CB_NULL" },		\
1640		{ OP_CB_GETATTR,		"CB_GETATTR" },		\
1641		{ OP_CB_RECALL,			"CB_RECALL" },		\
1642		{ OP_CB_LAYOUTRECALL,		"CB_LAYOUTRECALL" },	\
1643		{ OP_CB_RECALL_ANY,		"CB_RECALL_ANY" },	\
1644		{ OP_CB_NOTIFY_LOCK,		"CB_NOTIFY_LOCK" },	\
1645		{ OP_CB_OFFLOAD,		"CB_OFFLOAD" })
1646
1647DECLARE_EVENT_CLASS(nfsd_cb_lifetime_class,
1648	TP_PROTO(
1649		const struct nfs4_client *clp,
1650		const struct nfsd4_callback *cb
1651	),
1652	TP_ARGS(clp, cb),
1653	TP_STRUCT__entry(
1654		__field(u32, cl_boot)
1655		__field(u32, cl_id)
1656		__field(const void *, cb)
1657		__field(unsigned long, opcode)
1658		__field(bool, need_restart)
1659		__sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1660	),
1661	TP_fast_assign(
1662		__entry->cl_boot = clp->cl_clientid.cl_boot;
1663		__entry->cl_id = clp->cl_clientid.cl_id;
1664		__entry->cb = cb;
1665		__entry->opcode = cb->cb_ops ? cb->cb_ops->opcode : _CB_NULL;
1666		__entry->need_restart = test_bit(NFSD4_CALLBACK_REQUEUE, &cb->cb_flags);
1667		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1668				  clp->cl_cb_conn.cb_addrlen)
1669	),
1670	TP_printk("addr=%pISpc client %08x:%08x cb=%p%s opcode=%s",
1671		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, __entry->cb,
1672		__entry->need_restart ?  " (need restart)" : " (first try)",
1673		show_nfsd_cb_opcode(__entry->opcode)
1674	)
1675);
1676
1677#define DEFINE_NFSD_CB_LIFETIME_EVENT(name)		\
1678DEFINE_EVENT(nfsd_cb_lifetime_class, nfsd_cb_##name,	\
1679	TP_PROTO(					\
1680		const struct nfs4_client *clp,		\
1681		const struct nfsd4_callback *cb		\
1682	),						\
1683	TP_ARGS(clp, cb))
1684
1685DEFINE_NFSD_CB_LIFETIME_EVENT(queue);
1686DEFINE_NFSD_CB_LIFETIME_EVENT(destroy);
1687DEFINE_NFSD_CB_LIFETIME_EVENT(restart);
1688DEFINE_NFSD_CB_LIFETIME_EVENT(bc_update);
1689DEFINE_NFSD_CB_LIFETIME_EVENT(bc_shutdown);
1690
1691TRACE_EVENT(nfsd_cb_seq_status,
1692	TP_PROTO(
1693		const struct rpc_task *task,
1694		const struct nfsd4_callback *cb
1695	),
1696	TP_ARGS(task, cb),
1697	TP_STRUCT__entry(
1698		__field(unsigned int, task_id)
1699		__field(unsigned int, client_id)
1700		__field(u32, cl_boot)
1701		__field(u32, cl_id)
1702		__field(u32, seqno)
1703		__field(u32, reserved)
1704		__field(int, tk_status)
1705		__field(int, seq_status)
1706	),
1707	TP_fast_assign(
1708		const struct nfs4_client *clp = cb->cb_clp;
1709		const struct nfsd4_session *session = clp->cl_cb_session;
1710		const struct nfsd4_sessionid *sid =
1711			(struct nfsd4_sessionid *)&session->se_sessionid;
1712
1713		__entry->task_id = task->tk_pid;
1714		__entry->client_id = task->tk_client ?
1715				     task->tk_client->cl_clid : -1;
1716		__entry->cl_boot = sid->clientid.cl_boot;
1717		__entry->cl_id = sid->clientid.cl_id;
1718		__entry->seqno = sid->sequence;
1719		__entry->reserved = sid->reserved;
1720		__entry->tk_status = task->tk_status;
1721		__entry->seq_status = cb->cb_seq_status;
1722	),
1723	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1724		" sessionid=%08x:%08x:%08x:%08x tk_status=%d seq_status=%d",
1725		__entry->task_id, __entry->client_id,
1726		__entry->cl_boot, __entry->cl_id,
1727		__entry->seqno, __entry->reserved,
1728		__entry->tk_status, __entry->seq_status
1729	)
1730);
1731
1732TRACE_EVENT(nfsd_cb_free_slot,
1733	TP_PROTO(
1734		const struct rpc_task *task,
1735		const struct nfsd4_callback *cb
1736	),
1737	TP_ARGS(task, cb),
1738	TP_STRUCT__entry(
1739		__field(unsigned int, task_id)
1740		__field(unsigned int, client_id)
1741		__field(u32, cl_boot)
1742		__field(u32, cl_id)
1743		__field(u32, seqno)
1744		__field(u32, reserved)
1745		__field(u32, slot_seqno)
1746	),
1747	TP_fast_assign(
1748		const struct nfs4_client *clp = cb->cb_clp;
1749		const struct nfsd4_session *session = clp->cl_cb_session;
1750		const struct nfsd4_sessionid *sid =
1751			(struct nfsd4_sessionid *)&session->se_sessionid;
1752
1753		__entry->task_id = task->tk_pid;
1754		__entry->client_id = task->tk_client ?
1755				     task->tk_client->cl_clid : -1;
1756		__entry->cl_boot = sid->clientid.cl_boot;
1757		__entry->cl_id = sid->clientid.cl_id;
1758		__entry->seqno = sid->sequence;
1759		__entry->reserved = sid->reserved;
1760		__entry->slot_seqno = session->se_cb_seq_nr[cb->cb_held_slot];
1761	),
1762	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1763		" sessionid=%08x:%08x:%08x:%08x new slot seqno=%u",
1764		__entry->task_id, __entry->client_id,
1765		__entry->cl_boot, __entry->cl_id,
1766		__entry->seqno, __entry->reserved,
1767		__entry->slot_seqno
1768	)
1769);
1770
1771TRACE_EVENT_CONDITION(nfsd_cb_recall,
1772	TP_PROTO(
1773		const struct nfs4_stid *stid
1774	),
1775	TP_ARGS(stid),
1776	TP_CONDITION(stid->sc_client),
1777	TP_STRUCT__entry(
1778		__field(u32, cl_boot)
1779		__field(u32, cl_id)
1780		__field(u32, si_id)
1781		__field(u32, si_generation)
1782		__sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen)
1783	),
1784	TP_fast_assign(
1785		const stateid_t *stp = &stid->sc_stateid;
1786		const struct nfs4_client *clp = stid->sc_client;
1787
1788		__entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1789		__entry->cl_id = stp->si_opaque.so_clid.cl_id;
1790		__entry->si_id = stp->si_opaque.so_id;
1791		__entry->si_generation = stp->si_generation;
1792		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1793				  clp->cl_cb_conn.cb_addrlen)
1794	),
1795	TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x",
1796		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1797		__entry->si_id, __entry->si_generation)
1798);
1799
1800TRACE_EVENT(nfsd_cb_notify_lock,
1801	TP_PROTO(
1802		const struct nfs4_lockowner *lo,
1803		const struct nfsd4_blocked_lock *nbl
1804	),
1805	TP_ARGS(lo, nbl),
1806	TP_STRUCT__entry(
1807		__field(u32, cl_boot)
1808		__field(u32, cl_id)
1809		__field(u32, fh_hash)
1810		__sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen)
1811	),
1812	TP_fast_assign(
1813		const struct nfs4_client *clp = lo->lo_owner.so_client;
1814
1815		__entry->cl_boot = clp->cl_clientid.cl_boot;
1816		__entry->cl_id = clp->cl_clientid.cl_id;
1817		__entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh);
1818		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1819				  clp->cl_cb_conn.cb_addrlen)
1820	),
1821	TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x",
1822		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1823		__entry->fh_hash)
1824);
1825
1826TRACE_EVENT(nfsd_cb_offload,
1827	TP_PROTO(
1828		const struct nfs4_client *clp,
1829		const stateid_t *stp,
1830		const struct knfsd_fh *fh,
1831		u64 count,
1832		__be32 status
1833	),
1834	TP_ARGS(clp, stp, fh, count, status),
1835	TP_STRUCT__entry(
1836		__field(u32, cl_boot)
1837		__field(u32, cl_id)
1838		__field(u32, si_id)
1839		__field(u32, si_generation)
1840		__field(u32, fh_hash)
1841		__field(int, status)
1842		__field(u64, count)
1843		__sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1844	),
1845	TP_fast_assign(
1846		__entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1847		__entry->cl_id = stp->si_opaque.so_clid.cl_id;
1848		__entry->si_id = stp->si_opaque.so_id;
1849		__entry->si_generation = stp->si_generation;
1850		__entry->fh_hash = knfsd_fh_hash(fh);
1851		__entry->status = be32_to_cpu(status);
1852		__entry->count = count;
1853		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1854				  clp->cl_cb_conn.cb_addrlen)
1855	),
1856	TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d",
1857		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1858		__entry->si_id, __entry->si_generation,
1859		__entry->fh_hash, __entry->count, __entry->status)
1860);
1861
1862TRACE_EVENT(nfsd_cb_recall_any,
1863	TP_PROTO(
1864		const struct nfsd4_cb_recall_any *ra
1865	),
1866	TP_ARGS(ra),
1867	TP_STRUCT__entry(
1868		__field(u32, cl_boot)
1869		__field(u32, cl_id)
1870		__field(u32, keep)
1871		__field(unsigned long, bmval0)
1872		__sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen)
1873	),
1874	TP_fast_assign(
1875		__entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot;
1876		__entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id;
1877		__entry->keep = ra->ra_keep;
1878		__entry->bmval0 = ra->ra_bmval[0];
1879		__assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr,
1880				  ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen);
1881	),
1882	TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s",
1883		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1884		__entry->keep, show_rca_mask(__entry->bmval0)
1885	)
1886);
1887
1888DECLARE_EVENT_CLASS(nfsd_cb_done_class,
1889	TP_PROTO(
1890		const stateid_t *stp,
1891		const struct rpc_task *task
1892	),
1893	TP_ARGS(stp, task),
1894	TP_STRUCT__entry(
1895		__field(u32, cl_boot)
1896		__field(u32, cl_id)
1897		__field(u32, si_id)
1898		__field(u32, si_generation)
1899		__field(int, status)
1900	),
1901	TP_fast_assign(
1902		__entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1903		__entry->cl_id = stp->si_opaque.so_clid.cl_id;
1904		__entry->si_id = stp->si_opaque.so_id;
1905		__entry->si_generation = stp->si_generation;
1906		__entry->status = task->tk_status;
1907	),
1908	TP_printk("client %08x:%08x stateid %08x:%08x status=%d",
1909		__entry->cl_boot, __entry->cl_id, __entry->si_id,
1910		__entry->si_generation, __entry->status
1911	)
1912);
1913
1914#define DEFINE_NFSD_CB_DONE_EVENT(name)			\
1915DEFINE_EVENT(nfsd_cb_done_class, name,			\
1916	TP_PROTO(					\
1917		const stateid_t *stp,			\
1918		const struct rpc_task *task		\
1919	),						\
1920	TP_ARGS(stp, task))
1921
1922DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done);
1923DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done);
1924DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done);
1925DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done);
1926DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_getattr_done);
1927
1928TRACE_EVENT(nfsd_cb_recall_any_done,
1929	TP_PROTO(
1930		const struct nfsd4_callback *cb,
1931		const struct rpc_task *task
1932	),
1933	TP_ARGS(cb, task),
1934	TP_STRUCT__entry(
1935		__field(u32, cl_boot)
1936		__field(u32, cl_id)
1937		__field(int, status)
1938	),
1939	TP_fast_assign(
1940		__entry->status = task->tk_status;
1941		__entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot;
1942		__entry->cl_id = cb->cb_clp->cl_clientid.cl_id;
1943	),
1944	TP_printk("client %08x:%08x status=%d",
1945		__entry->cl_boot, __entry->cl_id, __entry->status
1946	)
1947);
1948
1949TRACE_EVENT(nfsd_ctl_unlock_ip,
1950	TP_PROTO(
1951		const struct net *net,
1952		const char *address
1953	),
1954	TP_ARGS(net, address),
1955	TP_STRUCT__entry(
1956		__field(unsigned int, netns_ino)
1957		__string(address, address)
1958	),
1959	TP_fast_assign(
1960		__entry->netns_ino = net->ns.inum;
1961		__assign_str(address);
1962	),
1963	TP_printk("address=%s",
1964		__get_str(address)
1965	)
1966);
1967
1968TRACE_EVENT(nfsd_ctl_unlock_fs,
1969	TP_PROTO(
1970		const struct net *net,
1971		const char *path
1972	),
1973	TP_ARGS(net, path),
1974	TP_STRUCT__entry(
1975		__field(unsigned int, netns_ino)
1976		__string(path, path)
1977	),
1978	TP_fast_assign(
1979		__entry->netns_ino = net->ns.inum;
1980		__assign_str(path);
1981	),
1982	TP_printk("path=%s",
1983		__get_str(path)
1984	)
1985);
1986
1987TRACE_EVENT(nfsd_ctl_filehandle,
1988	TP_PROTO(
1989		const struct net *net,
1990		const char *domain,
1991		const char *path,
1992		int maxsize
1993	),
1994	TP_ARGS(net, domain, path, maxsize),
1995	TP_STRUCT__entry(
1996		__field(unsigned int, netns_ino)
1997		__field(int, maxsize)
1998		__string(domain, domain)
1999		__string(path, path)
2000	),
2001	TP_fast_assign(
2002		__entry->netns_ino = net->ns.inum;
2003		__entry->maxsize = maxsize;
2004		__assign_str(domain);
2005		__assign_str(path);
2006	),
2007	TP_printk("domain=%s path=%s maxsize=%d",
2008		__get_str(domain), __get_str(path), __entry->maxsize
2009	)
2010);
2011
2012TRACE_EVENT(nfsd_ctl_threads,
2013	TP_PROTO(
2014		const struct net *net,
2015		int newthreads
2016	),
2017	TP_ARGS(net, newthreads),
2018	TP_STRUCT__entry(
2019		__field(unsigned int, netns_ino)
2020		__field(int, newthreads)
2021	),
2022	TP_fast_assign(
2023		__entry->netns_ino = net->ns.inum;
2024		__entry->newthreads = newthreads;
2025	),
2026	TP_printk("newthreads=%d",
2027		__entry->newthreads
2028	)
2029);
2030
2031TRACE_EVENT(nfsd_ctl_pool_threads,
2032	TP_PROTO(
2033		const struct net *net,
2034		int pool,
2035		int nrthreads
2036	),
2037	TP_ARGS(net, pool, nrthreads),
2038	TP_STRUCT__entry(
2039		__field(unsigned int, netns_ino)
2040		__field(int, pool)
2041		__field(int, nrthreads)
2042	),
2043	TP_fast_assign(
2044		__entry->netns_ino = net->ns.inum;
2045		__entry->pool = pool;
2046		__entry->nrthreads = nrthreads;
2047	),
2048	TP_printk("pool=%d nrthreads=%d",
2049		__entry->pool, __entry->nrthreads
2050	)
2051);
2052
2053TRACE_EVENT(nfsd_ctl_version,
2054	TP_PROTO(
2055		const struct net *net,
2056		const char *mesg
2057	),
2058	TP_ARGS(net, mesg),
2059	TP_STRUCT__entry(
2060		__field(unsigned int, netns_ino)
2061		__string(mesg, mesg)
2062	),
2063	TP_fast_assign(
2064		__entry->netns_ino = net->ns.inum;
2065		__assign_str(mesg);
2066	),
2067	TP_printk("%s",
2068		__get_str(mesg)
2069	)
2070);
2071
2072TRACE_EVENT(nfsd_ctl_ports_addfd,
2073	TP_PROTO(
2074		const struct net *net,
2075		int fd
2076	),
2077	TP_ARGS(net, fd),
2078	TP_STRUCT__entry(
2079		__field(unsigned int, netns_ino)
2080		__field(int, fd)
2081	),
2082	TP_fast_assign(
2083		__entry->netns_ino = net->ns.inum;
2084		__entry->fd = fd;
2085	),
2086	TP_printk("fd=%d",
2087		__entry->fd
2088	)
2089);
2090
2091TRACE_EVENT(nfsd_ctl_ports_addxprt,
2092	TP_PROTO(
2093		const struct net *net,
2094		const char *transport,
2095		int port
2096	),
2097	TP_ARGS(net, transport, port),
2098	TP_STRUCT__entry(
2099		__field(unsigned int, netns_ino)
2100		__field(int, port)
2101		__string(transport, transport)
2102	),
2103	TP_fast_assign(
2104		__entry->netns_ino = net->ns.inum;
2105		__entry->port = port;
2106		__assign_str(transport);
2107	),
2108	TP_printk("transport=%s port=%d",
2109		__get_str(transport), __entry->port
2110	)
2111);
2112
2113TRACE_EVENT(nfsd_ctl_maxblksize,
2114	TP_PROTO(
2115		const struct net *net,
2116		int bsize
2117	),
2118	TP_ARGS(net, bsize),
2119	TP_STRUCT__entry(
2120		__field(unsigned int, netns_ino)
2121		__field(int, bsize)
2122	),
2123	TP_fast_assign(
2124		__entry->netns_ino = net->ns.inum;
2125		__entry->bsize = bsize;
2126	),
2127	TP_printk("bsize=%d",
2128		__entry->bsize
2129	)
2130);
2131
2132TRACE_EVENT(nfsd_ctl_time,
2133	TP_PROTO(
2134		const struct net *net,
2135		const char *name,
2136		size_t namelen,
2137		int time
2138	),
2139	TP_ARGS(net, name, namelen, time),
2140	TP_STRUCT__entry(
2141		__field(unsigned int, netns_ino)
2142		__field(int, time)
2143		__string_len(name, name, namelen)
2144	),
2145	TP_fast_assign(
2146		__entry->netns_ino = net->ns.inum;
2147		__entry->time = time;
2148		__assign_str(name);
2149	),
2150	TP_printk("file=%s time=%d",
2151		__get_str(name), __entry->time
2152	)
2153);
2154
2155TRACE_EVENT(nfsd_ctl_recoverydir,
2156	TP_PROTO(
2157		const struct net *net,
2158		const char *recdir
2159	),
2160	TP_ARGS(net, recdir),
2161	TP_STRUCT__entry(
2162		__field(unsigned int, netns_ino)
2163		__string(recdir, recdir)
2164	),
2165	TP_fast_assign(
2166		__entry->netns_ino = net->ns.inum;
2167		__assign_str(recdir);
2168	),
2169	TP_printk("recdir=%s",
2170		__get_str(recdir)
2171	)
2172);
2173
2174TRACE_EVENT(nfsd_end_grace,
2175	TP_PROTO(
2176		const struct net *net
2177	),
2178	TP_ARGS(net),
2179	TP_STRUCT__entry(
2180		__field(unsigned int, netns_ino)
2181	),
2182	TP_fast_assign(
2183		__entry->netns_ino = net->ns.inum;
2184	),
2185	TP_printk("nn=%d", __entry->netns_ino
2186	)
2187);
2188
2189DECLARE_EVENT_CLASS(nfsd_copy_class,
2190	TP_PROTO(
2191		const struct nfsd4_copy *copy
2192	),
2193	TP_ARGS(copy),
2194	TP_STRUCT__entry(
2195		__field(bool, intra)
2196		__field(bool, async)
2197		__field(u32, src_cl_boot)
2198		__field(u32, src_cl_id)
2199		__field(u32, src_so_id)
2200		__field(u32, src_si_generation)
2201		__field(u32, dst_cl_boot)
2202		__field(u32, dst_cl_id)
2203		__field(u32, dst_so_id)
2204		__field(u32, dst_si_generation)
2205		__field(u32, cb_cl_boot)
2206		__field(u32, cb_cl_id)
2207		__field(u32, cb_so_id)
2208		__field(u32, cb_si_generation)
2209		__field(u64, src_cp_pos)
2210		__field(u64, dst_cp_pos)
2211		__field(u64, cp_count)
2212		__sockaddr(addr, sizeof(struct sockaddr_in6))
2213	),
2214	TP_fast_assign(
2215		const stateid_t *src_stp = &copy->cp_src_stateid;
2216		const stateid_t *dst_stp = &copy->cp_dst_stateid;
2217		const stateid_t *cb_stp = &copy->cp_res.cb_stateid;
2218
2219		__entry->intra = test_bit(NFSD4_COPY_F_INTRA, &copy->cp_flags);
2220		__entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, &copy->cp_flags);
2221		__entry->src_cl_boot = src_stp->si_opaque.so_clid.cl_boot;
2222		__entry->src_cl_id = src_stp->si_opaque.so_clid.cl_id;
2223		__entry->src_so_id = src_stp->si_opaque.so_id;
2224		__entry->src_si_generation = src_stp->si_generation;
2225		__entry->dst_cl_boot = dst_stp->si_opaque.so_clid.cl_boot;
2226		__entry->dst_cl_id = dst_stp->si_opaque.so_clid.cl_id;
2227		__entry->dst_so_id = dst_stp->si_opaque.so_id;
2228		__entry->dst_si_generation = dst_stp->si_generation;
2229		__entry->cb_cl_boot = cb_stp->si_opaque.so_clid.cl_boot;
2230		__entry->cb_cl_id = cb_stp->si_opaque.so_clid.cl_id;
2231		__entry->cb_so_id = cb_stp->si_opaque.so_id;
2232		__entry->cb_si_generation = cb_stp->si_generation;
2233		__entry->src_cp_pos = copy->cp_src_pos;
2234		__entry->dst_cp_pos = copy->cp_dst_pos;
2235		__entry->cp_count = copy->cp_count;
2236		__assign_sockaddr(addr, &copy->cp_clp->cl_addr,
2237				sizeof(struct sockaddr_in6));
2238	),
2239	TP_printk("client=%pISpc intra=%d async=%d "
2240		"src_client %08x:%08x src_stateid %08x:%08x "
2241		"dst_client %08x:%08x dst_stateid %08x:%08x "
2242		"cb_client %08x:%08x cb_stateid %08x:%08x "
2243		"cp_src_pos=%llu cp_dst_pos=%llu cp_count=%llu",
2244		__get_sockaddr(addr), __entry->intra, __entry->async,
2245		__entry->src_cl_boot, __entry->src_cl_id,
2246		__entry->src_so_id, __entry->src_si_generation,
2247		__entry->dst_cl_boot, __entry->dst_cl_id,
2248		__entry->dst_so_id, __entry->dst_si_generation,
2249		__entry->cb_cl_boot, __entry->cb_cl_id,
2250		__entry->cb_so_id, __entry->cb_si_generation,
2251		__entry->src_cp_pos, __entry->dst_cp_pos, __entry->cp_count
2252	)
2253);
2254
2255#define DEFINE_COPY_EVENT(name)				\
2256DEFINE_EVENT(nfsd_copy_class, nfsd_copy_##name,	\
2257	TP_PROTO(const struct nfsd4_copy *copy),	\
2258	TP_ARGS(copy))
2259
2260DEFINE_COPY_EVENT(inter);
2261DEFINE_COPY_EVENT(intra);
2262DEFINE_COPY_EVENT(async);
2263
2264TRACE_EVENT(nfsd_copy_done,
2265	TP_PROTO(
2266		const struct nfsd4_copy *copy,
2267		__be32 status
2268	),
2269	TP_ARGS(copy, status),
2270	TP_STRUCT__entry(
2271		__field(int, status)
2272		__field(bool, intra)
2273		__field(bool, async)
2274		__sockaddr(addr, sizeof(struct sockaddr_in6))
2275	),
2276	TP_fast_assign(
2277		__entry->status = be32_to_cpu(status);
2278		__entry->intra = test_bit(NFSD4_COPY_F_INTRA, &copy->cp_flags);
2279		__entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, &copy->cp_flags);
2280		__assign_sockaddr(addr, &copy->cp_clp->cl_addr,
2281				sizeof(struct sockaddr_in6));
2282	),
2283	TP_printk("addr=%pISpc status=%d intra=%d async=%d",
2284		__get_sockaddr(addr), __entry->status, __entry->intra, __entry->async
2285	)
2286);
2287
2288DECLARE_EVENT_CLASS(nfsd_copy_async_done_class,
2289	TP_PROTO(
2290		const struct nfsd4_copy *copy
2291	),
2292	TP_ARGS(copy),
2293	TP_STRUCT__entry(
2294		__field(int, status)
2295		__field(bool, intra)
2296		__field(bool, async)
2297		__field(u32, src_cl_boot)
2298		__field(u32, src_cl_id)
2299		__field(u32, src_so_id)
2300		__field(u32, src_si_generation)
2301		__field(u32, dst_cl_boot)
2302		__field(u32, dst_cl_id)
2303		__field(u32, dst_so_id)
2304		__field(u32, dst_si_generation)
2305		__field(u32, cb_cl_boot)
2306		__field(u32, cb_cl_id)
2307		__field(u32, cb_so_id)
2308		__field(u32, cb_si_generation)
2309		__field(u64, src_cp_pos)
2310		__field(u64, dst_cp_pos)
2311		__field(u64, cp_count)
2312		__sockaddr(addr, sizeof(struct sockaddr_in6))
2313	),
2314	TP_fast_assign(
2315		const stateid_t *src_stp = &copy->cp_src_stateid;
2316		const stateid_t *dst_stp = &copy->cp_dst_stateid;
2317		const stateid_t *cb_stp = &copy->cp_res.cb_stateid;
2318
2319		__entry->status = be32_to_cpu(copy->nfserr);
2320		__entry->intra = test_bit(NFSD4_COPY_F_INTRA, &copy->cp_flags);
2321		__entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, &copy->cp_flags);
2322		__entry->src_cl_boot = src_stp->si_opaque.so_clid.cl_boot;
2323		__entry->src_cl_id = src_stp->si_opaque.so_clid.cl_id;
2324		__entry->src_so_id = src_stp->si_opaque.so_id;
2325		__entry->src_si_generation = src_stp->si_generation;
2326		__entry->dst_cl_boot = dst_stp->si_opaque.so_clid.cl_boot;
2327		__entry->dst_cl_id = dst_stp->si_opaque.so_clid.cl_id;
2328		__entry->dst_so_id = dst_stp->si_opaque.so_id;
2329		__entry->dst_si_generation = dst_stp->si_generation;
2330		__entry->cb_cl_boot = cb_stp->si_opaque.so_clid.cl_boot;
2331		__entry->cb_cl_id = cb_stp->si_opaque.so_clid.cl_id;
2332		__entry->cb_so_id = cb_stp->si_opaque.so_id;
2333		__entry->cb_si_generation = cb_stp->si_generation;
2334		__entry->src_cp_pos = copy->cp_src_pos;
2335		__entry->dst_cp_pos = copy->cp_dst_pos;
2336		__entry->cp_count = copy->cp_count;
2337		__assign_sockaddr(addr, &copy->cp_clp->cl_addr,
2338				sizeof(struct sockaddr_in6));
2339	),
2340	TP_printk("client=%pISpc status=%d intra=%d async=%d "
2341		"src_client %08x:%08x src_stateid %08x:%08x "
2342		"dst_client %08x:%08x dst_stateid %08x:%08x "
2343		"cb_client %08x:%08x cb_stateid %08x:%08x "
2344		"cp_src_pos=%llu cp_dst_pos=%llu cp_count=%llu",
2345		__get_sockaddr(addr),
2346		__entry->status, __entry->intra, __entry->async,
2347		__entry->src_cl_boot, __entry->src_cl_id,
2348		__entry->src_so_id, __entry->src_si_generation,
2349		__entry->dst_cl_boot, __entry->dst_cl_id,
2350		__entry->dst_so_id, __entry->dst_si_generation,
2351		__entry->cb_cl_boot, __entry->cb_cl_id,
2352		__entry->cb_so_id, __entry->cb_si_generation,
2353		__entry->src_cp_pos, __entry->dst_cp_pos, __entry->cp_count
2354	)
2355);
2356
2357#define DEFINE_COPY_ASYNC_DONE_EVENT(name)		\
2358DEFINE_EVENT(nfsd_copy_async_done_class,		\
2359	nfsd_copy_async_##name,				\
2360	TP_PROTO(const struct nfsd4_copy *copy),	\
2361	TP_ARGS(copy))
2362
2363DEFINE_COPY_ASYNC_DONE_EVENT(done);
2364DEFINE_COPY_ASYNC_DONE_EVENT(cancel);
2365
2366TRACE_EVENT(nfsd_vfs_setattr,
2367	TP_PROTO(
2368		const struct svc_rqst *rqstp,
2369		const struct svc_fh *fhp,
2370		const struct iattr *iap,
2371		const struct timespec64 *guardtime
2372	),
2373	TP_ARGS(rqstp, fhp, iap, guardtime),
2374	TP_STRUCT__entry(
2375		NFSD_TRACE_PROC_CALL_FIELDS(rqstp)
2376		__field(u32, fh_hash)
2377		__field(s64, gtime_tv_sec)
2378		__field(u32, gtime_tv_nsec)
2379		__field(unsigned int, ia_valid)
2380		__field(loff_t, ia_size)
2381		__field(uid_t, ia_uid)
2382		__field(gid_t, ia_gid)
2383		__field(umode_t, ia_mode)
2384	),
2385	TP_fast_assign(
2386		NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp);
2387		__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
2388		__entry->gtime_tv_sec = guardtime ? guardtime->tv_sec : 0;
2389		__entry->gtime_tv_nsec = guardtime ? guardtime->tv_nsec : 0;
2390		__entry->ia_valid = iap->ia_valid;
2391		__entry->ia_size = iap->ia_size;
2392		__entry->ia_uid = __kuid_val(iap->ia_uid);
2393		__entry->ia_gid = __kgid_val(iap->ia_gid);
2394		__entry->ia_mode = iap->ia_mode;
2395	),
2396	TP_printk(
2397		"xid=0x%08x fh_hash=0x%08x ia_valid=%s ia_size=%llu ia_mode=0%o ia_uid=%u ia_gid=%u guard_time=%lld.%u",
2398		__entry->xid, __entry->fh_hash, show_ia_valid_flags(__entry->ia_valid),
2399		__entry->ia_size, __entry->ia_mode, __entry->ia_uid, __entry->ia_gid,
2400		__entry->gtime_tv_sec, __entry->gtime_tv_nsec
2401	)
2402)
2403
2404TRACE_EVENT(nfsd_vfs_lookup,
2405	TP_PROTO(
2406		const struct svc_rqst *rqstp,
2407		const struct svc_fh *fhp,
2408		const char *name,
2409		unsigned int len
2410	),
2411	TP_ARGS(rqstp, fhp, name, len),
2412	TP_STRUCT__entry(
2413		NFSD_TRACE_PROC_CALL_FIELDS(rqstp)
2414		__field(u32, fh_hash)
2415		__string_len(name, name, len)
2416	),
2417	TP_fast_assign(
2418		NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp);
2419		__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
2420		__assign_str(name);
2421	),
2422	TP_printk("xid=0x%08x fh_hash=0x%08x name=%s",
2423		__entry->xid, __entry->fh_hash, __get_str(name)
2424	)
2425);
2426
2427TRACE_EVENT(nfsd_vfs_create,
2428	TP_PROTO(
2429		const struct svc_rqst *rqstp,
2430		const struct svc_fh *fhp,
2431		umode_t type,
2432		const char *name,
2433		unsigned int len
2434	),
2435	TP_ARGS(rqstp, fhp, type, name, len),
2436	TP_STRUCT__entry(
2437		NFSD_TRACE_PROC_CALL_FIELDS(rqstp)
2438		__field(u32, fh_hash)
2439		__field(umode_t, type)
2440		__string_len(name, name, len)
2441	),
2442	TP_fast_assign(
2443		NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp);
2444		__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
2445		__entry->type = type;
2446		__assign_str(name);
2447	),
2448	TP_printk("xid=0x%08x fh_hash=0x%08x type=%s name=%s",
2449		__entry->xid, __entry->fh_hash,
2450		show_fs_file_type(__entry->type), __get_str(name)
2451	)
2452);
2453
2454TRACE_EVENT(nfsd_vfs_symlink,
2455	TP_PROTO(
2456		const struct svc_rqst *rqstp,
2457		const struct svc_fh *fhp,
2458		const char *name,
2459		unsigned int namelen,
2460		const char *target
2461	),
2462	TP_ARGS(rqstp, fhp, name, namelen, target),
2463	TP_STRUCT__entry(
2464		NFSD_TRACE_PROC_CALL_FIELDS(rqstp)
2465		__field(u32, fh_hash)
2466		__string_len(name, name, namelen)
2467		__string(target, target)
2468	),
2469	TP_fast_assign(
2470		NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp);
2471		__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
2472		__assign_str(name);
2473		__assign_str(target);
2474	),
2475	TP_printk("xid=0x%08x fh_hash=0x%08x name=%s target=%s",
2476		__entry->xid, __entry->fh_hash,
2477		__get_str(name), __get_str(target)
2478	)
2479);
2480
2481TRACE_EVENT(nfsd_vfs_link,
2482	TP_PROTO(
2483		const struct svc_rqst *rqstp,
2484		const struct svc_fh *sfhp,
2485		const struct svc_fh *tfhp,
2486		const char *name,
2487		unsigned int namelen
2488	),
2489	TP_ARGS(rqstp, sfhp, tfhp, name, namelen),
2490	TP_STRUCT__entry(
2491		NFSD_TRACE_PROC_CALL_FIELDS(rqstp)
2492		__field(u32, sfh_hash)
2493		__field(u32, tfh_hash)
2494		__string_len(name, name, namelen)
2495	),
2496	TP_fast_assign(
2497		NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp);
2498		__entry->sfh_hash = knfsd_fh_hash(&sfhp->fh_handle);
2499		__entry->tfh_hash = knfsd_fh_hash(&tfhp->fh_handle);
2500		__assign_str(name);
2501	),
2502	TP_printk("xid=0x%08x src_fh=0x%08x tgt_fh=0x%08x name=%s",
2503		__entry->xid, __entry->sfh_hash, __entry->tfh_hash,
2504		__get_str(name)
2505	)
2506);
2507
2508TRACE_EVENT(nfsd_vfs_unlink,
2509	TP_PROTO(
2510		const struct svc_rqst *rqstp,
2511		const struct svc_fh *fhp,
2512		const char *name,
2513		unsigned int len
2514	),
2515	TP_ARGS(rqstp, fhp, name, len),
2516	TP_STRUCT__entry(
2517		NFSD_TRACE_PROC_CALL_FIELDS(rqstp)
2518		__field(u32, fh_hash)
2519		__string_len(name, name, len)
2520	),
2521	TP_fast_assign(
2522		NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp);
2523		__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
2524		__assign_str(name);
2525	),
2526	TP_printk("xid=0x%08x fh_hash=0x%08x name=%s",
2527		__entry->xid, __entry->fh_hash,
2528		__get_str(name)
2529	)
2530);
2531
2532TRACE_EVENT(nfsd_vfs_rename,
2533	TP_PROTO(
2534		const struct svc_rqst *rqstp,
2535		const struct svc_fh *sfhp,
2536		const struct svc_fh *tfhp,
2537		const char *source,
2538		unsigned int sourcelen,
2539		const char *target,
2540		unsigned int targetlen
2541	),
2542	TP_ARGS(rqstp, sfhp, tfhp, source, sourcelen, target, targetlen),
2543	TP_STRUCT__entry(
2544		NFSD_TRACE_PROC_CALL_FIELDS(rqstp)
2545		__field(u32, sfh_hash)
2546		__field(u32, tfh_hash)
2547		__string_len(source, source, sourcelen)
2548		__string_len(target, target, targetlen)
2549	),
2550	TP_fast_assign(
2551		NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp);
2552		__entry->sfh_hash = knfsd_fh_hash(&sfhp->fh_handle);
2553		__entry->tfh_hash = knfsd_fh_hash(&tfhp->fh_handle);
2554		__assign_str(source);
2555		__assign_str(target);
2556	),
2557	TP_printk("xid=0x%08x sfh_hash=0x%08x tfh_hash=0x%08x source=%s target=%s",
2558		__entry->xid, __entry->sfh_hash, __entry->tfh_hash,
2559		__get_str(source), __get_str(target)
2560	)
2561);
2562
2563TRACE_EVENT(nfsd_vfs_readdir,
2564	TP_PROTO(
2565		const struct svc_rqst *rqstp,
2566		const struct svc_fh *fhp,
2567		u32 count,
2568		u64 offset
2569	),
2570	TP_ARGS(rqstp, fhp, count, offset),
2571	TP_STRUCT__entry(
2572		NFSD_TRACE_PROC_CALL_FIELDS(rqstp)
2573		__field(u32, fh_hash)
2574		__field(u32, count)
2575		__field(u64, offset)
2576	),
2577	TP_fast_assign(
2578		NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp);
2579		__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
2580		__entry->count = count;
2581		__entry->offset = offset;
2582	),
2583	TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu count=%u",
2584		__entry->xid, __entry->fh_hash,
2585		__entry->offset, __entry->count
2586	)
2587);
2588
2589DECLARE_EVENT_CLASS(nfsd_vfs_getattr_class,
2590	TP_PROTO(
2591		const struct svc_rqst *rqstp,
2592		const struct svc_fh *fhp
2593	),
2594	TP_ARGS(rqstp, fhp),
2595	TP_STRUCT__entry(
2596		NFSD_TRACE_PROC_CALL_FIELDS(rqstp)
2597		__field(u32, fh_hash)
2598	),
2599	TP_fast_assign(
2600		NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp);
2601		__entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
2602	),
2603	TP_printk("xid=0x%08x fh_hash=0x%08x",
2604		__entry->xid, __entry->fh_hash
2605	)
2606);
2607
2608#define DEFINE_NFSD_VFS_GETATTR_EVENT(__name)		\
2609DEFINE_EVENT(nfsd_vfs_getattr_class, __name,		\
2610	TP_PROTO(					\
2611		const struct svc_rqst *rqstp,		\
2612		const struct svc_fh *fhp		\
2613	),						\
2614	TP_ARGS(rqstp, fhp))
2615
2616DEFINE_NFSD_VFS_GETATTR_EVENT(nfsd_vfs_getattr);
2617DEFINE_NFSD_VFS_GETATTR_EVENT(nfsd_vfs_statfs);
2618
2619DECLARE_EVENT_CLASS(nfsd_pnfs_class,
2620	TP_PROTO(
2621		const struct nfs4_client *clp,
2622		const char *dev,
2623		int error
2624	),
2625	TP_ARGS(clp, dev, error),
2626	TP_STRUCT__entry(
2627		__sockaddr(addr, sizeof(struct sockaddr_in6))
2628		__field(unsigned int, netns_ino)
2629		__string(dev, dev)
2630		__field(int, error)
2631	),
2632	TP_fast_assign(
2633		__assign_sockaddr(addr, &clp->cl_addr,
2634				sizeof(struct sockaddr_in6));
2635		__entry->netns_ino = clp->net->ns.inum;
2636		__assign_str(dev);
2637		__entry->error = error;
2638	),
2639	TP_printk("client=%pISpc nn=%d dev=%s error=%d",
2640		__get_sockaddr(addr),
2641		__entry->netns_ino,
2642		__get_str(dev),
2643		__entry->error
2644	)
2645);
2646
2647#define DEFINE_NFSD_PNFS_ERR_EVENT(name)		\
2648DEFINE_EVENT(nfsd_pnfs_class, nfsd_pnfs_##name,	\
2649	TP_PROTO(					\
2650		const struct nfs4_client *clp,		\
2651		const char *dev,				\
2652		int error				\
2653	),						\
2654	TP_ARGS(clp, dev, error))
2655
2656DEFINE_NFSD_PNFS_ERR_EVENT(fence);
2657#endif /* _NFSD_TRACE_H */
2658
2659#undef TRACE_INCLUDE_PATH
2660#define TRACE_INCLUDE_PATH .
2661#define TRACE_INCLUDE_FILE trace
2662#include <trace/define_trace.h>