[PATCH 01/10] NFSv4: Add tracepoints for debugging state management problems

[PATCH 01/10] NFSv4: Add tracepoints for debugging state management problems

[Trond Myklebust]

Set up basic tracepoints for debugging client id creation/destruction
and session creation/destruction.

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
---
 fs/nfs/Makefile    |   3 +-
 fs/nfs/nfs4proc.c  |   9 +++
 fs/nfs/nfs4trace.c |  10 +++
 fs/nfs/nfs4trace.h | 205 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 226 insertions(+), 1 deletion(-)
 create mode 100644 fs/nfs/nfs4trace.c
 create mode 100644 fs/nfs/nfs4trace.h

diff --git a/fs/nfs/Makefile b/fs/nfs/Makefile
index e0bb048..71ba4c2 100644
--- a/fs/nfs/Makefile
+++ b/fs/nfs/Makefile
@@ -21,7 +21,8 @@ nfsv3-$(CONFIG_NFS_V3_ACL) += nfs3acl.o
 obj-$(CONFIG_NFS_V4) += nfsv4.o
 nfsv4-y := nfs4proc.o nfs4xdr.o nfs4state.o nfs4renewd.o nfs4super.o nfs4file.o \
 	  delegation.o idmap.o callback.o callback_xdr.o callback_proc.o \
-	  nfs4namespace.o nfs4getroot.o nfs4client.o dns_resolve.o
+	  nfs4namespace.o nfs4getroot.o nfs4client.o dns_resolve.o \
+	  nfs4trace.c
 nfsv4-$(CONFIG_NFS_USE_LEGACY_DNS) += cache_lib.o
 nfsv4-$(CONFIG_SYSCTL)	+= nfs4sysctl.o
 nfsv4-$(CONFIG_NFS_V4_1)	+= nfs4session.o pnfs.o pnfs_dev.o
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index a187f4d..3a55f24 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -66,6 +66,8 @@
 #include "nfs4session.h"
 #include "fscache.h"
 
+#include "nfs4trace.h"
+
 #define NFSDBG_FACILITY		NFSDBG_PROC
 
 #define NFS4_POLL_RETRY_MIN	(HZ/10)
@@ -4730,6 +4732,7 @@ int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
 		clp->cl_rpcclient->cl_auth->au_ops->au_name,
 		setclientid.sc_name_len, setclientid.sc_name);
 	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
+	trace_nfs4_setclientid(clp, status);
 	dprintk("NFS reply setclientid: %d\n", status);
 	return status;
 }
@@ -4757,6 +4760,7 @@ int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
 		clp->cl_rpcclient->cl_auth->au_ops->au_name,
 		clp->cl_clientid);
 	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
+	trace_nfs4_setclientid_confirm(clp, status);
 	dprintk("NFS reply setclientid_confirm: %d\n", status);
 	return status;
 }
@@ -5887,6 +5891,7 @@ int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred
 	}
 
 	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
+	trace_nfs4_bind_conn_to_session(clp, status);
 	if (status == 0) {
 		if (memcmp(res.session->sess_id.data,
 		    clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) {
@@ -5972,6 +5977,7 @@ int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
 	}
 
 	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
+	trace_nfs4_exchange_id(clp, status);
 	if (status == 0)
 		status = nfs4_check_cl_exchange_flags(res.flags);
 
@@ -6032,6 +6038,7 @@ static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
 	int status;
 
 	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
+	trace_nfs4_destroy_clientid(clp, status);
 	if (status)
 		dprintk("NFS: Got error %d from the server %s on "
 			"DESTROY_CLIENTID.", status, clp->cl_hostname);
@@ -6295,6 +6302,7 @@ static int _nfs4_proc_create_session(struct nfs_client *clp,
 	args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);
 
 	status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
+	trace_nfs4_create_session(clp, status);
 
 	if (!status) {
 		/* Verify the session's negotiated channel_attrs values */
@@ -6358,6 +6366,7 @@ int nfs4_proc_destroy_session(struct nfs4_session *session,
 		return status;
 
 	status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
+	trace_nfs4_destroy_session(session->clp, status);
 
 	if (status)
 		dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
diff --git a/fs/nfs/nfs4trace.c b/fs/nfs/nfs4trace.c
new file mode 100644
index 0000000..3f02183
--- /dev/null
+++ b/fs/nfs/nfs4trace.c
@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2013 Trond Myklebust <Trond.Myklebust@netapp.com>
+ */
+#include <linux/nfs_fs.h>
+#include "nfs4_fs.h"
+#include "internal.h"
+
+#define CREATE_TRACE_POINTS
+#include "nfs4trace.h"
+
diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h
new file mode 100644
index 0000000..451954f
--- /dev/null
+++ b/fs/nfs/nfs4trace.h
@@ -0,0 +1,205 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM nfs4
+
+#if !defined(_TRACE_NFS4_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_NFS4_H
+
+#include <linux/tracepoint.h>
+
+#define show_nfsv4_errors(error) __print_symbolic(error,		\
+		{ NFS4_OK,			"OK" },			\
+		/* Mapped by nfs4_stat_to_errno() */			\
+		{ -EPERM,			"EPERM" },		\
+		{ -ENOENT,			"ENOENT" },		\
+		{ -EIO,				"EIO" },		\
+		{ -ENXIO,			"ENXIO" },		\
+		{ -EACCES,			"EACCES" },		\
+		{ -EEXIST,			"EEXIST" },		\
+		{ -EXDEV,			"EXDEV" },		\
+		{ -ENOTDIR,			"ENOTDIR" },		\
+		{ -EISDIR,			"EISDIR" },		\
+		{ -EFBIG,			"EFBIG" },		\
+		{ -ENOSPC,			"ENOSPC" },		\
+		{ -EROFS,			"EROFS" },		\
+		{ -EMLINK,			"EMLINK" },		\
+		{ -ENAMETOOLONG,		"ENAMETOOLONG" },	\
+		{ -ENOTEMPTY,			"ENOTEMPTY" },		\
+		{ -EDQUOT,			"EDQUOT" },		\
+		{ -ESTALE,			"ESTALE" },		\
+		{ -EBADHANDLE,			"EBADHANDLE" },		\
+		{ -EBADCOOKIE,			"EBADCOOKIE" },		\
+		{ -ENOTSUPP,			"ENOTSUPP" },		\
+		{ -ETOOSMALL,			"ETOOSMALL" },		\
+		{ -EREMOTEIO,			"EREMOTEIO" },		\
+		{ -EBADTYPE,			"EBADTYPE" },		\
+		{ -EAGAIN,			"EAGAIN" },		\
+		{ -ELOOP,			"ELOOP" },		\
+		{ -EOPNOTSUPP,			"EOPNOTSUPP" },		\
+		{ -EDEADLK,			"EDEADLK" },		\
+		/* RPC errors */					\
+		{ -ENOMEM,			"ENOMEM" },		\
+		{ -EKEYEXPIRED,			"EKEYEXPIRED" },	\
+		{ -ETIMEDOUT,			"ETIMEDOUT" },		\
+		{ -ERESTARTSYS,			"ERESTARTSYS" },	\
+		{ -ECONNREFUSED,		"ECONNREFUSED" },	\
+		{ -ECONNRESET,			"ECONNRESET" },		\
+		{ -ENETUNREACH,			"ENETUNREACH" },	\
+		{ -EHOSTUNREACH,		"EHOSTUNREACH" },	\
+		{ -EHOSTDOWN,			"EHOSTDOWN" },		\
+		{ -EPIPE,			"EPIPE" },		\
+		{ -EPFNOSUPPORT,		"EPFNOSUPPORT" },	\
+		{ -EPROTONOSUPPORT,		"EPROTONOSUPPORT" },	\
+		/* NFSv4 native errors */				\
+		{ -NFS4ERR_ACCESS,		"ACCESS" },		\
+		{ -NFS4ERR_ATTRNOTSUPP,		"ATTRNOTSUPP" },	\
+		{ -NFS4ERR_ADMIN_REVOKED,	"ADMIN_REVOKED" },	\
+		{ -NFS4ERR_BACK_CHAN_BUSY,	"BACK_CHAN_BUSY" },	\
+		{ -NFS4ERR_BADCHAR,		"BADCHAR" },		\
+		{ -NFS4ERR_BADHANDLE,		"BADHANDLE" },		\
+		{ -NFS4ERR_BADIOMODE,		"BADIOMODE" },		\
+		{ -NFS4ERR_BADLAYOUT,		"BADLAYOUT" },		\
+		{ -NFS4ERR_BADNAME,		"BADNAME" },		\
+		{ -NFS4ERR_BADOWNER,		"BADOWNER" },		\
+		{ -NFS4ERR_BADSESSION,		"BADSESSION" },		\
+		{ -NFS4ERR_BADSLOT,		"BADSLOT" },		\
+		{ -NFS4ERR_BADTYPE,		"BADTYPE" },		\
+		{ -NFS4ERR_BADXDR,		"BADXDR" },		\
+		{ -NFS4ERR_BAD_COOKIE,		"BAD_COOKIE" },		\
+		{ -NFS4ERR_BAD_HIGH_SLOT,	"BAD_HIGH_SLOT" },	\
+		{ -NFS4ERR_BAD_RANGE,		"BAD_RANGE" },		\
+		{ -NFS4ERR_BAD_SEQID,		"BAD_SEQID" },		\
+		{ -NFS4ERR_BAD_SESSION_DIGEST,	"BAD_SESSION_DIGEST" },	\
+		{ -NFS4ERR_BAD_STATEID,		"BAD_STATEID" },	\
+		{ -NFS4ERR_CB_PATH_DOWN,	"CB_PATH_DOWN" },	\
+		{ -NFS4ERR_CLID_INUSE,		"CLID_INUSE" },		\
+		{ -NFS4ERR_CLIENTID_BUSY,	"CLIENTID_BUSY" },	\
+		{ -NFS4ERR_COMPLETE_ALREADY,	"COMPLETE_ALREADY" },	\
+		{ -NFS4ERR_CONN_NOT_BOUND_TO_SESSION,			\
+						"CONN_NOT_BOUND_TO_SESSION" }, \
+		{ -NFS4ERR_DEADLOCK,		"DEADLOCK" },		\
+		{ -NFS4ERR_DEADSESSION,		"DEAD_SESSION" },	\
+		{ -NFS4ERR_DELAY,		"DELAY" },		\
+		{ -NFS4ERR_DELEG_ALREADY_WANTED,			\
+						"DELEG_ALREADY_WANTED" }, \
+		{ -NFS4ERR_DELEG_REVOKED,	"DELEG_REVOKED" },	\
+		{ -NFS4ERR_DENIED,		"DENIED" },		\
+		{ -NFS4ERR_DIRDELEG_UNAVAIL,	"DIRDELEG_UNAVAIL" },	\
+		{ -NFS4ERR_DQUOT,		"DQUOT" },		\
+		{ -NFS4ERR_ENCR_ALG_UNSUPP,	"ENCR_ALG_UNSUPP" },	\
+		{ -NFS4ERR_EXIST,		"EXIST" },		\
+		{ -NFS4ERR_EXPIRED,		"EXPIRED" },		\
+		{ -NFS4ERR_FBIG,		"FBIG" },		\
+		{ -NFS4ERR_FHEXPIRED,		"FHEXPIRED" },		\
+		{ -NFS4ERR_FILE_OPEN,		"FILE_OPEN" },		\
+		{ -NFS4ERR_GRACE,		"GRACE" },		\
+		{ -NFS4ERR_HASH_ALG_UNSUPP,	"HASH_ALG_UNSUPP" },	\
+		{ -NFS4ERR_INVAL,		"INVAL" },		\
+		{ -NFS4ERR_IO,			"IO" },			\
+		{ -NFS4ERR_ISDIR,		"ISDIR" },		\
+		{ -NFS4ERR_LAYOUTTRYLATER,	"LAYOUTTRYLATER" },	\
+		{ -NFS4ERR_LAYOUTUNAVAILABLE,	"LAYOUTUNAVAILABLE" },	\
+		{ -NFS4ERR_LEASE_MOVED,		"LEASE_MOVED" },	\
+		{ -NFS4ERR_LOCKED,		"LOCKED" },		\
+		{ -NFS4ERR_LOCKS_HELD,		"LOCKS_HELD" },		\
+		{ -NFS4ERR_LOCK_RANGE,		"LOCK_RANGE" },		\
+		{ -NFS4ERR_MINOR_VERS_MISMATCH,	"MINOR_VERS_MISMATCH" }, \
+		{ -NFS4ERR_MLINK,		"MLINK" },		\
+		{ -NFS4ERR_MOVED,		"MOVED" },		\
+		{ -NFS4ERR_NAMETOOLONG,		"NAMETOOLONG" },	\
+		{ -NFS4ERR_NOENT,		"NOENT" },		\
+		{ -NFS4ERR_NOFILEHANDLE,	"NOFILEHANDLE" },	\
+		{ -NFS4ERR_NOMATCHING_LAYOUT,	"NOMATCHING_LAYOUT" },	\
+		{ -NFS4ERR_NOSPC,		"NOSPC" },		\
+		{ -NFS4ERR_NOTDIR,		"NOTDIR" },		\
+		{ -NFS4ERR_NOTEMPTY,		"NOTEMPTY" },		\
+		{ -NFS4ERR_NOTSUPP,		"NOTSUPP" },		\
+		{ -NFS4ERR_NOT_ONLY_OP,		"NOT_ONLY_OP" },	\
+		{ -NFS4ERR_NOT_SAME,		"NOT_SAME" },		\
+		{ -NFS4ERR_NO_GRACE,		"NO_GRACE" },		\
+		{ -NFS4ERR_NXIO,		"NXIO" },		\
+		{ -NFS4ERR_OLD_STATEID,		"OLD_STATEID" },	\
+		{ -NFS4ERR_OPENMODE,		"OPENMODE" },		\
+		{ -NFS4ERR_OP_ILLEGAL,		"OP_ILLEGAL" },		\
+		{ -NFS4ERR_OP_NOT_IN_SESSION,	"OP_NOT_IN_SESSION" },	\
+		{ -NFS4ERR_PERM,		"PERM" },		\
+		{ -NFS4ERR_PNFS_IO_HOLE,	"PNFS_IO_HOLE" },	\
+		{ -NFS4ERR_PNFS_NO_LAYOUT,	"PNFS_NO_LAYOUT" },	\
+		{ -NFS4ERR_RECALLCONFLICT,	"RECALLCONFLICT" },	\
+		{ -NFS4ERR_RECLAIM_BAD,		"RECLAIM_BAD" },	\
+		{ -NFS4ERR_RECLAIM_CONFLICT,	"RECLAIM_CONFLICT" },	\
+		{ -NFS4ERR_REJECT_DELEG,	"REJECT_DELEG" },	\
+		{ -NFS4ERR_REP_TOO_BIG,		"REP_TOO_BIG" },	\
+		{ -NFS4ERR_REP_TOO_BIG_TO_CACHE,			\
+						"REP_TOO_BIG_TO_CACHE" }, \
+		{ -NFS4ERR_REQ_TOO_BIG,		"REQ_TOO_BIG" },	\
+		{ -NFS4ERR_RESTOREFH,		"RESTOREFH" },		\
+		{ -NFS4ERR_RETRY_UNCACHED_REP,	"RETRY_UNCACHED_REP" },	\
+		{ -NFS4ERR_RETURNCONFLICT,	"RETURNCONFLICT" },	\
+		{ -NFS4ERR_ROFS,		"ROFS" },		\
+		{ -NFS4ERR_SAME,		"SAME" },		\
+		{ -NFS4ERR_SHARE_DENIED,	"SHARE_DENIED" },	\
+		{ -NFS4ERR_SEQUENCE_POS,	"SEQUENCE_POS" },	\
+		{ -NFS4ERR_SEQ_FALSE_RETRY,	"SEQ_FALSE_RETRY" },	\
+		{ -NFS4ERR_SEQ_MISORDERED,	"SEQ_MISORDERED" },	\
+		{ -NFS4ERR_SERVERFAULT,		"SERVERFAULT" },	\
+		{ -NFS4ERR_STALE,		"STALE" },		\
+		{ -NFS4ERR_STALE_CLIENTID,	"STALE_CLIENTID" },	\
+		{ -NFS4ERR_STALE_STATEID,	"STALE_STATEID" },	\
+		{ -NFS4ERR_SYMLINK,		"SYMLINK" },		\
+		{ -NFS4ERR_TOOSMALL,		"TOOSMALL" },		\
+		{ -NFS4ERR_TOO_MANY_OPS,	"TOO_MANY_OPS" },	\
+		{ -NFS4ERR_UNKNOWN_LAYOUTTYPE,	"UNKNOWN_LAYOUTTYPE" },	\
+		{ -NFS4ERR_UNSAFE_COMPOUND,	"UNSAFE_COMPOUND" },	\
+		{ -NFS4ERR_WRONGSEC,		"WRONGSEC" },		\
+		{ -NFS4ERR_WRONG_CRED,		"WRONG_CRED" },		\
+		{ -NFS4ERR_WRONG_TYPE,		"WRONG_TYPE" },		\
+		{ -NFS4ERR_XDEV,		"XDEV" })
+
+DECLARE_EVENT_CLASS(nfs4_clientid_event,
+		TP_PROTO(const struct nfs_client *clp,
+			int error),
+
+		TP_ARGS(clp, error),
+
+		TP_STRUCT__entry(
+			__string(dstaddr,
+				rpc_peeraddr2str(clp->cl_rpcclient,
+					RPC_DISPLAY_ADDR))
+			__field(int, error)
+		),
+
+		TP_fast_assign(
+			__entry->error = error;
+			__assign_str(dstaddr,
+				rpc_peeraddr2str(clp->cl_rpcclient,
+						RPC_DISPLAY_ADDR));
+		),
+
+		TP_printk("error=%d (%s), dstaddr=%s",
+			__entry->error,
+			show_nfsv4_errors(__entry->error),
+			__get_str(dstaddr)
+		)
+);
+#define DEFINE_NFS4_CLIENTID_EVENT(name)		\
+DEFINE_EVENT(nfs4_clientid_event, name,			\
+		TP_PROTO(const struct nfs_client *clp,	\
+			int error),			\
+		TP_ARGS(clp, error))
+DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid);
+DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid_confirm);
+#ifdef CONFIG_NFS_V4_1
+DEFINE_NFS4_CLIENTID_EVENT(nfs4_exchange_id);
+DEFINE_NFS4_CLIENTID_EVENT(nfs4_create_session);
+DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_session);
+DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_clientid);
+DEFINE_NFS4_CLIENTID_EVENT(nfs4_bind_conn_to_session);
+#endif /* CONFIG_NFS_V4_1 */
+
+#endif /* _TRACE_NFS4_H */
+
+#undef TRACE_INCLUDE_PATH
+#define TRACE_INCLUDE_PATH .
+#define TRACE_INCLUDE_FILE nfs4trace
+/* This part must be outside protection */
+#include <trace/define_trace.h>
-- 
1.8.3.1

