Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 48c9579a authored by Olga Kornievskaia's avatar Olga Kornievskaia Committed by Trond Myklebust
Browse files

Adding stateid information to tracepoints 



Operations to which stateid information is added:
close, delegreturn, open, read, setattr, layoutget, layoutcommit, test_stateid,
write, lock, locku, lockt

Format is "stateid=<seqid>:<crc32 hash stateid.other>", also "openstateid=",
"layoutstateid=", and "lockstateid=" for open_file, layoutget, set_lock
tracepoints.

New function is added to internal.h, nfs_stateid_hash(), to compute the hash

trace_nfs4_setattr() is moved from nfs4_do_setattr() to _nfs4_do_setattr()
to get access to stateid.

trace_nfs4_setattr and trace_nfs4_delegreturn are changed from INODE_EVENT
to new event type, INODE_STATEID_EVENT which is same as INODE_EVENT but adds
stateid information

for locking tracepoints, moved trace_nfs4_set_lock() into _nfs4_do_setlk()
to get access to stateid information, and removed trace_nfs4_lock_reclaim(),
trace_nfs4_lock_expired() as they call into _nfs4_do_setlk() and both were
previously same LOCK_EVENT type.

Signed-off-by: default avatarOlga Kornievskaia <kolga@netapp.com>
Signed-off-by: default avatarTrond Myklebust <trond.myklebust@primarydata.com>
parent 74bf8efb

fs/nfs/internal.h

+9 −0
Original line number Diff line number Diff line
@@ -696,9 +696,18 @@ static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh) 
{

	return ~crc32_le(0xFFFFFFFF, &fh->data[0], fh->size);

}

static inline u32 nfs_stateid_hash(const nfs4_stateid *stateid)

{

	return ~crc32_le(0xFFFFFFFF, &stateid->other[0],

				NFS4_STATEID_OTHER_SIZE);

}

#else

static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)

{

	return 0;

}

static inline u32 nfs_stateid_hash(nfs4_stateid *stateid)

{

	return 0;

}

#endif

fs/nfs/nfs4proc.c

+6 −7
Original line number Diff line number Diff line
@@ -2703,6 +2703,7 @@ static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 
	status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);

	if (status == 0 && state != NULL)

		renew_lease(server, timestamp);

	trace_nfs4_setattr(inode, &arg.stateid, status);

	return status;

}
@@ -2719,7 +2720,6 @@ 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)) {
@@ -5426,7 +5426,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);

		trace_nfs4_delegreturn(inode, stateid, err);

		switch (err) {

			case -NFS4ERR_STALE_STATEID:

			case -NFS4ERR_EXPIRED:
@@ -5936,6 +5936,7 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *f 
		data->cancelled = 1;

	rpc_put_task(task);

	dprintk("%s: done, ret = %d!\n", __func__, ret);

	trace_nfs4_set_lock(fl, state, &data->res.stateid, cmd, ret);

	return ret;

}
@@ -5952,7 +5953,6 @@ 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);
@@ -5979,7 +5979,6 @@ 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;
@@ -6087,7 +6086,6 @@ 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),
@@ -7994,6 +7992,7 @@ nfs4_proc_layoutget(struct nfs4_layoutget *lgp, gfp_t gfp_flags) 
	trace_nfs4_layoutget(lgp->args.ctx,

			&lgp->args.range,

			&lgp->res.range,

			&lgp->res.stateid,

			status);

	/* if layoutp->len is 0, nfs4_layoutget_prepare called rpc_exit */

	if (status == 0 && lgp->res.layoutp->len)
@@ -8101,7 +8100,7 @@ int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync) 
		return PTR_ERR(task);

	if (sync)

		status = task->tk_status;

	trace_nfs4_layoutreturn(lrp->args.inode, status);

	trace_nfs4_layoutreturn(lrp->args.inode, &lrp->args.stateid, status);

	dprintk("<-- %s status=%d\n", __func__, status);

	rpc_put_task(task);

	return status;
@@ -8249,7 +8248,7 @@ nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync) 
		return PTR_ERR(task);

	if (sync)

		status = task->tk_status;

	trace_nfs4_layoutcommit(data->args.inode, status);

	trace_nfs4_layoutcommit(data->args.inode, &data->args.stateid, status);

	dprintk("%s: status %d\n", __func__, status);

	rpc_put_task(task);

	return status;

