1/* SPDX-License-Identifier: GPL-2.0 */
   2/*
   3 * Copyright (c) 2013 Trond Myklebust <Trond.Myklebust@netapp.com>
   4 */
   5#undef TRACE_SYSTEM
   6#define TRACE_SYSTEM nfs4
   7
   8#if !defined(_TRACE_NFS4_H) || defined(TRACE_HEADER_MULTI_READ)
   9#define _TRACE_NFS4_H
  10
  11#include <linux/tracepoint.h>
  12#include <trace/misc/sunrpc.h>
  13
  14#include <trace/misc/fs.h>
  15#include <trace/misc/nfs.h>
  16
  17#define show_nfs_fattr_flags(valid) \
  18	__print_flags((unsigned long)valid, "|", \
  19		{ NFS_ATTR_FATTR_TYPE, "TYPE" }, \
  20		{ NFS_ATTR_FATTR_MODE, "MODE" }, \
  21		{ NFS_ATTR_FATTR_NLINK, "NLINK" }, \
  22		{ NFS_ATTR_FATTR_OWNER, "OWNER" }, \
  23		{ NFS_ATTR_FATTR_GROUP, "GROUP" }, \
  24		{ NFS_ATTR_FATTR_RDEV, "RDEV" }, \
  25		{ NFS_ATTR_FATTR_SIZE, "SIZE" }, \
  26		{ NFS_ATTR_FATTR_FSID, "FSID" }, \
  27		{ NFS_ATTR_FATTR_FILEID, "FILEID" }, \
  28		{ NFS_ATTR_FATTR_ATIME, "ATIME" }, \
  29		{ NFS_ATTR_FATTR_MTIME, "MTIME" }, \
  30		{ NFS_ATTR_FATTR_CTIME, "CTIME" }, \
  31		{ NFS_ATTR_FATTR_CHANGE, "CHANGE" }, \
  32		{ NFS_ATTR_FATTR_OWNER_NAME, "OWNER_NAME" }, \
  33		{ NFS_ATTR_FATTR_GROUP_NAME, "GROUP_NAME" })
  34
  35DECLARE_EVENT_CLASS(nfs4_clientid_event,
  36		TP_PROTO(
  37			const struct nfs_client *clp,
  38			int error
  39		),
  40
  41		TP_ARGS(clp, error),
  42
  43		TP_STRUCT__entry(
  44			__string(dstaddr, clp->cl_hostname)
  45			__field(unsigned long, error)
  46		),
  47
  48		TP_fast_assign(
  49			__entry->error = error < 0 ? -error : 0;
  50			__assign_str(dstaddr, clp->cl_hostname);
  51		),
  52
  53		TP_printk(
  54			"error=%ld (%s) dstaddr=%s",
  55			-__entry->error,
  56			show_nfs4_status(__entry->error),
  57			__get_str(dstaddr)
  58		)
  59);
  60#define DEFINE_NFS4_CLIENTID_EVENT(name) \
  61	DEFINE_EVENT(nfs4_clientid_event, name,	 \
  62			TP_PROTO( \
  63				const struct nfs_client *clp, \
  64				int error \
  65			), \
  66			TP_ARGS(clp, error))
  67DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid);
  68DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid_confirm);
  69DEFINE_NFS4_CLIENTID_EVENT(nfs4_renew);
  70DEFINE_NFS4_CLIENTID_EVENT(nfs4_renew_async);
  71#ifdef CONFIG_NFS_V4_1
  72DEFINE_NFS4_CLIENTID_EVENT(nfs4_exchange_id);
  73DEFINE_NFS4_CLIENTID_EVENT(nfs4_create_session);
  74DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_session);
  75DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_clientid);
  76DEFINE_NFS4_CLIENTID_EVENT(nfs4_bind_conn_to_session);
  77DEFINE_NFS4_CLIENTID_EVENT(nfs4_sequence);
  78DEFINE_NFS4_CLIENTID_EVENT(nfs4_reclaim_complete);
  79
  80TRACE_EVENT(nfs4_trunked_exchange_id,
  81		TP_PROTO(
  82			const struct nfs_client *clp,
  83			const char *addr,
  84			int error
  85		),
  86
  87		TP_ARGS(clp, addr, error),
  88
  89		TP_STRUCT__entry(
  90			__string(main_addr, clp->cl_hostname)
  91			__string(trunk_addr, addr)
  92			__field(unsigned long, error)
  93		),
  94
  95		TP_fast_assign(
  96			__entry->error = error < 0 ? -error : 0;
  97			__assign_str(main_addr, clp->cl_hostname);
  98			__assign_str(trunk_addr, addr);
  99		),
 100
 101		TP_printk(
 102			"error=%ld (%s) main_addr=%s trunk_addr=%s",
 103			-__entry->error,
 104			show_nfs4_status(__entry->error),
 105			__get_str(main_addr),
 106			__get_str(trunk_addr)
 107		)
 108);
 109
 110TRACE_EVENT(nfs4_sequence_done,
 111		TP_PROTO(
 112			const struct nfs4_session *session,
 113			const struct nfs4_sequence_res *res
 114		),
 115		TP_ARGS(session, res),
 116
 117		TP_STRUCT__entry(
 118			__field(unsigned int, session)
 119			__field(unsigned int, slot_nr)
 120			__field(unsigned int, seq_nr)
 121			__field(unsigned int, highest_slotid)
 122			__field(unsigned int, target_highest_slotid)
 123			__field(unsigned long, status_flags)
 124			__field(unsigned long, error)
 125		),
 126
 127		TP_fast_assign(
 128			const struct nfs4_slot *sr_slot = res->sr_slot;
 129			__entry->session = nfs_session_id_hash(&session->sess_id);
 130			__entry->slot_nr = sr_slot->slot_nr;
 131			__entry->seq_nr = sr_slot->seq_nr;
 132			__entry->highest_slotid = res->sr_highest_slotid;
 133			__entry->target_highest_slotid =
 134					res->sr_target_highest_slotid;
 135			__entry->status_flags = res->sr_status_flags;
 136			__entry->error = res->sr_status < 0 ?
 137					-res->sr_status : 0;
 138		),
 139		TP_printk(
 140			"error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
 141			"highest_slotid=%u target_highest_slotid=%u "
 142			"status_flags=0x%lx (%s)",
 143			-__entry->error,
 144			show_nfs4_status(__entry->error),
 145			__entry->session,
 146			__entry->slot_nr,
 147			__entry->seq_nr,
 148			__entry->highest_slotid,
 149			__entry->target_highest_slotid,
 150			__entry->status_flags,
 151			show_nfs4_seq4_status(__entry->status_flags)
 152		)
 153);
 154
 155struct cb_sequenceargs;
 156struct cb_sequenceres;
 157
 158TRACE_EVENT(nfs4_cb_sequence,
 159		TP_PROTO(
 160			const struct cb_sequenceargs *args,
 161			const struct cb_sequenceres *res,
 162			__be32 status
 163		),
 164		TP_ARGS(args, res, status),
 165
 166		TP_STRUCT__entry(
 167			__field(unsigned int, session)
 168			__field(unsigned int, slot_nr)
 169			__field(unsigned int, seq_nr)
 170			__field(unsigned int, highest_slotid)
 171			__field(unsigned int, cachethis)
 172			__field(unsigned long, error)
 173		),
 174
 175		TP_fast_assign(
 176			__entry->session = nfs_session_id_hash(&args->csa_sessionid);
 177			__entry->slot_nr = args->csa_slotid;
 178			__entry->seq_nr = args->csa_sequenceid;
 179			__entry->highest_slotid = args->csa_highestslotid;
 180			__entry->cachethis = args->csa_cachethis;
 181			__entry->error = be32_to_cpu(status);
 182		),
 183
 184		TP_printk(
 185			"error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
 186			"highest_slotid=%u",
 187			-__entry->error,
 188			show_nfs4_status(__entry->error),
 189			__entry->session,
 190			__entry->slot_nr,
 191			__entry->seq_nr,
 192			__entry->highest_slotid
 193		)
 194);
 195
 196TRACE_EVENT(nfs4_cb_seqid_err,
 197		TP_PROTO(
 198			const struct cb_sequenceargs *args,
 199			__be32 status
 200		),
 201		TP_ARGS(args, status),
 202
 203		TP_STRUCT__entry(
 204			__field(unsigned int, session)
 205			__field(unsigned int, slot_nr)
 206			__field(unsigned int, seq_nr)
 207			__field(unsigned int, highest_slotid)
 208			__field(unsigned int, cachethis)
 209			__field(unsigned long, error)
 210		),
 211
 212		TP_fast_assign(
 213			__entry->session = nfs_session_id_hash(&args->csa_sessionid);
 214			__entry->slot_nr = args->csa_slotid;
 215			__entry->seq_nr = args->csa_sequenceid;
 216			__entry->highest_slotid = args->csa_highestslotid;
 217			__entry->cachethis = args->csa_cachethis;
 218			__entry->error = be32_to_cpu(status);
 219		),
 220
 221		TP_printk(
 222			"error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
 223			"highest_slotid=%u",
 224			-__entry->error,
 225			show_nfs4_status(__entry->error),
 226			__entry->session,
 227			__entry->slot_nr,
 228			__entry->seq_nr,
 229			__entry->highest_slotid
 230		)
 231);
 232
 233TRACE_EVENT(nfs4_cb_offload,
 234		TP_PROTO(
 235			const struct nfs_fh *cb_fh,
 236			const nfs4_stateid *cb_stateid,
 237			uint64_t cb_count,
 238			int cb_error,
 239			int cb_how_stable
 240		),
 241
 242		TP_ARGS(cb_fh, cb_stateid, cb_count, cb_error,
 243			cb_how_stable),
 244
 245		TP_STRUCT__entry(
 246			__field(unsigned long, error)
 247			__field(u32, fhandle)
 248			__field(loff_t, cb_count)
 249			__field(int, cb_how)
 250			__field(int, cb_stateid_seq)
 251			__field(u32, cb_stateid_hash)
 252		),
 253
 254		TP_fast_assign(
 255			__entry->error = cb_error < 0 ? -cb_error : 0;
 256			__entry->fhandle = nfs_fhandle_hash(cb_fh);
 257			__entry->cb_stateid_seq =
 258				be32_to_cpu(cb_stateid->seqid);
 259			__entry->cb_stateid_hash =
 260				nfs_stateid_hash(cb_stateid);
 261			__entry->cb_count = cb_count;
 262			__entry->cb_how = cb_how_stable;
 263		),
 264
 265		TP_printk(
 266			"error=%ld (%s) fhandle=0x%08x cb_stateid=%d:0x%08x "
 267			"cb_count=%llu cb_how=%s",
 268			-__entry->error,
 269			show_nfs4_status(__entry->error),
 270			__entry->fhandle,
 271			__entry->cb_stateid_seq, __entry->cb_stateid_hash,
 272			__entry->cb_count,
 273			show_nfs_stable_how(__entry->cb_how)
 274		)
 275);
 276#endif /* CONFIG_NFS_V4_1 */
 277
 278TRACE_EVENT(nfs4_setup_sequence,
 279		TP_PROTO(
 280			const struct nfs4_session *session,
 281			const struct nfs4_sequence_args *args
 282		),
 283		TP_ARGS(session, args),
 284
 285		TP_STRUCT__entry(
 286			__field(unsigned int, session)
 287			__field(unsigned int, slot_nr)
 288			__field(unsigned int, seq_nr)
 289			__field(unsigned int, highest_used_slotid)
 290		),
 291
 292		TP_fast_assign(
 293			const struct nfs4_slot *sa_slot = args->sa_slot;
 294			__entry->session = session ? nfs_session_id_hash(&session->sess_id) : 0;
 295			__entry->slot_nr = sa_slot->slot_nr;
 296			__entry->seq_nr = sa_slot->seq_nr;
 297			__entry->highest_used_slotid =
 298					sa_slot->table->highest_used_slotid;
 299		),
 300		TP_printk(
 301			"session=0x%08x slot_nr=%u seq_nr=%u "
 302			"highest_used_slotid=%u",
 303			__entry->session,
 304			__entry->slot_nr,
 305			__entry->seq_nr,
 306			__entry->highest_used_slotid
 307		)
 308);
 309
 310TRACE_DEFINE_ENUM(NFS4CLNT_MANAGER_RUNNING);
 311TRACE_DEFINE_ENUM(NFS4CLNT_CHECK_LEASE);
 312TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_EXPIRED);
 313TRACE_DEFINE_ENUM(NFS4CLNT_RECLAIM_REBOOT);
 314TRACE_DEFINE_ENUM(NFS4CLNT_RECLAIM_NOGRACE);
 315TRACE_DEFINE_ENUM(NFS4CLNT_DELEGRETURN);
 316TRACE_DEFINE_ENUM(NFS4CLNT_SESSION_RESET);
 317TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_CONFIRM);
 318TRACE_DEFINE_ENUM(NFS4CLNT_SERVER_SCOPE_MISMATCH);
 319TRACE_DEFINE_ENUM(NFS4CLNT_PURGE_STATE);
 320TRACE_DEFINE_ENUM(NFS4CLNT_BIND_CONN_TO_SESSION);
 321TRACE_DEFINE_ENUM(NFS4CLNT_MOVED);
 322TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_MOVED);
 323TRACE_DEFINE_ENUM(NFS4CLNT_DELEGATION_EXPIRED);
 324TRACE_DEFINE_ENUM(NFS4CLNT_RUN_MANAGER);
 325TRACE_DEFINE_ENUM(NFS4CLNT_MANAGER_AVAILABLE);
 326TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_RUNNING);
 327TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_ANY_LAYOUT_READ);
 328TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_ANY_LAYOUT_RW);
 329TRACE_DEFINE_ENUM(NFS4CLNT_DELEGRETURN_DELAYED);
 330
 331#define show_nfs4_clp_state(state) \
 332	__print_flags(state, "|", \
 333	{ BIT(NFS4CLNT_MANAGER_RUNNING),	"MANAGER_RUNNING" }, \
 334	{ BIT(NFS4CLNT_CHECK_LEASE),		"CHECK_LEASE" }, \
 335	{ BIT(NFS4CLNT_LEASE_EXPIRED),	"LEASE_EXPIRED" }, \
 336	{ BIT(NFS4CLNT_RECLAIM_REBOOT),	"RECLAIM_REBOOT" }, \
 337	{ BIT(NFS4CLNT_RECLAIM_NOGRACE),	"RECLAIM_NOGRACE" }, \
 338	{ BIT(NFS4CLNT_DELEGRETURN),		"DELEGRETURN" }, \
 339	{ BIT(NFS4CLNT_SESSION_RESET),	"SESSION_RESET" }, \
 340	{ BIT(NFS4CLNT_LEASE_CONFIRM),	"LEASE_CONFIRM" }, \
 341	{ BIT(NFS4CLNT_SERVER_SCOPE_MISMATCH),	"SERVER_SCOPE_MISMATCH" }, \
 342	{ BIT(NFS4CLNT_PURGE_STATE),		"PURGE_STATE" }, \
 343	{ BIT(NFS4CLNT_BIND_CONN_TO_SESSION),	"BIND_CONN_TO_SESSION" }, \
 344	{ BIT(NFS4CLNT_MOVED),		"MOVED" }, \
 345	{ BIT(NFS4CLNT_LEASE_MOVED),		"LEASE_MOVED" }, \
 346	{ BIT(NFS4CLNT_DELEGATION_EXPIRED),	"DELEGATION_EXPIRED" }, \
 347	{ BIT(NFS4CLNT_RUN_MANAGER),		"RUN_MANAGER" }, \
 348	{ BIT(NFS4CLNT_MANAGER_AVAILABLE), "MANAGER_AVAILABLE" }, \
 349	{ BIT(NFS4CLNT_RECALL_RUNNING),	"RECALL_RUNNING" }, \
 350	{ BIT(NFS4CLNT_RECALL_ANY_LAYOUT_READ), "RECALL_ANY_LAYOUT_READ" }, \
 351	{ BIT(NFS4CLNT_RECALL_ANY_LAYOUT_RW), "RECALL_ANY_LAYOUT_RW" }, \
 352	{ BIT(NFS4CLNT_DELEGRETURN_DELAYED), "DELERETURN_DELAYED" })
 353
 354TRACE_EVENT(nfs4_state_mgr,
 355		TP_PROTO(
 356			const struct nfs_client *clp
 357		),
 358
 359		TP_ARGS(clp),
 360
 361		TP_STRUCT__entry(
 362			__field(unsigned long, state)
 363			__string(hostname, clp->cl_hostname)
 364		),
 365
 366		TP_fast_assign(
 367			__entry->state = clp->cl_state;
 368			__assign_str(hostname, clp->cl_hostname);
 369		),
 370
 371		TP_printk(
 372			"hostname=%s clp state=%s", __get_str(hostname),
 373			show_nfs4_clp_state(__entry->state)
 374		)
 375)
 376
 377TRACE_EVENT(nfs4_state_mgr_failed,
 378		TP_PROTO(
 379			const struct nfs_client *clp,
 380			const char *section,
 381			int status
 382		),
 383
 384		TP_ARGS(clp, section, status),
 385
 386		TP_STRUCT__entry(
 387			__field(unsigned long, error)
 388			__field(unsigned long, state)
 389			__string(hostname, clp->cl_hostname)
 390			__string(section, section)
 391		),
 392
 393		TP_fast_assign(
 394			__entry->error = status < 0 ? -status : 0;
 395			__entry->state = clp->cl_state;
 396			__assign_str(hostname, clp->cl_hostname);
 397			__assign_str(section, section);
 398		),
 399
 400		TP_printk(
 401			"hostname=%s clp state=%s error=%ld (%s) section=%s",
 402			__get_str(hostname),
 403			show_nfs4_clp_state(__entry->state), -__entry->error,
 404			show_nfs4_status(__entry->error), __get_str(section)
 405
 406		)
 407)
 408
 409TRACE_EVENT(nfs4_xdr_bad_operation,
 410		TP_PROTO(
 411			const struct xdr_stream *xdr,
 412			u32 op,
 413			u32 expected
 414		),
 415
 416		TP_ARGS(xdr, op, expected),
 417
 418		TP_STRUCT__entry(
 419			__field(unsigned int, task_id)
 420			__field(unsigned int, client_id)
 421			__field(u32, xid)
 422			__field(u32, op)
 423			__field(u32, expected)
 424		),
 425
 426		TP_fast_assign(
 427			const struct rpc_rqst *rqstp = xdr->rqst;
 428			const struct rpc_task *task = rqstp->rq_task;
 429
 430			__entry->task_id = task->tk_pid;
 431			__entry->client_id = task->tk_client->cl_clid;
 432			__entry->xid = be32_to_cpu(rqstp->rq_xid);
 433			__entry->op = op;
 434			__entry->expected = expected;
 435		),
 436
 437		TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 438			  " xid=0x%08x operation=%u, expected=%u",
 439			__entry->task_id, __entry->client_id, __entry->xid,
 440			__entry->op, __entry->expected
 441		)
 442);
 443
 444DECLARE_EVENT_CLASS(nfs4_xdr_event,
 445		TP_PROTO(
 446			const struct xdr_stream *xdr,
 447			u32 op,
 448			u32 error
 449		),
 450
 451		TP_ARGS(xdr, op, error),
 452
 453		TP_STRUCT__entry(
 454			__field(unsigned int, task_id)
 455			__field(unsigned int, client_id)
 456			__field(u32, xid)
 457			__field(u32, op)
 458			__field(unsigned long, error)
 459		),
 460
 461		TP_fast_assign(
 462			const struct rpc_rqst *rqstp = xdr->rqst;
 463			const struct rpc_task *task = rqstp->rq_task;
 464
 465			__entry->task_id = task->tk_pid;
 466			__entry->client_id = task->tk_client->cl_clid;
 467			__entry->xid = be32_to_cpu(rqstp->rq_xid);
 468			__entry->op = op;
 469			__entry->error = error;
 470		),
 471
 472		TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 473			  " xid=0x%08x error=%ld (%s) operation=%u",
 474			__entry->task_id, __entry->client_id, __entry->xid,
 475			-__entry->error, show_nfs4_status(__entry->error),
 476			__entry->op
 477		)
 478);
 479#define DEFINE_NFS4_XDR_EVENT(name) \
 480	DEFINE_EVENT(nfs4_xdr_event, name, \
 481			TP_PROTO( \
 482				const struct xdr_stream *xdr, \
 483				u32 op, \
 484				u32 error \
 485			), \
 486			TP_ARGS(xdr, op, error))
 487DEFINE_NFS4_XDR_EVENT(nfs4_xdr_status);
 488DEFINE_NFS4_XDR_EVENT(nfs4_xdr_bad_filehandle);
 489
 490DECLARE_EVENT_CLASS(nfs4_cb_error_class,
 491		TP_PROTO(
 492			__be32 xid,
 493			u32 cb_ident
 494		),
 495
 496		TP_ARGS(xid, cb_ident),
 497
 498		TP_STRUCT__entry(
 499			__field(u32, xid)
 500			__field(u32, cbident)
 501		),
 502
 503		TP_fast_assign(
 504			__entry->xid = be32_to_cpu(xid);
 505			__entry->cbident = cb_ident;
 506		),
 507
 508		TP_printk(
 509			"xid=0x%08x cb_ident=0x%08x",
 510			__entry->xid, __entry->cbident
 511		)
 512);
 513
 514#define DEFINE_CB_ERROR_EVENT(name) \
 515	DEFINE_EVENT(nfs4_cb_error_class, nfs_cb_##name, \
 516			TP_PROTO( \
 517				__be32 xid, \
 518				u32 cb_ident \
 519			), \
 520			TP_ARGS(xid, cb_ident))
 521
 522DEFINE_CB_ERROR_EVENT(no_clp);
 523DEFINE_CB_ERROR_EVENT(badprinc);
 524
 525DECLARE_EVENT_CLASS(nfs4_open_event,
 526		TP_PROTO(
 527			const struct nfs_open_context *ctx,
 528			int flags,
 529			int error
 530		),
 531
 532		TP_ARGS(ctx, flags, error),
 533
 534		TP_STRUCT__entry(
 535			__field(unsigned long, error)
 536			__field(unsigned long, flags)
 537			__field(unsigned long, fmode)
 538			__field(dev_t, dev)
 539			__field(u32, fhandle)
 540			__field(u64, fileid)
 541			__field(u64, dir)
 542			__string(name, ctx->dentry->d_name.name)
 543			__field(int, stateid_seq)
 544			__field(u32, stateid_hash)
 545			__field(int, openstateid_seq)
 546			__field(u32, openstateid_hash)
 547		),
 548
 549		TP_fast_assign(
 550			const struct nfs4_state *state = ctx->state;
 551			const struct inode *inode = NULL;
 552
 553			__entry->error = -error;
 554			__entry->flags = flags;
 555			__entry->fmode = (__force unsigned long)ctx->mode;
 556			__entry->dev = ctx->dentry->d_sb->s_dev;
 557			if (!IS_ERR_OR_NULL(state)) {
 558				inode = state->inode;
 559				__entry->stateid_seq =
 560					be32_to_cpu(state->stateid.seqid);
 561				__entry->stateid_hash =
 562					nfs_stateid_hash(&state->stateid);
 563				__entry->openstateid_seq =
 564					be32_to_cpu(state->open_stateid.seqid);
 565				__entry->openstateid_hash =
 566					nfs_stateid_hash(&state->open_stateid);
 567			} else {
 568				__entry->stateid_seq = 0;
 569				__entry->stateid_hash = 0;
 570				__entry->openstateid_seq = 0;
 571				__entry->openstateid_hash = 0;
 572			}
 573			if (inode != NULL) {
 574				__entry->fileid = NFS_FILEID(inode);
 575				__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
 576			} else {
 577				__entry->fileid = 0;
 578				__entry->fhandle = 0;
 579			}
 580			__entry->dir = NFS_FILEID(d_inode(ctx->dentry->d_parent));
 581			__assign_str(name, ctx->dentry->d_name.name);
 582		),
 583
 584		TP_printk(
 585			"error=%ld (%s) flags=%lu (%s) fmode=%s "
 586			"fileid=%02x:%02x:%llu fhandle=0x%08x "
 587			"name=%02x:%02x:%llu/%s stateid=%d:0x%08x "
 588			"openstateid=%d:0x%08x",
 589			 -__entry->error,
 590			 show_nfs4_status(__entry->error),
 591			 __entry->flags,
 592			 show_fs_fcntl_open_flags(__entry->flags),
 593			 show_fs_fmode_flags(__entry->fmode),
 594			 MAJOR(__entry->dev), MINOR(__entry->dev),
 595			 (unsigned long long)__entry->fileid,
 596			 __entry->fhandle,
 597			 MAJOR(__entry->dev), MINOR(__entry->dev),
 598			 (unsigned long long)__entry->dir,
 599			 __get_str(name),
 600			 __entry->stateid_seq, __entry->stateid_hash,
 601			 __entry->openstateid_seq, __entry->openstateid_hash
 602		)
 603);
 604
 605#define DEFINE_NFS4_OPEN_EVENT(name) \
 606	DEFINE_EVENT(nfs4_open_event, name, \
 607			TP_PROTO( \
 608				const struct nfs_open_context *ctx, \
 609				int flags, \
 610				int error \
 611			), \
 612			TP_ARGS(ctx, flags, error))
 613DEFINE_NFS4_OPEN_EVENT(nfs4_open_reclaim);
 614DEFINE_NFS4_OPEN_EVENT(nfs4_open_expired);
 615DEFINE_NFS4_OPEN_EVENT(nfs4_open_file);
 616
 617TRACE_EVENT(nfs4_cached_open,
 618		TP_PROTO(
 619			const struct nfs4_state *state
 620		),
 621		TP_ARGS(state),
 622		TP_STRUCT__entry(
 623			__field(dev_t, dev)
 624			__field(u32, fhandle)
 625			__field(u64, fileid)
 626			__field(unsigned int, fmode)
 627			__field(int, stateid_seq)
 628			__field(u32, stateid_hash)
 629		),
 630
 631		TP_fast_assign(
 632			const struct inode *inode = state->inode;
 633
 634			__entry->dev = inode->i_sb->s_dev;
 635			__entry->fileid = NFS_FILEID(inode);
 636			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
 637			__entry->fmode = (__force unsigned int)state->state;
 638			__entry->stateid_seq =
 639				be32_to_cpu(state->stateid.seqid);
 640			__entry->stateid_hash =
 641				nfs_stateid_hash(&state->stateid);
 642		),
 643
 644		TP_printk(
 645			"fmode=%s fileid=%02x:%02x:%llu "
 646			"fhandle=0x%08x stateid=%d:0x%08x",
 647			__entry->fmode ?  show_fs_fmode_flags(__entry->fmode) :
 648					  "closed",
 649			MAJOR(__entry->dev), MINOR(__entry->dev),
 650			(unsigned long long)__entry->fileid,
 651			__entry->fhandle,
 652			__entry->stateid_seq, __entry->stateid_hash
 653		)
 654);
 655
 656TRACE_EVENT(nfs4_close,
 657		TP_PROTO(
 658			const struct nfs4_state *state,
 659			const struct nfs_closeargs *args,
 660			const struct nfs_closeres *res,
 661			int error
 662		),
 663
 664		TP_ARGS(state, args, res, error),
 665
 666		TP_STRUCT__entry(
 667			__field(dev_t, dev)
 668			__field(u32, fhandle)
 669			__field(u64, fileid)
 670			__field(unsigned int, fmode)
 671			__field(unsigned long, error)
 672			__field(int, stateid_seq)
 673			__field(u32, stateid_hash)
 674		),
 675
 676		TP_fast_assign(
 677			const struct inode *inode = state->inode;
 678
 679			__entry->dev = inode->i_sb->s_dev;
 680			__entry->fileid = NFS_FILEID(inode);
 681			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
 682			__entry->fmode = (__force unsigned int)state->state;
 683			__entry->error = error < 0 ? -error : 0;
 684			__entry->stateid_seq =
 685				be32_to_cpu(args->stateid.seqid);
 686			__entry->stateid_hash =
 687				nfs_stateid_hash(&args->stateid);
 688		),
 689
 690		TP_printk(
 691			"error=%ld (%s) fmode=%s fileid=%02x:%02x:%llu "
 692			"fhandle=0x%08x openstateid=%d:0x%08x",
 693			-__entry->error,
 694			show_nfs4_status(__entry->error),
 695			__entry->fmode ?  show_fs_fmode_flags(__entry->fmode) :
 696					  "closed",
 697			MAJOR(__entry->dev), MINOR(__entry->dev),
 698			(unsigned long long)__entry->fileid,
 699			__entry->fhandle,
 700			__entry->stateid_seq, __entry->stateid_hash
 701		)
 702);
 703
 704DECLARE_EVENT_CLASS(nfs4_lock_event,
 705		TP_PROTO(
 706			const struct file_lock *request,
 707			const struct nfs4_state *state,
 708			int cmd,
 709			int error
 710		),
 711
 712		TP_ARGS(request, state, cmd, error),
 713
 714		TP_STRUCT__entry(
 715			__field(unsigned long, error)
 716			__field(unsigned long, cmd)
 717			__field(unsigned long, type)
 718			__field(loff_t, start)
 719			__field(loff_t, end)
 720			__field(dev_t, dev)
 721			__field(u32, fhandle)
 722			__field(u64, fileid)
 723			__field(int, stateid_seq)
 724			__field(u32, stateid_hash)
 725		),
 726
 727		TP_fast_assign(
 728			const struct inode *inode = state->inode;
 729
 730			__entry->error = error < 0 ? -error : 0;
 731			__entry->cmd = cmd;
 732			__entry->type = request->c.flc_type;
 733			__entry->start = request->fl_start;
 734			__entry->end = request->fl_end;
 735			__entry->dev = inode->i_sb->s_dev;
 736			__entry->fileid = NFS_FILEID(inode);
 737			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
 738			__entry->stateid_seq =
 739				be32_to_cpu(state->stateid.seqid);
 740			__entry->stateid_hash =
 741				nfs_stateid_hash(&state->stateid);
 742		),
 743
 744		TP_printk(
 745			"error=%ld (%s) cmd=%s:%s range=%lld:%lld "
 746			"fileid=%02x:%02x:%llu fhandle=0x%08x "
 747			"stateid=%d:0x%08x",
 748			-__entry->error,
 749			show_nfs4_status(__entry->error),
 750			show_fs_fcntl_cmd(__entry->cmd),
 751			show_fs_fcntl_lock_type(__entry->type),
 752			(long long)__entry->start,
 753			(long long)__entry->end,
 754			MAJOR(__entry->dev), MINOR(__entry->dev),
 755			(unsigned long long)__entry->fileid,
 756			__entry->fhandle,
 757			__entry->stateid_seq, __entry->stateid_hash
 758		)
 759);
 760
 761#define DEFINE_NFS4_LOCK_EVENT(name) \
 762	DEFINE_EVENT(nfs4_lock_event, name, \
 763			TP_PROTO( \
 764				const struct file_lock *request, \
 765				const struct nfs4_state *state, \
 766				int cmd, \
 767				int error \
 768			), \
 769			TP_ARGS(request, state, cmd, error))
 770DEFINE_NFS4_LOCK_EVENT(nfs4_get_lock);
 771DEFINE_NFS4_LOCK_EVENT(nfs4_unlock);
 772
 773TRACE_EVENT(nfs4_set_lock,
 774		TP_PROTO(
 775			const struct file_lock *request,
 776			const struct nfs4_state *state,
 777			const nfs4_stateid *lockstateid,
 778			int cmd,
 779			int error
 780		),
 781
 782		TP_ARGS(request, state, lockstateid, cmd, error),
 783
 784		TP_STRUCT__entry(
 785			__field(unsigned long, error)
 786			__field(unsigned long, cmd)
 787			__field(unsigned long, type)
 788			__field(loff_t, start)
 789			__field(loff_t, end)
 790			__field(dev_t, dev)
 791			__field(u32, fhandle)
 792			__field(u64, fileid)
 793			__field(int, stateid_seq)
 794			__field(u32, stateid_hash)
 795			__field(int, lockstateid_seq)
 796			__field(u32, lockstateid_hash)
 797		),
 798
 799		TP_fast_assign(
 800			const struct inode *inode = state->inode;
 801
 802			__entry->error = error < 0 ? -error : 0;
 803			__entry->cmd = cmd;
 804			__entry->type = request->c.flc_type;
 805			__entry->start = request->fl_start;
 806			__entry->end = request->fl_end;
 807			__entry->dev = inode->i_sb->s_dev;
 808			__entry->fileid = NFS_FILEID(inode);
 809			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
 810			__entry->stateid_seq =
 811				be32_to_cpu(state->stateid.seqid);
 812			__entry->stateid_hash =
 813				nfs_stateid_hash(&state->stateid);
 814			__entry->lockstateid_seq =
 815				be32_to_cpu(lockstateid->seqid);
 816			__entry->lockstateid_hash =
 817				nfs_stateid_hash(lockstateid);
 818		),
 819
 820		TP_printk(
 821			"error=%ld (%s) cmd=%s:%s range=%lld:%lld "
 822			"fileid=%02x:%02x:%llu fhandle=0x%08x "
 823			"stateid=%d:0x%08x lockstateid=%d:0x%08x",
 824			-__entry->error,
 825			show_nfs4_status(__entry->error),
 826			show_fs_fcntl_cmd(__entry->cmd),
 827			show_fs_fcntl_lock_type(__entry->type),
 828			(long long)__entry->start,
 829			(long long)__entry->end,
 830			MAJOR(__entry->dev), MINOR(__entry->dev),
 831			(unsigned long long)__entry->fileid,
 832			__entry->fhandle,
 833			__entry->stateid_seq, __entry->stateid_hash,
 834			__entry->lockstateid_seq, __entry->lockstateid_hash
 835		)
 836);
 837
 838TRACE_DEFINE_ENUM(LK_STATE_IN_USE);
 839TRACE_DEFINE_ENUM(NFS_DELEGATED_STATE);
 840TRACE_DEFINE_ENUM(NFS_OPEN_STATE);
 841TRACE_DEFINE_ENUM(NFS_O_RDONLY_STATE);
 842TRACE_DEFINE_ENUM(NFS_O_WRONLY_STATE);
 843TRACE_DEFINE_ENUM(NFS_O_RDWR_STATE);
 844TRACE_DEFINE_ENUM(NFS_STATE_RECLAIM_REBOOT);
 845TRACE_DEFINE_ENUM(NFS_STATE_RECLAIM_NOGRACE);
 846TRACE_DEFINE_ENUM(NFS_STATE_POSIX_LOCKS);
 847TRACE_DEFINE_ENUM(NFS_STATE_RECOVERY_FAILED);
 848TRACE_DEFINE_ENUM(NFS_STATE_MAY_NOTIFY_LOCK);
 849TRACE_DEFINE_ENUM(NFS_STATE_CHANGE_WAIT);
 850TRACE_DEFINE_ENUM(NFS_CLNT_DST_SSC_COPY_STATE);
 851TRACE_DEFINE_ENUM(NFS_CLNT_SRC_SSC_COPY_STATE);
 852TRACE_DEFINE_ENUM(NFS_SRV_SSC_COPY_STATE);
 853
 854#define show_nfs4_state_flags(flags) \
 855	__print_flags(flags, "|", \
 856		{ LK_STATE_IN_USE,		"IN_USE" }, \
 857		{ NFS_DELEGATED_STATE,		"DELEGATED" }, \
 858		{ NFS_OPEN_STATE,		"OPEN" }, \
 859		{ NFS_O_RDONLY_STATE,		"O_RDONLY" }, \
 860		{ NFS_O_WRONLY_STATE,		"O_WRONLY" }, \
 861		{ NFS_O_RDWR_STATE,		"O_RDWR" }, \
 862		{ NFS_STATE_RECLAIM_REBOOT,	"RECLAIM_REBOOT" }, \
 863		{ NFS_STATE_RECLAIM_NOGRACE,	"RECLAIM_NOGRACE" }, \
 864		{ NFS_STATE_POSIX_LOCKS,	"POSIX_LOCKS" }, \
 865		{ NFS_STATE_RECOVERY_FAILED,	"RECOVERY_FAILED" }, \
 866		{ NFS_STATE_MAY_NOTIFY_LOCK,	"MAY_NOTIFY_LOCK" }, \
 867		{ NFS_STATE_CHANGE_WAIT,	"CHANGE_WAIT" }, \
 868		{ NFS_CLNT_DST_SSC_COPY_STATE,	"CLNT_DST_SSC_COPY" }, \
 869		{ NFS_CLNT_SRC_SSC_COPY_STATE,	"CLNT_SRC_SSC_COPY" }, \
 870		{ NFS_SRV_SSC_COPY_STATE,	"SRV_SSC_COPY" })
 871
 872#define show_nfs4_lock_flags(flags) \
 873	__print_flags(flags, "|", \
 874		{ BIT(NFS_LOCK_INITIALIZED),	"INITIALIZED" }, \
 875		{ BIT(NFS_LOCK_LOST),		"LOST" })
 876
 877TRACE_EVENT(nfs4_state_lock_reclaim,
 878		TP_PROTO(
 879			const struct nfs4_state *state,
 880			const struct nfs4_lock_state *lock
 881		),
 882
 883		TP_ARGS(state, lock),
 884
 885		TP_STRUCT__entry(
 886			__field(dev_t, dev)
 887			__field(u32, fhandle)
 888			__field(u64, fileid)
 889			__field(unsigned long, state_flags)
 890			__field(unsigned long, lock_flags)
 891			__field(int, stateid_seq)
 892			__field(u32, stateid_hash)
 893		),
 894
 895		TP_fast_assign(
 896			const struct inode *inode = state->inode;
 897
 898			__entry->dev = inode->i_sb->s_dev;
 899			__entry->fileid = NFS_FILEID(inode);
 900			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
 901			__entry->state_flags = state->flags;
 902			__entry->lock_flags = lock->ls_flags;
 903			__entry->stateid_seq =
 904				be32_to_cpu(state->stateid.seqid);
 905			__entry->stateid_hash =
 906				nfs_stateid_hash(&state->stateid);
 907		),
 908
 909		TP_printk(
 910			"fileid=%02x:%02x:%llu fhandle=0x%08x "
 911			"stateid=%d:0x%08x state_flags=%s lock_flags=%s",
 912			MAJOR(__entry->dev), MINOR(__entry->dev),
 913			(unsigned long long)__entry->fileid, __entry->fhandle,
 914			__entry->stateid_seq, __entry->stateid_hash,
 915			show_nfs4_state_flags(__entry->state_flags),
 916			show_nfs4_lock_flags(__entry->lock_flags)
 917		)
 918)
 919
 920DECLARE_EVENT_CLASS(nfs4_set_delegation_event,
 921		TP_PROTO(
 922			const struct inode *inode,
 923			fmode_t fmode
 924		),
 925
 926		TP_ARGS(inode, fmode),
 927
 928		TP_STRUCT__entry(
 929			__field(dev_t, dev)
 930			__field(u32, fhandle)
 931			__field(u64, fileid)
 932			__field(unsigned int, fmode)
 933		),
 934
 935		TP_fast_assign(
 936			__entry->dev = inode->i_sb->s_dev;
 937			__entry->fileid = NFS_FILEID(inode);
 938			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
 939			__entry->fmode = (__force unsigned int)fmode;
 940		),
 941
 942		TP_printk(
 943			"fmode=%s fileid=%02x:%02x:%llu fhandle=0x%08x",
 944			show_fs_fmode_flags(__entry->fmode),
 945			MAJOR(__entry->dev), MINOR(__entry->dev),
 946			(unsigned long long)__entry->fileid,
 947			__entry->fhandle
 948		)
 949);
 950#define DEFINE_NFS4_SET_DELEGATION_EVENT(name) \
 951	DEFINE_EVENT(nfs4_set_delegation_event, name, \
 952			TP_PROTO( \
 953				const struct inode *inode, \
 954				fmode_t fmode \
 955			), \
 956			TP_ARGS(inode, fmode))
 957DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_set_delegation);
 958DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_reclaim_delegation);
 959
 960TRACE_EVENT(nfs4_delegreturn_exit,
 961		TP_PROTO(
 962			const struct nfs4_delegreturnargs *args,
 963			const struct nfs4_delegreturnres *res,
 964			int error
 965		),
 966
 967		TP_ARGS(args, res, error),
 968
 969		TP_STRUCT__entry(
 970			__field(dev_t, dev)
 971			__field(u32, fhandle)
 972			__field(unsigned long, error)
 973			__field(int, stateid_seq)
 974			__field(u32, stateid_hash)
 975		),
 976
 977		TP_fast_assign(
 978			__entry->dev = res->server->s_dev;
 979			__entry->fhandle = nfs_fhandle_hash(args->fhandle);
 980			__entry->error = error < 0 ? -error : 0;
 981			__entry->stateid_seq =
 982				be32_to_cpu(args->stateid->seqid);
 983			__entry->stateid_hash =
 984				nfs_stateid_hash(args->stateid);
 985		),
 986
 987		TP_printk(
 988			"error=%ld (%s) dev=%02x:%02x fhandle=0x%08x "
 989			"stateid=%d:0x%08x",
 990			-__entry->error,
 991			show_nfs4_status(__entry->error),
 992			MAJOR(__entry->dev), MINOR(__entry->dev),
 993			__entry->fhandle,
 994			__entry->stateid_seq, __entry->stateid_hash
 995		)
 996);
 997
 998#ifdef CONFIG_NFS_V4_1
 999DECLARE_EVENT_CLASS(nfs4_test_stateid_event,
1000		TP_PROTO(
1001			const struct nfs4_state *state,
1002			const struct nfs4_lock_state *lsp,
1003			int error
1004		),
1005
1006		TP_ARGS(state, lsp, error),
1007
1008		TP_STRUCT__entry(
1009			__field(unsigned long, error)
1010			__field(dev_t, dev)
1011			__field(u32, fhandle)
1012			__field(u64, fileid)
1013			__field(int, stateid_seq)
1014			__field(u32, stateid_hash)
1015		),
1016
1017		TP_fast_assign(
1018			const struct inode *inode = state->inode;
1019
1020			__entry->error = error < 0 ? -error : 0;
1021			__entry->dev = inode->i_sb->s_dev;
1022			__entry->fileid = NFS_FILEID(inode);
1023			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1024			__entry->stateid_seq =
1025				be32_to_cpu(state->stateid.seqid);
1026			__entry->stateid_hash =
1027				nfs_stateid_hash(&state->stateid);
1028		),
1029
1030		TP_printk(
1031			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1032			"stateid=%d:0x%08x",
1033			-__entry->error,
1034			show_nfs4_status(__entry->error),
1035			MAJOR(__entry->dev), MINOR(__entry->dev),
1036			(unsigned long long)__entry->fileid,
1037			__entry->fhandle,
1038			__entry->stateid_seq, __entry->stateid_hash
1039		)
1040);
1041
1042#define DEFINE_NFS4_TEST_STATEID_EVENT(name) \
1043	DEFINE_EVENT(nfs4_test_stateid_event, name, \
1044			TP_PROTO( \
1045				const struct nfs4_state *state, \
1046				const struct nfs4_lock_state *lsp, \
1047				int error \
1048			), \
1049			TP_ARGS(state, lsp, error))
1050DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_delegation_stateid);
1051DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_open_stateid);
1052DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_lock_stateid);
1053#endif /* CONFIG_NFS_V4_1 */
1054
1055DECLARE_EVENT_CLASS(nfs4_lookup_event,
1056		TP_PROTO(
1057			const struct inode *dir,
1058			const struct qstr *name,
1059			int error
1060		),
1061
1062		TP_ARGS(dir, name, error),
1063
1064		TP_STRUCT__entry(
1065			__field(dev_t, dev)
1066			__field(unsigned long, error)
1067			__field(u64, dir)
1068			__string(name, name->name)
1069		),
1070
1071		TP_fast_assign(
1072			__entry->dev = dir->i_sb->s_dev;
1073			__entry->dir = NFS_FILEID(dir);
1074			__entry->error = -error;
1075			__assign_str(name, name->name);
1076		),
1077
1078		TP_printk(
1079			"error=%ld (%s) name=%02x:%02x:%llu/%s",
1080			-__entry->error,
1081			show_nfs4_status(__entry->error),
1082			MAJOR(__entry->dev), MINOR(__entry->dev),
1083			(unsigned long long)__entry->dir,
1084			__get_str(name)
1085		)
1086);
1087
1088#define DEFINE_NFS4_LOOKUP_EVENT(name) \
1089	DEFINE_EVENT(nfs4_lookup_event, name, \
1090			TP_PROTO( \
1091				const struct inode *dir, \
1092				const struct qstr *name, \
1093				int error \
1094			), \
1095			TP_ARGS(dir, name, error))
1096
1097DEFINE_NFS4_LOOKUP_EVENT(nfs4_lookup);
1098DEFINE_NFS4_LOOKUP_EVENT(nfs4_symlink);
1099DEFINE_NFS4_LOOKUP_EVENT(nfs4_mkdir);
1100DEFINE_NFS4_LOOKUP_EVENT(nfs4_mknod);
1101DEFINE_NFS4_LOOKUP_EVENT(nfs4_remove);
1102DEFINE_NFS4_LOOKUP_EVENT(nfs4_get_fs_locations);
1103DEFINE_NFS4_LOOKUP_EVENT(nfs4_secinfo);
1104
1105TRACE_EVENT(nfs4_lookupp,
1106		TP_PROTO(
1107			const struct inode *inode,
1108			int error
1109		),
1110
1111		TP_ARGS(inode, error),
1112
1113		TP_STRUCT__entry(
1114			__field(dev_t, dev)
1115			__field(u64, ino)
1116			__field(unsigned long, error)
1117		),
1118
1119		TP_fast_assign(
1120			__entry->dev = inode->i_sb->s_dev;
1121			__entry->ino = NFS_FILEID(inode);
1122			__entry->error = error < 0 ? -error : 0;
1123		),
1124
1125		TP_printk(
1126			"error=%ld (%s) inode=%02x:%02x:%llu",
1127			-__entry->error,
1128			show_nfs4_status(__entry->error),
1129			MAJOR(__entry->dev), MINOR(__entry->dev),
1130			(unsigned long long)__entry->ino
1131		)
1132);
1133
1134TRACE_EVENT(nfs4_rename,
1135		TP_PROTO(
1136			const struct inode *olddir,
1137			const struct qstr *oldname,
1138			const struct inode *newdir,
1139			const struct qstr *newname,
1140			int error
1141		),
1142
1143		TP_ARGS(olddir, oldname, newdir, newname, error),
1144
1145		TP_STRUCT__entry(
1146			__field(dev_t, dev)
1147			__field(unsigned long, error)
1148			__field(u64, olddir)
1149			__string(oldname, oldname->name)
1150			__field(u64, newdir)
1151			__string(newname, newname->name)
1152		),
1153
1154		TP_fast_assign(
1155			__entry->dev = olddir->i_sb->s_dev;
1156			__entry->olddir = NFS_FILEID(olddir);
1157			__entry->newdir = NFS_FILEID(newdir);
1158			__entry->error = error < 0 ? -error : 0;
1159			__assign_str(oldname, oldname->name);
1160			__assign_str(newname, newname->name);
1161		),
1162
1163		TP_printk(
1164			"error=%ld (%s) oldname=%02x:%02x:%llu/%s "
1165			"newname=%02x:%02x:%llu/%s",
1166			-__entry->error,
1167			show_nfs4_status(__entry->error),
1168			MAJOR(__entry->dev), MINOR(__entry->dev),
1169			(unsigned long long)__entry->olddir,
1170			__get_str(oldname),
1171			MAJOR(__entry->dev), MINOR(__entry->dev),
1172			(unsigned long long)__entry->newdir,
1173			__get_str(newname)
1174		)
1175);
1176
1177DECLARE_EVENT_CLASS(nfs4_inode_event,
1178		TP_PROTO(
1179			const struct inode *inode,
1180			int error
1181		),
1182
1183		TP_ARGS(inode, error),
1184
1185		TP_STRUCT__entry(
1186			__field(dev_t, dev)
1187			__field(u32, fhandle)
1188			__field(u64, fileid)
1189			__field(unsigned long, error)
1190		),
1191
1192		TP_fast_assign(
1193			__entry->dev = inode->i_sb->s_dev;
1194			__entry->fileid = NFS_FILEID(inode);
1195			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1196			__entry->error = error < 0 ? -error : 0;
1197		),
1198
1199		TP_printk(
1200			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x",
1201			-__entry->error,
1202			show_nfs4_status(__entry->error),
1203			MAJOR(__entry->dev), MINOR(__entry->dev),
1204			(unsigned long long)__entry->fileid,
1205			__entry->fhandle
1206		)
1207);
1208
1209#define DEFINE_NFS4_INODE_EVENT(name) \
1210	DEFINE_EVENT(nfs4_inode_event, name, \
1211			TP_PROTO( \
1212				const struct inode *inode, \
1213				int error \
1214			), \
1215			TP_ARGS(inode, error))
1216
1217DEFINE_NFS4_INODE_EVENT(nfs4_access);
1218DEFINE_NFS4_INODE_EVENT(nfs4_readlink);
1219DEFINE_NFS4_INODE_EVENT(nfs4_readdir);
1220DEFINE_NFS4_INODE_EVENT(nfs4_get_acl);
1221DEFINE_NFS4_INODE_EVENT(nfs4_set_acl);
1222#ifdef CONFIG_NFS_V4_SECURITY_LABEL
1223DEFINE_NFS4_INODE_EVENT(nfs4_get_security_label);
1224DEFINE_NFS4_INODE_EVENT(nfs4_set_security_label);
1225#endif /* CONFIG_NFS_V4_SECURITY_LABEL */
1226
1227DECLARE_EVENT_CLASS(nfs4_inode_stateid_event,
1228		TP_PROTO(
1229			const struct inode *inode,
1230			const nfs4_stateid *stateid,
1231			int error
1232		),
1233
1234		TP_ARGS(inode, stateid, error),
1235
1236		TP_STRUCT__entry(
1237			__field(dev_t, dev)
1238			__field(u32, fhandle)
1239			__field(u64, fileid)
1240			__field(unsigned long, error)
1241			__field(int, stateid_seq)
1242			__field(u32, stateid_hash)
1243		),
1244
1245		TP_fast_assign(
1246			__entry->dev = inode->i_sb->s_dev;
1247			__entry->fileid = NFS_FILEID(inode);
1248			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1249			__entry->error = error < 0 ? -error : 0;
1250			__entry->stateid_seq =
1251				be32_to_cpu(stateid->seqid);
1252			__entry->stateid_hash =
1253				nfs_stateid_hash(stateid);
1254		),
1255
1256		TP_printk(
1257			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1258			"stateid=%d:0x%08x",
1259			-__entry->error,
1260			show_nfs4_status(__entry->error),
1261			MAJOR(__entry->dev), MINOR(__entry->dev),
1262			(unsigned long long)__entry->fileid,
1263			__entry->fhandle,
1264			__entry->stateid_seq, __entry->stateid_hash
1265		)
1266);
1267
1268#define DEFINE_NFS4_INODE_STATEID_EVENT(name) \
1269	DEFINE_EVENT(nfs4_inode_stateid_event, name, \
1270			TP_PROTO( \
1271				const struct inode *inode, \
1272				const nfs4_stateid *stateid, \
1273				int error \
1274			), \
1275			TP_ARGS(inode, stateid, error))
1276
1277DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_setattr);
1278DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_delegreturn);
1279DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update);
1280DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update_wait);
1281DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_close_stateid_update_wait);
1282
1283DECLARE_EVENT_CLASS(nfs4_getattr_event,
1284		TP_PROTO(
1285			const struct nfs_server *server,
1286			const struct nfs_fh *fhandle,
1287			const struct nfs_fattr *fattr,
1288			int error
1289		),
1290
1291		TP_ARGS(server, fhandle, fattr, error),
1292
1293		TP_STRUCT__entry(
1294			__field(dev_t, dev)
1295			__field(u32, fhandle)
1296			__field(u64, fileid)
1297			__field(unsigned int, valid)
1298			__field(unsigned long, error)
1299		),
1300
1301		TP_fast_assign(
1302			__entry->dev = server->s_dev;
1303			__entry->valid = fattr->valid;
1304			__entry->fhandle = nfs_fhandle_hash(fhandle);
1305			__entry->fileid = (fattr->valid & NFS_ATTR_FATTR_FILEID) ? fattr->fileid : 0;
1306			__entry->error = error < 0 ? -error : 0;
1307		),
1308
1309		TP_printk(
1310			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1311			"valid=%s",
1312			-__entry->error,
1313			show_nfs4_status(__entry->error),
1314			MAJOR(__entry->dev), MINOR(__entry->dev),
1315			(unsigned long long)__entry->fileid,
1316			__entry->fhandle,
1317			show_nfs_fattr_flags(__entry->valid)
1318		)
1319);
1320
1321#define DEFINE_NFS4_GETATTR_EVENT(name) \
1322	DEFINE_EVENT(nfs4_getattr_event, name, \
1323			TP_PROTO( \
1324				const struct nfs_server *server, \
1325				const struct nfs_fh *fhandle, \
1326				const struct nfs_fattr *fattr, \
1327				int error \
1328			), \
1329			TP_ARGS(server, fhandle, fattr, error))
1330DEFINE_NFS4_GETATTR_EVENT(nfs4_getattr);
1331DEFINE_NFS4_GETATTR_EVENT(nfs4_lookup_root);
1332DEFINE_NFS4_GETATTR_EVENT(nfs4_fsinfo);
1333
1334DECLARE_EVENT_CLASS(nfs4_inode_callback_event,
1335		TP_PROTO(
1336			const struct nfs_client *clp,
1337			const struct nfs_fh *fhandle,
1338			const struct inode *inode,
1339			int error
1340		),
1341
1342		TP_ARGS(clp, fhandle, inode, error),
1343
1344		TP_STRUCT__entry(
1345			__field(unsigned long, error)
1346			__field(dev_t, dev)
1347			__field(u32, fhandle)
1348			__field(u64, fileid)
1349			__string(dstaddr, clp ? clp->cl_hostname : "unknown")
1350		),
1351
1352		TP_fast_assign(
1353			__entry->error = error < 0 ? -error : 0;
1354			__entry->fhandle = nfs_fhandle_hash(fhandle);
1355			if (!IS_ERR_OR_NULL(inode)) {
1356				__entry->fileid = NFS_FILEID(inode);
1357				__entry->dev = inode->i_sb->s_dev;
1358			} else {
1359				__entry->fileid = 0;
1360				__entry->dev = 0;
1361			}
1362			__assign_str(dstaddr, clp ? clp->cl_hostname : "unknown");
1363		),
1364
1365		TP_printk(
1366			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1367			"dstaddr=%s",
1368			-__entry->error,
1369			show_nfs4_status(__entry->error),
1370			MAJOR(__entry->dev), MINOR(__entry->dev),
1371			(unsigned long long)__entry->fileid,
1372			__entry->fhandle,
1373			__get_str(dstaddr)
1374		)
1375);
1376
1377#define DEFINE_NFS4_INODE_CALLBACK_EVENT(name) \
1378	DEFINE_EVENT(nfs4_inode_callback_event, name, \
1379			TP_PROTO( \
1380				const struct nfs_client *clp, \
1381				const struct nfs_fh *fhandle, \
1382				const struct inode *inode, \
1383				int error \
1384			), \
1385			TP_ARGS(clp, fhandle, inode, error))
1386DEFINE_NFS4_INODE_CALLBACK_EVENT(nfs4_cb_getattr);
1387
1388DECLARE_EVENT_CLASS(nfs4_inode_stateid_callback_event,
1389		TP_PROTO(
1390			const struct nfs_client *clp,
1391			const struct nfs_fh *fhandle,
1392			const struct inode *inode,
1393			const nfs4_stateid *stateid,
1394			int error
1395		),
1396
1397		TP_ARGS(clp, fhandle, inode, stateid, error),
1398
1399		TP_STRUCT__entry(
1400			__field(unsigned long, error)
1401			__field(dev_t, dev)
1402			__field(u32, fhandle)
1403			__field(u64, fileid)
1404			__string(dstaddr, clp ? clp->cl_hostname : "unknown")
1405			__field(int, stateid_seq)
1406			__field(u32, stateid_hash)
1407		),
1408
1409		TP_fast_assign(
1410			__entry->error = error < 0 ? -error : 0;
1411			__entry->fhandle = nfs_fhandle_hash(fhandle);
1412			if (!IS_ERR_OR_NULL(inode)) {
1413				__entry->fileid = NFS_FILEID(inode);
1414				__entry->dev = inode->i_sb->s_dev;
1415			} else {
1416				__entry->fileid = 0;
1417				__entry->dev = 0;
1418			}
1419			__assign_str(dstaddr, clp ? clp->cl_hostname : "unknown");
1420			__entry->stateid_seq =
1421				be32_to_cpu(stateid->seqid);
1422			__entry->stateid_hash =
1423				nfs_stateid_hash(stateid);
1424		),
1425
1426		TP_printk(
1427			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1428			"stateid=%d:0x%08x dstaddr=%s",
1429			-__entry->error,
1430			show_nfs4_status(__entry->error),
1431			MAJOR(__entry->dev), MINOR(__entry->dev),
1432			(unsigned long long)__entry->fileid,
1433			__entry->fhandle,
1434			__entry->stateid_seq, __entry->stateid_hash,
1435			__get_str(dstaddr)
1436		)
1437);
1438
1439#define DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(name) \
1440	DEFINE_EVENT(nfs4_inode_stateid_callback_event, name, \
1441			TP_PROTO( \
1442				const struct nfs_client *clp, \
1443				const struct nfs_fh *fhandle, \
1444				const struct inode *inode, \
1445				const nfs4_stateid *stateid, \
1446				int error \
1447			), \
1448			TP_ARGS(clp, fhandle, inode, stateid, error))
1449DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_recall);
1450DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_layoutrecall_file);
1451
1452DECLARE_EVENT_CLASS(nfs4_idmap_event,
1453		TP_PROTO(
1454			const char *name,
1455			int len,
1456			u32 id,
1457			int error
1458		),
1459
1460		TP_ARGS(name, len, id, error),
1461
1462		TP_STRUCT__entry(
1463			__field(unsigned long, error)
1464			__field(u32, id)
1465			__dynamic_array(char, name, len > 0 ? len + 1 : 1)
1466		),
1467
1468		TP_fast_assign(
1469			if (len < 0)
1470				len = 0;
1471			__entry->error = error < 0 ? error : 0;
1472			__entry->id = id;
1473			memcpy(__get_str(name), name, len);
1474			__get_str(name)[len] = 0;
1475		),
1476
1477		TP_printk(
1478			"error=%ld (%s) id=%u name=%s",
1479			-__entry->error, show_nfs4_status(__entry->error),
1480			__entry->id,
1481			__get_str(name)
1482		)
1483);
1484#define DEFINE_NFS4_IDMAP_EVENT(name) \
1485	DEFINE_EVENT(nfs4_idmap_event, name, \
1486			TP_PROTO( \
1487				const char *name, \
1488				int len, \
1489				u32 id, \
1490				int error \
1491			), \
1492			TP_ARGS(name, len, id, error))
1493DEFINE_NFS4_IDMAP_EVENT(nfs4_map_name_to_uid);
1494DEFINE_NFS4_IDMAP_EVENT(nfs4_map_group_to_gid);
1495DEFINE_NFS4_IDMAP_EVENT(nfs4_map_uid_to_name);
1496DEFINE_NFS4_IDMAP_EVENT(nfs4_map_gid_to_group);
1497
1498#ifdef CONFIG_NFS_V4_1
1499#define NFS4_LSEG_LAYOUT_STATEID_HASH(lseg) \
1500	(lseg ? nfs_stateid_hash(&lseg->pls_layout->plh_stateid) : 0)
1501#else
1502#define NFS4_LSEG_LAYOUT_STATEID_HASH(lseg) (0)
1503#endif
1504
1505DECLARE_EVENT_CLASS(nfs4_read_event,
1506		TP_PROTO(
1507			const struct nfs_pgio_header *hdr,
1508			int error
1509		),
1510
1511		TP_ARGS(hdr, error),
1512
1513		TP_STRUCT__entry(
1514			__field(dev_t, dev)
1515			__field(u32, fhandle)
1516			__field(u64, fileid)
1517			__field(loff_t, offset)
1518			__field(u32, arg_count)
1519			__field(u32, res_count)
1520			__field(unsigned long, error)
1521			__field(int, stateid_seq)
1522			__field(u32, stateid_hash)
1523			__field(int, layoutstateid_seq)
1524			__field(u32, layoutstateid_hash)
1525		),
1526
1527		TP_fast_assign(
1528			const struct inode *inode = hdr->inode;
1529			const struct nfs_inode *nfsi = NFS_I(inode);
1530			const struct nfs_fh *fh = hdr->args.fh ?
1531						  hdr->args.fh : &nfsi->fh;
1532			const struct nfs4_state *state =
1533				hdr->args.context->state;
1534			const struct pnfs_layout_segment *lseg = hdr->lseg;
1535
1536			__entry->dev = inode->i_sb->s_dev;
1537			__entry->fileid = nfsi->fileid;
1538			__entry->fhandle = nfs_fhandle_hash(fh);
1539			__entry->offset = hdr->args.offset;
1540			__entry->arg_count = hdr->args.count;
1541			__entry->res_count = hdr->res.count;
1542			__entry->error = error < 0 ? -error : 0;
1543			__entry->stateid_seq =
1544				be32_to_cpu(state->stateid.seqid);
1545			__entry->stateid_hash =
1546				nfs_stateid_hash(&state->stateid);
1547			__entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
1548			__entry->layoutstateid_hash =
1549				NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
1550		),
1551
1552		TP_printk(
1553			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1554			"offset=%lld count=%u res=%u stateid=%d:0x%08x "
1555			"layoutstateid=%d:0x%08x",
1556			-__entry->error,
1557			show_nfs4_status(__entry->error),
1558			MAJOR(__entry->dev), MINOR(__entry->dev),
1559			(unsigned long long)__entry->fileid,
1560			__entry->fhandle,
1561			(long long)__entry->offset,
1562			__entry->arg_count, __entry->res_count,
1563			__entry->stateid_seq, __entry->stateid_hash,
1564			__entry->layoutstateid_seq, __entry->layoutstateid_hash
1565		)
1566);
1567#define DEFINE_NFS4_READ_EVENT(name) \
1568	DEFINE_EVENT(nfs4_read_event, name, \
1569			TP_PROTO( \
1570				const struct nfs_pgio_header *hdr, \
1571				int error \
1572			), \
1573			TP_ARGS(hdr, error))
1574DEFINE_NFS4_READ_EVENT(nfs4_read);
1575#ifdef CONFIG_NFS_V4_1
1576DEFINE_NFS4_READ_EVENT(nfs4_pnfs_read);
1577#endif /* CONFIG_NFS_V4_1 */
1578
1579DECLARE_EVENT_CLASS(nfs4_write_event,
1580		TP_PROTO(
1581			const struct nfs_pgio_header *hdr,
1582			int error
1583		),
1584
1585		TP_ARGS(hdr, error),
1586
1587		TP_STRUCT__entry(
1588			__field(dev_t, dev)
1589			__field(u32, fhandle)
1590			__field(u64, fileid)
1591			__field(loff_t, offset)
1592			__field(u32, arg_count)
1593			__field(u32, res_count)
1594			__field(unsigned long, error)
1595			__field(int, stateid_seq)
1596			__field(u32, stateid_hash)
1597			__field(int, layoutstateid_seq)
1598			__field(u32, layoutstateid_hash)
1599		),
1600
1601		TP_fast_assign(
1602			const struct inode *inode = hdr->inode;
1603			const struct nfs_inode *nfsi = NFS_I(inode);
1604			const struct nfs_fh *fh = hdr->args.fh ?
1605						  hdr->args.fh : &nfsi->fh;
1606			const struct nfs4_state *state =
1607				hdr->args.context->state;
1608			const struct pnfs_layout_segment *lseg = hdr->lseg;
1609
1610			__entry->dev = inode->i_sb->s_dev;
1611			__entry->fileid = nfsi->fileid;
1612			__entry->fhandle = nfs_fhandle_hash(fh);
1613			__entry->offset = hdr->args.offset;
1614			__entry->arg_count = hdr->args.count;
1615			__entry->res_count = hdr->res.count;
1616			__entry->error = error < 0 ? -error : 0;
1617			__entry->stateid_seq =
1618				be32_to_cpu(state->stateid.seqid);
1619			__entry->stateid_hash =
1620				nfs_stateid_hash(&state->stateid);
1621			__entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
1622			__entry->layoutstateid_hash =
1623				NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
1624		),
1625
1626		TP_printk(
1627			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1628			"offset=%lld count=%u res=%u stateid=%d:0x%08x "
1629			"layoutstateid=%d:0x%08x",
1630			-__entry->error,
1631			show_nfs4_status(__entry->error),
1632			MAJOR(__entry->dev), MINOR(__entry->dev),
1633			(unsigned long long)__entry->fileid,
1634			__entry->fhandle,
1635			(long long)__entry->offset,
1636			__entry->arg_count, __entry->res_count,
1637			__entry->stateid_seq, __entry->stateid_hash,
1638			__entry->layoutstateid_seq, __entry->layoutstateid_hash
1639		)
1640);
1641
1642#define DEFINE_NFS4_WRITE_EVENT(name) \
1643	DEFINE_EVENT(nfs4_write_event, name, \
1644			TP_PROTO( \
1645				const struct nfs_pgio_header *hdr, \
1646				int error \
1647			), \
1648			TP_ARGS(hdr, error))
1649DEFINE_NFS4_WRITE_EVENT(nfs4_write);
1650#ifdef CONFIG_NFS_V4_1
1651DEFINE_NFS4_WRITE_EVENT(nfs4_pnfs_write);
1652#endif /* CONFIG_NFS_V4_1 */
1653
1654DECLARE_EVENT_CLASS(nfs4_commit_event,
1655		TP_PROTO(
1656			const struct nfs_commit_data *data,
1657			int error
1658		),
1659
1660		TP_ARGS(data, error),
1661
1662		TP_STRUCT__entry(
1663			__field(dev_t, dev)
1664			__field(u32, fhandle)
1665			__field(u64, fileid)
1666			__field(unsigned long, error)
1667			__field(loff_t, offset)
1668			__field(u32, count)
1669			__field(int, layoutstateid_seq)
1670			__field(u32, layoutstateid_hash)
1671		),
1672
1673		TP_fast_assign(
1674			const struct inode *inode = data->inode;
1675			const struct nfs_inode *nfsi = NFS_I(inode);
1676			const struct nfs_fh *fh = data->args.fh ?
1677						  data->args.fh : &nfsi->fh;
1678			const struct pnfs_layout_segment *lseg = data->lseg;
1679
1680			__entry->dev = inode->i_sb->s_dev;
1681			__entry->fileid = nfsi->fileid;
1682			__entry->fhandle = nfs_fhandle_hash(fh);
1683			__entry->offset = data->args.offset;
1684			__entry->count = data->args.count;
1685			__entry->error = error < 0 ? -error : 0;
1686			__entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
1687			__entry->layoutstateid_hash =
1688				NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
1689		),
1690
1691		TP_printk(
1692			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1693			"offset=%lld count=%u layoutstateid=%d:0x%08x",
1694			-__entry->error,
1695			show_nfs4_status(__entry->error),
1696			MAJOR(__entry->dev), MINOR(__entry->dev),
1697			(unsigned long long)__entry->fileid,
1698			__entry->fhandle,
1699			(long long)__entry->offset,
1700			__entry->count,
1701			__entry->layoutstateid_seq, __entry->layoutstateid_hash
1702		)
1703);
1704#define DEFINE_NFS4_COMMIT_EVENT(name) \
1705	DEFINE_EVENT(nfs4_commit_event, name, \
1706			TP_PROTO( \
1707				const struct nfs_commit_data *data, \
1708				int error \
1709			), \
1710			TP_ARGS(data, error))
1711DEFINE_NFS4_COMMIT_EVENT(nfs4_commit);
1712#ifdef CONFIG_NFS_V4_1
1713DEFINE_NFS4_COMMIT_EVENT(nfs4_pnfs_commit_ds);
1714
1715TRACE_EVENT(nfs4_layoutget,
1716		TP_PROTO(
1717			const struct nfs_open_context *ctx,
1718			const struct pnfs_layout_range *args,
1719			const struct pnfs_layout_range *res,
1720			const nfs4_stateid *layout_stateid,
1721			int error
1722		),
1723
1724		TP_ARGS(ctx, args, res, layout_stateid, error),
1725
1726		TP_STRUCT__entry(
1727			__field(dev_t, dev)
1728			__field(u32, fhandle)
1729			__field(u64, fileid)
1730			__field(u32, iomode)
1731			__field(u64, offset)
1732			__field(u64, count)
1733			__field(unsigned long, error)
1734			__field(int, stateid_seq)
1735			__field(u32, stateid_hash)
1736			__field(int, layoutstateid_seq)
1737			__field(u32, layoutstateid_hash)
1738		),
1739
1740		TP_fast_assign(
1741			const struct inode *inode = d_inode(ctx->dentry);
1742			const struct nfs4_state *state = ctx->state;
1743			__entry->dev = inode->i_sb->s_dev;
1744			__entry->fileid = NFS_FILEID(inode);
1745			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1746			__entry->iomode = args->iomode;
1747			__entry->offset = args->offset;
1748			__entry->count = args->length;
1749			__entry->error = error < 0 ? -error : 0;
1750			__entry->stateid_seq =
1751				be32_to_cpu(state->stateid.seqid);
1752			__entry->stateid_hash =
1753				nfs_stateid_hash(&state->stateid);
1754			if (!error) {
1755				__entry->layoutstateid_seq =
1756				be32_to_cpu(layout_stateid->seqid);
1757				__entry->layoutstateid_hash =
1758				nfs_stateid_hash(layout_stateid);
1759			} else {
1760				__entry->layoutstateid_seq = 0;
1761				__entry->layoutstateid_hash = 0;
1762			}
1763		),
1764
1765		TP_printk(
1766			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1767			"iomode=%s offset=%llu count=%llu stateid=%d:0x%08x "
1768			"layoutstateid=%d:0x%08x",
1769			-__entry->error,
1770			show_nfs4_status(__entry->error),
1771			MAJOR(__entry->dev), MINOR(__entry->dev),
1772			(unsigned long long)__entry->fileid,
1773			__entry->fhandle,
1774			show_pnfs_layout_iomode(__entry->iomode),
1775			(unsigned long long)__entry->offset,
1776			(unsigned long long)__entry->count,
1777			__entry->stateid_seq, __entry->stateid_hash,
1778			__entry->layoutstateid_seq, __entry->layoutstateid_hash
1779		)
1780);
1781
1782DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutcommit);
1783DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn);
1784DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn_on_close);
1785DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layouterror);
1786DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutstats);
1787
1788TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_UNKNOWN);
1789TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NO_PNFS);
1790TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RD_ZEROLEN);
1791TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_MDSTHRESH);
1792TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NOMEM);
1793TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_BULK_RECALL);
1794TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_IO_TEST_FAIL);
1795TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_FOUND_CACHED);
1796TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RETURN);
1797TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_BLOCKED);
1798TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_INVALID_OPEN);
1799TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RETRY);
1800TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET);
1801TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_EXIT);
1802
1803#define show_pnfs_update_layout_reason(reason)				\
1804	__print_symbolic(reason,					\
1805		{ PNFS_UPDATE_LAYOUT_UNKNOWN, "unknown" },		\
1806		{ PNFS_UPDATE_LAYOUT_NO_PNFS, "no pnfs" },		\
1807		{ PNFS_UPDATE_LAYOUT_RD_ZEROLEN, "read+zerolen" },	\
1808		{ PNFS_UPDATE_LAYOUT_MDSTHRESH, "mdsthresh" },		\
1809		{ PNFS_UPDATE_LAYOUT_NOMEM, "nomem" },			\
1810		{ PNFS_UPDATE_LAYOUT_BULK_RECALL, "bulk recall" },	\
1811		{ PNFS_UPDATE_LAYOUT_IO_TEST_FAIL, "io test fail" },	\
1812		{ PNFS_UPDATE_LAYOUT_FOUND_CACHED, "found cached" },	\
1813		{ PNFS_UPDATE_LAYOUT_RETURN, "layoutreturn" },		\
1814		{ PNFS_UPDATE_LAYOUT_BLOCKED, "layouts blocked" },	\
1815		{ PNFS_UPDATE_LAYOUT_INVALID_OPEN, "invalid open" },	\
1816		{ PNFS_UPDATE_LAYOUT_RETRY, "retrying" },	\
1817		{ PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET, "sent layoutget" }, \
1818		{ PNFS_UPDATE_LAYOUT_EXIT, "exit" })
1819
1820TRACE_EVENT(pnfs_update_layout,
1821		TP_PROTO(struct inode *inode,
1822			loff_t pos,
1823			u64 count,
1824			enum pnfs_iomode iomode,
1825			struct pnfs_layout_hdr *lo,
1826			struct pnfs_layout_segment *lseg,
1827			enum pnfs_update_layout_reason reason
1828		),
1829		TP_ARGS(inode, pos, count, iomode, lo, lseg, reason),
1830		TP_STRUCT__entry(
1831			__field(dev_t, dev)
1832			__field(u64, fileid)
1833			__field(u32, fhandle)
1834			__field(loff_t, pos)
1835			__field(u64, count)
1836			__field(enum pnfs_iomode, iomode)
1837			__field(int, layoutstateid_seq)
1838			__field(u32, layoutstateid_hash)
1839			__field(long, lseg)
1840			__field(enum pnfs_update_layout_reason, reason)
1841		),
1842		TP_fast_assign(
1843			__entry->dev = inode->i_sb->s_dev;
1844			__entry->fileid = NFS_FILEID(inode);
1845			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1846			__entry->pos = pos;
1847			__entry->count = count;
1848			__entry->iomode = iomode;
1849			__entry->reason = reason;
1850			if (lo != NULL && pnfs_layout_is_valid(lo)) {
1851				__entry->layoutstateid_seq =
1852				be32_to_cpu(lo->plh_stateid.seqid);
1853				__entry->layoutstateid_hash =
1854				nfs_stateid_hash(&lo->plh_stateid);
1855			} else {
1856				__entry->layoutstateid_seq = 0;
1857				__entry->layoutstateid_hash = 0;
1858			}
1859			__entry->lseg = (long)lseg;
1860		),
1861		TP_printk(
1862			"fileid=%02x:%02x:%llu fhandle=0x%08x "
1863			"iomode=%s pos=%llu count=%llu "
1864			"layoutstateid=%d:0x%08x lseg=0x%lx (%s)",
1865			MAJOR(__entry->dev), MINOR(__entry->dev),
1866			(unsigned long long)__entry->fileid,
1867			__entry->fhandle,
1868			show_pnfs_layout_iomode(__entry->iomode),
1869			(unsigned long long)__entry->pos,
1870			(unsigned long long)__entry->count,
1871			__entry->layoutstateid_seq, __entry->layoutstateid_hash,
1872			__entry->lseg,
1873			show_pnfs_update_layout_reason(__entry->reason)
1874		)
1875);
1876
1877DECLARE_EVENT_CLASS(pnfs_layout_event,
1878		TP_PROTO(struct inode *inode,
1879			loff_t pos,
1880			u64 count,
1881			enum pnfs_iomode iomode,
1882			struct pnfs_layout_hdr *lo,
1883			struct pnfs_layout_segment *lseg
1884		),
1885		TP_ARGS(inode, pos, count, iomode, lo, lseg),
1886		TP_STRUCT__entry(
1887			__field(dev_t, dev)
1888			__field(u64, fileid)
1889			__field(u32, fhandle)
1890			__field(loff_t, pos)
1891			__field(u64, count)
1892			__field(enum pnfs_iomode, iomode)
1893			__field(int, layoutstateid_seq)
1894			__field(u32, layoutstateid_hash)
1895			__field(long, lseg)
1896		),
1897		TP_fast_assign(
1898			__entry->dev = inode->i_sb->s_dev;
1899			__entry->fileid = NFS_FILEID(inode);
1900			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1901			__entry->pos = pos;
1902			__entry->count = count;
1903			__entry->iomode = iomode;
1904			if (lo != NULL && pnfs_layout_is_valid(lo)) {
1905				__entry->layoutstateid_seq =
1906				be32_to_cpu(lo->plh_stateid.seqid);
1907				__entry->layoutstateid_hash =
1908				nfs_stateid_hash(&lo->plh_stateid);
1909			} else {
1910				__entry->layoutstateid_seq = 0;
1911				__entry->layoutstateid_hash = 0;
1912			}
1913			__entry->lseg = (long)lseg;
1914		),
1915		TP_printk(
1916			"fileid=%02x:%02x:%llu fhandle=0x%08x "
1917			"iomode=%s pos=%llu count=%llu "
1918			"layoutstateid=%d:0x%08x lseg=0x%lx",
1919			MAJOR(__entry->dev), MINOR(__entry->dev),
1920			(unsigned long long)__entry->fileid,
1921			__entry->fhandle,
1922			show_pnfs_layout_iomode(__entry->iomode),
1923			(unsigned long long)__entry->pos,
1924			(unsigned long long)__entry->count,
1925			__entry->layoutstateid_seq, __entry->layoutstateid_hash,
1926			__entry->lseg
1927		)
1928);
1929
1930#define DEFINE_PNFS_LAYOUT_EVENT(name) \
1931	DEFINE_EVENT(pnfs_layout_event, name, \
1932		TP_PROTO(struct inode *inode, \
1933			loff_t pos, \
1934			u64 count, \
1935			enum pnfs_iomode iomode, \
1936			struct pnfs_layout_hdr *lo, \
1937			struct pnfs_layout_segment *lseg \
1938		), \
1939		TP_ARGS(inode, pos, count, iomode, lo, lseg))
1940
1941DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_init_read);
1942DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_init_write);
1943DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_get_mirror_count);
1944DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_read_done);
1945DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_write_done);
1946DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_read_pagelist);
1947DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_write_pagelist);
1948
1949DECLARE_EVENT_CLASS(nfs4_deviceid_event,
1950		TP_PROTO(
1951			const struct nfs_client *clp,
1952			const struct nfs4_deviceid *deviceid
1953		),
1954
1955		TP_ARGS(clp, deviceid),
1956
1957		TP_STRUCT__entry(
1958			__string(dstaddr, clp->cl_hostname)
1959			__array(unsigned char, deviceid, NFS4_DEVICEID4_SIZE)
1960		),
1961
1962		TP_fast_assign(
1963			__assign_str(dstaddr, clp->cl_hostname);
1964			memcpy(__entry->deviceid, deviceid->data,
1965			       NFS4_DEVICEID4_SIZE);
1966		),
1967
1968		TP_printk(
1969			"deviceid=%s, dstaddr=%s",
1970			__print_hex(__entry->deviceid, NFS4_DEVICEID4_SIZE),
1971			__get_str(dstaddr)
1972		)
1973);
1974#define DEFINE_PNFS_DEVICEID_EVENT(name) \
1975	DEFINE_EVENT(nfs4_deviceid_event, name, \
1976			TP_PROTO(const struct nfs_client *clp, \
1977				const struct nfs4_deviceid *deviceid \
1978			), \
1979			TP_ARGS(clp, deviceid))
1980DEFINE_PNFS_DEVICEID_EVENT(nfs4_deviceid_free);
1981
1982DECLARE_EVENT_CLASS(nfs4_deviceid_status,
1983		TP_PROTO(
1984			const struct nfs_server *server,
1985			const struct nfs4_deviceid *deviceid,
1986			int status
1987		),
1988
1989		TP_ARGS(server, deviceid, status),
1990
1991		TP_STRUCT__entry(
1992			__field(dev_t, dev)
1993			__field(int, status)
1994			__string(dstaddr, server->nfs_client->cl_hostname)
1995			__array(unsigned char, deviceid, NFS4_DEVICEID4_SIZE)
1996		),
1997
1998		TP_fast_assign(
1999			__entry->dev = server->s_dev;
2000			__entry->status = status;
2001			__assign_str(dstaddr, server->nfs_client->cl_hostname);
2002			memcpy(__entry->deviceid, deviceid->data,
2003			       NFS4_DEVICEID4_SIZE);
2004		),
2005
2006		TP_printk(
2007			"dev=%02x:%02x: deviceid=%s, dstaddr=%s, status=%d",
2008			MAJOR(__entry->dev), MINOR(__entry->dev),
2009			__print_hex(__entry->deviceid, NFS4_DEVICEID4_SIZE),
2010			__get_str(dstaddr),
2011			__entry->status
2012		)
2013);
2014#define DEFINE_PNFS_DEVICEID_STATUS(name) \
2015	DEFINE_EVENT(nfs4_deviceid_status, name, \
2016			TP_PROTO(const struct nfs_server *server, \
2017				const struct nfs4_deviceid *deviceid, \
2018				int status \
2019			), \
2020			TP_ARGS(server, deviceid, status))
2021DEFINE_PNFS_DEVICEID_STATUS(nfs4_getdeviceinfo);
2022DEFINE_PNFS_DEVICEID_STATUS(nfs4_find_deviceid);
2023
2024TRACE_EVENT(fl_getdevinfo,
2025		TP_PROTO(
2026			const struct nfs_server *server,
2027			const struct nfs4_deviceid *deviceid,
2028			char *ds_remotestr
2029		),
2030		TP_ARGS(server, deviceid, ds_remotestr),
2031
2032		TP_STRUCT__entry(
2033			__string(mds_addr, server->nfs_client->cl_hostname)
2034			__array(unsigned char, deviceid, NFS4_DEVICEID4_SIZE)
2035			__string(ds_ips, ds_remotestr)
2036		),
2037
2038		TP_fast_assign(
2039			__assign_str(mds_addr, server->nfs_client->cl_hostname);
2040			__assign_str(ds_ips, ds_remotestr);
2041			memcpy(__entry->deviceid, deviceid->data,
2042			       NFS4_DEVICEID4_SIZE);
2043		),
2044		TP_printk(
2045			"deviceid=%s, mds_addr=%s, ds_ips=%s",
2046			__print_hex(__entry->deviceid, NFS4_DEVICEID4_SIZE),
2047			__get_str(mds_addr),
2048			__get_str(ds_ips)
2049		)
2050);
2051
2052DECLARE_EVENT_CLASS(nfs4_flexfiles_io_event,
2053		TP_PROTO(
2054			const struct nfs_pgio_header *hdr
2055		),
2056
2057		TP_ARGS(hdr),
2058
2059		TP_STRUCT__entry(
2060			__field(unsigned long, error)
2061			__field(dev_t, dev)
2062			__field(u32, fhandle)
2063			__field(u64, fileid)
2064			__field(loff_t, offset)
2065			__field(u32, count)
2066			__field(int, stateid_seq)
2067			__field(u32, stateid_hash)
2068			__string(dstaddr, hdr->ds_clp ?
2069				rpc_peeraddr2str(hdr->ds_clp->cl_rpcclient,
2070					RPC_DISPLAY_ADDR) : "unknown")
2071		),
2072
2073		TP_fast_assign(
2074			const struct inode *inode = hdr->inode;
2075
2076			__entry->error = hdr->res.op_status;
2077			__entry->fhandle = nfs_fhandle_hash(hdr->args.fh);
2078			__entry->fileid = NFS_FILEID(inode);
2079			__entry->dev = inode->i_sb->s_dev;
2080			__entry->offset = hdr->args.offset;
2081			__entry->count = hdr->args.count;
2082			__entry->stateid_seq =
2083				be32_to_cpu(hdr->args.stateid.seqid);
2084			__entry->stateid_hash =
2085				nfs_stateid_hash(&hdr->args.stateid);
2086			__assign_str(dstaddr, hdr->ds_clp ?
2087				rpc_peeraddr2str(hdr->ds_clp->cl_rpcclient,
2088					RPC_DISPLAY_ADDR) : "unknown");
2089		),
2090
2091		TP_printk(
2092			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2093			"offset=%llu count=%u stateid=%d:0x%08x dstaddr=%s",
2094			-__entry->error,
2095			show_nfs4_status(__entry->error),
2096			MAJOR(__entry->dev), MINOR(__entry->dev),
2097			(unsigned long long)__entry->fileid,
2098			__entry->fhandle,
2099			__entry->offset, __entry->count,
2100			__entry->stateid_seq, __entry->stateid_hash,
2101			__get_str(dstaddr)
2102		)
2103);
2104
2105#define DEFINE_NFS4_FLEXFILES_IO_EVENT(name) \
2106	DEFINE_EVENT(nfs4_flexfiles_io_event, name, \
2107			TP_PROTO( \
2108				const struct nfs_pgio_header *hdr \
2109			), \
2110			TP_ARGS(hdr))
2111DEFINE_NFS4_FLEXFILES_IO_EVENT(ff_layout_read_error);
2112DEFINE_NFS4_FLEXFILES_IO_EVENT(ff_layout_write_error);
2113
2114TRACE_EVENT(ff_layout_commit_error,
2115		TP_PROTO(
2116			const struct nfs_commit_data *data
2117		),
2118
2119		TP_ARGS(data),
2120
2121		TP_STRUCT__entry(
2122			__field(unsigned long, error)
2123			__field(dev_t, dev)
2124			__field(u32, fhandle)
2125			__field(u64, fileid)
2126			__field(loff_t, offset)
2127			__field(u32, count)
2128			__string(dstaddr, data->ds_clp ?
2129				rpc_peeraddr2str(data->ds_clp->cl_rpcclient,
2130					RPC_DISPLAY_ADDR) : "unknown")
2131		),
2132
2133		TP_fast_assign(
2134			const struct inode *inode = data->inode;
2135
2136			__entry->error = data->res.op_status;
2137			__entry->fhandle = nfs_fhandle_hash(data->args.fh);
2138			__entry->fileid = NFS_FILEID(inode);
2139			__entry->dev = inode->i_sb->s_dev;
2140			__entry->offset = data->args.offset;
2141			__entry->count = data->args.count;
2142			__assign_str(dstaddr, data->ds_clp ?
2143				rpc_peeraddr2str(data->ds_clp->cl_rpcclient,
2144					RPC_DISPLAY_ADDR) : "unknown");
2145		),
2146
2147		TP_printk(
2148			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2149			"offset=%llu count=%u dstaddr=%s",
2150			-__entry->error,
2151			show_nfs4_status(__entry->error),
2152			MAJOR(__entry->dev), MINOR(__entry->dev),
2153			(unsigned long long)__entry->fileid,
2154			__entry->fhandle,
2155			__entry->offset, __entry->count,
2156			__get_str(dstaddr)
2157		)
2158);
2159
2160#ifdef CONFIG_NFS_V4_2
2161TRACE_DEFINE_ENUM(NFS4_CONTENT_DATA);
2162TRACE_DEFINE_ENUM(NFS4_CONTENT_HOLE);
2163
2164#define show_llseek_mode(what)			\
2165	__print_symbolic(what,			\
2166		{ NFS4_CONTENT_DATA, "DATA" },		\
2167		{ NFS4_CONTENT_HOLE, "HOLE" })
2168
2169TRACE_EVENT(nfs4_llseek,
2170		TP_PROTO(
2171			const struct inode *inode,
2172			const struct nfs42_seek_args *args,
2173			const struct nfs42_seek_res *res,
2174			int error
2175		),
2176
2177		TP_ARGS(inode, args, res, error),
2178
2179		TP_STRUCT__entry(
2180			__field(unsigned long, error)
2181			__field(u32, fhandle)
2182			__field(u32, fileid)
2183			__field(dev_t, dev)
2184			__field(int, stateid_seq)
2185			__field(u32, stateid_hash)
2186			__field(loff_t, offset_s)
2187			__field(u32, what)
2188			__field(loff_t, offset_r)
2189			__field(u32, eof)
2190		),
2191
2192		TP_fast_assign(
2193			const struct nfs_inode *nfsi = NFS_I(inode);
2194			const struct nfs_fh *fh = args->sa_fh;
2195
2196			__entry->fileid = nfsi->fileid;
2197			__entry->dev = inode->i_sb->s_dev;
2198			__entry->fhandle = nfs_fhandle_hash(fh);
2199			__entry->offset_s = args->sa_offset;
2200			__entry->stateid_seq =
2201				be32_to_cpu(args->sa_stateid.seqid);
2202			__entry->stateid_hash =
2203				nfs_stateid_hash(&args->sa_stateid);
2204			__entry->what = args->sa_what;
2205			if (error) {
2206				__entry->error = -error;
2207				__entry->offset_r = 0;
2208				__entry->eof = 0;
2209			} else {
2210				__entry->error = 0;
2211				__entry->offset_r = res->sr_offset;
2212				__entry->eof = res->sr_eof;
2213			}
2214		),
2215
2216		TP_printk(
2217			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2218			"stateid=%d:0x%08x offset_s=%llu what=%s "
2219			"offset_r=%llu eof=%u",
2220			-__entry->error,
2221			show_nfs4_status(__entry->error),
2222			MAJOR(__entry->dev), MINOR(__entry->dev),
2223			(unsigned long long)__entry->fileid,
2224			__entry->fhandle,
2225			__entry->stateid_seq, __entry->stateid_hash,
2226			__entry->offset_s,
2227			show_llseek_mode(__entry->what),
2228			__entry->offset_r,
2229			__entry->eof
2230		)
2231);
2232
2233DECLARE_EVENT_CLASS(nfs4_sparse_event,
2234		TP_PROTO(
2235			const struct inode *inode,
2236			const struct nfs42_falloc_args *args,
2237			int error
2238		),
2239
2240		TP_ARGS(inode, args, error),
2241
2242		TP_STRUCT__entry(
2243			__field(unsigned long, error)
2244			__field(loff_t, offset)
2245			__field(loff_t, len)
2246			__field(dev_t, dev)
2247			__field(u32, fhandle)
2248			__field(u64, fileid)
2249			__field(int, stateid_seq)
2250			__field(u32, stateid_hash)
2251		),
2252
2253		TP_fast_assign(
2254			__entry->error = error < 0 ? -error : 0;
2255			__entry->offset = args->falloc_offset;
2256			__entry->len = args->falloc_length;
2257			__entry->dev = inode->i_sb->s_dev;
2258			__entry->fileid = NFS_FILEID(inode);
2259			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
2260			__entry->stateid_seq =
2261				be32_to_cpu(args->falloc_stateid.seqid);
2262			__entry->stateid_hash =
2263				nfs_stateid_hash(&args->falloc_stateid);
2264		),
2265
2266		TP_printk(
2267			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2268			"stateid=%d:0x%08x offset=%llu len=%llu",
2269			-__entry->error,
2270			show_nfs4_status(__entry->error),
2271			MAJOR(__entry->dev), MINOR(__entry->dev),
2272			(unsigned long long)__entry->fileid,
2273			__entry->fhandle,
2274			__entry->stateid_seq, __entry->stateid_hash,
2275			(long long)__entry->offset,
2276			(long long)__entry->len
2277		)
2278);
2279#define DEFINE_NFS4_SPARSE_EVENT(name) \
2280	DEFINE_EVENT(nfs4_sparse_event, name, \
2281			TP_PROTO( \
2282				const struct inode *inode, \
2283				const struct nfs42_falloc_args *args, \
2284				int error \
2285			), \
2286			TP_ARGS(inode, args, error))
2287DEFINE_NFS4_SPARSE_EVENT(nfs4_fallocate);
2288DEFINE_NFS4_SPARSE_EVENT(nfs4_deallocate);
2289
2290TRACE_EVENT(nfs4_copy,
2291		TP_PROTO(
2292			const struct inode *src_inode,
2293			const struct inode *dst_inode,
2294			const struct nfs42_copy_args *args,
2295			const struct nfs42_copy_res *res,
2296			const struct nl4_server *nss,
2297			int error
2298		),
2299
2300		TP_ARGS(src_inode, dst_inode, args, res, nss, error),
2301
2302		TP_STRUCT__entry(
2303			__field(unsigned long, error)
2304			__field(u32, src_fhandle)
2305			__field(u32, src_fileid)
2306			__field(u32, dst_fhandle)
2307			__field(u32, dst_fileid)
2308			__field(dev_t, src_dev)
2309			__field(dev_t, dst_dev)
2310			__field(int, src_stateid_seq)
2311			__field(u32, src_stateid_hash)
2312			__field(int, dst_stateid_seq)
2313			__field(u32, dst_stateid_hash)
2314			__field(loff_t, src_offset)
2315			__field(loff_t, dst_offset)
2316			__field(bool, sync)
2317			__field(loff_t, len)
2318			__field(int, res_stateid_seq)
2319			__field(u32, res_stateid_hash)
2320			__field(loff_t, res_count)
2321			__field(bool, res_sync)
2322			__field(bool, res_cons)
2323			__field(bool, intra)
2324		),
2325
2326		TP_fast_assign(
2327			const struct nfs_inode *src_nfsi = NFS_I(src_inode);
2328			const struct nfs_inode *dst_nfsi = NFS_I(dst_inode);
2329
2330			__entry->src_fileid = src_nfsi->fileid;
2331			__entry->src_dev = src_inode->i_sb->s_dev;
2332			__entry->src_fhandle = nfs_fhandle_hash(args->src_fh);
2333			__entry->src_offset = args->src_pos;
2334			__entry->dst_fileid = dst_nfsi->fileid;
2335			__entry->dst_dev = dst_inode->i_sb->s_dev;
2336			__entry->dst_fhandle = nfs_fhandle_hash(args->dst_fh);
2337			__entry->dst_offset = args->dst_pos;
2338			__entry->len = args->count;
2339			__entry->sync = args->sync;
2340			__entry->src_stateid_seq =
2341				be32_to_cpu(args->src_stateid.seqid);
2342			__entry->src_stateid_hash =
2343				nfs_stateid_hash(&args->src_stateid);
2344			__entry->dst_stateid_seq =
2345				be32_to_cpu(args->dst_stateid.seqid);
2346			__entry->dst_stateid_hash =
2347				nfs_stateid_hash(&args->dst_stateid);
2348			__entry->intra = nss ? 0 : 1;
2349			if (error) {
2350				__entry->error = -error;
2351				__entry->res_stateid_seq = 0;
2352				__entry->res_stateid_hash = 0;
2353				__entry->res_count = 0;
2354				__entry->res_sync = 0;
2355				__entry->res_cons = 0;
2356			} else {
2357				__entry->error = 0;
2358				__entry->res_stateid_seq =
2359					be32_to_cpu(res->write_res.stateid.seqid);
2360				__entry->res_stateid_hash =
2361					nfs_stateid_hash(&res->write_res.stateid);
2362				__entry->res_count = res->write_res.count;
2363				__entry->res_sync = res->synchronous;
2364				__entry->res_cons = res->consecutive;
2365			}
2366		),
2367
2368		TP_printk(
2369			"error=%ld (%s) intra=%d src_fileid=%02x:%02x:%llu "
2370			"src_fhandle=0x%08x dst_fileid=%02x:%02x:%llu "
2371			"dst_fhandle=0x%08x src_stateid=%d:0x%08x "
2372			"dst_stateid=%d:0x%08x src_offset=%llu dst_offset=%llu "
2373			"len=%llu sync=%d cb_stateid=%d:0x%08x res_sync=%d "
2374			"res_cons=%d res_count=%llu",
2375			-__entry->error,
2376			show_nfs4_status(__entry->error),
2377			__entry->intra,
2378			MAJOR(__entry->src_dev), MINOR(__entry->src_dev),
2379			(unsigned long long)__entry->src_fileid,
2380			__entry->src_fhandle,
2381			MAJOR(__entry->dst_dev), MINOR(__entry->dst_dev),
2382			(unsigned long long)__entry->dst_fileid,
2383			__entry->dst_fhandle,
2384			__entry->src_stateid_seq, __entry->src_stateid_hash,
2385			__entry->dst_stateid_seq, __entry->dst_stateid_hash,
2386			__entry->src_offset,
2387			__entry->dst_offset,
2388			__entry->len,
2389			__entry->sync,
2390			__entry->res_stateid_seq, __entry->res_stateid_hash,
2391			__entry->res_sync,
2392			__entry->res_cons,
2393			__entry->res_count
2394		)
2395);
2396
2397TRACE_EVENT(nfs4_clone,
2398		TP_PROTO(
2399			const struct inode *src_inode,
2400			const struct inode *dst_inode,
2401			const struct nfs42_clone_args *args,
2402			int error
2403		),
2404
2405		TP_ARGS(src_inode, dst_inode, args, error),
2406
2407		TP_STRUCT__entry(
2408			__field(unsigned long, error)
2409			__field(u32, src_fhandle)
2410			__field(u32, src_fileid)
2411			__field(u32, dst_fhandle)
2412			__field(u32, dst_fileid)
2413			__field(dev_t, src_dev)
2414			__field(dev_t, dst_dev)
2415			__field(loff_t, src_offset)
2416			__field(loff_t, dst_offset)
2417			__field(int, src_stateid_seq)
2418			__field(u32, src_stateid_hash)
2419			__field(int, dst_stateid_seq)
2420			__field(u32, dst_stateid_hash)
2421			__field(loff_t, len)
2422		),
2423
2424		TP_fast_assign(
2425			const struct nfs_inode *src_nfsi = NFS_I(src_inode);
2426			const struct nfs_inode *dst_nfsi = NFS_I(dst_inode);
2427
2428			__entry->src_fileid = src_nfsi->fileid;
2429			__entry->src_dev = src_inode->i_sb->s_dev;
2430			__entry->src_fhandle = nfs_fhandle_hash(args->src_fh);
2431			__entry->src_offset = args->src_offset;
2432			__entry->dst_fileid = dst_nfsi->fileid;
2433			__entry->dst_dev = dst_inode->i_sb->s_dev;
2434			__entry->dst_fhandle = nfs_fhandle_hash(args->dst_fh);
2435			__entry->dst_offset = args->dst_offset;
2436			__entry->len = args->count;
2437			__entry->error = error < 0 ? -error : 0;
2438			__entry->src_stateid_seq =
2439				be32_to_cpu(args->src_stateid.seqid);
2440			__entry->src_stateid_hash =
2441				nfs_stateid_hash(&args->src_stateid);
2442			__entry->dst_stateid_seq =
2443				be32_to_cpu(args->dst_stateid.seqid);
2444			__entry->dst_stateid_hash =
2445				nfs_stateid_hash(&args->dst_stateid);
2446		),
2447
2448		TP_printk(
2449			"error=%ld (%s) src_fileid=%02x:%02x:%llu "
2450			"src_fhandle=0x%08x dst_fileid=%02x:%02x:%llu "
2451			"dst_fhandle=0x%08x src_stateid=%d:0x%08x "
2452			"dst_stateid=%d:0x%08x src_offset=%llu "
2453			"dst_offset=%llu len=%llu",
2454			-__entry->error,
2455			show_nfs4_status(__entry->error),
2456			MAJOR(__entry->src_dev), MINOR(__entry->src_dev),
2457			(unsigned long long)__entry->src_fileid,
2458			__entry->src_fhandle,
2459			MAJOR(__entry->dst_dev), MINOR(__entry->dst_dev),
2460			(unsigned long long)__entry->dst_fileid,
2461			__entry->dst_fhandle,
2462			__entry->src_stateid_seq, __entry->src_stateid_hash,
2463			__entry->dst_stateid_seq, __entry->dst_stateid_hash,
2464			__entry->src_offset,
2465			__entry->dst_offset,
2466			__entry->len
2467		)
2468);
2469
2470TRACE_EVENT(nfs4_copy_notify,
2471		TP_PROTO(
2472			const struct inode *inode,
2473			const struct nfs42_copy_notify_args *args,
2474			const struct nfs42_copy_notify_res *res,
2475			int error
2476		),
2477
2478		TP_ARGS(inode, args, res, error),
2479
2480		TP_STRUCT__entry(
2481			__field(unsigned long, error)
2482			__field(u32, fhandle)
2483			__field(u32, fileid)
2484			__field(dev_t, dev)
2485			__field(int, stateid_seq)
2486			__field(u32, stateid_hash)
2487			__field(int, res_stateid_seq)
2488			__field(u32, res_stateid_hash)
2489		),
2490
2491		TP_fast_assign(
2492			const struct nfs_inode *nfsi = NFS_I(inode);
2493
2494			__entry->fileid = nfsi->fileid;
2495			__entry->dev = inode->i_sb->s_dev;
2496			__entry->fhandle = nfs_fhandle_hash(args->cna_src_fh);
2497			__entry->stateid_seq =
2498				be32_to_cpu(args->cna_src_stateid.seqid);
2499			__entry->stateid_hash =
2500				nfs_stateid_hash(&args->cna_src_stateid);
2501			if (error) {
2502				__entry->error = -error;
2503				__entry->res_stateid_seq = 0;
2504				__entry->res_stateid_hash = 0;
2505			} else {
2506				__entry->error = 0;
2507				__entry->res_stateid_seq =
2508					be32_to_cpu(res->cnr_stateid.seqid);
2509				__entry->res_stateid_hash =
2510					nfs_stateid_hash(&res->cnr_stateid);
2511			}
2512		),
2513
2514		TP_printk(
2515			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2516			"stateid=%d:0x%08x res_stateid=%d:0x%08x",
2517			-__entry->error,
2518			show_nfs4_status(__entry->error),
2519			MAJOR(__entry->dev), MINOR(__entry->dev),
2520			(unsigned long long)__entry->fileid,
2521			__entry->fhandle,
2522			__entry->stateid_seq, __entry->stateid_hash,
2523			__entry->res_stateid_seq, __entry->res_stateid_hash
2524		)
2525);
2526
2527TRACE_EVENT(nfs4_offload_cancel,
2528		TP_PROTO(
2529			const struct nfs42_offload_status_args *args,
2530			int error
2531		),
2532
2533		TP_ARGS(args, error),
2534
2535		TP_STRUCT__entry(
2536			__field(unsigned long, error)
2537			__field(u32, fhandle)
2538			__field(int, stateid_seq)
2539			__field(u32, stateid_hash)
2540		),
2541
2542		TP_fast_assign(
2543			__entry->fhandle = nfs_fhandle_hash(args->osa_src_fh);
2544			__entry->error = error < 0 ? -error : 0;
2545			__entry->stateid_seq =
2546				be32_to_cpu(args->osa_stateid.seqid);
2547			__entry->stateid_hash =
2548				nfs_stateid_hash(&args->osa_stateid);
2549		),
2550
2551		TP_printk(
2552			"error=%ld (%s) fhandle=0x%08x stateid=%d:0x%08x",
2553			-__entry->error,
2554			show_nfs4_status(__entry->error),
2555			__entry->fhandle,
2556			__entry->stateid_seq, __entry->stateid_hash
2557		)
2558);
2559
2560DECLARE_EVENT_CLASS(nfs4_xattr_event,
2561		TP_PROTO(
2562			const struct inode *inode,
2563			const char *name,
2564			int error
2565		),
2566
2567		TP_ARGS(inode, name, error),
2568
2569		TP_STRUCT__entry(
2570			__field(unsigned long, error)
2571			__field(dev_t, dev)
2572			__field(u32, fhandle)
2573			__field(u64, fileid)
2574			__string(name, name)
2575		),
2576
2577		TP_fast_assign(
2578			__entry->error = error < 0 ? -error : 0;
2579			__entry->dev = inode->i_sb->s_dev;
2580			__entry->fileid = NFS_FILEID(inode);
2581			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
2582			__assign_str(name, name);
2583		),
2584
2585		TP_printk(
2586			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2587			"name=%s",
2588			-__entry->error, show_nfs4_status(__entry->error),
2589			MAJOR(__entry->dev), MINOR(__entry->dev),
2590			(unsigned long long)__entry->fileid,
2591			__entry->fhandle, __get_str(name)
2592		)
2593);
2594#define DEFINE_NFS4_XATTR_EVENT(name) \
2595	DEFINE_EVENT(nfs4_xattr_event, name,  \
2596			TP_PROTO( \
2597				const struct inode *inode, \
2598				const char *name, \
2599				int error \
2600			), \
2601			TP_ARGS(inode, name, error))
2602DEFINE_NFS4_XATTR_EVENT(nfs4_getxattr);
2603DEFINE_NFS4_XATTR_EVENT(nfs4_setxattr);
2604DEFINE_NFS4_XATTR_EVENT(nfs4_removexattr);
2605
2606DEFINE_NFS4_INODE_EVENT(nfs4_listxattr);
2607#endif /* CONFIG_NFS_V4_2 */
2608
2609#endif /* CONFIG_NFS_V4_1 */
2610
2611#endif /* _TRACE_NFS4_H */
2612
2613#undef TRACE_INCLUDE_PATH
2614#define TRACE_INCLUDE_PATH .
2615#define TRACE_INCLUDE_FILE nfs4trace
2616/* This part must be outside protection */
2617#include <trace/define_trace.h>