[PATCH 02/10] NFS: refactor code for calculating the crc32 hash of a filehandle

[Trond Myklebust]

We want to be able to display the crc32 hash of the filehandle in
tracepoints.

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
---
 fs/nfs/inode.c    |  3 +--
 fs/nfs/internal.h | 20 ++++++++++++++++++++
 2 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index af6e806..9a98b04 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -38,7 +38,6 @@
 #include <linux/slab.h>
 #include <linux/compat.h>
 #include <linux/freezer.h>
-#include <linux/crc32.h>
 
 #include <asm/uaccess.h>
 
@@ -1190,7 +1189,7 @@ u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
 {
 	/* wireshark uses 32-bit AUTODIN crc and does a bitwise
 	 * not on the result */
-	return ~crc32(0xFFFFFFFF, &fh->data[0], fh->size);
+	return nfs_fhandle_hash(fh);
 }
 
 /*
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 9b694f1..50f7068 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -5,6 +5,7 @@
 #include "nfs4_fs.h"
 #include <linux/mount.h>
 #include <linux/security.h>
+#include <linux/crc32.h>
 
 #define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS)
 
@@ -574,3 +575,22 @@ u64 nfs_timespec_to_change_attr(const struct timespec *ts)
 {
 	return ((u64)ts->tv_sec << 30) + ts->tv_nsec;
 }
+
+#ifdef CONFIG_CRC32
+/**
+ * nfs_fhandle_hash - calculate the crc32 hash for the filehandle
+ * @fh - pointer to filehandle
+ *
+ * returns a crc32 hash for the filehandle that is compatible with
+ * the one displayed by "wireshark".
+ */
+static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)
+{
+	return ~crc32_le(0xFFFFFFFF, &fh->data[0], fh->size);
+}
+#else
+static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)
+{
+	return 0;
+}
+#endif
-- 
1.8.3.1

[PATCH 03/10] NFSv4: Add tracepoints for debugging file open

[Trond Myklebust]

