PageRenderTime 8ms CodeModel.GetById 3ms app.highlight 72ms RepoModel.GetById 1ms app.codeStats 0ms

/fs/nfs/nfs4trace.h

http://github.com/torvalds/linux
C Header | 2276 lines | 2052 code | 219 blank | 5 comment | 19 complexity | e136e8e29766f5b0eeb0923bbd18cff7 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   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
  13TRACE_DEFINE_ENUM(EPERM);
  14TRACE_DEFINE_ENUM(ENOENT);
  15TRACE_DEFINE_ENUM(EIO);
  16TRACE_DEFINE_ENUM(ENXIO);
  17TRACE_DEFINE_ENUM(EACCES);
  18TRACE_DEFINE_ENUM(EEXIST);
  19TRACE_DEFINE_ENUM(EXDEV);
  20TRACE_DEFINE_ENUM(ENOTDIR);
  21TRACE_DEFINE_ENUM(EISDIR);
  22TRACE_DEFINE_ENUM(EFBIG);
  23TRACE_DEFINE_ENUM(ENOSPC);
  24TRACE_DEFINE_ENUM(EROFS);
  25TRACE_DEFINE_ENUM(EMLINK);
  26TRACE_DEFINE_ENUM(ENAMETOOLONG);
  27TRACE_DEFINE_ENUM(ENOTEMPTY);
  28TRACE_DEFINE_ENUM(EDQUOT);
  29TRACE_DEFINE_ENUM(ESTALE);
  30TRACE_DEFINE_ENUM(EBADHANDLE);
  31TRACE_DEFINE_ENUM(EBADCOOKIE);
  32TRACE_DEFINE_ENUM(ENOTSUPP);
  33TRACE_DEFINE_ENUM(ETOOSMALL);
  34TRACE_DEFINE_ENUM(EREMOTEIO);
  35TRACE_DEFINE_ENUM(EBADTYPE);
  36TRACE_DEFINE_ENUM(EAGAIN);
  37TRACE_DEFINE_ENUM(ELOOP);
  38TRACE_DEFINE_ENUM(EOPNOTSUPP);
  39TRACE_DEFINE_ENUM(EDEADLK);
  40TRACE_DEFINE_ENUM(ENOMEM);
  41TRACE_DEFINE_ENUM(EKEYEXPIRED);
  42TRACE_DEFINE_ENUM(ETIMEDOUT);
  43TRACE_DEFINE_ENUM(ERESTARTSYS);
  44TRACE_DEFINE_ENUM(ECONNREFUSED);
  45TRACE_DEFINE_ENUM(ECONNRESET);
  46TRACE_DEFINE_ENUM(ENETUNREACH);
  47TRACE_DEFINE_ENUM(EHOSTUNREACH);
  48TRACE_DEFINE_ENUM(EHOSTDOWN);
  49TRACE_DEFINE_ENUM(EPIPE);
  50TRACE_DEFINE_ENUM(EPFNOSUPPORT);
  51TRACE_DEFINE_ENUM(EPROTONOSUPPORT);
  52
  53TRACE_DEFINE_ENUM(NFS4_OK);
  54TRACE_DEFINE_ENUM(NFS4ERR_ACCESS);
  55TRACE_DEFINE_ENUM(NFS4ERR_ATTRNOTSUPP);
  56TRACE_DEFINE_ENUM(NFS4ERR_ADMIN_REVOKED);
  57TRACE_DEFINE_ENUM(NFS4ERR_BACK_CHAN_BUSY);
  58TRACE_DEFINE_ENUM(NFS4ERR_BADCHAR);
  59TRACE_DEFINE_ENUM(NFS4ERR_BADHANDLE);
  60TRACE_DEFINE_ENUM(NFS4ERR_BADIOMODE);
  61TRACE_DEFINE_ENUM(NFS4ERR_BADLAYOUT);
  62TRACE_DEFINE_ENUM(NFS4ERR_BADLABEL);
  63TRACE_DEFINE_ENUM(NFS4ERR_BADNAME);
  64TRACE_DEFINE_ENUM(NFS4ERR_BADOWNER);
  65TRACE_DEFINE_ENUM(NFS4ERR_BADSESSION);
  66TRACE_DEFINE_ENUM(NFS4ERR_BADSLOT);
  67TRACE_DEFINE_ENUM(NFS4ERR_BADTYPE);
  68TRACE_DEFINE_ENUM(NFS4ERR_BADXDR);
  69TRACE_DEFINE_ENUM(NFS4ERR_BAD_COOKIE);
  70TRACE_DEFINE_ENUM(NFS4ERR_BAD_HIGH_SLOT);
  71TRACE_DEFINE_ENUM(NFS4ERR_BAD_RANGE);
  72TRACE_DEFINE_ENUM(NFS4ERR_BAD_SEQID);
  73TRACE_DEFINE_ENUM(NFS4ERR_BAD_SESSION_DIGEST);
  74TRACE_DEFINE_ENUM(NFS4ERR_BAD_STATEID);
  75TRACE_DEFINE_ENUM(NFS4ERR_CB_PATH_DOWN);
  76TRACE_DEFINE_ENUM(NFS4ERR_CLID_INUSE);
  77TRACE_DEFINE_ENUM(NFS4ERR_CLIENTID_BUSY);
  78TRACE_DEFINE_ENUM(NFS4ERR_COMPLETE_ALREADY);
  79TRACE_DEFINE_ENUM(NFS4ERR_CONN_NOT_BOUND_TO_SESSION);
  80TRACE_DEFINE_ENUM(NFS4ERR_DEADLOCK);
  81TRACE_DEFINE_ENUM(NFS4ERR_DEADSESSION);
  82TRACE_DEFINE_ENUM(NFS4ERR_DELAY);
  83TRACE_DEFINE_ENUM(NFS4ERR_DELEG_ALREADY_WANTED);
  84TRACE_DEFINE_ENUM(NFS4ERR_DELEG_REVOKED);
  85TRACE_DEFINE_ENUM(NFS4ERR_DENIED);
  86TRACE_DEFINE_ENUM(NFS4ERR_DIRDELEG_UNAVAIL);
  87TRACE_DEFINE_ENUM(NFS4ERR_DQUOT);
  88TRACE_DEFINE_ENUM(NFS4ERR_ENCR_ALG_UNSUPP);
  89TRACE_DEFINE_ENUM(NFS4ERR_EXIST);
  90TRACE_DEFINE_ENUM(NFS4ERR_EXPIRED);
  91TRACE_DEFINE_ENUM(NFS4ERR_FBIG);
  92TRACE_DEFINE_ENUM(NFS4ERR_FHEXPIRED);
  93TRACE_DEFINE_ENUM(NFS4ERR_FILE_OPEN);
  94TRACE_DEFINE_ENUM(NFS4ERR_GRACE);
  95TRACE_DEFINE_ENUM(NFS4ERR_HASH_ALG_UNSUPP);
  96TRACE_DEFINE_ENUM(NFS4ERR_INVAL);
  97TRACE_DEFINE_ENUM(NFS4ERR_IO);
  98TRACE_DEFINE_ENUM(NFS4ERR_ISDIR);
  99TRACE_DEFINE_ENUM(NFS4ERR_LAYOUTTRYLATER);
 100TRACE_DEFINE_ENUM(NFS4ERR_LAYOUTUNAVAILABLE);
 101TRACE_DEFINE_ENUM(NFS4ERR_LEASE_MOVED);
 102TRACE_DEFINE_ENUM(NFS4ERR_LOCKED);
 103TRACE_DEFINE_ENUM(NFS4ERR_LOCKS_HELD);
 104TRACE_DEFINE_ENUM(NFS4ERR_LOCK_RANGE);
 105TRACE_DEFINE_ENUM(NFS4ERR_MINOR_VERS_MISMATCH);
 106TRACE_DEFINE_ENUM(NFS4ERR_MLINK);
 107TRACE_DEFINE_ENUM(NFS4ERR_MOVED);
 108TRACE_DEFINE_ENUM(NFS4ERR_NAMETOOLONG);
 109TRACE_DEFINE_ENUM(NFS4ERR_NOENT);
 110TRACE_DEFINE_ENUM(NFS4ERR_NOFILEHANDLE);
 111TRACE_DEFINE_ENUM(NFS4ERR_NOMATCHING_LAYOUT);
 112TRACE_DEFINE_ENUM(NFS4ERR_NOSPC);
 113TRACE_DEFINE_ENUM(NFS4ERR_NOTDIR);
 114TRACE_DEFINE_ENUM(NFS4ERR_NOTEMPTY);
 115TRACE_DEFINE_ENUM(NFS4ERR_NOTSUPP);
 116TRACE_DEFINE_ENUM(NFS4ERR_NOT_ONLY_OP);
 117TRACE_DEFINE_ENUM(NFS4ERR_NOT_SAME);
 118TRACE_DEFINE_ENUM(NFS4ERR_NO_GRACE);
 119TRACE_DEFINE_ENUM(NFS4ERR_NXIO);
 120TRACE_DEFINE_ENUM(NFS4ERR_OLD_STATEID);
 121TRACE_DEFINE_ENUM(NFS4ERR_OPENMODE);
 122TRACE_DEFINE_ENUM(NFS4ERR_OP_ILLEGAL);
 123TRACE_DEFINE_ENUM(NFS4ERR_OP_NOT_IN_SESSION);
 124TRACE_DEFINE_ENUM(NFS4ERR_PERM);
 125TRACE_DEFINE_ENUM(NFS4ERR_PNFS_IO_HOLE);
 126TRACE_DEFINE_ENUM(NFS4ERR_PNFS_NO_LAYOUT);
 127TRACE_DEFINE_ENUM(NFS4ERR_RECALLCONFLICT);
 128TRACE_DEFINE_ENUM(NFS4ERR_RECLAIM_BAD);
 129TRACE_DEFINE_ENUM(NFS4ERR_RECLAIM_CONFLICT);
 130TRACE_DEFINE_ENUM(NFS4ERR_REJECT_DELEG);
 131TRACE_DEFINE_ENUM(NFS4ERR_REP_TOO_BIG);
 132TRACE_DEFINE_ENUM(NFS4ERR_REP_TOO_BIG_TO_CACHE);
 133TRACE_DEFINE_ENUM(NFS4ERR_REQ_TOO_BIG);
 134TRACE_DEFINE_ENUM(NFS4ERR_RESOURCE);
 135TRACE_DEFINE_ENUM(NFS4ERR_RESTOREFH);
 136TRACE_DEFINE_ENUM(NFS4ERR_RETRY_UNCACHED_REP);
 137TRACE_DEFINE_ENUM(NFS4ERR_RETURNCONFLICT);
 138TRACE_DEFINE_ENUM(NFS4ERR_ROFS);
 139TRACE_DEFINE_ENUM(NFS4ERR_SAME);
 140TRACE_DEFINE_ENUM(NFS4ERR_SHARE_DENIED);
 141TRACE_DEFINE_ENUM(NFS4ERR_SEQUENCE_POS);
 142TRACE_DEFINE_ENUM(NFS4ERR_SEQ_FALSE_RETRY);
 143TRACE_DEFINE_ENUM(NFS4ERR_SEQ_MISORDERED);
 144TRACE_DEFINE_ENUM(NFS4ERR_SERVERFAULT);
 145TRACE_DEFINE_ENUM(NFS4ERR_STALE);
 146TRACE_DEFINE_ENUM(NFS4ERR_STALE_CLIENTID);
 147TRACE_DEFINE_ENUM(NFS4ERR_STALE_STATEID);
 148TRACE_DEFINE_ENUM(NFS4ERR_SYMLINK);
 149TRACE_DEFINE_ENUM(NFS4ERR_TOOSMALL);
 150TRACE_DEFINE_ENUM(NFS4ERR_TOO_MANY_OPS);
 151TRACE_DEFINE_ENUM(NFS4ERR_UNKNOWN_LAYOUTTYPE);
 152TRACE_DEFINE_ENUM(NFS4ERR_UNSAFE_COMPOUND);
 153TRACE_DEFINE_ENUM(NFS4ERR_WRONGSEC);
 154TRACE_DEFINE_ENUM(NFS4ERR_WRONG_CRED);
 155TRACE_DEFINE_ENUM(NFS4ERR_WRONG_TYPE);
 156TRACE_DEFINE_ENUM(NFS4ERR_XDEV);
 157
 158TRACE_DEFINE_ENUM(NFS4ERR_RESET_TO_MDS);
 159TRACE_DEFINE_ENUM(NFS4ERR_RESET_TO_PNFS);
 160
 161#define show_nfsv4_errors(error) \
 162	__print_symbolic(error, \
 163		{ NFS4_OK, "OK" }, \
 164		/* Mapped by nfs4_stat_to_errno() */ \
 165		{ EPERM, "EPERM" }, \
 166		{ ENOENT, "ENOENT" }, \
 167		{ EIO, "EIO" }, \
 168		{ ENXIO, "ENXIO" }, \
 169		{ EACCES, "EACCES" }, \
 170		{ EEXIST, "EEXIST" }, \
 171		{ EXDEV, "EXDEV" }, \
 172		{ ENOTDIR, "ENOTDIR" }, \
 173		{ EISDIR, "EISDIR" }, \
 174		{ EFBIG, "EFBIG" }, \
 175		{ ENOSPC, "ENOSPC" }, \
 176		{ EROFS, "EROFS" }, \
 177		{ EMLINK, "EMLINK" }, \
 178		{ ENAMETOOLONG, "ENAMETOOLONG" }, \
 179		{ ENOTEMPTY, "ENOTEMPTY" }, \
 180		{ EDQUOT, "EDQUOT" }, \
 181		{ ESTALE, "ESTALE" }, \
 182		{ EBADHANDLE, "EBADHANDLE" }, \
 183		{ EBADCOOKIE, "EBADCOOKIE" }, \
 184		{ ENOTSUPP, "ENOTSUPP" }, \
 185		{ ETOOSMALL, "ETOOSMALL" }, \
 186		{ EREMOTEIO, "EREMOTEIO" }, \
 187		{ EBADTYPE, "EBADTYPE" }, \
 188		{ EAGAIN, "EAGAIN" }, \
 189		{ ELOOP, "ELOOP" }, \
 190		{ EOPNOTSUPP, "EOPNOTSUPP" }, \
 191		{ EDEADLK, "EDEADLK" }, \
 192		/* RPC errors */ \
 193		{ ENOMEM, "ENOMEM" }, \
 194		{ EKEYEXPIRED, "EKEYEXPIRED" }, \
 195		{ ETIMEDOUT, "ETIMEDOUT" }, \
 196		{ ERESTARTSYS, "ERESTARTSYS" }, \
 197		{ ECONNREFUSED, "ECONNREFUSED" }, \
 198		{ ECONNRESET, "ECONNRESET" }, \
 199		{ ENETUNREACH, "ENETUNREACH" }, \
 200		{ EHOSTUNREACH, "EHOSTUNREACH" }, \
 201		{ EHOSTDOWN, "EHOSTDOWN" }, \
 202		{ EPIPE, "EPIPE" }, \
 203		{ EPFNOSUPPORT, "EPFNOSUPPORT" }, \
 204		{ EPROTONOSUPPORT, "EPROTONOSUPPORT" }, \
 205		/* NFSv4 native errors */ \
 206		{ NFS4ERR_ACCESS, "ACCESS" }, \
 207		{ NFS4ERR_ATTRNOTSUPP, "ATTRNOTSUPP" }, \
 208		{ NFS4ERR_ADMIN_REVOKED, "ADMIN_REVOKED" }, \
 209		{ NFS4ERR_BACK_CHAN_BUSY, "BACK_CHAN_BUSY" }, \
 210		{ NFS4ERR_BADCHAR, "BADCHAR" }, \
 211		{ NFS4ERR_BADHANDLE, "BADHANDLE" }, \
 212		{ NFS4ERR_BADIOMODE, "BADIOMODE" }, \
 213		{ NFS4ERR_BADLAYOUT, "BADLAYOUT" }, \
 214		{ NFS4ERR_BADLABEL, "BADLABEL" }, \
 215		{ NFS4ERR_BADNAME, "BADNAME" }, \
 216		{ NFS4ERR_BADOWNER, "BADOWNER" }, \
 217		{ NFS4ERR_BADSESSION, "BADSESSION" }, \
 218		{ NFS4ERR_BADSLOT, "BADSLOT" }, \
 219		{ NFS4ERR_BADTYPE, "BADTYPE" }, \
 220		{ NFS4ERR_BADXDR, "BADXDR" }, \
 221		{ NFS4ERR_BAD_COOKIE, "BAD_COOKIE" }, \
 222		{ NFS4ERR_BAD_HIGH_SLOT, "BAD_HIGH_SLOT" }, \
 223		{ NFS4ERR_BAD_RANGE, "BAD_RANGE" }, \
 224		{ NFS4ERR_BAD_SEQID, "BAD_SEQID" }, \
 225		{ NFS4ERR_BAD_SESSION_DIGEST, "BAD_SESSION_DIGEST" }, \
 226		{ NFS4ERR_BAD_STATEID, "BAD_STATEID" }, \
 227		{ NFS4ERR_CB_PATH_DOWN, "CB_PATH_DOWN" }, \
 228		{ NFS4ERR_CLID_INUSE, "CLID_INUSE" }, \
 229		{ NFS4ERR_CLIENTID_BUSY, "CLIENTID_BUSY" }, \
 230		{ NFS4ERR_COMPLETE_ALREADY, "COMPLETE_ALREADY" }, \
 231		{ NFS4ERR_CONN_NOT_BOUND_TO_SESSION, \
 232			"CONN_NOT_BOUND_TO_SESSION" }, \
 233		{ NFS4ERR_DEADLOCK, "DEADLOCK" }, \
 234		{ NFS4ERR_DEADSESSION, "DEAD_SESSION" }, \
 235		{ NFS4ERR_DELAY, "DELAY" }, \
 236		{ NFS4ERR_DELEG_ALREADY_WANTED, \
 237			"DELEG_ALREADY_WANTED" }, \
 238		{ NFS4ERR_DELEG_REVOKED, "DELEG_REVOKED" }, \
 239		{ NFS4ERR_DENIED, "DENIED" }, \
 240		{ NFS4ERR_DIRDELEG_UNAVAIL, "DIRDELEG_UNAVAIL" }, \
 241		{ NFS4ERR_DQUOT, "DQUOT" }, \
 242		{ NFS4ERR_ENCR_ALG_UNSUPP, "ENCR_ALG_UNSUPP" }, \
 243		{ NFS4ERR_EXIST, "EXIST" }, \
 244		{ NFS4ERR_EXPIRED, "EXPIRED" }, \
 245		{ NFS4ERR_FBIG, "FBIG" }, \
 246		{ NFS4ERR_FHEXPIRED, "FHEXPIRED" }, \
 247		{ NFS4ERR_FILE_OPEN, "FILE_OPEN" }, \
 248		{ NFS4ERR_GRACE, "GRACE" }, \
 249		{ NFS4ERR_HASH_ALG_UNSUPP, "HASH_ALG_UNSUPP" }, \
 250		{ NFS4ERR_INVAL, "INVAL" }, \
 251		{ NFS4ERR_IO, "IO" }, \
 252		{ NFS4ERR_ISDIR, "ISDIR" }, \
 253		{ NFS4ERR_LAYOUTTRYLATER, "LAYOUTTRYLATER" }, \
 254		{ NFS4ERR_LAYOUTUNAVAILABLE, "LAYOUTUNAVAILABLE" }, \
 255		{ NFS4ERR_LEASE_MOVED, "LEASE_MOVED" }, \
 256		{ NFS4ERR_LOCKED, "LOCKED" }, \
 257		{ NFS4ERR_LOCKS_HELD, "LOCKS_HELD" }, \
 258		{ NFS4ERR_LOCK_RANGE, "LOCK_RANGE" }, \
 259		{ NFS4ERR_MINOR_VERS_MISMATCH, "MINOR_VERS_MISMATCH" }, \
 260		{ NFS4ERR_MLINK, "MLINK" }, \
 261		{ NFS4ERR_MOVED, "MOVED" }, \
 262		{ NFS4ERR_NAMETOOLONG, "NAMETOOLONG" }, \
 263		{ NFS4ERR_NOENT, "NOENT" }, \
 264		{ NFS4ERR_NOFILEHANDLE, "NOFILEHANDLE" }, \
 265		{ NFS4ERR_NOMATCHING_LAYOUT, "NOMATCHING_LAYOUT" }, \
 266		{ NFS4ERR_NOSPC, "NOSPC" }, \
 267		{ NFS4ERR_NOTDIR, "NOTDIR" }, \
 268		{ NFS4ERR_NOTEMPTY, "NOTEMPTY" }, \
 269		{ NFS4ERR_NOTSUPP, "NOTSUPP" }, \
 270		{ NFS4ERR_NOT_ONLY_OP, "NOT_ONLY_OP" }, \
 271		{ NFS4ERR_NOT_SAME, "NOT_SAME" }, \
 272		{ NFS4ERR_NO_GRACE, "NO_GRACE" }, \
 273		{ NFS4ERR_NXIO, "NXIO" }, \
 274		{ NFS4ERR_OLD_STATEID, "OLD_STATEID" }, \
 275		{ NFS4ERR_OPENMODE, "OPENMODE" }, \
 276		{ NFS4ERR_OP_ILLEGAL, "OP_ILLEGAL" }, \
 277		{ NFS4ERR_OP_NOT_IN_SESSION, "OP_NOT_IN_SESSION" }, \
 278		{ NFS4ERR_PERM, "PERM" }, \
 279		{ NFS4ERR_PNFS_IO_HOLE, "PNFS_IO_HOLE" }, \
 280		{ NFS4ERR_PNFS_NO_LAYOUT, "PNFS_NO_LAYOUT" }, \
 281		{ NFS4ERR_RECALLCONFLICT, "RECALLCONFLICT" }, \
 282		{ NFS4ERR_RECLAIM_BAD, "RECLAIM_BAD" }, \
 283		{ NFS4ERR_RECLAIM_CONFLICT, "RECLAIM_CONFLICT" }, \
 284		{ NFS4ERR_REJECT_DELEG, "REJECT_DELEG" }, \
 285		{ NFS4ERR_REP_TOO_BIG, "REP_TOO_BIG" }, \
 286		{ NFS4ERR_REP_TOO_BIG_TO_CACHE, \
 287			"REP_TOO_BIG_TO_CACHE" }, \
 288		{ NFS4ERR_REQ_TOO_BIG, "REQ_TOO_BIG" }, \
 289		{ NFS4ERR_RESOURCE, "RESOURCE" }, \
 290		{ NFS4ERR_RESTOREFH, "RESTOREFH" }, \
 291		{ NFS4ERR_RETRY_UNCACHED_REP, "RETRY_UNCACHED_REP" }, \
 292		{ NFS4ERR_RETURNCONFLICT, "RETURNCONFLICT" }, \
 293		{ NFS4ERR_ROFS, "ROFS" }, \
 294		{ NFS4ERR_SAME, "SAME" }, \
 295		{ NFS4ERR_SHARE_DENIED, "SHARE_DENIED" }, \
 296		{ NFS4ERR_SEQUENCE_POS, "SEQUENCE_POS" }, \
 297		{ NFS4ERR_SEQ_FALSE_RETRY, "SEQ_FALSE_RETRY" }, \
 298		{ NFS4ERR_SEQ_MISORDERED, "SEQ_MISORDERED" }, \
 299		{ NFS4ERR_SERVERFAULT, "SERVERFAULT" }, \
 300		{ NFS4ERR_STALE, "STALE" }, \
 301		{ NFS4ERR_STALE_CLIENTID, "STALE_CLIENTID" }, \
 302		{ NFS4ERR_STALE_STATEID, "STALE_STATEID" }, \
 303		{ NFS4ERR_SYMLINK, "SYMLINK" }, \
 304		{ NFS4ERR_TOOSMALL, "TOOSMALL" }, \
 305		{ NFS4ERR_TOO_MANY_OPS, "TOO_MANY_OPS" }, \
 306		{ NFS4ERR_UNKNOWN_LAYOUTTYPE, "UNKNOWN_LAYOUTTYPE" }, \
 307		{ NFS4ERR_UNSAFE_COMPOUND, "UNSAFE_COMPOUND" }, \
 308		{ NFS4ERR_WRONGSEC, "WRONGSEC" }, \
 309		{ NFS4ERR_WRONG_CRED, "WRONG_CRED" }, \
 310		{ NFS4ERR_WRONG_TYPE, "WRONG_TYPE" }, \
 311		{ NFS4ERR_XDEV, "XDEV" }, \
 312		/* ***** Internal to Linux NFS client ***** */ \
 313		{ NFS4ERR_RESET_TO_MDS, "RESET_TO_MDS" }, \
 314		{ NFS4ERR_RESET_TO_PNFS, "RESET_TO_PNFS" })
 315
 316#define show_open_flags(flags) \
 317	__print_flags(flags, "|", \
 318		{ O_CREAT, "O_CREAT" }, \
 319		{ O_EXCL, "O_EXCL" }, \
 320		{ O_TRUNC, "O_TRUNC" }, \
 321		{ O_DIRECT, "O_DIRECT" })
 322
 323#define show_fmode_flags(mode) \
 324	__print_flags(mode, "|", \
 325		{ ((__force unsigned long)FMODE_READ), "READ" }, \
 326		{ ((__force unsigned long)FMODE_WRITE), "WRITE" }, \
 327		{ ((__force unsigned long)FMODE_EXEC), "EXEC" })
 328
 329#define show_nfs_fattr_flags(valid) \
 330	__print_flags((unsigned long)valid, "|", \
 331		{ NFS_ATTR_FATTR_TYPE, "TYPE" }, \
 332		{ NFS_ATTR_FATTR_MODE, "MODE" }, \
 333		{ NFS_ATTR_FATTR_NLINK, "NLINK" }, \
 334		{ NFS_ATTR_FATTR_OWNER, "OWNER" }, \
 335		{ NFS_ATTR_FATTR_GROUP, "GROUP" }, \
 336		{ NFS_ATTR_FATTR_RDEV, "RDEV" }, \
 337		{ NFS_ATTR_FATTR_SIZE, "SIZE" }, \
 338		{ NFS_ATTR_FATTR_FSID, "FSID" }, \
 339		{ NFS_ATTR_FATTR_FILEID, "FILEID" }, \
 340		{ NFS_ATTR_FATTR_ATIME, "ATIME" }, \
 341		{ NFS_ATTR_FATTR_MTIME, "MTIME" }, \
 342		{ NFS_ATTR_FATTR_CTIME, "CTIME" }, \
 343		{ NFS_ATTR_FATTR_CHANGE, "CHANGE" }, \
 344		{ NFS_ATTR_FATTR_OWNER_NAME, "OWNER_NAME" }, \
 345		{ NFS_ATTR_FATTR_GROUP_NAME, "GROUP_NAME" })
 346
 347DECLARE_EVENT_CLASS(nfs4_clientid_event,
 348		TP_PROTO(
 349			const struct nfs_client *clp,
 350			int error
 351		),
 352
 353		TP_ARGS(clp, error),
 354
 355		TP_STRUCT__entry(
 356			__string(dstaddr, clp->cl_hostname)
 357			__field(unsigned long, error)
 358		),
 359
 360		TP_fast_assign(
 361			__entry->error = error < 0 ? -error : 0;
 362			__assign_str(dstaddr, clp->cl_hostname);
 363		),
 364
 365		TP_printk(
 366			"error=%ld (%s) dstaddr=%s",
 367			-__entry->error,
 368			show_nfsv4_errors(__entry->error),
 369			__get_str(dstaddr)
 370		)
 371);
 372#define DEFINE_NFS4_CLIENTID_EVENT(name) \
 373	DEFINE_EVENT(nfs4_clientid_event, name,	 \
 374			TP_PROTO( \
 375				const struct nfs_client *clp, \
 376				int error \
 377			), \
 378			TP_ARGS(clp, error))
 379DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid);
 380DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid_confirm);
 381DEFINE_NFS4_CLIENTID_EVENT(nfs4_renew);
 382DEFINE_NFS4_CLIENTID_EVENT(nfs4_renew_async);
 383#ifdef CONFIG_NFS_V4_1
 384DEFINE_NFS4_CLIENTID_EVENT(nfs4_exchange_id);
 385DEFINE_NFS4_CLIENTID_EVENT(nfs4_create_session);
 386DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_session);
 387DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_clientid);
 388DEFINE_NFS4_CLIENTID_EVENT(nfs4_bind_conn_to_session);
 389DEFINE_NFS4_CLIENTID_EVENT(nfs4_sequence);
 390DEFINE_NFS4_CLIENTID_EVENT(nfs4_reclaim_complete);
 391
 392#define show_nfs4_sequence_status_flags(status) \
 393	__print_flags((unsigned long)status, "|", \
 394		{ SEQ4_STATUS_CB_PATH_DOWN, "CB_PATH_DOWN" }, \
 395		{ SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING, \
 396			"CB_GSS_CONTEXTS_EXPIRING" }, \
 397		{ SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED, \
 398			"CB_GSS_CONTEXTS_EXPIRED" }, \
 399		{ SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED, \
 400			"EXPIRED_ALL_STATE_REVOKED" }, \
 401		{ SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED, \
 402			"EXPIRED_SOME_STATE_REVOKED" }, \
 403		{ SEQ4_STATUS_ADMIN_STATE_REVOKED, \
 404			"ADMIN_STATE_REVOKED" }, \
 405		{ SEQ4_STATUS_RECALLABLE_STATE_REVOKED,	 \
 406			"RECALLABLE_STATE_REVOKED" }, \
 407		{ SEQ4_STATUS_LEASE_MOVED, "LEASE_MOVED" }, \
 408		{ SEQ4_STATUS_RESTART_RECLAIM_NEEDED, \
 409			"RESTART_RECLAIM_NEEDED" }, \
 410		{ SEQ4_STATUS_CB_PATH_DOWN_SESSION, \
 411			"CB_PATH_DOWN_SESSION" }, \
 412		{ SEQ4_STATUS_BACKCHANNEL_FAULT, \
 413			"BACKCHANNEL_FAULT" })
 414
 415TRACE_EVENT(nfs4_sequence_done,
 416		TP_PROTO(
 417			const struct nfs4_session *session,
 418			const struct nfs4_sequence_res *res
 419		),
 420		TP_ARGS(session, res),
 421
 422		TP_STRUCT__entry(
 423			__field(unsigned int, session)
 424			__field(unsigned int, slot_nr)
 425			__field(unsigned int, seq_nr)
 426			__field(unsigned int, highest_slotid)
 427			__field(unsigned int, target_highest_slotid)
 428			__field(unsigned int, status_flags)
 429			__field(unsigned long, error)
 430		),
 431
 432		TP_fast_assign(
 433			const struct nfs4_slot *sr_slot = res->sr_slot;
 434			__entry->session = nfs_session_id_hash(&session->sess_id);
 435			__entry->slot_nr = sr_slot->slot_nr;
 436			__entry->seq_nr = sr_slot->seq_nr;
 437			__entry->highest_slotid = res->sr_highest_slotid;
 438			__entry->target_highest_slotid =
 439					res->sr_target_highest_slotid;
 440			__entry->status_flags = res->sr_status_flags;
 441			__entry->error = res->sr_status < 0 ?
 442					-res->sr_status : 0;
 443		),
 444		TP_printk(
 445			"error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
 446			"highest_slotid=%u target_highest_slotid=%u "
 447			"status_flags=%u (%s)",
 448			-__entry->error,
 449			show_nfsv4_errors(__entry->error),
 450			__entry->session,
 451			__entry->slot_nr,
 452			__entry->seq_nr,
 453			__entry->highest_slotid,
 454			__entry->target_highest_slotid,
 455			__entry->status_flags,
 456			show_nfs4_sequence_status_flags(__entry->status_flags)
 457		)
 458);
 459
 460struct cb_sequenceargs;
 461struct cb_sequenceres;
 462
 463TRACE_EVENT(nfs4_cb_sequence,
 464		TP_PROTO(
 465			const struct cb_sequenceargs *args,
 466			const struct cb_sequenceres *res,
 467			__be32 status
 468		),
 469		TP_ARGS(args, res, status),
 470
 471		TP_STRUCT__entry(
 472			__field(unsigned int, session)
 473			__field(unsigned int, slot_nr)
 474			__field(unsigned int, seq_nr)
 475			__field(unsigned int, highest_slotid)
 476			__field(unsigned int, cachethis)
 477			__field(unsigned long, error)
 478		),
 479
 480		TP_fast_assign(
 481			__entry->session = nfs_session_id_hash(&args->csa_sessionid);
 482			__entry->slot_nr = args->csa_slotid;
 483			__entry->seq_nr = args->csa_sequenceid;
 484			__entry->highest_slotid = args->csa_highestslotid;
 485			__entry->cachethis = args->csa_cachethis;
 486			__entry->error = be32_to_cpu(status);
 487		),
 488
 489		TP_printk(
 490			"error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
 491			"highest_slotid=%u",
 492			-__entry->error,
 493			show_nfsv4_errors(__entry->error),
 494			__entry->session,
 495			__entry->slot_nr,
 496			__entry->seq_nr,
 497			__entry->highest_slotid
 498		)
 499);
 500
 501TRACE_EVENT(nfs4_cb_seqid_err,
 502		TP_PROTO(
 503			const struct cb_sequenceargs *args,
 504			__be32 status
 505		),
 506		TP_ARGS(args, status),
 507
 508		TP_STRUCT__entry(
 509			__field(unsigned int, session)
 510			__field(unsigned int, slot_nr)
 511			__field(unsigned int, seq_nr)
 512			__field(unsigned int, highest_slotid)
 513			__field(unsigned int, cachethis)
 514			__field(unsigned long, error)
 515		),
 516
 517		TP_fast_assign(
 518			__entry->session = nfs_session_id_hash(&args->csa_sessionid);
 519			__entry->slot_nr = args->csa_slotid;
 520			__entry->seq_nr = args->csa_sequenceid;
 521			__entry->highest_slotid = args->csa_highestslotid;
 522			__entry->cachethis = args->csa_cachethis;
 523			__entry->error = be32_to_cpu(status);
 524		),
 525
 526		TP_printk(
 527			"error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
 528			"highest_slotid=%u",
 529			-__entry->error,
 530			show_nfsv4_errors(__entry->error),
 531			__entry->session,
 532			__entry->slot_nr,
 533			__entry->seq_nr,
 534			__entry->highest_slotid
 535		)
 536);
 537
 538#endif /* CONFIG_NFS_V4_1 */
 539
 540TRACE_EVENT(nfs4_setup_sequence,
 541		TP_PROTO(
 542			const struct nfs4_session *session,
 543			const struct nfs4_sequence_args *args
 544		),
 545		TP_ARGS(session, args),
 546
 547		TP_STRUCT__entry(
 548			__field(unsigned int, session)
 549			__field(unsigned int, slot_nr)
 550			__field(unsigned int, seq_nr)
 551			__field(unsigned int, highest_used_slotid)
 552		),
 553
 554		TP_fast_assign(
 555			const struct nfs4_slot *sa_slot = args->sa_slot;
 556			__entry->session = session ? nfs_session_id_hash(&session->sess_id) : 0;
 557			__entry->slot_nr = sa_slot->slot_nr;
 558			__entry->seq_nr = sa_slot->seq_nr;
 559			__entry->highest_used_slotid =
 560					sa_slot->table->highest_used_slotid;
 561		),
 562		TP_printk(
 563			"session=0x%08x slot_nr=%u seq_nr=%u "
 564			"highest_used_slotid=%u",
 565			__entry->session,
 566			__entry->slot_nr,
 567			__entry->seq_nr,
 568			__entry->highest_used_slotid
 569		)
 570);
 571
 572TRACE_DEFINE_ENUM(NFS4CLNT_MANAGER_RUNNING);
 573TRACE_DEFINE_ENUM(NFS4CLNT_CHECK_LEASE);
 574TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_EXPIRED);
 575TRACE_DEFINE_ENUM(NFS4CLNT_RECLAIM_REBOOT);
 576TRACE_DEFINE_ENUM(NFS4CLNT_RECLAIM_NOGRACE);
 577TRACE_DEFINE_ENUM(NFS4CLNT_DELEGRETURN);
 578TRACE_DEFINE_ENUM(NFS4CLNT_SESSION_RESET);
 579TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_CONFIRM);
 580TRACE_DEFINE_ENUM(NFS4CLNT_SERVER_SCOPE_MISMATCH);
 581TRACE_DEFINE_ENUM(NFS4CLNT_PURGE_STATE);
 582TRACE_DEFINE_ENUM(NFS4CLNT_BIND_CONN_TO_SESSION);
 583TRACE_DEFINE_ENUM(NFS4CLNT_MOVED);
 584TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_MOVED);
 585TRACE_DEFINE_ENUM(NFS4CLNT_DELEGATION_EXPIRED);
 586TRACE_DEFINE_ENUM(NFS4CLNT_RUN_MANAGER);
 587TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_RUNNING);
 588TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_ANY_LAYOUT_READ);
 589TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_ANY_LAYOUT_RW);
 590
 591#define show_nfs4_clp_state(state) \
 592	__print_flags(state, "|", \
 593		{ NFS4CLNT_MANAGER_RUNNING,	"MANAGER_RUNNING" }, \
 594		{ NFS4CLNT_CHECK_LEASE,		"CHECK_LEASE" }, \
 595		{ NFS4CLNT_LEASE_EXPIRED,	"LEASE_EXPIRED" }, \
 596		{ NFS4CLNT_RECLAIM_REBOOT,	"RECLAIM_REBOOT" }, \
 597		{ NFS4CLNT_RECLAIM_NOGRACE,	"RECLAIM_NOGRACE" }, \
 598		{ NFS4CLNT_DELEGRETURN,		"DELEGRETURN" }, \
 599		{ NFS4CLNT_SESSION_RESET,	"SESSION_RESET" }, \
 600		{ NFS4CLNT_LEASE_CONFIRM,	"LEASE_CONFIRM" }, \
 601		{ NFS4CLNT_SERVER_SCOPE_MISMATCH, \
 602						"SERVER_SCOPE_MISMATCH" }, \
 603		{ NFS4CLNT_PURGE_STATE,		"PURGE_STATE" }, \
 604		{ NFS4CLNT_BIND_CONN_TO_SESSION, \
 605						"BIND_CONN_TO_SESSION" }, \
 606		{ NFS4CLNT_MOVED,		"MOVED" }, \
 607		{ NFS4CLNT_LEASE_MOVED,		"LEASE_MOVED" }, \
 608		{ NFS4CLNT_DELEGATION_EXPIRED,	"DELEGATION_EXPIRED" }, \
 609		{ NFS4CLNT_RUN_MANAGER,		"RUN_MANAGER" }, \
 610		{ NFS4CLNT_RECALL_RUNNING,	"RECALL_RUNNING" }, \
 611		{ NFS4CLNT_RECALL_ANY_LAYOUT_READ, "RECALL_ANY_LAYOUT_READ" }, \
 612		{ NFS4CLNT_RECALL_ANY_LAYOUT_RW, "RECALL_ANY_LAYOUT_RW" })
 613
 614TRACE_EVENT(nfs4_state_mgr,
 615		TP_PROTO(
 616			const struct nfs_client *clp
 617		),
 618
 619		TP_ARGS(clp),
 620
 621		TP_STRUCT__entry(
 622			__field(unsigned long, state)
 623			__string(hostname, clp->cl_hostname)
 624		),
 625
 626		TP_fast_assign(
 627			__entry->state = clp->cl_state;
 628			__assign_str(hostname, clp->cl_hostname)
 629		),
 630
 631		TP_printk(
 632			"hostname=%s clp state=%s", __get_str(hostname),
 633			show_nfs4_clp_state(__entry->state)
 634		)
 635)
 636
 637TRACE_EVENT(nfs4_state_mgr_failed,
 638		TP_PROTO(
 639			const struct nfs_client *clp,
 640			const char *section,
 641			int status
 642		),
 643
 644		TP_ARGS(clp, section, status),
 645
 646		TP_STRUCT__entry(
 647			__field(unsigned long, error)
 648			__field(unsigned long, state)
 649			__string(hostname, clp->cl_hostname)
 650			__string(section, section)
 651		),
 652
 653		TP_fast_assign(
 654			__entry->error = status < 0 ? -status : 0;
 655			__entry->state = clp->cl_state;
 656			__assign_str(hostname, clp->cl_hostname);
 657			__assign_str(section, section);
 658		),
 659
 660		TP_printk(
 661			"hostname=%s clp state=%s error=%ld (%s) section=%s",
 662			__get_str(hostname),
 663			show_nfs4_clp_state(__entry->state), -__entry->error,
 664			show_nfsv4_errors(__entry->error), __get_str(section)
 665
 666		)
 667)
 668
 669TRACE_EVENT(nfs4_xdr_status,
 670		TP_PROTO(
 671			const struct xdr_stream *xdr,
 672			u32 op,
 673			u32 error
 674		),
 675
 676		TP_ARGS(xdr, op, error),
 677
 678		TP_STRUCT__entry(
 679			__field(unsigned int, task_id)
 680			__field(unsigned int, client_id)
 681			__field(u32, xid)
 682			__field(u32, op)
 683			__field(unsigned long, error)
 684		),
 685
 686		TP_fast_assign(
 687			const struct rpc_rqst *rqstp = xdr->rqst;
 688			const struct rpc_task *task = rqstp->rq_task;
 689
 690			__entry->task_id = task->tk_pid;
 691			__entry->client_id = task->tk_client->cl_clid;
 692			__entry->xid = be32_to_cpu(rqstp->rq_xid);
 693			__entry->op = op;
 694			__entry->error = error;
 695		),
 696
 697		TP_printk(
 698			"task:%u@%d xid=0x%08x error=%ld (%s) operation=%u",
 699			__entry->task_id, __entry->client_id, __entry->xid,
 700			-__entry->error, show_nfsv4_errors(__entry->error),
 701			__entry->op
 702		)
 703);
 704
 705DECLARE_EVENT_CLASS(nfs4_cb_error_class,
 706		TP_PROTO(
 707			__be32 xid,
 708			u32 cb_ident
 709		),
 710
 711		TP_ARGS(xid, cb_ident),
 712
 713		TP_STRUCT__entry(
 714			__field(u32, xid)
 715			__field(u32, cbident)
 716		),
 717
 718		TP_fast_assign(
 719			__entry->xid = be32_to_cpu(xid);
 720			__entry->cbident = cb_ident;
 721		),
 722
 723		TP_printk(
 724			"xid=0x%08x cb_ident=0x%08x",
 725			__entry->xid, __entry->cbident
 726		)
 727);
 728
 729#define DEFINE_CB_ERROR_EVENT(name) \
 730	DEFINE_EVENT(nfs4_cb_error_class, nfs_cb_##name, \
 731			TP_PROTO( \
 732				__be32 xid, \
 733				u32 cb_ident \
 734			), \
 735			TP_ARGS(xid, cb_ident))
 736
 737DEFINE_CB_ERROR_EVENT(no_clp);
 738DEFINE_CB_ERROR_EVENT(badprinc);
 739
 740DECLARE_EVENT_CLASS(nfs4_open_event,
 741		TP_PROTO(
 742			const struct nfs_open_context *ctx,
 743			int flags,
 744			int error
 745		),
 746
 747		TP_ARGS(ctx, flags, error),
 748
 749		TP_STRUCT__entry(
 750			__field(unsigned long, error)
 751			__field(unsigned int, flags)
 752			__field(unsigned int, fmode)
 753			__field(dev_t, dev)
 754			__field(u32, fhandle)
 755			__field(u64, fileid)
 756			__field(u64, dir)
 757			__string(name, ctx->dentry->d_name.name)
 758			__field(int, stateid_seq)
 759			__field(u32, stateid_hash)
 760			__field(int, openstateid_seq)
 761			__field(u32, openstateid_hash)
 762		),
 763
 764		TP_fast_assign(
 765			const struct nfs4_state *state = ctx->state;
 766			const struct inode *inode = NULL;
 767
 768			__entry->error = -error;
 769			__entry->flags = flags;
 770			__entry->fmode = (__force unsigned int)ctx->mode;
 771			__entry->dev = ctx->dentry->d_sb->s_dev;
 772			if (!IS_ERR_OR_NULL(state)) {
 773				inode = state->inode;
 774				__entry->stateid_seq =
 775					be32_to_cpu(state->stateid.seqid);
 776				__entry->stateid_hash =
 777					nfs_stateid_hash(&state->stateid);
 778				__entry->openstateid_seq =
 779					be32_to_cpu(state->open_stateid.seqid);
 780				__entry->openstateid_hash =
 781					nfs_stateid_hash(&state->open_stateid);
 782			} else {
 783				__entry->stateid_seq = 0;
 784				__entry->stateid_hash = 0;
 785				__entry->openstateid_seq = 0;
 786				__entry->openstateid_hash = 0;
 787			}
 788			if (inode != NULL) {
 789				__entry->fileid = NFS_FILEID(inode);
 790				__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
 791			} else {
 792				__entry->fileid = 0;
 793				__entry->fhandle = 0;
 794			}
 795			__entry->dir = NFS_FILEID(d_inode(ctx->dentry->d_parent));
 796			__assign_str(name, ctx->dentry->d_name.name);
 797		),
 798
 799		TP_printk(
 800			"error=%ld (%s) flags=%d (%s) fmode=%s "
 801			"fileid=%02x:%02x:%llu fhandle=0x%08x "
 802			"name=%02x:%02x:%llu/%s stateid=%d:0x%08x "
 803			"openstateid=%d:0x%08x",
 804			 -__entry->error,
 805			 show_nfsv4_errors(__entry->error),
 806			 __entry->flags,
 807			 show_open_flags(__entry->flags),
 808			 show_fmode_flags(__entry->fmode),
 809			 MAJOR(__entry->dev), MINOR(__entry->dev),
 810			 (unsigned long long)__entry->fileid,
 811			 __entry->fhandle,
 812			 MAJOR(__entry->dev), MINOR(__entry->dev),
 813			 (unsigned long long)__entry->dir,
 814			 __get_str(name),
 815			 __entry->stateid_seq, __entry->stateid_hash,
 816			 __entry->openstateid_seq, __entry->openstateid_hash
 817		)
 818);
 819
 820#define DEFINE_NFS4_OPEN_EVENT(name) \
 821	DEFINE_EVENT(nfs4_open_event, name, \
 822			TP_PROTO( \
 823				const struct nfs_open_context *ctx, \
 824				int flags, \
 825				int error \
 826			), \
 827			TP_ARGS(ctx, flags, error))
 828DEFINE_NFS4_OPEN_EVENT(nfs4_open_reclaim);
 829DEFINE_NFS4_OPEN_EVENT(nfs4_open_expired);
 830DEFINE_NFS4_OPEN_EVENT(nfs4_open_file);
 831
 832TRACE_EVENT(nfs4_cached_open,
 833		TP_PROTO(
 834			const struct nfs4_state *state
 835		),
 836		TP_ARGS(state),
 837		TP_STRUCT__entry(
 838			__field(dev_t, dev)
 839			__field(u32, fhandle)
 840			__field(u64, fileid)
 841			__field(unsigned int, fmode)
 842			__field(int, stateid_seq)
 843			__field(u32, stateid_hash)
 844		),
 845
 846		TP_fast_assign(
 847			const struct inode *inode = state->inode;
 848
 849			__entry->dev = inode->i_sb->s_dev;
 850			__entry->fileid = NFS_FILEID(inode);
 851			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
 852			__entry->fmode = (__force unsigned int)state->state;
 853			__entry->stateid_seq =
 854				be32_to_cpu(state->stateid.seqid);
 855			__entry->stateid_hash =
 856				nfs_stateid_hash(&state->stateid);
 857		),
 858
 859		TP_printk(
 860			"fmode=%s fileid=%02x:%02x:%llu "
 861			"fhandle=0x%08x stateid=%d:0x%08x",
 862			__entry->fmode ?  show_fmode_flags(__entry->fmode) :
 863					  "closed",
 864			MAJOR(__entry->dev), MINOR(__entry->dev),
 865			(unsigned long long)__entry->fileid,
 866			__entry->fhandle,
 867			__entry->stateid_seq, __entry->stateid_hash
 868		)
 869);
 870
 871TRACE_EVENT(nfs4_close,
 872		TP_PROTO(
 873			const struct nfs4_state *state,
 874			const struct nfs_closeargs *args,
 875			const struct nfs_closeres *res,
 876			int error
 877		),
 878
 879		TP_ARGS(state, args, res, error),
 880
 881		TP_STRUCT__entry(
 882			__field(dev_t, dev)
 883			__field(u32, fhandle)
 884			__field(u64, fileid)
 885			__field(unsigned int, fmode)
 886			__field(unsigned long, error)
 887			__field(int, stateid_seq)
 888			__field(u32, stateid_hash)
 889		),
 890
 891		TP_fast_assign(
 892			const struct inode *inode = state->inode;
 893
 894			__entry->dev = inode->i_sb->s_dev;
 895			__entry->fileid = NFS_FILEID(inode);
 896			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
 897			__entry->fmode = (__force unsigned int)state->state;
 898			__entry->error = error < 0 ? -error : 0;
 899			__entry->stateid_seq =
 900				be32_to_cpu(args->stateid.seqid);
 901			__entry->stateid_hash =
 902				nfs_stateid_hash(&args->stateid);
 903		),
 904
 905		TP_printk(
 906			"error=%ld (%s) fmode=%s fileid=%02x:%02x:%llu "
 907			"fhandle=0x%08x openstateid=%d:0x%08x",
 908			-__entry->error,
 909			show_nfsv4_errors(__entry->error),
 910			__entry->fmode ?  show_fmode_flags(__entry->fmode) :
 911					  "closed",
 912			MAJOR(__entry->dev), MINOR(__entry->dev),
 913			(unsigned long long)__entry->fileid,
 914			__entry->fhandle,
 915			__entry->stateid_seq, __entry->stateid_hash
 916		)
 917);
 918
 919TRACE_DEFINE_ENUM(F_GETLK);
 920TRACE_DEFINE_ENUM(F_SETLK);
 921TRACE_DEFINE_ENUM(F_SETLKW);
 922TRACE_DEFINE_ENUM(F_RDLCK);
 923TRACE_DEFINE_ENUM(F_WRLCK);
 924TRACE_DEFINE_ENUM(F_UNLCK);
 925
 926#define show_lock_cmd(type) \
 927	__print_symbolic((int)type, \
 928		{ F_GETLK, "GETLK" }, \
 929		{ F_SETLK, "SETLK" }, \
 930		{ F_SETLKW, "SETLKW" })
 931#define show_lock_type(type) \
 932	__print_symbolic((int)type, \
 933		{ F_RDLCK, "RDLCK" }, \
 934		{ F_WRLCK, "WRLCK" }, \
 935		{ F_UNLCK, "UNLCK" })
 936
 937DECLARE_EVENT_CLASS(nfs4_lock_event,
 938		TP_PROTO(
 939			const struct file_lock *request,
 940			const struct nfs4_state *state,
 941			int cmd,
 942			int error
 943		),
 944
 945		TP_ARGS(request, state, cmd, error),
 946
 947		TP_STRUCT__entry(
 948			__field(unsigned long, error)
 949			__field(int, cmd)
 950			__field(char, type)
 951			__field(loff_t, start)
 952			__field(loff_t, end)
 953			__field(dev_t, dev)
 954			__field(u32, fhandle)
 955			__field(u64, fileid)
 956			__field(int, stateid_seq)
 957			__field(u32, stateid_hash)
 958		),
 959
 960		TP_fast_assign(
 961			const struct inode *inode = state->inode;
 962
 963			__entry->error = error < 0 ? -error : 0;
 964			__entry->cmd = cmd;
 965			__entry->type = request->fl_type;
 966			__entry->start = request->fl_start;
 967			__entry->end = request->fl_end;
 968			__entry->dev = inode->i_sb->s_dev;
 969			__entry->fileid = NFS_FILEID(inode);
 970			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
 971			__entry->stateid_seq =
 972				be32_to_cpu(state->stateid.seqid);
 973			__entry->stateid_hash =
 974				nfs_stateid_hash(&state->stateid);
 975		),
 976
 977		TP_printk(
 978			"error=%ld (%s) cmd=%s:%s range=%lld:%lld "
 979			"fileid=%02x:%02x:%llu fhandle=0x%08x "
 980			"stateid=%d:0x%08x",
 981			-__entry->error,
 982			show_nfsv4_errors(__entry->error),
 983			show_lock_cmd(__entry->cmd),
 984			show_lock_type(__entry->type),
 985			(long long)__entry->start,
 986			(long long)__entry->end,
 987			MAJOR(__entry->dev), MINOR(__entry->dev),
 988			(unsigned long long)__entry->fileid,
 989			__entry->fhandle,
 990			__entry->stateid_seq, __entry->stateid_hash
 991		)
 992);
 993
 994#define DEFINE_NFS4_LOCK_EVENT(name) \
 995	DEFINE_EVENT(nfs4_lock_event, name, \
 996			TP_PROTO( \
 997				const struct file_lock *request, \
 998				const struct nfs4_state *state, \
 999				int cmd, \
1000				int error \
1001			), \
1002			TP_ARGS(request, state, cmd, error))
1003DEFINE_NFS4_LOCK_EVENT(nfs4_get_lock);
1004DEFINE_NFS4_LOCK_EVENT(nfs4_unlock);
1005
1006TRACE_EVENT(nfs4_set_lock,
1007		TP_PROTO(
1008			const struct file_lock *request,
1009			const struct nfs4_state *state,
1010			const nfs4_stateid *lockstateid,
1011			int cmd,
1012			int error
1013		),
1014
1015		TP_ARGS(request, state, lockstateid, cmd, error),
1016
1017		TP_STRUCT__entry(
1018			__field(unsigned long, error)
1019			__field(int, cmd)
1020			__field(char, type)
1021			__field(loff_t, start)
1022			__field(loff_t, end)
1023			__field(dev_t, dev)
1024			__field(u32, fhandle)
1025			__field(u64, fileid)
1026			__field(int, stateid_seq)
1027			__field(u32, stateid_hash)
1028			__field(int, lockstateid_seq)
1029			__field(u32, lockstateid_hash)
1030		),
1031
1032		TP_fast_assign(
1033			const struct inode *inode = state->inode;
1034
1035			__entry->error = error < 0 ? -error : 0;
1036			__entry->cmd = cmd;
1037			__entry->type = request->fl_type;
1038			__entry->start = request->fl_start;
1039			__entry->end = request->fl_end;
1040			__entry->dev = inode->i_sb->s_dev;
1041			__entry->fileid = NFS_FILEID(inode);
1042			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1043			__entry->stateid_seq =
1044				be32_to_cpu(state->stateid.seqid);
1045			__entry->stateid_hash =
1046				nfs_stateid_hash(&state->stateid);
1047			__entry->lockstateid_seq =
1048				be32_to_cpu(lockstateid->seqid);
1049			__entry->lockstateid_hash =
1050				nfs_stateid_hash(lockstateid);
1051		),
1052
1053		TP_printk(
1054			"error=%ld (%s) cmd=%s:%s range=%lld:%lld "
1055			"fileid=%02x:%02x:%llu fhandle=0x%08x "
1056			"stateid=%d:0x%08x lockstateid=%d:0x%08x",
1057			-__entry->error,
1058			show_nfsv4_errors(__entry->error),
1059			show_lock_cmd(__entry->cmd),
1060			show_lock_type(__entry->type),
1061			(long long)__entry->start,
1062			(long long)__entry->end,
1063			MAJOR(__entry->dev), MINOR(__entry->dev),
1064			(unsigned long long)__entry->fileid,
1065			__entry->fhandle,
1066			__entry->stateid_seq, __entry->stateid_hash,
1067			__entry->lockstateid_seq, __entry->lockstateid_hash
1068		)
1069);
1070
1071TRACE_DEFINE_ENUM(LK_STATE_IN_USE);
1072TRACE_DEFINE_ENUM(NFS_DELEGATED_STATE);
1073TRACE_DEFINE_ENUM(NFS_OPEN_STATE);
1074TRACE_DEFINE_ENUM(NFS_O_RDONLY_STATE);
1075TRACE_DEFINE_ENUM(NFS_O_WRONLY_STATE);
1076TRACE_DEFINE_ENUM(NFS_O_RDWR_STATE);
1077TRACE_DEFINE_ENUM(NFS_STATE_RECLAIM_REBOOT);
1078TRACE_DEFINE_ENUM(NFS_STATE_RECLAIM_NOGRACE);
1079TRACE_DEFINE_ENUM(NFS_STATE_POSIX_LOCKS);
1080TRACE_DEFINE_ENUM(NFS_STATE_RECOVERY_FAILED);
1081TRACE_DEFINE_ENUM(NFS_STATE_MAY_NOTIFY_LOCK);
1082TRACE_DEFINE_ENUM(NFS_STATE_CHANGE_WAIT);
1083TRACE_DEFINE_ENUM(NFS_CLNT_DST_SSC_COPY_STATE);
1084TRACE_DEFINE_ENUM(NFS_CLNT_SRC_SSC_COPY_STATE);
1085TRACE_DEFINE_ENUM(NFS_SRV_SSC_COPY_STATE);
1086
1087#define show_nfs4_state_flags(flags) \
1088	__print_flags(flags, "|", \
1089		{ LK_STATE_IN_USE,		"IN_USE" }, \
1090		{ NFS_DELEGATED_STATE,		"DELEGATED" }, \
1091		{ NFS_OPEN_STATE,		"OPEN" }, \
1092		{ NFS_O_RDONLY_STATE,		"O_RDONLY" }, \
1093		{ NFS_O_WRONLY_STATE,		"O_WRONLY" }, \
1094		{ NFS_O_RDWR_STATE,		"O_RDWR" }, \
1095		{ NFS_STATE_RECLAIM_REBOOT,	"RECLAIM_REBOOT" }, \
1096		{ NFS_STATE_RECLAIM_NOGRACE,	"RECLAIM_NOGRACE" }, \
1097		{ NFS_STATE_POSIX_LOCKS,	"POSIX_LOCKS" }, \
1098		{ NFS_STATE_RECOVERY_FAILED,	"RECOVERY_FAILED" }, \
1099		{ NFS_STATE_MAY_NOTIFY_LOCK,	"MAY_NOTIFY_LOCK" }, \
1100		{ NFS_STATE_CHANGE_WAIT,	"CHANGE_WAIT" }, \
1101		{ NFS_CLNT_DST_SSC_COPY_STATE,	"CLNT_DST_SSC_COPY" }, \
1102		{ NFS_CLNT_SRC_SSC_COPY_STATE,	"CLNT_SRC_SSC_COPY" }, \
1103		{ NFS_SRV_SSC_COPY_STATE,	"SRV_SSC_COPY" })
1104
1105#define show_nfs4_lock_flags(flags) \
1106	__print_flags(flags, "|", \
1107		{ BIT(NFS_LOCK_INITIALIZED),	"INITIALIZED" }, \
1108		{ BIT(NFS_LOCK_LOST),		"LOST" })
1109
1110TRACE_EVENT(nfs4_state_lock_reclaim,
1111		TP_PROTO(
1112			const struct nfs4_state *state,
1113			const struct nfs4_lock_state *lock
1114		),
1115
1116		TP_ARGS(state, lock),
1117
1118		TP_STRUCT__entry(
1119			__field(dev_t, dev)
1120			__field(u32, fhandle)
1121			__field(u64, fileid)
1122			__field(unsigned long, state_flags)
1123			__field(unsigned long, lock_flags)
1124			__field(int, stateid_seq)
1125			__field(u32, stateid_hash)
1126		),
1127
1128		TP_fast_assign(
1129			const struct inode *inode = state->inode;
1130
1131			__entry->dev = inode->i_sb->s_dev;
1132			__entry->fileid = NFS_FILEID(inode);
1133			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1134			__entry->state_flags = state->flags;
1135			__entry->lock_flags = lock->ls_flags;
1136			__entry->stateid_seq =
1137				be32_to_cpu(state->stateid.seqid);
1138			__entry->stateid_hash =
1139				nfs_stateid_hash(&state->stateid);
1140		),
1141
1142		TP_printk(
1143			"fileid=%02x:%02x:%llu fhandle=0x%08x "
1144			"stateid=%d:0x%08x state_flags=%s lock_flags=%s",
1145			MAJOR(__entry->dev), MINOR(__entry->dev),
1146			(unsigned long long)__entry->fileid, __entry->fhandle,
1147			__entry->stateid_seq, __entry->stateid_hash,
1148			show_nfs4_state_flags(__entry->state_flags),
1149			show_nfs4_lock_flags(__entry->lock_flags)
1150		)
1151)
1152
1153DECLARE_EVENT_CLASS(nfs4_set_delegation_event,
1154		TP_PROTO(
1155			const struct inode *inode,
1156			fmode_t fmode
1157		),
1158
1159		TP_ARGS(inode, fmode),
1160
1161		TP_STRUCT__entry(
1162			__field(dev_t, dev)
1163			__field(u32, fhandle)
1164			__field(u64, fileid)
1165			__field(unsigned int, fmode)
1166		),
1167
1168		TP_fast_assign(
1169			__entry->dev = inode->i_sb->s_dev;
1170			__entry->fileid = NFS_FILEID(inode);
1171			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1172			__entry->fmode = (__force unsigned int)fmode;
1173		),
1174
1175		TP_printk(
1176			"fmode=%s fileid=%02x:%02x:%llu fhandle=0x%08x",
1177			show_fmode_flags(__entry->fmode),
1178			MAJOR(__entry->dev), MINOR(__entry->dev),
1179			(unsigned long long)__entry->fileid,
1180			__entry->fhandle
1181		)
1182);
1183#define DEFINE_NFS4_SET_DELEGATION_EVENT(name) \
1184	DEFINE_EVENT(nfs4_set_delegation_event, name, \
1185			TP_PROTO( \
1186				const struct inode *inode, \
1187				fmode_t fmode \
1188			), \
1189			TP_ARGS(inode, fmode))
1190DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_set_delegation);
1191DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_reclaim_delegation);
1192
1193TRACE_EVENT(nfs4_delegreturn_exit,
1194		TP_PROTO(
1195			const struct nfs4_delegreturnargs *args,
1196			const struct nfs4_delegreturnres *res,
1197			int error
1198		),
1199
1200		TP_ARGS(args, res, error),
1201
1202		TP_STRUCT__entry(
1203			__field(dev_t, dev)
1204			__field(u32, fhandle)
1205			__field(unsigned long, error)
1206			__field(int, stateid_seq)
1207			__field(u32, stateid_hash)
1208		),
1209
1210		TP_fast_assign(
1211			__entry->dev = res->server->s_dev;
1212			__entry->fhandle = nfs_fhandle_hash(args->fhandle);
1213			__entry->error = error < 0 ? -error : 0;
1214			__entry->stateid_seq =
1215				be32_to_cpu(args->stateid->seqid);
1216			__entry->stateid_hash =
1217				nfs_stateid_hash(args->stateid);
1218		),
1219
1220		TP_printk(
1221			"error=%ld (%s) dev=%02x:%02x fhandle=0x%08x "
1222			"stateid=%d:0x%08x",
1223			-__entry->error,
1224			show_nfsv4_errors(__entry->error),
1225			MAJOR(__entry->dev), MINOR(__entry->dev),
1226			__entry->fhandle,
1227			__entry->stateid_seq, __entry->stateid_hash
1228		)
1229);
1230
1231#ifdef CONFIG_NFS_V4_1
1232DECLARE_EVENT_CLASS(nfs4_test_stateid_event,
1233		TP_PROTO(
1234			const struct nfs4_state *state,
1235			const struct nfs4_lock_state *lsp,
1236			int error
1237		),
1238
1239		TP_ARGS(state, lsp, error),
1240
1241		TP_STRUCT__entry(
1242			__field(unsigned long, error)
1243			__field(dev_t, dev)
1244			__field(u32, fhandle)
1245			__field(u64, fileid)
1246			__field(int, stateid_seq)
1247			__field(u32, stateid_hash)
1248		),
1249
1250		TP_fast_assign(
1251			const struct inode *inode = state->inode;
1252
1253			__entry->error = error < 0 ? -error : 0;
1254			__entry->dev = inode->i_sb->s_dev;
1255			__entry->fileid = NFS_FILEID(inode);
1256			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1257			__entry->stateid_seq =
1258				be32_to_cpu(state->stateid.seqid);
1259			__entry->stateid_hash =
1260				nfs_stateid_hash(&state->stateid);
1261		),
1262
1263		TP_printk(
1264			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1265			"stateid=%d:0x%08x",
1266			-__entry->error,
1267			show_nfsv4_errors(__entry->error),
1268			MAJOR(__entry->dev), MINOR(__entry->dev),
1269			(unsigned long long)__entry->fileid,
1270			__entry->fhandle,
1271			__entry->stateid_seq, __entry->stateid_hash
1272		)
1273);
1274
1275#define DEFINE_NFS4_TEST_STATEID_EVENT(name) \
1276	DEFINE_EVENT(nfs4_test_stateid_event, name, \
1277			TP_PROTO( \
1278				const struct nfs4_state *state, \
1279				const struct nfs4_lock_state *lsp, \
1280				int error \
1281			), \
1282			TP_ARGS(state, lsp, error))
1283DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_delegation_stateid);
1284DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_open_stateid);
1285DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_lock_stateid);
1286#endif /* CONFIG_NFS_V4_1 */
1287
1288DECLARE_EVENT_CLASS(nfs4_lookup_event,
1289		TP_PROTO(
1290			const struct inode *dir,
1291			const struct qstr *name,
1292			int error
1293		),
1294
1295		TP_ARGS(dir, name, error),
1296
1297		TP_STRUCT__entry(
1298			__field(dev_t, dev)
1299			__field(unsigned long, error)
1300			__field(u64, dir)
1301			__string(name, name->name)
1302		),
1303
1304		TP_fast_assign(
1305			__entry->dev = dir->i_sb->s_dev;
1306			__entry->dir = NFS_FILEID(dir);
1307			__entry->error = -error;
1308			__assign_str(name, name->name);
1309		),
1310
1311		TP_printk(
1312			"error=%ld (%s) name=%02x:%02x:%llu/%s",
1313			-__entry->error,
1314			show_nfsv4_errors(__entry->error),
1315			MAJOR(__entry->dev), MINOR(__entry->dev),
1316			(unsigned long long)__entry->dir,
1317			__get_str(name)
1318		)
1319);
1320
1321#define DEFINE_NFS4_LOOKUP_EVENT(name) \
1322	DEFINE_EVENT(nfs4_lookup_event, name, \
1323			TP_PROTO( \
1324				const struct inode *dir, \
1325				const struct qstr *name, \
1326				int error \
1327			), \
1328			TP_ARGS(dir, name, error))
1329
1330DEFINE_NFS4_LOOKUP_EVENT(nfs4_lookup);
1331DEFINE_NFS4_LOOKUP_EVENT(nfs4_symlink);
1332DEFINE_NFS4_LOOKUP_EVENT(nfs4_mkdir);
1333DEFINE_NFS4_LOOKUP_EVENT(nfs4_mknod);
1334DEFINE_NFS4_LOOKUP_EVENT(nfs4_remove);
1335DEFINE_NFS4_LOOKUP_EVENT(nfs4_get_fs_locations);
1336DEFINE_NFS4_LOOKUP_EVENT(nfs4_secinfo);
1337
1338TRACE_EVENT(nfs4_lookupp,
1339		TP_PROTO(
1340			const struct inode *inode,
1341			int error
1342		),
1343
1344		TP_ARGS(inode, error),
1345
1346		TP_STRUCT__entry(
1347			__field(dev_t, dev)
1348			__field(u64, ino)
1349			__field(unsigned long, error)
1350		),
1351
1352		TP_fast_assign(
1353			__entry->dev = inode->i_sb->s_dev;
1354			__entry->ino = NFS_FILEID(inode);
1355			__entry->error = error < 0 ? -error : 0;
1356		),
1357
1358		TP_printk(
1359			"error=%ld (%s) inode=%02x:%02x:%llu",
1360			-__entry->error,
1361			show_nfsv4_errors(__entry->error),
1362			MAJOR(__entry->dev), MINOR(__entry->dev),
1363			(unsigned long long)__entry->ino
1364		)
1365);
1366
1367TRACE_EVENT(nfs4_rename,
1368		TP_PROTO(
1369			const struct inode *olddir,
1370			const struct qstr *oldname,
1371			const struct inode *newdir,
1372			const struct qstr *newname,
1373			int error
1374		),
1375
1376		TP_ARGS(olddir, oldname, newdir, newname, error),
1377
1378		TP_STRUCT__entry(
1379			__field(dev_t, dev)
1380			__field(unsigned long, error)
1381			__field(u64, olddir)
1382			__string(oldname, oldname->name)
1383			__field(u64, newdir)
1384			__string(newname, newname->name)
1385		),
1386
1387		TP_fast_assign(
1388			__entry->dev = olddir->i_sb->s_dev;
1389			__entry->olddir = NFS_FILEID(olddir);
1390			__entry->newdir = NFS_FILEID(newdir);
1391			__entry->error = error < 0 ? -error : 0;
1392			__assign_str(oldname, oldname->name);
1393			__assign_str(newname, newname->name);
1394		),
1395
1396		TP_printk(
1397			"error=%ld (%s) oldname=%02x:%02x:%llu/%s "
1398			"newname=%02x:%02x:%llu/%s",
1399			-__entry->error,
1400			show_nfsv4_errors(__entry->error),
1401			MAJOR(__entry->dev), MINOR(__entry->dev),
1402			(unsigned long long)__entry->olddir,
1403			__get_str(oldname),
1404			MAJOR(__entry->dev), MINOR(__entry->dev),
1405			(unsigned long long)__entry->newdir,
1406			__get_str(newname)
1407		)
1408);
1409
1410DECLARE_EVENT_CLASS(nfs4_inode_event,
1411		TP_PROTO(
1412			const struct inode *inode,
1413			int error
1414		),
1415
1416		TP_ARGS(inode, error),
1417
1418		TP_STRUCT__entry(
1419			__field(dev_t, dev)
1420			__field(u32, fhandle)
1421			__field(u64, fileid)
1422			__field(unsigned long, error)
1423		),
1424
1425		TP_fast_assign(
1426			__entry->dev = inode->i_sb->s_dev;
1427			__entry->fileid = NFS_FILEID(inode);
1428			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1429			__entry->error = error < 0 ? -error : 0;
1430		),
1431
1432		TP_printk(
1433			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x",
1434			-__entry->error,
1435			show_nfsv4_errors(__entry->error),
1436			MAJOR(__entry->dev), MINOR(__entry->dev),
1437			(unsigned long long)__entry->fileid,
1438			__entry->fhandle
1439		)
1440);
1441
1442#define DEFINE_NFS4_INODE_EVENT(name) \
1443	DEFINE_EVENT(nfs4_inode_event, name, \
1444			TP_PROTO( \
1445				const struct inode *inode, \
1446				int error \
1447			), \
1448			TP_ARGS(inode, error))
1449
1450DEFINE_NFS4_INODE_EVENT(nfs4_access);
1451DEFINE_NFS4_INODE_EVENT(nfs4_readlink);
1452DEFINE_NFS4_INODE_EVENT(nfs4_readdir);
1453DEFINE_NFS4_INODE_EVENT(nfs4_get_acl);
1454DEFINE_NFS4_INODE_EVENT(nfs4_set_acl);
1455#ifdef CONFIG_NFS_V4_SECURITY_LABEL
1456DEFINE_NFS4_INODE_EVENT(nfs4_get_security_label);
1457DEFINE_NFS4_INODE_EVENT(nfs4_set_security_label);
1458#endif /* CONFIG_NFS_V4_SECURITY_LABEL */
1459
1460DECLARE_EVENT_CLASS(nfs4_inode_stateid_event,
1461		TP_PROTO(
1462			const struct inode *inode,
1463			const nfs4_stateid *stateid,
1464			int error
1465		),
1466
1467		TP_ARGS(inode, stateid, error),
1468
1469		TP_STRUCT__entry(
1470			__field(dev_t, dev)
1471			__field(u32, fhandle)
1472			__field(u64, fileid)
1473			__field(unsigned long, error)
1474			__field(int, stateid_seq)
1475			__field(u32, stateid_hash)
1476		),
1477
1478		TP_fast_assign(
1479			__entry->dev = inode->i_sb->s_dev;
1480			__entry->fileid = NFS_FILEID(inode);
1481			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1482			__entry->error = error < 0 ? -error : 0;
1483			__entry->stateid_seq =
1484				be32_to_cpu(stateid->seqid);
1485			__entry->stateid_hash =
1486				nfs_stateid_hash(stateid);
1487		),
1488
1489		TP_printk(
1490			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1491			"stateid=%d:0x%08x",
1492			-__entry->error,
1493			show_nfsv4_errors(__entry->error),
1494			MAJOR(__entry->dev), MINOR(__entry->dev),
1495			(unsigned long long)__entry->fileid,
1496			__entry->fhandle,
1497			__entry->stateid_seq, __entry->stateid_hash
1498		)
1499);
1500
1501#define DEFINE_NFS4_INODE_STATEID_EVENT(name) \
1502	DEFINE_EVENT(nfs4_inode_stateid_event, name, \
1503			TP_PROTO( \
1504				const struct inode *inode, \
1505				const nfs4_stateid *stateid, \
1506				int error \
1507			), \
1508			TP_ARGS(inode, stateid, error))
1509
1510DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_setattr);
1511DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_delegreturn);
1512DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update);
1513DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update_wait);
1514
1515DECLARE_EVENT_CLASS(nfs4_getattr_event,
1516		TP_PROTO(
1517			const struct nfs_server *server,
1518			const struct nfs_fh *fhandle,
1519			const struct nfs_fattr *fattr,
1520			int error
1521		),
1522
1523		TP_ARGS(server, fhandle, fattr, error),
1524
1525		TP_STRUCT__entry(
1526			__field(dev_t, dev)
1527			__field(u32, fhandle)
1528			__field(u64, fileid)
1529			__field(unsigned int, valid)
1530			__field(unsigned long, error)
1531		),
1532
1533		TP_fast_assign(
1534			__entry->dev = server->s_dev;
1535			__entry->valid = fattr->valid;
1536			__entry->fhandle = nfs_fhandle_hash(fhandle);
1537			__entry->fileid = (fattr->valid & NFS_ATTR_FATTR_FILEID) ? fattr->fileid : 0;
1538			__entry->error = error < 0 ? -error : 0;
1539		),
1540
1541		TP_printk(
1542			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1543			"valid=%s",
1544			-__entry->error,
1545			show_nfsv4_errors(__entry->error),
1546			MAJOR(__entry->dev), MINOR(__entry->dev),
1547			(unsigned long long)__entry->fileid,
1548			__entry->fhandle,
1549			show_nfs_fattr_flags(__entry->valid)
1550		)
1551);
1552
1553#define DEFINE_NFS4_GETATTR_EVENT(name) \
1554	DEFINE_EVENT(nfs4_getattr_event, name, \
1555			TP_PROTO( \
1556				const struct nfs_server *server, \
1557				const struct nfs_fh *fhandle, \
1558				const struct nfs_fattr *fattr, \
1559				int error \
1560			), \
1561			TP_ARGS(server, fhandle, fattr, error))
1562DEFINE_NFS4_GETATTR_EVENT(nfs4_getattr);
1563DEFINE_NFS4_GETATTR_EVENT(nfs4_lookup_root);
1564DEFINE_NFS4_GETATTR_EVENT(nfs4_fsinfo);
1565
1566DECLARE_EVENT_CLASS(nfs4_inode_callback_event,
1567		TP_PROTO(
1568			const struct nfs_client *clp,
1569			const struct nfs_fh *fhandle,
1570			const struct inode *inode,
1571			int error
1572		),
1573
1574		TP_ARGS(clp, fhandle, inode, error),
1575
1576		TP_STRUCT__entry(
1577			__field(unsigned long, error)
1578			__field(dev_t, dev)
1579			__field(u32, fhandle)
1580			__field(u64, fileid)
1581			__string(dstaddr, clp ? clp->cl_hostname : "unknown")
1582		),
1583
1584		TP_fast_assign(
1585			__entry->error = error < 0 ? -error : 0;
1586			__entry->fhandle = nfs_fhandle_hash(fhandle);
1587			if (!IS_ERR_OR_NULL(inode)) {
1588				__entry->fileid = NFS_FILEID(inode);
1589				__entry->dev = inode->i_sb->s_dev;
1590			} else {
1591				__entry->fileid = 0;
1592				__entry->dev = 0;
1593			}
1594			__assign_str(dstaddr, clp ? clp->cl_hostname : "unknown")
1595		),
1596
1597		TP_printk(
1598			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1599			"dstaddr=%s",
1600			-__entry->error,
1601			show_nfsv4_errors(__entry->error),
1602			MAJOR(__entry->dev), MINOR(__entry->dev),
1603			(unsigned long long)__entry->fileid,
1604			__entry->fhandle,
1605			__get_str(dstaddr)
1606		)
1607);
1608
1609#define DEFINE_NFS4_INODE_CALLBACK_EVENT(name) \
1610	DEFINE_EVENT(nfs4_inode_callback_event, name, \
1611			TP_PROTO( \
1612				const struct nfs_client *clp, \
1613				const struct nfs_fh *fhandle, \
1614				const struct inode *inode, \
1615				int error \
1616			), \
1617			TP_ARGS(clp, fhandle, inode, error))
1618DEFINE_NFS4_INODE_CALLBACK_EVENT(nfs4_cb_getattr);
1619
1620DECLARE_EVENT_CLASS(nfs4_inode_stateid_callback_event,
1621		TP_PROTO(
1622			const struct nfs_client *clp,
1623			const struct nfs_fh *fhandle,
1624			const struct inode *inode,
1625			const nfs4_stateid *stateid,
1626			int error
1627		),
1628
1629		TP_ARGS(clp, fhandle, inode, stateid, error),
1630
1631		TP_STRUCT__entry(
1632			__field(unsigned long, error)
1633			__field(dev_t, dev)
1634			__field(u32, fhandle)
1635			__field(u64, fileid)
1636			__string(dstaddr, clp ? clp->cl_hostname : "unknown")
1637			__field(int, stateid_seq)
1638			__field(u32, stateid_hash)
1639		),
1640
1641		TP_fast_assign(
1642			__entry->error = error < 0 ? -error : 0;
1643			__entry->fhandle = nfs_fhandle_hash(fhandle);
1644			if (!IS_ERR_OR_NULL(inode)) {
1645				__entry->fileid = NFS_FILEID(inode);
1646				__entry->dev = inode->i_sb->s_dev;
1647			} else {
1648				__entry->fileid = 0;
1649				__entry->dev = 0;
1650			}
1651			__assign_str(dstaddr, clp ? clp->cl_hostname : "unknown")
1652			__entry->stateid_seq =
1653				be32_to_cpu(stateid->seqid);
1654			__entry->stateid_hash =
1655				nfs_stateid_hash(stateid);
1656		),
1657
1658		TP_printk(
1659			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1660			"stateid=%d:0x%08x dstaddr=%s",
1661			-__entry->error,
1662			show_nfsv4_errors(__entry->error),
1663			MAJOR(__entry->dev), MINOR(__entry->dev),
1664			(unsigned long long)__entry->fileid,
1665			__entry->fhandle,
1666			__entry->stateid_seq, __entry->stateid_hash,
1667			__get_str(dstaddr)
1668		)
1669);
1670
1671#define DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(name) \
1672	DEFINE_EVENT(nfs4_inode_stateid_callback_event, name, \
1673			TP_PROTO( \
1674				const struct nfs_client *clp, \
1675				const struct nfs_fh *fhandle, \
1676				const struct inode *inode, \
1677				const nfs4_stateid *stateid, \
1678				int error \
1679			), \
1680			TP_ARGS(clp, fhandle, inode, stateid, error))
1681DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_recall);
1682DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_layoutrecall_file);
1683
1684DECLARE_EVENT_CLASS(nfs4_idmap_event,
1685		TP_PROTO(
1686			const char *name,
1687			int len,
1688			u32 id,
1689			int error
1690		),
1691
1692		TP_ARGS(name, len, id, error),
1693
1694		TP_STRUCT__entry(
1695			__field(unsigned long, error)
1696			__field(u32, id)
1697			__dynamic_array(char, name, len > 0 ? len + 1 : 1)
1698		),
1699
1700		TP_fast_assign(
1701			if (len < 0)
1702				len = 0;
1703			__entry->error = error < 0 ? error : 0;
1704			__entry->id = id;
1705			memcpy(__get_str(name), name, len);
1706			__get_str(name)[len] = 0;
1707		),
1708
1709		TP_printk(
1710			"error=%ld (%s) id=%u name=%s",
1711			-__entry->error, show_nfsv4_errors(__entry->error),
1712			__entry->id,
1713			__get_str(name)
1714		)
1715);
1716#define DEFINE_NFS4_IDMAP_EVENT(name) \
1717	DEFINE_EVENT(nfs4_idmap_event, name, \
1718			TP_PROTO( \
1719				const char *name, \
1720				int len, \
1721				u32 id, \
1722				int error \
1723			), \
1724			TP_ARGS(name, len, id, error))
1725DEFINE_NFS4_IDMAP_EVENT(nfs4_map_name_to_uid);
1726DEFINE_NFS4_IDMAP_EVENT(nfs4_map_group_to_gid);
1727DEFINE_NFS4_IDMAP_EVENT(nfs4_map_uid_to_name);
1728DEFINE_NFS4_IDMAP_EVENT(nfs4_map_gid_to_group);
1729
1730DECLARE_EVENT_CLASS(nfs4_read_event,
1731		TP_PROTO(
1732			const struct nfs_pgio_header *hdr,
1733			int error
1734		),
1735
1736		TP_ARGS(hdr, error),
1737
1738		TP_STRUCT__entry(
1739			__field(dev_t, dev)
1740			__field(u32, fhandle)
1741			__field(u64, fileid)
1742			__field(loff_t, offset)
1743			__field(u32, arg_count)
1744			__field(u32, res_count)
1745			__field(unsigned long, error)
1746			__field(int, stateid_seq)
1747			__field(u32, stateid_hash)
1748		),
1749
1750		TP_fast_assign(
1751			const struct inode *inode = hdr->inode;
1752			const struct nfs_inode *nfsi = NFS_I(inode);
1753			const struct nfs_fh *fh = hdr->args.fh ?
1754						  hdr->args.fh : &nfsi->fh;
1755			const struct nfs4_state *state =
1756				hdr->args.context->state;
1757
1758			__entry->dev = inode->i_sb->s_dev;
1759			__entry->fileid = nfsi->fileid;
1760			__entry->fhandle = nfs_fhandle_hash(fh);
1761			__entry->offset = hdr->args.offset;
1762			__entry->arg_count = hdr->args.count;
1763			__entry->res_count = hdr

Large files files are truncated, but you can click here to view the full file