fs/nfs/nfs4trace.h

+230 −25
Original line number Diff line number Diff line
@@ -399,6 +399,10 @@ DECLARE_EVENT_CLASS(nfs4_open_event, 
			__field(u64, fileid)

			__field(u64, dir)

			__string(name, ctx->dentry->d_name.name)

			__field(int, stateid_seq)

			__field(u32, stateid_hash)

			__field(int, openstateid_seq)

			__field(u32, openstateid_hash)

		),



		TP_fast_assign(
@@ -409,8 +413,22 @@ DECLARE_EVENT_CLASS(nfs4_open_event, 
			__entry->flags = flags;

			__entry->fmode = (__force unsigned int)ctx->mode;

			__entry->dev = ctx->dentry->d_sb->s_dev;

			if (!IS_ERR_OR_NULL(state))

			if (!IS_ERR_OR_NULL(state)) {

				inode = state->inode;

				__entry->stateid_seq =

					be32_to_cpu(state->stateid.seqid);

				__entry->stateid_hash =

					nfs_stateid_hash(&state->stateid);

				__entry->openstateid_seq =

					be32_to_cpu(state->open_stateid.seqid);

				__entry->openstateid_hash =

					nfs_stateid_hash(&state->open_stateid);

			} else {

				__entry->stateid_seq = 0;

				__entry->stateid_hash = 0;

				__entry->openstateid_seq = 0;

				__entry->openstateid_hash = 0;

			}

			if (inode != NULL) {

				__entry->fileid = NFS_FILEID(inode);

				__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
@@ -425,7 +443,8 @@ DECLARE_EVENT_CLASS(nfs4_open_event, 
		TP_printk(

			"error=%d (%s) flags=%d (%s) fmode=%s "

			"fileid=%02x:%02x:%llu fhandle=0x%08x "

			"name=%02x:%02x:%llu/%s",

			"name=%02x:%02x:%llu/%s stateid=%d:0x%08x "

			"openstateid=%d:0x%08x",

			 __entry->error,

			 show_nfsv4_errors(__entry->error),

			 __entry->flags,
@@ -436,7 +455,9 @@ DECLARE_EVENT_CLASS(nfs4_open_event, 
			 __entry->fhandle,

			 MAJOR(__entry->dev), MINOR(__entry->dev),

			 (unsigned long long)__entry->dir,

			 __get_str(name)

			 __get_str(name),

			 __entry->stateid_seq, __entry->stateid_hash,

			 __entry->openstateid_seq, __entry->openstateid_hash

		)

);
@@ -468,6 +489,8 @@ TRACE_EVENT(nfs4_close, 
			__field(u64, fileid)

			__field(unsigned int, fmode)

			__field(int, error)

			__field(int, stateid_seq)

			__field(u32, stateid_hash)

		),



		TP_fast_assign(
@@ -478,18 +501,23 @@ TRACE_EVENT(nfs4_close, 
			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));

			__entry->fmode = (__force unsigned int)state->state;

			__entry->error = error;

			__entry->stateid_seq =

				be32_to_cpu(args->stateid.seqid);

			__entry->stateid_hash =

				nfs_stateid_hash(&args->stateid);

		),



		TP_printk(

			"error=%d (%s) fmode=%s fileid=%02x:%02x:%llu "

			"fhandle=0x%08x",

			"fhandle=0x%08x openstateid=%d:0x%08x",

			__entry->error,

			show_nfsv4_errors(__entry->error),

			__entry->fmode ?  show_fmode_flags(__entry->fmode) :

					  "closed",

			MAJOR(__entry->dev), MINOR(__entry->dev),

			(unsigned long long)__entry->fileid,

			__entry->fhandle

			__entry->fhandle,

			__entry->stateid_seq, __entry->stateid_hash

		)

);
@@ -523,6 +551,8 @@ DECLARE_EVENT_CLASS(nfs4_lock_event, 
			__field(dev_t, dev)

			__field(u32, fhandle)

			__field(u64, fileid)

			__field(int, stateid_seq)

			__field(u32, stateid_hash)

		),



		TP_fast_assign(
@@ -536,11 +566,16 @@ DECLARE_EVENT_CLASS(nfs4_lock_event, 
			__entry->dev = inode->i_sb->s_dev;

			__entry->fileid = NFS_FILEID(inode);

			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));

			__entry->stateid_seq =

				be32_to_cpu(state->stateid.seqid);

			__entry->stateid_hash =

				nfs_stateid_hash(&state->stateid);

		),



		TP_printk(

			"error=%d (%s) cmd=%s:%s range=%lld:%lld "

			"fileid=%02x:%02x:%llu fhandle=0x%08x",

			"fileid=%02x:%02x:%llu fhandle=0x%08x "

			"stateid=%d:0x%08x",

			__entry->error,

			show_nfsv4_errors(__entry->error),

			show_lock_cmd(__entry->cmd),
@@ -549,7 +584,8 @@ DECLARE_EVENT_CLASS(nfs4_lock_event, 
			(long long)__entry->end,

			MAJOR(__entry->dev), MINOR(__entry->dev),

			(unsigned long long)__entry->fileid,

			__entry->fhandle

			__entry->fhandle,

			__entry->stateid_seq, __entry->stateid_hash

		)

);
@@ -563,11 +599,73 @@ DECLARE_EVENT_CLASS(nfs4_lock_event, 
			), \

			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);



