nfs4trace.h

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