Set up basic tracepoints for debugging NFSv4 file open/close

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
---
 fs/nfs/nfs4proc.c  |   4 ++
 fs/nfs/nfs4trace.h | 112 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 116 insertions(+)

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 3a55f24..213c519 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -1442,6 +1442,7 @@ static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state
 	int err;
 	do {
 		err = _nfs4_do_open_reclaim(ctx, state);
+		trace_nfs4_open_reclaim(ctx, state, 0, err);
 		if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
 			continue;
 		if (err != -NFS4ERR_DELAY)
@@ -1897,6 +1898,7 @@ static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state
 
 	do {
 		err = _nfs4_open_expired(ctx, state);
+		trace_nfs4_open_expired(ctx, state, 0, err);
 		if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
 			continue;
 		switch (err) {
@@ -2199,6 +2201,7 @@ static struct nfs4_state *nfs4_do_open(struct inode *dir,
 	do {
 		status = _nfs4_do_open(dir, ctx, flags, sattr, label);
 		res = ctx->state;
+		trace_nfs4_open_file(ctx, res, flags, status);
 		if (status == 0)
 			break;
 		/* NOTE: BAD_SEQID means the server and client disagree about the
@@ -2389,6 +2392,7 @@ static void nfs4_close_done(struct rpc_task *task, void *data)
 	dprintk("%s: begin!\n", __func__);
 	if (!nfs4_sequence_done(task, &calldata->res.seq_res))
 		return;
+	trace_nfs4_close(state, calldata->arg.fmode, task->tk_status);
         /* hmm. we are done with the inode, and in the process of freeing
 	 * the state_owner. we keep this around to process errors
 	 */
diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h
index 451954f..251806f 100644
--- a/fs/nfs/nfs4trace.h
+++ b/fs/nfs/nfs4trace.h
@@ -155,6 +155,19 @@
 		{ -NFS4ERR_WRONG_TYPE,		"WRONG_TYPE" },		\
 		{ -NFS4ERR_XDEV,		"XDEV" })
 
+#define show_open_flags(flag)						\
+	__print_flags((unsigned long)flags, "|",			\
+		{ O_CREAT,			"O_CREAT" },		\
+		{ O_EXCL,			"O_EXCL" },		\
+		{ O_TRUNC,			"O_TRUNC" },		\
+		{ O_DIRECT,			"O_DIRECT" })
+
+#define show_fmode_flags(fmode)						\
+	__print_flags((unsigned long)fmode, "|",			\
+		{ FMODE_READ,			"READ" },		\
+		{ FMODE_WRITE,			"WRITE" },		\
+		{ FMODE_EXEC,			"EXEC" })
+
 DECLARE_EVENT_CLASS(nfs4_clientid_event,
 		TP_PROTO(const struct nfs_client *clp,
 			int error),
@@ -196,6 +209,105 @@ DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_clientid);
 DEFINE_NFS4_CLIENTID_EVENT(nfs4_bind_conn_to_session);
 #endif /* CONFIG_NFS_V4_1 */
 
+DECLARE_EVENT_CLASS(nfs4_open_event,
+		TP_PROTO(const struct nfs_open_context *ctx,
+			const struct nfs4_state *state,
+			int flags,
+			int error),
+
+		TP_ARGS(ctx, state, flags, error),
+
+		TP_STRUCT__entry(
+			__field(int, error)
+			__field(int, flags)
+			__field(fmode_t, fmode)
+			__field(dev_t, dev)
+			__field(u32, fhandle)
+			__field(u64, fileid)
+			__field(u64, dir)
+			__string(name, ctx->dentry->d_name.name)
+		),
+
+		TP_fast_assign(
+			struct inode *inode = NULL;
+			if (!IS_ERR(state))
+				inode = state->inode;
+			__entry->error = error;
+			__entry->flags = flags;
+			__entry->dev = ctx->dentry->d_sb->s_dev;
+			if (inode != NULL) {
+				__entry->fileid = NFS_FILEID(inode);
+				__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
+			} else {
+				__entry->fileid = 0;
+				__entry->fhandle = 0;
+			}
+			__entry->dir = NFS_FILEID(ctx->dentry->d_parent->d_inode);
+			__assign_str(name, ctx->dentry->d_name.name);
+		),
+
+		TP_printk("error=%d (%s), flags=%d (%s) mode=%s fileid=%lld, "
+			  "fhandle=%0x08x name=%02x:%02x:%lld/%s",
+			  __entry->error,
+			  show_nfsv4_errors(__entry->error),
+			  __entry->flags,
+			  show_open_flags(__entry->flags),
+			  show_fmode_flags(__entry->fmode),
+			  (unsigned long long)__entry->fileid,
+			  __entry->fhandle,
+			  MAJOR(__entry->dev), MINOR(__entry->dev),
+			  (unsigned long long)__entry->dir,
+			  __get_str(name)
+		)
+);
+
+#define DEFINE_NFS4_OPEN_EVENT(name)		\
+DEFINE_EVENT(nfs4_open_event, name,			\
+		TP_PROTO(const struct nfs_open_context *ctx,	\
+			const struct nfs4_state *state,	\
+			int flags,			\
+			int error),			\
+		TP_ARGS(ctx, state, flags, error))
+DEFINE_NFS4_OPEN_EVENT(nfs4_open_reclaim);
+DEFINE_NFS4_OPEN_EVENT(nfs4_open_expired);
+DEFINE_NFS4_OPEN_EVENT(nfs4_open_file);
+
+TRACE_EVENT(nfs4_close,
+		TP_PROTO(const struct nfs4_state *state,
+			fmode_t fmode,
+			int error),
+
+		TP_ARGS(state, fmode, error),
+
+		TP_STRUCT__entry(
+			__field(dev_t, dev)
+			__field(u32, fhandle)
+			__field(u64, fileid)
+			__field(fmode_t, fmode)
+			__field(int, error)
+		),
+
+		TP_fast_assign(
+			struct inode *inode = state->inode;
+
+			__entry->dev = inode->i_sb->s_dev;
+			__entry->fileid = NFS_FILEID(inode);
+			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
+			__entry->fmode = fmode;
+			__entry->error = error;
+		),
+
+		TP_printk("error=%d (%s) mode=%s fileid=%02x:%02x:%lld, "
+			  "fhandle=%0x08x",
+			  __entry->error,
+			  show_nfsv4_errors(__entry->error),
+			  show_fmode_flags(__entry->fmode),
+			  MAJOR(__entry->dev), MINOR(__entry->dev),
+			  (unsigned long long)__entry->fileid,
+			  __entry->fhandle
+		)
+);
+
 #endif /* _TRACE_NFS4_H */
 
 #undef TRACE_INCLUDE_PATH
-- 
1.8.3.1

[PATCH 04/10] NFSv4: Add tracepoints for debugging file locking

[Trond Myklebust]

Set up basic tracepoints for debugging NFSv4 file lock/unlock

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
---
 fs/nfs/nfs4proc.c  |  9 +++++--
 fs/nfs/nfs4trace.h | 77 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 84 insertions(+), 2 deletions(-)

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 213c519..3be9bb3 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -4963,8 +4963,9 @@ static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *
 	int err;
 
 	do {
-		err = nfs4_handle_exception(NFS_SERVER(state->inode),
-				_nfs4_proc_getlk(state, cmd, request),
+		err = _nfs4_proc_getlk(state, cmd, request);
+		trace_nfs4_get_lock(request, state, cmd, err);
+		err = nfs4_handle_exception(NFS_SERVER(state->inode), err,
 				&exception);
 	} while (exception.retry);
 	return err;
@@ -5162,6 +5163,7 @@ static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *
 	rpc_put_task(task);
 out:
 	request->fl_flags = fl_flags;
+	trace_nfs4_unlock(request, state, F_SETLK, status);
 	return status;
 }
 
@@ -5385,6 +5387,7 @@ static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request
 		if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
 			return 0;
 		err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM);
+		trace_nfs4_lock_reclaim(request, state, F_SETLK, err);
 		if (err != -NFS4ERR_DELAY)
 			break;
 		nfs4_handle_exception(server, err, &exception);
@@ -5407,6 +5410,7 @@ static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request
 		if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
 			return 0;
 		err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED);
+		trace_nfs4_lock_expired(request, state, F_SETLK, err);
 		switch (err) {
 		default:
 			goto out;
@@ -5529,6 +5533,7 @@ static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *
 
 	do {
 		err = _nfs4_proc_setlk(state, cmd, request);
+		trace_nfs4_set_lock(request, state, cmd, err);
 		if (err == -NFS4ERR_DENIED)
 			err = -EAGAIN;
 		err = nfs4_handle_exception(NFS_SERVER(state->inode),
diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h
index 251806f..45972f2 100644
--- a/fs/nfs/nfs4trace.h
+++ b/fs/nfs/nfs4trace.h
@@ -308,6 +308,83 @@ TRACE_EVENT(nfs4_close,
 		)
 );
 
+#define show_lock_cmd(type)						\
+	__print_symbolic((int)type,					\
+		{ F_GETLK,			"GETLK" },		\
+		{ F_SETLK,			"SETLK" },		\
+		{ F_SETLKW,			"SETLKW" })
+#define show_lock_type(type)						\
+	__print_symbolic((int)type,					\
+		{ F_RDLCK,			"RDLCK" },		\
+		{ F_WRLCK,			"WRLCK" },		\
+		{ F_UNLCK,			"UNLCK" })
+
+DECLARE_EVENT_CLASS(nfs4_lock_event,
+		TP_PROTO(const struct file_lock *request,
+			const struct nfs4_state *state,
+			int cmd,
+			int error),
+
+		TP_ARGS(request, state, cmd, error),
+
+		TP_STRUCT__entry(
+			__field(int, error)
+			__field(int, cmd)
+			__field(char, type)
+			__field(loff_t, start)
+			__field(loff_t, end)
+			__field(dev_t, dev)
+			__field(u32, fhandle)
+			__field(u64, fileid)
+			__field(u64, dir)
+			__string(name, request->fl_file->f_path.dentry->d_name.name)
+		),
+
+		TP_fast_assign(
+			struct dentry *dentry = request->fl_file->f_path.dentry;
+			struct inode *inode = state->inode;
+
+			__entry->error = error;
+			__entry->cmd = cmd;
+			__entry->type = request->fl_type;
+			__entry->start = request->fl_start;
+			__entry->end = request->fl_end;
+			__entry->dev = inode->i_sb->s_dev;
+			__entry->fileid = NFS_FILEID(inode);
+			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
+			__entry->dir = NFS_FILEID(dentry->d_parent->d_inode);
+			__assign_str(name, dentry->d_name.name);
+		),
+
+		TP_printk("error=%d (%s), cmd=%s:%s range=%lld:%lld "
+			  "fileid=%lld, fhandle=%0x08x name=%02x:%02x:%lld/%s",
+			  __entry->error,
+			  show_nfsv4_errors(__entry->error),
+			  show_lock_cmd(__entry->cmd),
+			  show_lock_type(__entry->type),
+			  (unsigned long long)__entry->start,
+			  (unsigned long long)__entry->end,
+			  (unsigned long long)__entry->fileid,
+			  __entry->fhandle,
+			  MAJOR(__entry->dev), MINOR(__entry->dev),
+			  (unsigned long long)__entry->dir,
+			  __get_str(name)
+		)
+);
+
+#define DEFINE_NFS4_LOCK_EVENT(name)		\
+DEFINE_EVENT(nfs4_lock_event, name,			\
+		TP_PROTO(const struct file_lock *request,\
+			const struct nfs4_state *state,	\
+			int cmd,			\
+			int error),			\
+		TP_ARGS(request, state, cmd, error))
+DEFINE_NFS4_LOCK_EVENT(nfs4_get_lock);
+DEFINE_NFS4_LOCK_EVENT(nfs4_set_lock);
+DEFINE_NFS4_LOCK_EVENT(nfs4_lock_reclaim);
+DEFINE_NFS4_LOCK_EVENT(nfs4_lock_expired);
+DEFINE_NFS4_LOCK_EVENT(nfs4_unlock);
+
 #endif /* _TRACE_NFS4_H */
 
 #undef TRACE_INCLUDE_PATH
-- 
1.8.3.1

[PATCH 05/10] NFSv4: Add tracepoints for debugging lookup/create operations

[Trond Myklebust]

Set up basic tracepoints for debugging NFSv4 lookup, unlink/remove,
symlink, mkdir, mknod, fs_locations and secinfo.

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
---
 fs/nfs/nfs4proc.c  | 37 +++++++++++++++++++++++--------------
 fs/nfs/nfs4trace.h | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+), 14 deletions(-)

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 3be9bb3..3f639c8 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -3026,6 +3026,7 @@ static int nfs4_proc_lookup_common(struct rpc_clnt **clnt, struct inode *dir,
 	int err;
 	do {
 		err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr, label);
+		trace_nfs4_lookup(dir, name, err);
 		switch (err) {
 		case -NFS4ERR_BADNAME:
 			err = -ENOENT;
@@ -3261,8 +3262,9 @@ static int nfs4_proc_remove(struct inode *dir, struct qstr *name)
 	struct nfs4_exception exception = { };
 	int err;
 	do {
-		err = nfs4_handle_exception(NFS_SERVER(dir),
-				_nfs4_proc_remove(dir, name),
+		err = _nfs4_proc_remove(dir, name);
+		trace_nfs4_remove(dir, name, err);
+		err = nfs4_handle_exception(NFS_SERVER(dir), err,
 				&exception);
 	} while (exception.retry);
 	return err;
@@ -3291,10 +3293,12 @@ static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlin
 
 static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
 {
-	struct nfs_removeres *res = task->tk_msg.rpc_resp;
+	struct nfs_unlinkdata *data = task->tk_calldata;
+	struct nfs_removeres *res = &data->res;
 
 	if (!nfs4_sequence_done(task, &res->seq_res))
 		return 0;
+	trace_nfs4_remove_async(dir, &data->args.name, task->tk_status);
 	if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
 		return 0;
 	update_changeattr(dir, &res->cinfo);
@@ -3533,9 +3537,9 @@ static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
 	label = nfs4_label_init_security(dir, dentry, sattr, &l);
 
 	do {
-		err = nfs4_handle_exception(NFS_SERVER(dir),
-				_nfs4_proc_symlink(dir, dentry, page,
-							len, sattr, label),
+		err = _nfs4_proc_symlink(dir, dentry, page, len, sattr, label);
+		trace_nfs4_symlink(dir, &dentry->d_name, err);
+		err = nfs4_handle_exception(NFS_SERVER(dir), err,
 				&exception);
 	} while (exception.retry);
 
@@ -3572,8 +3576,9 @@ static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
 
 	sattr->ia_mode &= ~current_umask();
 	do {
-		err = nfs4_handle_exception(NFS_SERVER(dir),
-				_nfs4_proc_mkdir(dir, dentry, sattr, label),
+		err = _nfs4_proc_mkdir(dir, dentry, sattr, label);
+		trace_nfs4_mkdir(dir, &dentry->d_name, err);
+		err = nfs4_handle_exception(NFS_SERVER(dir), err,
 				&exception);
 	} while (exception.retry);
 	nfs4_label_release_security(label);
@@ -3680,8 +3685,9 @@ static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
 
 	sattr->ia_mode &= ~current_umask();
 	do {
-		err = nfs4_handle_exception(NFS_SERVER(dir),
-				_nfs4_proc_mknod(dir, dentry, sattr, label, rdev),
+		err = _nfs4_proc_mknod(dir, dentry, sattr, label, rdev);
+		trace_nfs4_mknod(dir, &dentry->d_name, err);
+		err = nfs4_handle_exception(NFS_SERVER(dir), err,
 				&exception);
 	} while (exception.retry);
 
@@ -5800,8 +5806,10 @@ int nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
 	struct nfs4_exception exception = { };
 	int err;
 	do {
-		err = nfs4_handle_exception(NFS_SERVER(dir),
-				_nfs4_proc_fs_locations(client, dir, name, fs_locations, page),
+		err = _nfs4_proc_fs_locations(client, dir, name,
+				fs_locations, page);
+		trace_nfs4_get_fs_locations(dir, name, err);
+		err = nfs4_handle_exception(NFS_SERVER(dir), err,
 				&exception);
 	} while (exception.retry);
 	return err;
@@ -5835,8 +5843,9 @@ int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name,
 	struct nfs4_exception exception = { };
 	int err;
 	do {
-		err = nfs4_handle_exception(NFS_SERVER(dir),
-				_nfs4_proc_secinfo(dir, name, flavors),
+		err = _nfs4_proc_secinfo(dir, name, flavors);
+		trace_nfs4_secinfo(dir, name, err);
+		err = nfs4_handle_exception(NFS_SERVER(dir), err,
 				&exception);
 	} while (exception.retry);
 	return err;
diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h
index 45972f2..3e68a75 100644
--- a/fs/nfs/nfs4trace.h
+++ b/fs/nfs/nfs4trace.h
@@ -385,6 +385,52 @@ DEFINE_NFS4_LOCK_EVENT(nfs4_lock_reclaim);
 DEFINE_NFS4_LOCK_EVENT(nfs4_lock_expired);
 DEFINE_NFS4_LOCK_EVENT(nfs4_unlock);
 
+DECLARE_EVENT_CLASS(nfs4_lookup_event,
+		TP_PROTO(const struct inode *dir,
+			const struct qstr *name,
+			int error),
+
+		TP_ARGS(dir, name, error),
+
+		TP_STRUCT__entry(
+			__field(dev_t, dev)
+			__field(int, error)
+			__field(u64, dir)
+			__string(name, name->name)
+		),
+
+		TP_fast_assign(
+			__entry->dev = dir->i_sb->s_dev;
+			__entry->dir = NFS_FILEID(dir);
+			__entry->error = error;
+			__assign_str(name, name->name);
+		),
+
+		TP_printk("error=%d (%s), name=%02x:%02x:%lld/%s",
+			__entry->error,
+			show_nfsv4_errors(__entry->error),
+			MAJOR(__entry->dev), MINOR(__entry->dev),
+			(unsigned long long)__entry->dir,
+			__get_str(name)
+		)
+);
+
+#define DEFINE_NFS4_LOOKUP_EVENT(name)	\
+DEFINE_EVENT(nfs4_lookup_event, name,		\
+		TP_PROTO(const struct inode *dir,	\
+			const struct qstr *name,	\
+			int error),			\
+		TP_ARGS(dir, name, error))
+
+DEFINE_NFS4_LOOKUP_EVENT(nfs4_lookup);
+DEFINE_NFS4_LOOKUP_EVENT(nfs4_symlink);
+DEFINE_NFS4_LOOKUP_EVENT(nfs4_mkdir);
+DEFINE_NFS4_LOOKUP_EVENT(nfs4_mknod);
+DEFINE_NFS4_LOOKUP_EVENT(nfs4_remove);
+DEFINE_NFS4_LOOKUP_EVENT(nfs4_remove_async);
+DEFINE_NFS4_LOOKUP_EVENT(nfs4_get_fs_locations);
+DEFINE_NFS4_LOOKUP_EVENT(nfs4_secinfo);
+
 #endif /* _TRACE_NFS4_H */
 
 #undef TRACE_INCLUDE_PATH
-- 
1.8.3.1

[PATCH 06/10] NFSv4: Add tracepoints for debugging inode manipulations

[Trond Myklebust]

Set up basic tracepoints for debugging NFSv4 setattr, access,
readlink, readdir, get_acl set_acl get_security_label,
and set_security_label.

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
---
 fs/nfs/nfs4proc.c  | 36 ++++++++++++++++++++++--------------
 fs/nfs/nfs4trace.h | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 68 insertions(+), 14 deletions(-)

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 3f639c8..be75a11 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -2315,6 +2315,7 @@ static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
 	int err;
 	do {
 		err = _nfs4_do_setattr(inode, cred, fattr, sattr, state, ilabel, olabel);
+		trace_nfs4_setattr(inode, err);
 		switch (err) {
 		case -NFS4ERR_OPENMODE:
 			if (!(sattr->ia_valid & ATTR_SIZE)) {
@@ -3143,8 +3144,9 @@ static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
 	struct nfs4_exception exception = { };
 	int err;
 	do {
-		err = nfs4_handle_exception(NFS_SERVER(inode),
-				_nfs4_proc_access(inode, entry),
+		err = _nfs4_proc_access(inode, entry);
+		trace_nfs4_access(inode, err);
+		err = nfs4_handle_exception(NFS_SERVER(inode), err,
 				&exception);
 	} while (exception.retry);
 	return err;
@@ -3197,8 +3199,9 @@ static int nfs4_proc_readlink(struct inode *inode, struct page *page,
 	struct nfs4_exception exception = { };
 	int err;
 	do {
-		err = nfs4_handle_exception(NFS_SERVER(inode),
-				_nfs4_proc_readlink(inode, page, pgbase, pglen),
+		err = _nfs4_proc_readlink(inode, page, pgbase, pglen);
+		trace_nfs4_readlink(inode, err);
+		err = nfs4_handle_exception(NFS_SERVER(inode), err,
 				&exception);
 	} while (exception.retry);
 	return err;
@@ -3631,9 +3634,10 @@ static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
 	struct nfs4_exception exception = { };
 	int err;
 	do {
-		err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode),
-				_nfs4_proc_readdir(dentry, cred, cookie,
-					pages, count, plus),
+		err = _nfs4_proc_readdir(dentry, cred, cookie,
+				pages, count, plus);
+		trace_nfs4_readdir(dentry->d_inode, err);
+		err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode), err,
 				&exception);
 	} while (exception.retry);
 	return err;
@@ -4333,6 +4337,7 @@ static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t bufl
 	ssize_t ret;
 	do {
 		ret = __nfs4_get_acl_uncached(inode, buf, buflen);
+		trace_nfs4_get_acl(inode, ret);
 		if (ret >= 0)
 			break;
 		ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);
@@ -4412,8 +4417,9 @@ static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen
 	struct nfs4_exception exception = { };
 	int err;
 	do {
-		err = nfs4_handle_exception(NFS_SERVER(inode),
-				__nfs4_proc_set_acl(inode, buf, buflen),
+		err = __nfs4_proc_set_acl(inode, buf, buflen);
+		trace_nfs4_set_acl(inode, err);
+		err = nfs4_handle_exception(NFS_SERVER(inode), err,
 				&exception);
 	} while (exception.retry);
 	return err;
@@ -4466,8 +4472,9 @@ static int nfs4_get_security_label(struct inode *inode, void *buf,
 		return -EOPNOTSUPP;
 
 	do {
-		err = nfs4_handle_exception(NFS_SERVER(inode),
-				_nfs4_get_security_label(inode, buf, buflen),
+		err = _nfs4_get_security_label(inode, buf, buflen);
+		trace_nfs4_get_security_label(inode, err);
+		err = nfs4_handle_exception(NFS_SERVER(inode), err,
 				&exception);
 	} while (exception.retry);
 	return err;
@@ -4519,9 +4526,10 @@ static int nfs4_do_set_security_label(struct inode *inode,
 	int err;
 
 	do {
-		err = nfs4_handle_exception(NFS_SERVER(inode),
-				_nfs4_do_set_security_label(inode, ilabel,
-				fattr, olabel),
+		err = _nfs4_do_set_security_label(inode, ilabel,
+				fattr, olabel);
+		trace_nfs4_set_security_label(inode, err);
+		err = nfs4_handle_exception(NFS_SERVER(inode), err,
 				&exception);
 	} while (exception.retry);
 	return err;
diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h
index 3e68a75..f32cd614 100644
--- a/fs/nfs/nfs4trace.h
+++ b/fs/nfs/nfs4trace.h
@@ -431,6 +431,52 @@ DEFINE_NFS4_LOOKUP_EVENT(nfs4_remove_async);
 DEFINE_NFS4_LOOKUP_EVENT(nfs4_get_fs_locations);
 DEFINE_NFS4_LOOKUP_EVENT(nfs4_secinfo);
 
+DECLARE_EVENT_CLASS(nfs4_inode_event,
+		TP_PROTO(const struct inode *inode,
+			int error),
+
+		TP_ARGS(inode, error),
+
+		TP_STRUCT__entry(
+			__field(dev_t, dev)
+			__field(u32, fhandle)
+			__field(u64, fileid)
+			__field(int, error)
+		),
+
+		TP_fast_assign(
+			__entry->dev = inode->i_sb->s_dev;
+			__entry->fileid = NFS_FILEID(inode);
+			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
+			__entry->error = error;
+		),
+
+		TP_printk("error=%d (%s) fileid=%02x:%02x:%lld, fhandle=%0x08x",
+			__entry->error,
+			show_nfsv4_errors(__entry->error),
+			MAJOR(__entry->dev), MINOR(__entry->dev),
+			(unsigned long long)__entry->fileid,
+			__entry->fhandle
+		)
+);
+
+#define DEFINE_NFS4_INODE_EVENT(name)		\
+DEFINE_EVENT(nfs4_inode_event, name,			\
+		TP_PROTO(const struct inode *inode,	\
+			int error),			\
+		TP_ARGS(inode, error))
+
+DEFINE_NFS4_INODE_EVENT(nfs4_setattr);
+DEFINE_NFS4_INODE_EVENT(nfs4_access);
+DEFINE_NFS4_INODE_EVENT(nfs4_readlink);
+DEFINE_NFS4_INODE_EVENT(nfs4_readdir);
+DEFINE_NFS4_INODE_EVENT(nfs4_get_acl);
+DEFINE_NFS4_INODE_EVENT(nfs4_set_acl);
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+DEFINE_NFS4_INODE_EVENT(nfs4_get_security_label);
+DEFINE_NFS4_INODE_EVENT(nfs4_set_security_label);
+#endif /* CONFIG_NFS_V4_SECURITY_LABEL */
+
 #endif /* _TRACE_NFS4_H */
 
 #undef TRACE_INCLUDE_PATH
-- 
1.8.3.1

[PATCH 07/10] NFSv4: Add tracepoints for debugging rename

[Trond Myklebust]

Add tracepoints to debug both synchronous and asynchronous renames.

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
---
 fs/nfs/nfs4proc.c  | 13 +++++++++----
 fs/nfs/nfs4trace.h | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 59 insertions(+), 4 deletions(-)

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index be75a11..e3d69b3 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -3330,10 +3330,14 @@ static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renam
 static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
 				 struct inode *new_dir)
 {
-	struct nfs_renameres *res = task->tk_msg.rpc_resp;
+	struct nfs_renamedata *data = task->tk_calldata;
+	struct nfs_renameres *res = &data->res;
 
 	if (!nfs4_sequence_done(task, &res->seq_res))
 		return 0;
+	trace_nfs4_rename_async(old_dir, data->args.old_name,
+			new_dir, data->args.new_name,
+			task->tk_status);
 	if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
 		return 0;
 
@@ -3376,9 +3380,10 @@ static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
 	struct nfs4_exception exception = { };
 	int err;
 	do {
-		err = nfs4_handle_exception(NFS_SERVER(old_dir),
-				_nfs4_proc_rename(old_dir, old_name,
-					new_dir, new_name),
+		err = _nfs4_proc_rename(old_dir, old_name,
+					new_dir, new_name);
+		trace_nfs4_rename(old_dir, old_name, new_dir, new_name, err);
+		err = nfs4_handle_exception(NFS_SERVER(old_dir), err,
 				&exception);
 	} while (exception.retry);
 	return err;
diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h
index f32cd614..638fc7a 100644
--- a/fs/nfs/nfs4trace.h
+++ b/fs/nfs/nfs4trace.h
@@ -431,6 +431,56 @@ DEFINE_NFS4_LOOKUP_EVENT(nfs4_remove_async);
 DEFINE_NFS4_LOOKUP_EVENT(nfs4_get_fs_locations);
 DEFINE_NFS4_LOOKUP_EVENT(nfs4_secinfo);
 
+DECLARE_EVENT_CLASS(nfs4_rename_event,
+		TP_PROTO(const struct inode *olddir,
+			const struct qstr *oldname,
+			const struct inode *newdir,
+			const struct qstr *newname,
+			int error),
+
+		TP_ARGS(olddir, oldname, newdir, newname, error),
+
+		TP_STRUCT__entry(
+			__field(dev_t, dev)
+			__field(int, error)
+			__field(u64, olddir)
+			__string(oldname, oldname->name)
+			__field(u64, newdir)
+			__string(newname, newname->name)
+		),
+
+		TP_fast_assign(
+			__entry->dev = olddir->i_sb->s_dev;
+			__entry->olddir = NFS_FILEID(olddir);
+			__entry->newdir = NFS_FILEID(newdir);
+			__entry->error = error;
+			__assign_str(oldname, oldname->name);
+			__assign_str(newname, newname->name);
+		),
+
+		TP_printk("error=%d (%s), oldname=%02x:%02x:%lld/%s, "
+			  "newname=%02x:%02x:%lld/%s",
+			  __entry->error,
+			  show_nfsv4_errors(__entry->error),
+			  MAJOR(__entry->dev), MINOR(__entry->dev),
+			  (unsigned long long)__entry->olddir,
+			  __get_str(oldname),
+			  MAJOR(__entry->dev), MINOR(__entry->dev),
+			  (unsigned long long)__entry->newdir,
+			  __get_str(newname)
+		)
+);
+#define DEFINE_NFS4_RENAME_EVENT(name)				\
+	DEFINE_EVENT(nfs4_rename_event, name,			\
+		TP_PROTO(const struct inode *olddir,		\
+			const struct qstr *oldname,		\
+			const struct inode *newdir,		\
+			const struct qstr *newname,		\
+			int error),				\
+		TP_ARGS(olddir, oldname, newdir, newname, error))
+DEFINE_NFS4_RENAME_EVENT(nfs4_rename);
+DEFINE_NFS4_RENAME_EVENT(nfs4_rename_async);
+
 DECLARE_EVENT_CLASS(nfs4_inode_event,
 		TP_PROTO(const struct inode *inode,
 			int error),
-- 
1.8.3.1

[PATCH 08/10] NFSv4: Add tracepoints for debugging delegations

[Trond Myklebust]

Set up tracepoints to track when delegations are set, reclaimed,
returned by the client, or recalled by the server.

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
---
 fs/nfs/callback_proc.c |  2 ++
 fs/nfs/delegation.c    |  3 +++
 fs/nfs/nfs4proc.c      |  1 +
 fs/nfs/nfs4trace.h     | 37 +++++++++++++++++++++++++++++++++++++
 4 files changed, 43 insertions(+)

diff --git a/fs/nfs/callback_proc.c b/fs/nfs/callback_proc.c
index e6ebc4c..88d6d2f 100644
--- a/fs/nfs/callback_proc.c
+++ b/fs/nfs/callback_proc.c
@@ -15,6 +15,7 @@
 #include "internal.h"
 #include "pnfs.h"
 #include "nfs4session.h"
+#include "nfs4trace.h"
 
 #ifdef NFS_DEBUG
 #define NFSDBG_FACILITY NFSDBG_CALLBACK
@@ -93,6 +94,7 @@ __be32 nfs4_callback_recall(struct cb_recallargs *args, void *dummy,
 	default:
 		res = htonl(NFS4ERR_RESOURCE);
 	}
+	trace_nfs4_recall_delegation(inode, ntohl(res));
 	iput(inode);
 out:
 	dprintk("%s: exit with status = %d\n", __func__, ntohl(res));
diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
index 7ec4814..ef792f2 100644
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -20,6 +20,7 @@
 #include "nfs4_fs.h"
 #include "delegation.h"
 #include "internal.h"
+#include "nfs4trace.h"
 
 static void nfs_free_delegation(struct nfs_delegation *delegation)
 {
@@ -160,6 +161,7 @@ void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,
 			spin_unlock(&delegation->lock);
 			put_rpccred(oldcred);
 			rcu_read_unlock();
+			trace_nfs4_reclaim_delegation(inode, res->delegation_type);
 		} else {
 			/* We appear to have raced with a delegation return. */
 			spin_unlock(&delegation->lock);
@@ -344,6 +346,7 @@ int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct
 	spin_lock(&inode->i_lock);
 	nfsi->cache_validity |= NFS_INO_REVAL_FORCED;
 	spin_unlock(&inode->i_lock);
+	trace_nfs4_set_delegation(inode, res->delegation_type);
 
 out:
 	spin_unlock(&clp->cl_lock);
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index e3d69b3..ce6ef6a 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -4908,6 +4908,7 @@ int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4
 	int err;
 	do {
 		err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);
+		trace_nfs4_delegreturn(inode, err);
 		switch (err) {
 			case -NFS4ERR_STALE_STATEID:
 			case -NFS4ERR_EXPIRED:
diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h
index 638fc7a..91321c5 100644
--- a/fs/nfs/nfs4trace.h
+++ b/fs/nfs/nfs4trace.h
@@ -385,6 +385,41 @@ DEFINE_NFS4_LOCK_EVENT(nfs4_lock_reclaim);
 DEFINE_NFS4_LOCK_EVENT(nfs4_lock_expired);
 DEFINE_NFS4_LOCK_EVENT(nfs4_unlock);
 
+DECLARE_EVENT_CLASS(nfs4_set_delegation_event,
+		TP_PROTO(const struct inode *inode,
+			fmode_t fmode),
+
+		TP_ARGS(inode, fmode),
+
+		TP_STRUCT__entry(
+			__field(dev_t, dev)
+			__field(u32, fhandle)
+			__field(u64, fileid)
+			__field(fmode_t, fmode)
+		),
+
+		TP_fast_assign(
+			__entry->dev = inode->i_sb->s_dev;
+			__entry->fileid = NFS_FILEID(inode);
+			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
+			__entry->fmode = fmode;
+		),
+
+		TP_printk("mode=%s fileid=%02x:%02x:%lld, fhandle=%0x08x",
+			show_fmode_flags(__entry->fmode),
+			MAJOR(__entry->dev), MINOR(__entry->dev),
+			(unsigned long long)__entry->fileid,
+			__entry->fhandle
+		)
+);
+#define DEFINE_NFS4_SET_DELEGATION_EVENT(name)		\
+DEFINE_EVENT(nfs4_set_delegation_event, name,		\
+		TP_PROTO(const struct inode *inode,	\
+			fmode_t fmode),			\
+		TP_ARGS(inode, fmode))
+DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_set_delegation);
+DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_reclaim_delegation);
+
 DECLARE_EVENT_CLASS(nfs4_lookup_event,
 		TP_PROTO(const struct inode *dir,
 			const struct qstr *name,
@@ -526,6 +561,8 @@ DEFINE_NFS4_INODE_EVENT(nfs4_set_acl);
 DEFINE_NFS4_INODE_EVENT(nfs4_get_security_label);
 DEFINE_NFS4_INODE_EVENT(nfs4_set_security_label);
 #endif /* CONFIG_NFS_V4_SECURITY_LABEL */
+DEFINE_NFS4_INODE_EVENT(nfs4_recall_delegation);
+DEFINE_NFS4_INODE_EVENT(nfs4_delegreturn);
 
 #endif /* _TRACE_NFS4_H */
 
-- 
1.8.3.1

[PATCH 09/10] NFSv4: Add tracepoints for debugging the idmapper

[Trond Myklebust]

Add tracepoints to help debug uid/gid mappings to username/group.

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
---
 fs/nfs/idmap.c     |  5 +++++
 fs/nfs/nfs4trace.h | 41 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+)

diff --git a/fs/nfs/idmap.c b/fs/nfs/idmap.c
index c2c4163..f16a872 100644
--- a/fs/nfs/idmap.c
+++ b/fs/nfs/idmap.c
@@ -49,6 +49,7 @@
 
 #include "internal.h"
 #include "netns.h"
+#include "nfs4trace.h"
 
 #define NFS_UINT_MAXLEN 11
 
@@ -849,6 +850,7 @@ int nfs_map_name_to_uid(const struct nfs_server *server, const char *name, size_
 		if (!uid_valid(*uid))
 			ret = -ERANGE;
 	}
+	trace_nfs4_map_name_to_uid(name, namelen, id, ret);
 	return ret;
 }
 
@@ -865,6 +867,7 @@ int nfs_map_group_to_gid(const struct nfs_server *server, const char *name, size
 		if (!gid_valid(*gid))
 			ret = -ERANGE;
 	}
+	trace_nfs4_map_group_to_gid(name, namelen, id, ret);
 	return ret;
 }
 
@@ -879,6 +882,7 @@ int nfs_map_uid_to_name(const struct nfs_server *server, kuid_t uid, char *buf,
 		ret = nfs_idmap_lookup_name(id, "user", buf, buflen, idmap);
 	if (ret < 0)
 		ret = nfs_map_numeric_to_string(id, buf, buflen);
+	trace_nfs4_map_uid_to_name(buf, ret, id, ret);
 	return ret;
 }
 int nfs_map_gid_to_group(const struct nfs_server *server, kgid_t gid, char *buf, size_t buflen)
@@ -892,5 +896,6 @@ int nfs_map_gid_to_group(const struct nfs_server *server, kgid_t gid, char *buf,
 		ret = nfs_idmap_lookup_name(id, "group", buf, buflen, idmap);
 	if (ret < 0)
 		ret = nfs_map_numeric_to_string(id, buf, buflen);
+	trace_nfs4_map_gid_to_group(buf, ret, id, ret);
 	return ret;
 }
diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h
index 91321c5..11b2b98 100644
--- a/fs/nfs/nfs4trace.h
+++ b/fs/nfs/nfs4trace.h
@@ -564,6 +564,47 @@ DEFINE_NFS4_INODE_EVENT(nfs4_set_security_label);
 DEFINE_NFS4_INODE_EVENT(nfs4_recall_delegation);
 DEFINE_NFS4_INODE_EVENT(nfs4_delegreturn);
 
+DECLARE_EVENT_CLASS(nfs4_idmap_event,
+		TP_PROTO(const char *name,
+			int len,
+			u32 id,
+			int error),
+
+		TP_ARGS(name, len, id, error),
+
+		TP_STRUCT__entry(
+			__field(int, error)
+			__field(u32, id)
+			__dynamic_array(char, name, len > 0 ? len + 1 : 1)
+		),
+
+		TP_fast_assign(
+			if (len < 0)
+				len = 0;
+			__entry->error = error < 0 ? error : 0;
+			__entry->id = id;
+			memcpy(__get_dynamic_array(name), name, len);
+			((char *)__get_dynamic_array(name))[len] = 0;
+		),
+
+		TP_printk("error=%d, id=%u, name=%s",
+			__entry->error,
+			__entry->id,
+			__get_str(name)
+		)
+);
+#define DEFINE_NFS4_IDMAP_EVENT(name)		\
+DEFINE_EVENT(nfs4_idmap_event, name,		\
+		TP_PROTO(const char *name,	\
+			int len,		\
+			u32 id,			\
+			int error),		\
+		TP_ARGS(name, len, id, error))
+DEFINE_NFS4_IDMAP_EVENT(nfs4_map_name_to_uid);
+DEFINE_NFS4_IDMAP_EVENT(nfs4_map_group_to_gid);
+DEFINE_NFS4_IDMAP_EVENT(nfs4_map_uid_to_name);
+DEFINE_NFS4_IDMAP_EVENT(nfs4_map_gid_to_group);
+
 #endif /* _TRACE_NFS4_H */
 
 #undef TRACE_INCLUDE_PATH
-- 
1.8.3.1

[PATCH 10/10] NFSv4: Add tracepoints for debugging getattr

[Trond Myklebust]

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
---
 fs/nfs/nfs4proc.c  |  7 ++++--
 fs/nfs/nfs4trace.h | 64 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+), 2 deletions(-)

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index ce6ef6a..3330ac0 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -2697,6 +2697,7 @@ static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
 	int err;
 	do {
 		err = _nfs4_lookup_root(server, fhandle, info);
+		trace_nfs4_lookup_root(server, fhandle, info->fattr, err);
 		switch (err) {
 		case 0:
 		case -NFS4ERR_WRONGSEC:
@@ -2906,8 +2907,9 @@ static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
 	struct nfs4_exception exception = { };
 	int err;
 	do {
-		err = nfs4_handle_exception(server,
-				_nfs4_proc_getattr(server, fhandle, fattr, label),
+		err = _nfs4_proc_getattr(server, fhandle, fattr, label);
+		trace_nfs4_getattr(server, fhandle, fattr, err);
+		err = nfs4_handle_exception(server, err,
 				&exception);
 	} while (exception.retry);
 	return err;
@@ -3764,6 +3766,7 @@ static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, str
 
 	do {
 		err = _nfs4_do_fsinfo(server, fhandle, fsinfo);
+		trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err);
 		if (err == 0) {
 			struct nfs_client *clp = server->nfs_client;
 
diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h
index 11b2b98..67a6bbb 100644
--- a/fs/nfs/nfs4trace.h
+++ b/fs/nfs/nfs4trace.h
@@ -168,6 +168,24 @@
 		{ FMODE_WRITE,			"WRITE" },		\
 		{ FMODE_EXEC,			"EXEC" })
 
+#define show_nfs_fattr_flags(valid)					\
+	__print_flags((unsigned long)valid, "|",			\
+		{ NFS_ATTR_FATTR_TYPE,		"TYPE" },		\
+		{ NFS_ATTR_FATTR_MODE,		"MODE" },		\
+		{ NFS_ATTR_FATTR_NLINK,		"NLINK" },		\
+		{ NFS_ATTR_FATTR_OWNER,		"OWNER" },		\
+		{ NFS_ATTR_FATTR_GROUP,		"GROUP" },		\
+		{ NFS_ATTR_FATTR_RDEV,		"RDEV" },		\
+		{ NFS_ATTR_FATTR_SIZE,		"SIZE" },		\
+		{ NFS_ATTR_FATTR_FSID,		"FSID" },		\
+		{ NFS_ATTR_FATTR_FILEID,	"FILEID" },		\
+		{ NFS_ATTR_FATTR_ATIME,		"ATIME" },		\
+		{ NFS_ATTR_FATTR_MTIME,		"MTIME" },		\
+		{ NFS_ATTR_FATTR_CTIME,		"CTIME" },		\
+		{ NFS_ATTR_FATTR_CHANGE,	"CHANGE" },		\
+		{ NFS_ATTR_FATTR_OWNER_NAME,	"OWNER_NAME" },		\
+		{ NFS_ATTR_FATTR_GROUP_NAME,	"GROUP_NAME" })
+
 DECLARE_EVENT_CLASS(nfs4_clientid_event,
 		TP_PROTO(const struct nfs_client *clp,
 			int error),
@@ -564,6 +582,52 @@ DEFINE_NFS4_INODE_EVENT(nfs4_set_security_label);
 DEFINE_NFS4_INODE_EVENT(nfs4_recall_delegation);
 DEFINE_NFS4_INODE_EVENT(nfs4_delegreturn);
 
+DECLARE_EVENT_CLASS(nfs4_getattr_event,
+		TP_PROTO(const struct nfs_server *server,
+			const struct nfs_fh *fhandle,
+			const struct nfs_fattr *fattr,
+			int error),
+
+		TP_ARGS(server, fhandle, fattr, error),
+
+		TP_STRUCT__entry(
+			__field(dev_t, dev)
+			__field(u32, fhandle)
+			__field(u64, fileid)
+			__field(unsigned int, valid)
+			__field(int, error)
+		),
+
+		TP_fast_assign(
+			__entry->dev = server->s_dev;
+			__entry->valid = fattr->valid;
+			__entry->fhandle = nfs_fhandle_hash(fhandle);
+			__entry->fileid = (fattr->valid & NFS_ATTR_FATTR_FILEID) ? fattr->fileid : 0;
+			__entry->error = error;
+		),
+
+		TP_printk("error=%d (%s) fileid=%02x:%02x:%lld fhandle=%0x08x "
+			  "valid=%s",
+			  __entry->error,
+			  show_nfsv4_errors(__entry->error),
+			  MAJOR(__entry->dev), MINOR(__entry->dev),
+			  (unsigned long long)__entry->fileid,
+			  __entry->fhandle,
+			  show_nfs_fattr_flags(__entry->valid)
+		)
+);
+
+#define DEFINE_NFS4_GETATTR_EVENT(name)		\
+DEFINE_EVENT(nfs4_getattr_event, name,			\
+		TP_PROTO(const struct nfs_server *server, \
+			const struct nfs_fh *fhandle,	\
+			const struct nfs_fattr *fattr,	\
+			int error),			\
+		TP_ARGS(server, fhandle, fattr, error))
+DEFINE_NFS4_GETATTR_EVENT(nfs4_getattr);
+DEFINE_NFS4_GETATTR_EVENT(nfs4_lookup_root);
+DEFINE_NFS4_GETATTR_EVENT(nfs4_fsinfo);
+
 DECLARE_EVENT_CLASS(nfs4_idmap_event,
 		TP_PROTO(const char *name,
 			int len,
-- 
1.8.3.1

Re: [PATCH 02/10] NFS: refactor code for calculating the crc32 hash of a filehandle

[Adamson, Dros]

I think I was the last one to touch this.

On Aug 13, 2013, at 2:35 PM, Trond Myklebust <Trond.Myklebust@netapp.com> wrote:

> We want to be able to display the crc32 hash of the filehandle in
> tracepoints.
> 
> Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
> ---
> fs/nfs/inode.c    |  3 +--
> fs/nfs/internal.h | 20 ++++++++++++++++++++
> 2 files changed, 21 insertions(+), 2 deletions(-)
> 
> diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
> index af6e806..9a98b04 100644
> --- a/fs/nfs/inode.c
> +++ b/fs/nfs/inode.c
> @@ -38,7 +38,6 @@
> #include <linux/slab.h>
> #include <linux/compat.h>
> #include <linux/freezer.h>
> -#include <linux/crc32.h>
> 
> #include <asm/uaccess.h>
> 
> @@ -1190,7 +1189,7 @@ u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
> {
> 	/* wireshark uses 32-bit AUTODIN crc and does a bitwise
> 	 * not on the result */
> -	return ~crc32(0xFFFFFFFF, &fh->data[0], fh->size);
> +	return nfs_fhandle_hash(fh);
> }
> 
> /*
> diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
> index 9b694f1..50f7068 100644
> --- a/fs/nfs/internal.h
> +++ b/fs/nfs/internal.h
> @@ -5,6 +5,7 @@
> #include "nfs4_fs.h"
> #include <linux/mount.h>
> #include <linux/security.h>
> +#include <linux/crc32.h>
> 
> #define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS)
> 
> @@ -574,3 +575,22 @@ u64 nfs_timespec_to_change_attr(const struct timespec *ts)
> {
> 	return ((u64)ts->tv_sec << 30) + ts->tv_nsec;
> }
> +
> +#ifdef CONFIG_CRC32

Good catch!

> +/**
> + * nfs_fhandle_hash - calculate the crc32 hash for the filehandle
> + * @fh - pointer to filehandle
> + *
> + * returns a crc32 hash for the filehandle that is compatible with
> + * the one displayed by "wireshark".
> + */
> +static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)
> +{
> +	return ~crc32_le(0xFFFFFFFF, &fh->data[0], fh->size);

Why the change to crc32_le? Is that what wireshark does? I don't remember exactly what I found when I looked at how wireshark made FH hashes.

-dros

> +}
> +#else
> +static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)
> +{
> +	return 0;
> +}
> +#endif
> -- 
> 1.8.3.1
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH 01/10] NFSv4: Add tracepoints for debugging state management problems

[Myklebust, Trond]

T24gVHVlLCAyMDEzLTA4LTEzIGF0IDE0OjM1IC0wNDAwLCBUcm9uZCBNeWtsZWJ1c3Qgd3JvdGU6
DQo+IFNldCB1cCBiYXNpYyB0cmFjZXBvaW50cyBmb3IgZGVidWdnaW5nIGNsaWVudCBpZCBjcmVh
dGlvbi9kZXN0cnVjdGlvbg0KPiBhbmQgc2Vzc2lvbiBjcmVhdGlvbi9kZXN0cnVjdGlvbi4NCj4g
DQo+IFNpZ25lZC1vZmYtYnk6IFRyb25kIE15a2xlYnVzdCA8VHJvbmQuTXlrbGVidXN0QG5ldGFw
cC5jb20+DQo+IC0tLQ0KPiAgZnMvbmZzL01ha2VmaWxlICAgIHwgICAzICstDQo+ICBmcy9uZnMv
bmZzNHByb2MuYyAgfCAgIDkgKysrDQo+ICBmcy9uZnMvbmZzNHRyYWNlLmMgfCAgMTAgKysrDQo+
ICBmcy9uZnMvbmZzNHRyYWNlLmggfCAyMDUgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr
KysrKysrKysrKysrKysrKysrKysrKysNCj4gIDQgZmlsZXMgY2hhbmdlZCwgMjI2IGluc2VydGlv
bnMoKyksIDEgZGVsZXRpb24oLSkNCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBmcy9uZnMvbmZzNHRy
YWNlLmMNCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBmcy9uZnMvbmZzNHRyYWNlLmgNCj4gDQo+IGRp
ZmYgLS1naXQgYS9mcy9uZnMvTWFrZWZpbGUgYi9mcy9uZnMvTWFrZWZpbGUNCj4gaW5kZXggZTBi
YjA0OC4uNzFiYTRjMiAxMDA2NDQNCj4gLS0tIGEvZnMvbmZzL01ha2VmaWxlDQo+ICsrKyBiL2Zz
L25mcy9NYWtlZmlsZQ0KPiBAQCAtMjEsNyArMjEsOCBAQCBuZnN2My0kKENPTkZJR19ORlNfVjNf
QUNMKSArPSBuZnMzYWNsLm8NCj4gIG9iai0kKENPTkZJR19ORlNfVjQpICs9IG5mc3Y0Lm8NCj4g
IG5mc3Y0LXkgOj0gbmZzNHByb2MubyBuZnM0eGRyLm8gbmZzNHN0YXRlLm8gbmZzNHJlbmV3ZC5v
IG5mczRzdXBlci5vIG5mczRmaWxlLm8gXA0KPiAgCSAgZGVsZWdhdGlvbi5vIGlkbWFwLm8gY2Fs
bGJhY2subyBjYWxsYmFja194ZHIubyBjYWxsYmFja19wcm9jLm8gXA0KPiAtCSAgbmZzNG5hbWVz
cGFjZS5vIG5mczRnZXRyb290Lm8gbmZzNGNsaWVudC5vIGRuc19yZXNvbHZlLm8NCj4gKwkgIG5m
czRuYW1lc3BhY2UubyBuZnM0Z2V0cm9vdC5vIG5mczRjbGllbnQubyBkbnNfcmVzb2x2ZS5vIFwN
Cj4gKwkgIG5mczR0cmFjZS5jDQoNCkRvaCEgVGhlIGFib3ZlIHNob3VsZCBvZiBjb3Vyc2UgYmUg
bmZzNHRyYWNlLm8uLi4NCi0tIA0KVHJvbmQgTXlrbGVidXN0DQpMaW51eCBORlMgY2xpZW50IG1h
aW50YWluZXINCg0KTmV0QXBwDQpUcm9uZC5NeWtsZWJ1c3RAbmV0YXBwLmNvbQ0Kd3d3Lm5ldGFw
cC5jb20NCg==

Re: [PATCH 02/10] NFS: refactor code for calculating the crc32 hash of a filehandle

[Myklebust, Trond]
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Re: [PATCH 01/10] NFSv4: Add tracepoints for debugging state management problems

[J. Bruce Fields]

On Tue, Aug 13, 2013 at 02:35:43PM -0400, Trond Myklebust wrote:
> Set up basic tracepoints for debugging client id creation/destruction
> and session creation/destruction.

Looks good to me. Dumb questions, just out of curiosity:

	- Some of these are followed by dprintk's with similar
	  information.  Is it worth keeping those, or could they be
	  phased out at some point?

	- Some of them are paired with an rpc_call_sync.  What do these
	  get you that wouldn't get out of wireshark with a suitable
	  filter?

--b.

> 
> Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
> ---
>  fs/nfs/Makefile    |   3 +-
>  fs/nfs/nfs4proc.c  |   9 +++
>  fs/nfs/nfs4trace.c |  10 +++
>  fs/nfs/nfs4trace.h | 205 +++++++++++++++++++++++++++++++++++++++++++++++++++++
>  4 files changed, 226 insertions(+), 1 deletion(-)
>  create mode 100644 fs/nfs/nfs4trace.c
>  create mode 100644 fs/nfs/nfs4trace.h
> 
> diff --git a/fs/nfs/Makefile b/fs/nfs/Makefile
> index e0bb048..71ba4c2 100644
> --- a/fs/nfs/Makefile
> +++ b/fs/nfs/Makefile
> @@ -21,7 +21,8 @@ nfsv3-$(CONFIG_NFS_V3_ACL) += nfs3acl.o
>  obj-$(CONFIG_NFS_V4) += nfsv4.o
>  nfsv4-y := nfs4proc.o nfs4xdr.o nfs4state.o nfs4renewd.o nfs4super.o nfs4file.o \
>  	  delegation.o idmap.o callback.o callback_xdr.o callback_proc.o \
> -	  nfs4namespace.o nfs4getroot.o nfs4client.o dns_resolve.o
> +	  nfs4namespace.o nfs4getroot.o nfs4client.o dns_resolve.o \
> +	  nfs4trace.c
>  nfsv4-$(CONFIG_NFS_USE_LEGACY_DNS) += cache_lib.o
>  nfsv4-$(CONFIG_SYSCTL)	+= nfs4sysctl.o
>  nfsv4-$(CONFIG_NFS_V4_1)	+= nfs4session.o pnfs.o pnfs_dev.o
> diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
> index a187f4d..3a55f24 100644
> --- a/fs/nfs/nfs4proc.c
> +++ b/fs/nfs/nfs4proc.c
> @@ -66,6 +66,8 @@
>  #include "nfs4session.h"
>  #include "fscache.h"
>  
> +#include "nfs4trace.h"
> +
>  #define NFSDBG_FACILITY		NFSDBG_PROC
>  
>  #define NFS4_POLL_RETRY_MIN	(HZ/10)
> @@ -4730,6 +4732,7 @@ int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
>  		clp->cl_rpcclient->cl_auth->au_ops->au_name,
>  		setclientid.sc_name_len, setclientid.sc_name);
>  	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
> +	trace_nfs4_setclientid(clp, status);
>  	dprintk("NFS reply setclientid: %d\n", status);
>  	return status;
>  }
> @@ -4757,6 +4760,7 @@ int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
>  		clp->cl_rpcclient->cl_auth->au_ops->au_name,
>  		clp->cl_clientid);
>  	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
> +	trace_nfs4_setclientid_confirm(clp, status);
>  	dprintk("NFS reply setclientid_confirm: %d\n", status);
>  	return status;
>  }
> @@ -5887,6 +5891,7 @@ int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred
>  	}
>  
>  	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
> +	trace_nfs4_bind_conn_to_session(clp, status);
>  	if (status == 0) {
>  		if (memcmp(res.session->sess_id.data,
>  		    clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) {
> @@ -5972,6 +5977,7 @@ int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
>  	}
>  
>  	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
> +	trace_nfs4_exchange_id(clp, status);
>  	if (status == 0)
>  		status = nfs4_check_cl_exchange_flags(res.flags);
>  
> @@ -6032,6 +6038,7 @@ static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
>  	int status;
>  
>  	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
> +	trace_nfs4_destroy_clientid(clp, status);
>  	if (status)
>  		dprintk("NFS: Got error %d from the server %s on "
>  			"DESTROY_CLIENTID.", status, clp->cl_hostname);
> @@ -6295,6 +6302,7 @@ static int _nfs4_proc_create_session(struct nfs_client *clp,
>  	args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);
>  
>  	status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
> +	trace_nfs4_create_session(clp, status);
>  
>  	if (!status) {
>  		/* Verify the session's negotiated channel_attrs values */
> @@ -6358,6 +6366,7 @@ int nfs4_proc_destroy_session(struct nfs4_session *session,
>  		return status;
>  
>  	status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
> +	trace_nfs4_destroy_session(session->clp, status);
>  
>  	if (status)
>  		dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
> diff --git a/fs/nfs/nfs4trace.c b/fs/nfs/nfs4trace.c
> new file mode 100644
> index 0000000..3f02183
> --- /dev/null
> +++ b/fs/nfs/nfs4trace.c
> @@ -0,0 +1,10 @@
> +/*
> + * Copyright (c) 2013 Trond Myklebust <Trond.Myklebust@netapp.com>
> + */
> +#include <linux/nfs_fs.h>
> +#include "nfs4_fs.h"
> +#include "internal.h"
> +
> +#define CREATE_TRACE_POINTS
> +#include "nfs4trace.h"
> +
> diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h
> new file mode 100644
> index 0000000..451954f
> --- /dev/null
> +++ b/fs/nfs/nfs4trace.h
> @@ -0,0 +1,205 @@
> +#undef TRACE_SYSTEM
> +#define TRACE_SYSTEM nfs4
> +
> +#if !defined(_TRACE_NFS4_H) || defined(TRACE_HEADER_MULTI_READ)
> +#define _TRACE_NFS4_H
> +
> +#include <linux/tracepoint.h>
> +
> +#define show_nfsv4_errors(error) __print_symbolic(error,		\
> +		{ NFS4_OK,			"OK" },			\
> +		/* Mapped by nfs4_stat_to_errno() */			\
> +		{ -EPERM,			"EPERM" },		\
> +		{ -ENOENT,			"ENOENT" },		\
> +		{ -EIO,				"EIO" },		\
> +		{ -ENXIO,			"ENXIO" },		\
> +		{ -EACCES,			"EACCES" },		\
> +		{ -EEXIST,			"EEXIST" },		\
> +		{ -EXDEV,			"EXDEV" },		\
> +		{ -ENOTDIR,			"ENOTDIR" },		\
> +		{ -EISDIR,			"EISDIR" },		\
> +		{ -EFBIG,			"EFBIG" },		\
> +		{ -ENOSPC,			"ENOSPC" },		\
> +		{ -EROFS,			"EROFS" },		\
> +		{ -EMLINK,			"EMLINK" },		\
> +		{ -ENAMETOOLONG,		"ENAMETOOLONG" },	\
> +		{ -ENOTEMPTY,			"ENOTEMPTY" },		\
> +		{ -EDQUOT,			"EDQUOT" },		\
> +		{ -ESTALE,			"ESTALE" },		\
> +		{ -EBADHANDLE,			"EBADHANDLE" },		\
> +		{ -EBADCOOKIE,			"EBADCOOKIE" },		\
> +		{ -ENOTSUPP,			"ENOTSUPP" },		\
> +		{ -ETOOSMALL,			"ETOOSMALL" },		\
> +		{ -EREMOTEIO,			"EREMOTEIO" },		\
> +		{ -EBADTYPE,			"EBADTYPE" },		\
> +		{ -EAGAIN,			"EAGAIN" },		\
> +		{ -ELOOP,			"ELOOP" },		\
> +		{ -EOPNOTSUPP,			"EOPNOTSUPP" },		\
> +		{ -EDEADLK,			"EDEADLK" },		\
> +		/* RPC errors */					\
> +		{ -ENOMEM,			"ENOMEM" },		\
> +		{ -EKEYEXPIRED,			"EKEYEXPIRED" },	\
> +		{ -ETIMEDOUT,			"ETIMEDOUT" },		\
> +		{ -ERESTARTSYS,			"ERESTARTSYS" },	\
> +		{ -ECONNREFUSED,		"ECONNREFUSED" },	\
> +		{ -ECONNRESET,			"ECONNRESET" },		\
> +		{ -ENETUNREACH,			"ENETUNREACH" },	\
> +		{ -EHOSTUNREACH,		"EHOSTUNREACH" },	\
> +		{ -EHOSTDOWN,			"EHOSTDOWN" },		\
> +		{ -EPIPE,			"EPIPE" },		\
> +		{ -EPFNOSUPPORT,		"EPFNOSUPPORT" },	\
> +		{ -EPROTONOSUPPORT,		"EPROTONOSUPPORT" },	\
> +		/* NFSv4 native errors */				\
> +		{ -NFS4ERR_ACCESS,		"ACCESS" },		\
> +		{ -NFS4ERR_ATTRNOTSUPP,		"ATTRNOTSUPP" },	\
> +		{ -NFS4ERR_ADMIN_REVOKED,	"ADMIN_REVOKED" },	\
> +		{ -NFS4ERR_BACK_CHAN_BUSY,	"BACK_CHAN_BUSY" },	\
> +		{ -NFS4ERR_BADCHAR,		"BADCHAR" },		\
> +		{ -NFS4ERR_BADHANDLE,		"BADHANDLE" },		\
> +		{ -NFS4ERR_BADIOMODE,		"BADIOMODE" },		\
> +		{ -NFS4ERR_BADLAYOUT,		"BADLAYOUT" },		\
> +		{ -NFS4ERR_BADNAME,		"BADNAME" },		\
> +		{ -NFS4ERR_BADOWNER,		"BADOWNER" },		\
> +		{ -NFS4ERR_BADSESSION,		"BADSESSION" },		\
> +		{ -NFS4ERR_BADSLOT,		"BADSLOT" },		\
> +		{ -NFS4ERR_BADTYPE,		"BADTYPE" },		\
> +		{ -NFS4ERR_BADXDR,		"BADXDR" },		\
> +		{ -NFS4ERR_BAD_COOKIE,		"BAD_COOKIE" },		\
> +		{ -NFS4ERR_BAD_HIGH_SLOT,	"BAD_HIGH_SLOT" },	\
> +		{ -NFS4ERR_BAD_RANGE,		"BAD_RANGE" },		\
> +		{ -NFS4ERR_BAD_SEQID,		"BAD_SEQID" },		\
> +		{ -NFS4ERR_BAD_SESSION_DIGEST,	"BAD_SESSION_DIGEST" },	\
> +		{ -NFS4ERR_BAD_STATEID,		"BAD_STATEID" },	\
> +		{ -NFS4ERR_CB_PATH_DOWN,	"CB_PATH_DOWN" },	\
> +		{ -NFS4ERR_CLID_INUSE,		"CLID_INUSE" },		\
> +		{ -NFS4ERR_CLIENTID_BUSY,	"CLIENTID_BUSY" },	\
> +		{ -NFS4ERR_COMPLETE_ALREADY,	"COMPLETE_ALREADY" },	\
> +		{ -NFS4ERR_CONN_NOT_BOUND_TO_SESSION,			\
> +						"CONN_NOT_BOUND_TO_SESSION" }, \
> +		{ -NFS4ERR_DEADLOCK,		"DEADLOCK" },		\
> +		{ -NFS4ERR_DEADSESSION,		"DEAD_SESSION" },	\
> +		{ -NFS4ERR_DELAY,		"DELAY" },		\
> +		{ -NFS4ERR_DELEG_ALREADY_WANTED,			\
> +						"DELEG_ALREADY_WANTED" }, \
> +		{ -NFS4ERR_DELEG_REVOKED,	"DELEG_REVOKED" },	\
> +		{ -NFS4ERR_DENIED,		"DENIED" },		\
> +		{ -NFS4ERR_DIRDELEG_UNAVAIL,	"DIRDELEG_UNAVAIL" },	\
> +		{ -NFS4ERR_DQUOT,		"DQUOT" },		\
> +		{ -NFS4ERR_ENCR_ALG_UNSUPP,	"ENCR_ALG_UNSUPP" },	\
> +		{ -NFS4ERR_EXIST,		"EXIST" },		\
> +		{ -NFS4ERR_EXPIRED,		"EXPIRED" },		\
> +		{ -NFS4ERR_FBIG,		"FBIG" },		\
> +		{ -NFS4ERR_FHEXPIRED,		"FHEXPIRED" },		\
> +		{ -NFS4ERR_FILE_OPEN,		"FILE_OPEN" },		\
> +		{ -NFS4ERR_GRACE,		"GRACE" },		\
> +		{ -NFS4ERR_HASH_ALG_UNSUPP,	"HASH_ALG_UNSUPP" },	\
> +		{ -NFS4ERR_INVAL,		"INVAL" },		\
> +		{ -NFS4ERR_IO,			"IO" },			\
> +		{ -NFS4ERR_ISDIR,		"ISDIR" },		\
> +		{ -NFS4ERR_LAYOUTTRYLATER,	"LAYOUTTRYLATER" },	\
> +		{ -NFS4ERR_LAYOUTUNAVAILABLE,	"LAYOUTUNAVAILABLE" },	\
> +		{ -NFS4ERR_LEASE_MOVED,		"LEASE_MOVED" },	\
> +		{ -NFS4ERR_LOCKED,		"LOCKED" },		\
> +		{ -NFS4ERR_LOCKS_HELD,		"LOCKS_HELD" },		\
> +		{ -NFS4ERR_LOCK_RANGE,		"LOCK_RANGE" },		\
> +		{ -NFS4ERR_MINOR_VERS_MISMATCH,	"MINOR_VERS_MISMATCH" }, \
> +		{ -NFS4ERR_MLINK,		"MLINK" },		\
> +		{ -NFS4ERR_MOVED,		"MOVED" },		\
> +		{ -NFS4ERR_NAMETOOLONG,		"NAMETOOLONG" },	\
> +		{ -NFS4ERR_NOENT,		"NOENT" },		\
> +		{ -NFS4ERR_NOFILEHANDLE,	"NOFILEHANDLE" },	\
> +		{ -NFS4ERR_NOMATCHING_LAYOUT,	"NOMATCHING_LAYOUT" },	\
> +		{ -NFS4ERR_NOSPC,		"NOSPC" },		\
> +		{ -NFS4ERR_NOTDIR,		"NOTDIR" },		\
> +		{ -NFS4ERR_NOTEMPTY,		"NOTEMPTY" },		\
> +		{ -NFS4ERR_NOTSUPP,		"NOTSUPP" },		\
> +		{ -NFS4ERR_NOT_ONLY_OP,		"NOT_ONLY_OP" },	\
> +		{ -NFS4ERR_NOT_SAME,		"NOT_SAME" },		\
> +		{ -NFS4ERR_NO_GRACE,		"NO_GRACE" },		\
> +		{ -NFS4ERR_NXIO,		"NXIO" },		\
> +		{ -NFS4ERR_OLD_STATEID,		"OLD_STATEID" },	\
> +		{ -NFS4ERR_OPENMODE,		"OPENMODE" },		\
> +		{ -NFS4ERR_OP_ILLEGAL,		"OP_ILLEGAL" },		\
> +		{ -NFS4ERR_OP_NOT_IN_SESSION,	"OP_NOT_IN_SESSION" },	\
> +		{ -NFS4ERR_PERM,		"PERM" },		\
> +		{ -NFS4ERR_PNFS_IO_HOLE,	"PNFS_IO_HOLE" },	\
> +		{ -NFS4ERR_PNFS_NO_LAYOUT,	"PNFS_NO_LAYOUT" },	\
> +		{ -NFS4ERR_RECALLCONFLICT,	"RECALLCONFLICT" },	\
> +		{ -NFS4ERR_RECLAIM_BAD,		"RECLAIM_BAD" },	\
> +		{ -NFS4ERR_RECLAIM_CONFLICT,	"RECLAIM_CONFLICT" },	\
> +		{ -NFS4ERR_REJECT_DELEG,	"REJECT_DELEG" },	\
> +		{ -NFS4ERR_REP_TOO_BIG,		"REP_TOO_BIG" },	\
> +		{ -NFS4ERR_REP_TOO_BIG_TO_CACHE,			\
> +						"REP_TOO_BIG_TO_CACHE" }, \
> +		{ -NFS4ERR_REQ_TOO_BIG,		"REQ_TOO_BIG" },	\
> +		{ -NFS4ERR_RESTOREFH,		"RESTOREFH" },		\
> +		{ -NFS4ERR_RETRY_UNCACHED_REP,	"RETRY_UNCACHED_REP" },	\
> +		{ -NFS4ERR_RETURNCONFLICT,	"RETURNCONFLICT" },	\
> +		{ -NFS4ERR_ROFS,		"ROFS" },		\
> +		{ -NFS4ERR_SAME,		"SAME" },		\
> +		{ -NFS4ERR_SHARE_DENIED,	"SHARE_DENIED" },	\
> +		{ -NFS4ERR_SEQUENCE_POS,	"SEQUENCE_POS" },	\
> +		{ -NFS4ERR_SEQ_FALSE_RETRY,	"SEQ_FALSE_RETRY" },	\
> +		{ -NFS4ERR_SEQ_MISORDERED,	"SEQ_MISORDERED" },	\
> +		{ -NFS4ERR_SERVERFAULT,		"SERVERFAULT" },	\
> +		{ -NFS4ERR_STALE,		"STALE" },		\
> +		{ -NFS4ERR_STALE_CLIENTID,	"STALE_CLIENTID" },	\
> +		{ -NFS4ERR_STALE_STATEID,	"STALE_STATEID" },	\
> +		{ -NFS4ERR_SYMLINK,		"SYMLINK" },		\
> +		{ -NFS4ERR_TOOSMALL,		"TOOSMALL" },		\
> +		{ -NFS4ERR_TOO_MANY_OPS,	"TOO_MANY_OPS" },	\
> +		{ -NFS4ERR_UNKNOWN_LAYOUTTYPE,	"UNKNOWN_LAYOUTTYPE" },	\
> +		{ -NFS4ERR_UNSAFE_COMPOUND,	"UNSAFE_COMPOUND" },	\
> +		{ -NFS4ERR_WRONGSEC,		"WRONGSEC" },		\
> +		{ -NFS4ERR_WRONG_CRED,		"WRONG_CRED" },		\
> +		{ -NFS4ERR_WRONG_TYPE,		"WRONG_TYPE" },		\
> +		{ -NFS4ERR_XDEV,		"XDEV" })
> +
> +DECLARE_EVENT_CLASS(nfs4_clientid_event,
> +		TP_PROTO(const struct nfs_client *clp,
> +			int error),
> +
> +		TP_ARGS(clp, error),
> +
> +		TP_STRUCT__entry(
> +			__string(dstaddr,
> +				rpc_peeraddr2str(clp->cl_rpcclient,
> +					RPC_DISPLAY_ADDR))
> +			__field(int, error)
> +		),
> +
> +		TP_fast_assign(
> +			__entry->error = error;
> +			__assign_str(dstaddr,
> +				rpc_peeraddr2str(clp->cl_rpcclient,
> +						RPC_DISPLAY_ADDR));
> +		),
> +
> +		TP_printk("error=%d (%s), dstaddr=%s",
> +			__entry->error,
> +			show_nfsv4_errors(__entry->error),
> +			__get_str(dstaddr)
> +		)
> +);
> +#define DEFINE_NFS4_CLIENTID_EVENT(name)		\
> +DEFINE_EVENT(nfs4_clientid_event, name,			\
> +		TP_PROTO(const struct nfs_client *clp,	\
> +			int error),			\
> +		TP_ARGS(clp, error))
> +DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid);
> +DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid_confirm);
> +#ifdef CONFIG_NFS_V4_1
> +DEFINE_NFS4_CLIENTID_EVENT(nfs4_exchange_id);
> +DEFINE_NFS4_CLIENTID_EVENT(nfs4_create_session);
> +DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_session);
> +DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_clientid);
> +DEFINE_NFS4_CLIENTID_EVENT(nfs4_bind_conn_to_session);
> +#endif /* CONFIG_NFS_V4_1 */
> +
> +#endif /* _TRACE_NFS4_H */
> +
> +#undef TRACE_INCLUDE_PATH
> +#define TRACE_INCLUDE_PATH .
> +#define TRACE_INCLUDE_FILE nfs4trace
> +/* This part must be outside protection */
> +#include <trace/define_trace.h>
> -- 
> 1.8.3.1
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH 01/10] NFSv4: Add tracepoints for debugging state management problems

[Myklebust, Trond]
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=

Re: [PATCH 01/10] NFSv4: Add tracepoints for debugging state management problems

[Andy Adamson]

Looks good to me as well. I like the division trace points and NFS
operations. This should be very useful. I'm curious to see the
performance hit.

-->Andy

On Wed, Aug 14, 2013 at 11:57 AM, Myklebust, Trond
<Trond.Myklebust@netapp.com> wrote:
> On Wed, 2013-08-14 at 11:31 -0400, J. Bruce Fields wrote:
>> On Tue, Aug 13, 2013 at 02:35:43PM -0400, Trond Myklebust wrote:
>> > Set up basic tracepoints for debugging client id creation/destruction
>> > and session creation/destruction.
>>
>> Looks good to me. Dumb questions, just out of curiosity:
>>
>>       - Some of these are followed by dprintk's with similar
>>         information.  Is it worth keeping those, or could they be
>>         phased out at some point?
>
> I'd like to phase out the dprintks over time.
>
>>       - Some of them are paired with an rpc_call_sync.  What do these
>>         get you that wouldn't get out of wireshark with a suitable
>>         filter?
>
> The tracepoints give you the ability to do more sophisticated dynamic
> tracing using systemtap or lttng.
>
> The ringbuffer used by ftrace means that the overhead is relatively
> small: you're not spamming the syslog all the time. Furthermore, ftrace
> does support some simple filters. I'm therefore thinking that some
> sysadmins might want to consider enabling some of these tracepoints
> permanently on their systems in order to be able to post-mortem state
> recovery issues following networking outages and/or server reboots.
>
> Cheers
>   Trond
>
>> --b.
>>
>> >
>> > Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
>> > ---
>> >  fs/nfs/Makefile    |   3 +-
>> >  fs/nfs/nfs4proc.c  |   9 +++
>> >  fs/nfs/nfs4trace.c |  10 +++
>> >  fs/nfs/nfs4trace.h | 205 +++++++++++++++++++++++++++++++++++++++++++++++++++++
>> >  4 files changed, 226 insertions(+), 1 deletion(-)
>> >  create mode 100644 fs/nfs/nfs4trace.c
>> >  create mode 100644 fs/nfs/nfs4trace.h
>> >
>> > diff --git a/fs/nfs/Makefile b/fs/nfs/Makefile
>> > index e0bb048..71ba4c2 100644
>> > --- a/fs/nfs/Makefile
>> > +++ b/fs/nfs/Makefile
>> > @@ -21,7 +21,8 @@ nfsv3-$(CONFIG_NFS_V3_ACL) += nfs3acl.o
>> >  obj-$(CONFIG_NFS_V4) += nfsv4.o
>> >  nfsv4-y := nfs4proc.o nfs4xdr.o nfs4state.o nfs4renewd.o nfs4super.o nfs4file.o \
>> >       delegation.o idmap.o callback.o callback_xdr.o callback_proc.o \
>> > -     nfs4namespace.o nfs4getroot.o nfs4client.o dns_resolve.o
>> > +     nfs4namespace.o nfs4getroot.o nfs4client.o dns_resolve.o \
>> > +     nfs4trace.c
>> >  nfsv4-$(CONFIG_NFS_USE_LEGACY_DNS) += cache_lib.o
>> >  nfsv4-$(CONFIG_SYSCTL)     += nfs4sysctl.o
>> >  nfsv4-$(CONFIG_NFS_V4_1)   += nfs4session.o pnfs.o pnfs_dev.o
>> > diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
>> > index a187f4d..3a55f24 100644
>> > --- a/fs/nfs/nfs4proc.c
>> > +++ b/fs/nfs/nfs4proc.c
>> > @@ -66,6 +66,8 @@
>> >  #include "nfs4session.h"
>> >  #include "fscache.h"
>> >
>> > +#include "nfs4trace.h"
>> > +
>> >  #define NFSDBG_FACILITY            NFSDBG_PROC
>> >
>> >  #define NFS4_POLL_RETRY_MIN        (HZ/10)
>> > @@ -4730,6 +4732,7 @@ int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
>> >             clp->cl_rpcclient->cl_auth->au_ops->au_name,
>> >             setclientid.sc_name_len, setclientid.sc_name);
>> >     status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
>> > +   trace_nfs4_setclientid(clp, status);
>> >     dprintk("NFS reply setclientid: %d\n", status);
>> >     return status;
>> >  }
>> > @@ -4757,6 +4760,7 @@ int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
>> >             clp->cl_rpcclient->cl_auth->au_ops->au_name,
>> >             clp->cl_clientid);
>> >     status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
>> > +   trace_nfs4_setclientid_confirm(clp, status);
>> >     dprintk("NFS reply setclientid_confirm: %d\n", status);
>> >     return status;
>> >  }
>> > @@ -5887,6 +5891,7 @@ int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred
>> >     }
>> >
>> >     status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
>> > +   trace_nfs4_bind_conn_to_session(clp, status);
>> >     if (status == 0) {
>> >             if (memcmp(res.session->sess_id.data,
>> >                 clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) {
>> > @@ -5972,6 +5977,7 @@ int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
>> >     }
>> >
>> >     status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
>> > +   trace_nfs4_exchange_id(clp, status);
>> >     if (status == 0)
>> >             status = nfs4_check_cl_exchange_flags(res.flags);
>> >
>> > @@ -6032,6 +6038,7 @@ static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
>> >     int status;
>> >
>> >     status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
>> > +   trace_nfs4_destroy_clientid(clp, status);
>> >     if (status)
>> >             dprintk("NFS: Got error %d from the server %s on "
>> >                     "DESTROY_CLIENTID.", status, clp->cl_hostname);
>> > @@ -6295,6 +6302,7 @@ static int _nfs4_proc_create_session(struct nfs_client *clp,
>> >     args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);
>> >
>> >     status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
>> > +   trace_nfs4_create_session(clp, status);
>> >
>> >     if (!status) {
>> >             /* Verify the session's negotiated channel_attrs values */
>> > @@ -6358,6 +6366,7 @@ int nfs4_proc_destroy_session(struct nfs4_session *session,
>> >             return status;
>> >
>> >     status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
>> > +   trace_nfs4_destroy_session(session->clp, status);
>> >
>> >     if (status)
>> >             dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
>> > diff --git a/fs/nfs/nfs4trace.c b/fs/nfs/nfs4trace.c
>> > new file mode 100644
>> > index 0000000..3f02183
>> > --- /dev/null
>> > +++ b/fs/nfs/nfs4trace.c
>> > @@ -0,0 +1,10 @@
>> > +/*
>> > + * Copyright (c) 2013 Trond Myklebust <Trond.Myklebust@netapp.com>
>> > + */
>> > +#include <linux/nfs_fs.h>
>> > +#include "nfs4_fs.h"
>> > +#include "internal.h"
>> > +
>> > +#define CREATE_TRACE_POINTS
>> > +#include "nfs4trace.h"
>> > +
>> > diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h
>> > new file mode 100644
>> > index 0000000..451954f
>> > --- /dev/null
>> > +++ b/fs/nfs/nfs4trace.h
>> > @@ -0,0 +1,205 @@
>> > +#undef TRACE_SYSTEM
>> > +#define TRACE_SYSTEM nfs4
>> > +
>> > +#if !defined(_TRACE_NFS4_H) || defined(TRACE_HEADER_MULTI_READ)
>> > +#define _TRACE_NFS4_H
>> > +
>> > +#include <linux/tracepoint.h>
>> > +
>> > +#define show_nfsv4_errors(error) __print_symbolic(error,           \
>> > +           { NFS4_OK,                      "OK" },                 \
>> > +           /* Mapped by nfs4_stat_to_errno() */                    \
>> > +           { -EPERM,                       "EPERM" },              \
>> > +           { -ENOENT,                      "ENOENT" },             \
>> > +           { -EIO,                         "EIO" },                \
>> > +           { -ENXIO,                       "ENXIO" },              \
>> > +           { -EACCES,                      "EACCES" },             \
>> > +           { -EEXIST,                      "EEXIST" },             \
>> > +           { -EXDEV,                       "EXDEV" },              \
>> > +           { -ENOTDIR,                     "ENOTDIR" },            \
>> > +           { -EISDIR,                      "EISDIR" },             \
>> > +           { -EFBIG,                       "EFBIG" },              \
>> > +           { -ENOSPC,                      "ENOSPC" },             \
>> > +           { -EROFS,                       "EROFS" },              \
>> > +           { -EMLINK,                      "EMLINK" },             \
>> > +           { -ENAMETOOLONG,                "ENAMETOOLONG" },       \
>> > +           { -ENOTEMPTY,                   "ENOTEMPTY" },          \
>> > +           { -EDQUOT,                      "EDQUOT" },             \
>> > +           { -ESTALE,                      "ESTALE" },             \
>> > +           { -EBADHANDLE,                  "EBADHANDLE" },         \
>> > +           { -EBADCOOKIE,                  "EBADCOOKIE" },         \
>> > +           { -ENOTSUPP,                    "ENOTSUPP" },           \
>> > +           { -ETOOSMALL,                   "ETOOSMALL" },          \
>> > +           { -EREMOTEIO,                   "EREMOTEIO" },          \
>> > +           { -EBADTYPE,                    "EBADTYPE" },           \
>> > +           { -EAGAIN,                      "EAGAIN" },             \
>> > +           { -ELOOP,                       "ELOOP" },              \
>> > +           { -EOPNOTSUPP,                  "EOPNOTSUPP" },         \
>> > +           { -EDEADLK,                     "EDEADLK" },            \
>> > +           /* RPC errors */                                        \
>> > +           { -ENOMEM,                      "ENOMEM" },             \
>> > +           { -EKEYEXPIRED,                 "EKEYEXPIRED" },        \
>> > +           { -ETIMEDOUT,                   "ETIMEDOUT" },          \
>> > +           { -ERESTARTSYS,                 "ERESTARTSYS" },        \
>> > +           { -ECONNREFUSED,                "ECONNREFUSED" },       \
>> > +           { -ECONNRESET,                  "ECONNRESET" },         \
>> > +           { -ENETUNREACH,                 "ENETUNREACH" },        \
>> > +           { -EHOSTUNREACH,                "EHOSTUNREACH" },       \
>> > +           { -EHOSTDOWN,                   "EHOSTDOWN" },          \
>> > +           { -EPIPE,                       "EPIPE" },              \
>> > +           { -EPFNOSUPPORT,                "EPFNOSUPPORT" },       \
>> > +           { -EPROTONOSUPPORT,             "EPROTONOSUPPORT" },    \
>> > +           /* NFSv4 native errors */                               \
>> > +           { -NFS4ERR_ACCESS,              "ACCESS" },             \
>> > +           { -NFS4ERR_ATTRNOTSUPP,         "ATTRNOTSUPP" },        \
>> > +           { -NFS4ERR_ADMIN_REVOKED,       "ADMIN_REVOKED" },      \
>> > +           { -NFS4ERR_BACK_CHAN_BUSY,      "BACK_CHAN_BUSY" },     \
>> > +           { -NFS4ERR_BADCHAR,             "BADCHAR" },            \
>> > +           { -NFS4ERR_BADHANDLE,           "BADHANDLE" },          \
>> > +           { -NFS4ERR_BADIOMODE,           "BADIOMODE" },          \
>> > +           { -NFS4ERR_BADLAYOUT,           "BADLAYOUT" },          \
>> > +           { -NFS4ERR_BADNAME,             "BADNAME" },            \
>> > +           { -NFS4ERR_BADOWNER,            "BADOWNER" },           \
>> > +           { -NFS4ERR_BADSESSION,          "BADSESSION" },         \
>> > +           { -NFS4ERR_BADSLOT,             "BADSLOT" },            \
>> > +           { -NFS4ERR_BADTYPE,             "BADTYPE" },            \
>> > +           { -NFS4ERR_BADXDR,              "BADXDR" },             \
>> > +           { -NFS4ERR_BAD_COOKIE,          "BAD_COOKIE" },         \
>> > +           { -NFS4ERR_BAD_HIGH_SLOT,       "BAD_HIGH_SLOT" },      \
>> > +           { -NFS4ERR_BAD_RANGE,           "BAD_RANGE" },          \
>> > +           { -NFS4ERR_BAD_SEQID,           "BAD_SEQID" },          \
>> > +           { -NFS4ERR_BAD_SESSION_DIGEST,  "BAD_SESSION_DIGEST" }, \
>> > +           { -NFS4ERR_BAD_STATEID,         "BAD_STATEID" },        \
>> > +           { -NFS4ERR_CB_PATH_DOWN,        "CB_PATH_DOWN" },       \
>> > +           { -NFS4ERR_CLID_INUSE,          "CLID_INUSE" },         \
>> > +           { -NFS4ERR_CLIENTID_BUSY,       "CLIENTID_BUSY" },      \
>> > +           { -NFS4ERR_COMPLETE_ALREADY,    "COMPLETE_ALREADY" },   \
>> > +           { -NFS4ERR_CONN_NOT_BOUND_TO_SESSION,                   \
>> > +                                           "CONN_NOT_BOUND_TO_SESSION" }, \
>> > +           { -NFS4ERR_DEADLOCK,            "DEADLOCK" },           \
>> > +           { -NFS4ERR_DEADSESSION,         "DEAD_SESSION" },       \
>> > +           { -NFS4ERR_DELAY,               "DELAY" },              \
>> > +           { -NFS4ERR_DELEG_ALREADY_WANTED,                        \
>> > +                                           "DELEG_ALREADY_WANTED" }, \
>> > +           { -NFS4ERR_DELEG_REVOKED,       "DELEG_REVOKED" },      \
>> > +           { -NFS4ERR_DENIED,              "DENIED" },             \
>> > +           { -NFS4ERR_DIRDELEG_UNAVAIL,    "DIRDELEG_UNAVAIL" },   \
>> > +           { -NFS4ERR_DQUOT,               "DQUOT" },              \
>> > +           { -NFS4ERR_ENCR_ALG_UNSUPP,     "ENCR_ALG_UNSUPP" },    \
>> > +           { -NFS4ERR_EXIST,               "EXIST" },              \
>> > +           { -NFS4ERR_EXPIRED,             "EXPIRED" },            \
>> > +           { -NFS4ERR_FBIG,                "FBIG" },               \
>> > +           { -NFS4ERR_FHEXPIRED,           "FHEXPIRED" },          \
>> > +           { -NFS4ERR_FILE_OPEN,           "FILE_OPEN" },          \
>> > +           { -NFS4ERR_GRACE,               "GRACE" },              \
>> > +           { -NFS4ERR_HASH_ALG_UNSUPP,     "HASH_ALG_UNSUPP" },    \
>> > +           { -NFS4ERR_INVAL,               "INVAL" },              \
>> > +           { -NFS4ERR_IO,                  "IO" },                 \
>> > +           { -NFS4ERR_ISDIR,               "ISDIR" },              \
>> > +           { -NFS4ERR_LAYOUTTRYLATER,      "LAYOUTTRYLATER" },     \
>> > +           { -NFS4ERR_LAYOUTUNAVAILABLE,   "LAYOUTUNAVAILABLE" },  \
>> > +           { -NFS4ERR_LEASE_MOVED,         "LEASE_MOVED" },        \
>> > +           { -NFS4ERR_LOCKED,              "LOCKED" },             \
>> > +           { -NFS4ERR_LOCKS_HELD,          "LOCKS_HELD" },         \
>> > +           { -NFS4ERR_LOCK_RANGE,          "LOCK_RANGE" },         \
>> > +           { -NFS4ERR_MINOR_VERS_MISMATCH, "MINOR_VERS_MISMATCH" }, \
>> > +           { -NFS4ERR_MLINK,               "MLINK" },              \
>> > +           { -NFS4ERR_MOVED,               "MOVED" },              \
>> > +           { -NFS4ERR_NAMETOOLONG,         "NAMETOOLONG" },        \
>> > +           { -NFS4ERR_NOENT,               "NOENT" },              \
>> > +           { -NFS4ERR_NOFILEHANDLE,        "NOFILEHANDLE" },       \
>> > +           { -NFS4ERR_NOMATCHING_LAYOUT,   "NOMATCHING_LAYOUT" },  \
>> > +           { -NFS4ERR_NOSPC,               "NOSPC" },              \
>> > +           { -NFS4ERR_NOTDIR,              "NOTDIR" },             \
>> > +           { -NFS4ERR_NOTEMPTY,            "NOTEMPTY" },           \
>> > +           { -NFS4ERR_NOTSUPP,             "NOTSUPP" },            \
>> > +           { -NFS4ERR_NOT_ONLY_OP,         "NOT_ONLY_OP" },        \
>> > +           { -NFS4ERR_NOT_SAME,            "NOT_SAME" },           \
>> > +           { -NFS4ERR_NO_GRACE,            "NO_GRACE" },           \
>> > +           { -NFS4ERR_NXIO,                "NXIO" },               \
>> > +           { -NFS4ERR_OLD_STATEID,         "OLD_STATEID" },        \
>> > +           { -NFS4ERR_OPENMODE,            "OPENMODE" },           \
>> > +           { -NFS4ERR_OP_ILLEGAL,          "OP_ILLEGAL" },         \
>> > +           { -NFS4ERR_OP_NOT_IN_SESSION,   "OP_NOT_IN_SESSION" },  \
>> > +           { -NFS4ERR_PERM,                "PERM" },               \
>> > +           { -NFS4ERR_PNFS_IO_HOLE,        "PNFS_IO_HOLE" },       \
>> > +           { -NFS4ERR_PNFS_NO_LAYOUT,      "PNFS_NO_LAYOUT" },     \
>> > +           { -NFS4ERR_RECALLCONFLICT,      "RECALLCONFLICT" },     \
>> > +           { -NFS4ERR_RECLAIM_BAD,         "RECLAIM_BAD" },        \
>> > +           { -NFS4ERR_RECLAIM_CONFLICT,    "RECLAIM_CONFLICT" },   \
>> > +           { -NFS4ERR_REJECT_DELEG,        "REJECT_DELEG" },       \
>> > +           { -NFS4ERR_REP_TOO_BIG,         "REP_TOO_BIG" },        \
>> > +           { -NFS4ERR_REP_TOO_BIG_TO_CACHE,                        \
>> > +                                           "REP_TOO_BIG_TO_CACHE" }, \
>> > +           { -NFS4ERR_REQ_TOO_BIG,         "REQ_TOO_BIG" },        \
>> > +           { -NFS4ERR_RESTOREFH,           "RESTOREFH" },          \
>> > +           { -NFS4ERR_RETRY_UNCACHED_REP,  "RETRY_UNCACHED_REP" }, \
>> > +           { -NFS4ERR_RETURNCONFLICT,      "RETURNCONFLICT" },     \
>> > +           { -NFS4ERR_ROFS,                "ROFS" },               \
>> > +           { -NFS4ERR_SAME,                "SAME" },               \
>> > +           { -NFS4ERR_SHARE_DENIED,        "SHARE_DENIED" },       \
>> > +           { -NFS4ERR_SEQUENCE_POS,        "SEQUENCE_POS" },       \
>> > +           { -NFS4ERR_SEQ_FALSE_RETRY,     "SEQ_FALSE_RETRY" },    \
>> > +           { -NFS4ERR_SEQ_MISORDERED,      "SEQ_MISORDERED" },     \
>> > +           { -NFS4ERR_SERVERFAULT,         "SERVERFAULT" },        \
>> > +           { -NFS4ERR_STALE,               "STALE" },              \
>> > +           { -NFS4ERR_STALE_CLIENTID,      "STALE_CLIENTID" },     \
>> > +           { -NFS4ERR_STALE_STATEID,       "STALE_STATEID" },      \
>> > +           { -NFS4ERR_SYMLINK,             "SYMLINK" },            \
>> > +           { -NFS4ERR_TOOSMALL,            "TOOSMALL" },           \
>> > +           { -NFS4ERR_TOO_MANY_OPS,        "TOO_MANY_OPS" },       \
>> > +           { -NFS4ERR_UNKNOWN_LAYOUTTYPE,  "UNKNOWN_LAYOUTTYPE" }, \
>> > +           { -NFS4ERR_UNSAFE_COMPOUND,     "UNSAFE_COMPOUND" },    \
>> > +           { -NFS4ERR_WRONGSEC,            "WRONGSEC" },           \
>> > +           { -NFS4ERR_WRONG_CRED,          "WRONG_CRED" },         \
>> > +           { -NFS4ERR_WRONG_TYPE,          "WRONG_TYPE" },         \
>> > +           { -NFS4ERR_XDEV,                "XDEV" })
>> > +
>> > +DECLARE_EVENT_CLASS(nfs4_clientid_event,
>> > +           TP_PROTO(const struct nfs_client *clp,
>> > +                   int error),
>> > +
>> > +           TP_ARGS(clp, error),
>> > +
>> > +           TP_STRUCT__entry(
>> > +                   __string(dstaddr,
>> > +                           rpc_peeraddr2str(clp->cl_rpcclient,
>> > +                                   RPC_DISPLAY_ADDR))
>> > +                   __field(int, error)
>> > +           ),
>> > +
>> > +           TP_fast_assign(
>> > +                   __entry->error = error;
>> > +                   __assign_str(dstaddr,
>> > +                           rpc_peeraddr2str(clp->cl_rpcclient,
>> > +                                           RPC_DISPLAY_ADDR));
>> > +           ),
>> > +
>> > +           TP_printk("error=%d (%s), dstaddr=%s",
>> > +                   __entry->error,
>> > +                   show_nfsv4_errors(__entry->error),
>> > +                   __get_str(dstaddr)
>> > +           )
>> > +);
>> > +#define DEFINE_NFS4_CLIENTID_EVENT(name)           \
>> > +DEFINE_EVENT(nfs4_clientid_event, name,                    \
>> > +           TP_PROTO(const struct nfs_client *clp,  \
>> > +                   int error),                     \
>> > +           TP_ARGS(clp, error))
>> > +DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid);
>> > +DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid_confirm);
>> > +#ifdef CONFIG_NFS_V4_1
>> > +DEFINE_NFS4_CLIENTID_EVENT(nfs4_exchange_id);
>> > +DEFINE_NFS4_CLIENTID_EVENT(nfs4_create_session);
>> > +DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_session);
>> > +DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_clientid);
>> > +DEFINE_NFS4_CLIENTID_EVENT(nfs4_bind_conn_to_session);
>> > +#endif /* CONFIG_NFS_V4_1 */
>> > +
>> > +#endif /* _TRACE_NFS4_H */
>> > +
>> > +#undef TRACE_INCLUDE_PATH
>> > +#define TRACE_INCLUDE_PATH .
>> > +#define TRACE_INCLUDE_FILE nfs4trace
>> > +/* This part must be outside protection */
>> > +#include <trace/define_trace.h>
>> > --
>> > 1.8.3.1
>> >
>> > --
>> > To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
>> > the body of a message to majordomo@vger.kernel.org
>> > More majordomo info at  http://vger.kernel.org/majordomo-info.html
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>
> --
> Trond Myklebust
> Linux NFS client maintainer
>
> NetApp
> Trond.Myklebust@netapp.com
> www.netapp.com