TRACE_EVENT(nfs4_set_lock,

		TP_PROTO(

			const struct file_lock *request,

			const struct nfs4_state *state,

			const nfs4_stateid *lockstateid,

			int cmd,

			int error

		),



		TP_ARGS(request, state, lockstateid, 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(int, stateid_seq)

			__field(u32, stateid_hash)

			__field(int, lockstateid_seq)

			__field(u32, lockstateid_hash)

		),



		TP_fast_assign(

			const 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->stateid_seq =

				be32_to_cpu(state->stateid.seqid);

			__entry->stateid_hash =

				nfs_stateid_hash(&state->stateid);

			__entry->lockstateid_seq =

				be32_to_cpu(lockstateid->seqid);

			__entry->lockstateid_hash =

				nfs_stateid_hash(lockstateid);

		),



		TP_printk(

			"error=%d (%s) cmd=%s:%s range=%lld:%lld "

			"fileid=%02x:%02x:%llu fhandle=0x%08x "

			"stateid=%d:0x%08x lockstateid=%d:0x%08x",

			__entry->error,

			show_nfsv4_errors(__entry->error),

			show_lock_cmd(__entry->cmd),

			show_lock_type(__entry->type),

			(long long)__entry->start,

			(long long)__entry->end,

			MAJOR(__entry->dev), MINOR(__entry->dev),

			(unsigned long long)__entry->fileid,

			__entry->fhandle,

			__entry->stateid_seq, __entry->stateid_hash,

			__entry->lockstateid_seq, __entry->lockstateid_hash

		)

);



DECLARE_EVENT_CLASS(nfs4_set_delegation_event,

		TP_PROTO(

			const struct inode *inode,
@@ -621,20 +719,28 @@ TRACE_EVENT(nfs4_delegreturn_exit, 
			__field(dev_t, dev)

			__field(u32, fhandle)

			__field(int, error)

			__field(int, stateid_seq)

			__field(u32, stateid_hash)

		),



		TP_fast_assign(

			__entry->dev = res->server->s_dev;

			__entry->fhandle = nfs_fhandle_hash(args->fhandle);

			__entry->error = error;

			__entry->stateid_seq =

				be32_to_cpu(args->stateid->seqid);

			__entry->stateid_hash =

				nfs_stateid_hash(args->stateid);

		),



		TP_printk(

			"error=%d (%s) dev=%02x:%02x fhandle=0x%08x",

			"error=%d (%s) dev=%02x:%02x fhandle=0x%08x "

			"stateid=%d:0x%08x",

			__entry->error,

			show_nfsv4_errors(__entry->error),

			MAJOR(__entry->dev), MINOR(__entry->dev),

			__entry->fhandle

			__entry->fhandle,

			__entry->stateid_seq, __entry->stateid_hash

		)

);
@@ -653,6 +759,8 @@ DECLARE_EVENT_CLASS(nfs4_test_stateid_event, 
			__field(dev_t, dev)

			__field(u32, fhandle)

			__field(u64, fileid)

			__field(int, stateid_seq)

			__field(u32, stateid_hash)

		),



		TP_fast_assign(
@@ -662,15 +770,21 @@ DECLARE_EVENT_CLASS(nfs4_test_stateid_event, 
			__entry->dev = inode->i_sb->s_dev;

			__entry->fileid = NFS_FILEID(inode);

			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));

			__entry->stateid_seq =

				be32_to_cpu(state->stateid.seqid);

			__entry->stateid_hash =

				nfs_stateid_hash(&state->stateid);

		),



		TP_printk(

			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x",

			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "

			"stateid=%d:0x%08x",

			__entry->error,

			show_nfsv4_errors(__entry->error),

			MAJOR(__entry->dev), MINOR(__entry->dev),

			(unsigned long long)__entry->fileid,

			__entry->fhandle

			__entry->fhandle,

			__entry->stateid_seq, __entry->stateid_hash

		)

);
@@ -820,7 +934,6 @@ DECLARE_EVENT_CLASS(nfs4_inode_event, 
			), \

			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);
@@ -831,7 +944,59 @@ 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);



DECLARE_EVENT_CLASS(nfs4_inode_stateid_event,

		TP_PROTO(

			const struct inode *inode,

			const nfs4_stateid *stateid,

			int error

		),



		TP_ARGS(inode, stateid, error),



		TP_STRUCT__entry(

			__field(dev_t, dev)

			__field(u32, fhandle)

			__field(u64, fileid)

			__field(int, error)

			__field(int, stateid_seq)

			__field(u32, stateid_hash)

		),



		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;

			__entry->stateid_seq =

				be32_to_cpu(stateid->seqid);

			__entry->stateid_hash =

				nfs_stateid_hash(stateid);

		),



		TP_printk(

			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "

			"stateid=%d:0x%08x",

			__entry->error,

			show_nfsv4_errors(__entry->error),

			MAJOR(__entry->dev), MINOR(__entry->dev),

			(unsigned long long)__entry->fileid,

			__entry->fhandle,

			__entry->stateid_seq, __entry->stateid_hash

		)

);



#define DEFINE_NFS4_INODE_STATEID_EVENT(name) \

	DEFINE_EVENT(nfs4_inode_stateid_event, name, \

			TP_PROTO( \

				const struct inode *inode, \

				const nfs4_stateid *stateid, \

				int error \

			), \

			TP_ARGS(inode, stateid, error))



DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_setattr);

DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_delegreturn);



DECLARE_EVENT_CLASS(nfs4_getattr_event,

		TP_PROTO(
@@ -1005,28 +1170,37 @@ DECLARE_EVENT_CLASS(nfs4_read_event, 
			__field(loff_t, offset)

			__field(size_t, count)

			__field(int, error)

			__field(int, stateid_seq)

			__field(u32, stateid_hash)

		),



		TP_fast_assign(

			const struct inode *inode = hdr->inode;

			const struct nfs4_state *state =

				hdr->args.context->state;

			__entry->dev = inode->i_sb->s_dev;

			__entry->fileid = NFS_FILEID(inode);

			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));

			__entry->offset = hdr->args.offset;

			__entry->count = hdr->args.count;

			__entry->error = error;

			__entry->stateid_seq =

				be32_to_cpu(state->stateid.seqid);

			__entry->stateid_hash =

				nfs_stateid_hash(&state->stateid);

		),



		TP_printk(

			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "

			"offset=%lld count=%zu",

			"offset=%lld count=%zu stateid=%d:0x%08x",

			__entry->error,

			show_nfsv4_errors(__entry->error),

			MAJOR(__entry->dev), MINOR(__entry->dev),

			(unsigned long long)__entry->fileid,

			__entry->fhandle,

			(long long)__entry->offset,

			__entry->count

			__entry->count,

			__entry->stateid_seq, __entry->stateid_hash

		)

);

#define DEFINE_NFS4_READ_EVENT(name) \
@@ -1056,28 +1230,37 @@ DECLARE_EVENT_CLASS(nfs4_write_event, 
			__field(loff_t, offset)

			__field(size_t, count)

			__field(int, error)

			__field(int, stateid_seq)

			__field(u32, stateid_hash)

		),



		TP_fast_assign(

			const struct inode *inode = hdr->inode;

			const struct nfs4_state *state =

				hdr->args.context->state;

			__entry->dev = inode->i_sb->s_dev;

			__entry->fileid = NFS_FILEID(inode);

			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));

			__entry->offset = hdr->args.offset;

			__entry->count = hdr->args.count;

			__entry->error = error;

			__entry->stateid_seq =

				be32_to_cpu(state->stateid.seqid);

			__entry->stateid_hash =

				nfs_stateid_hash(&state->stateid);

		),



		TP_printk(

			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "

			"offset=%lld count=%zu",

			"offset=%lld count=%zu stateid=%d:0x%08x",

			__entry->error,

			show_nfsv4_errors(__entry->error),

			MAJOR(__entry->dev), MINOR(__entry->dev),

			(unsigned long long)__entry->fileid,

			__entry->fhandle,

			(long long)__entry->offset,

			__entry->count

			__entry->count,

			__entry->stateid_seq, __entry->stateid_hash

		)

);
@@ -1154,10 +1337,11 @@ TRACE_EVENT(nfs4_layoutget, 
			const struct nfs_open_context *ctx,

			const struct pnfs_layout_range *args,

			const struct pnfs_layout_range *res,

			const nfs4_stateid *layout_stateid,

			int error

		),



		TP_ARGS(ctx, args, res, error),

		TP_ARGS(ctx, args, res, layout_stateid, error),



		TP_STRUCT__entry(

			__field(dev_t, dev)
@@ -1167,10 +1351,15 @@ TRACE_EVENT(nfs4_layoutget, 
			__field(u64, offset)

			__field(u64, count)

			__field(int, error)

			__field(int, stateid_seq)

			__field(u32, stateid_hash)

			__field(int, layoutstateid_seq)

			__field(u32, layoutstateid_hash)

		),



		TP_fast_assign(

			const struct inode *inode = d_inode(ctx->dentry);

			const struct nfs4_state *state = ctx->state;

			__entry->dev = inode->i_sb->s_dev;

			__entry->fileid = NFS_FILEID(inode);

			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
@@ -1178,11 +1367,25 @@ TRACE_EVENT(nfs4_layoutget, 
			__entry->offset = args->offset;

			__entry->count = args->length;

			__entry->error = error;

			__entry->stateid_seq =

				be32_to_cpu(state->stateid.seqid);

			__entry->stateid_hash =

				nfs_stateid_hash(&state->stateid);

			if (!error) {

				__entry->layoutstateid_seq =

				be32_to_cpu(layout_stateid->seqid);

				__entry->layoutstateid_hash =

				nfs_stateid_hash(layout_stateid);

			} else {

				__entry->layoutstateid_seq = 0;

				__entry->layoutstateid_hash = 0;

			}

		),



		TP_printk(

			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "

			"iomode=%s offset=%llu count=%llu",

			"iomode=%s offset=%llu count=%llu stateid=%d:0x%08x "

			"layoutstateid=%d:0x%08x",

			__entry->error,

			show_nfsv4_errors(__entry->error),

			MAJOR(__entry->dev), MINOR(__entry->dev),
@@ -1190,12 +1393,14 @@ TRACE_EVENT(nfs4_layoutget, 
			__entry->fhandle,

			show_pnfs_iomode(__entry->iomode),

			(unsigned long long)__entry->offset,

			(unsigned long long)__entry->count

			(unsigned long long)__entry->count,

			__entry->stateid_seq, __entry->stateid_hash,

			__entry->layoutstateid_seq, __entry->layoutstateid_hash

		)

);



DEFINE_NFS4_INODE_EVENT(nfs4_layoutcommit);

DEFINE_NFS4_INODE_EVENT(nfs4_layoutreturn);

DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutcommit);

DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn);

DEFINE_NFS4_INODE_EVENT(nfs4_layoutreturn_on_close);



#endif /* CONFIG_NFS_V4_1 */