[linux-2.6-block.git] / fs / nfs / nfstrace.h

/*
 * Copyright (c) 2013 Trond Myklebust <Trond.Myklebust@netapp.com>
 */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM nfs

#if !defined(_TRACE_NFS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_NFS_H

#include <linux/tracepoint.h>

#define nfs_show_file_type(ftype) \
	__print_symbolic(ftype, \
			{ DT_UNKNOWN, "UNKNOWN" }, \
			{ DT_FIFO, "FIFO" }, \
			{ DT_CHR, "CHR" }, \
			{ DT_DIR, "DIR" }, \
			{ DT_BLK, "BLK" }, \
			{ DT_REG, "REG" }, \
			{ DT_LNK, "LNK" }, \
			{ DT_SOCK, "SOCK" }, \
			{ DT_WHT, "WHT" })

#define nfs_show_cache_validity(v) \
	__print_flags(v, "|", \
			{ NFS_INO_INVALID_ATTR, "INVALID_ATTR" }, \
			{ NFS_INO_INVALID_DATA, "INVALID_DATA" }, \
			{ NFS_INO_INVALID_ATIME, "INVALID_ATIME" }, \
			{ NFS_INO_INVALID_ACCESS, "INVALID_ACCESS" }, \
			{ NFS_INO_INVALID_ACL, "INVALID_ACL" }, \
			{ NFS_INO_REVAL_PAGECACHE, "REVAL_PAGECACHE" }, \
			{ NFS_INO_REVAL_FORCED, "REVAL_FORCED" }, \
			{ NFS_INO_INVALID_LABEL, "INVALID_LABEL" })

#define nfs_show_nfsi_flags(v) \
	__print_flags(v, "|", \
			{ 1 << NFS_INO_ADVISE_RDPLUS, "ADVISE_RDPLUS" }, \
			{ 1 << NFS_INO_STALE, "STALE" }, \
			{ 1 << NFS_INO_FLUSHING, "FLUSHING" }, \
			{ 1 << NFS_INO_FSCACHE, "FSCACHE" }, \
			{ 1 << NFS_INO_COMMIT, "COMMIT" }, \
			{ 1 << NFS_INO_LAYOUTCOMMIT, "NEED_LAYOUTCOMMIT" }, \
			{ 1 << NFS_INO_LAYOUTCOMMITTING, "LAYOUTCOMMIT" })

DECLARE_EVENT_CLASS(nfs_inode_event,
		TP_PROTO(
			const struct inode *inode
		),

		TP_ARGS(inode),

		TP_STRUCT__entry(
			__field(dev_t, dev)
			__field(u32, fhandle)
			__field(u64, fileid)
			__field(u64, version)
		),

		TP_fast_assign(
			const struct nfs_inode *nfsi = NFS_I(inode);
			__entry->dev = inode->i_sb->s_dev;
			__entry->fileid = nfsi->fileid;
			__entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
			__entry->version = inode->i_version;
		),

		TP_printk(
			"fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu ",
			MAJOR(__entry->dev), MINOR(__entry->dev),
			(unsigned long long)__entry->fileid,
			__entry->fhandle,
			(unsigned long long)__entry->version
		)
);

DECLARE_EVENT_CLASS(nfs_inode_event_done,
		TP_PROTO(
			const struct inode *inode,
			int error
		),

		TP_ARGS(inode, error),

		TP_STRUCT__entry(
			__field(int, error)
			__field(dev_t, dev)
			__field(u32, fhandle)
			__field(unsigned char, type)
			__field(u64, fileid)
			__field(u64, version)
			__field(loff_t, size)
			__field(unsigned long, nfsi_flags)
			__field(unsigned long, cache_validity)
		),

		TP_fast_assign(
			const struct nfs_inode *nfsi = NFS_I(inode);
			__entry->error = error;
			__entry->dev = inode->i_sb->s_dev;
			__entry->fileid = nfsi->fileid;
			__entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
			__entry->type = nfs_umode_to_dtype(inode->i_mode);
			__entry->version = inode->i_version;
			__entry->size = i_size_read(inode);
			__entry->nfsi_flags = nfsi->flags;
			__entry->cache_validity = nfsi->cache_validity;
		),

		TP_printk(
			"error=%d fileid=%02x:%02x:%llu fhandle=0x%08x "
			"type=%u (%s) version=%llu size=%lld "
			"cache_validity=%lu (%s) nfs_flags=%ld (%s)",
			__entry->error,
			MAJOR(__entry->dev), MINOR(__entry->dev),
			(unsigned long long)__entry->fileid,
			__entry->fhandle,
			__entry->type,
			nfs_show_file_type(__entry->type),
			(unsigned long long)__entry->version,
			(long long)__entry->size,
			__entry->cache_validity,
			nfs_show_cache_validity(__entry->cache_validity),
			__entry->nfsi_flags,
			nfs_show_nfsi_flags(__entry->nfsi_flags)
		)
);

#define DEFINE_NFS_INODE_EVENT(name) \
	DEFINE_EVENT(nfs_inode_event, name, \
			TP_PROTO( \
				const struct inode *inode \
			), \
			TP_ARGS(inode))
#define DEFINE_NFS_INODE_EVENT_DONE(name) \
	DEFINE_EVENT(nfs_inode_event_done, name, \
			TP_PROTO( \
				const struct inode *inode, \
				int error \
			), \
			TP_ARGS(inode, error))
DEFINE_NFS_INODE_EVENT(nfs_refresh_inode_enter);
DEFINE_NFS_INODE_EVENT_DONE(nfs_refresh_inode_exit);
DEFINE_NFS_INODE_EVENT(nfs_revalidate_inode_enter);
DEFINE_NFS_INODE_EVENT_DONE(nfs_revalidate_inode_exit);
DEFINE_NFS_INODE_EVENT(nfs_invalidate_mapping_enter);
DEFINE_NFS_INODE_EVENT_DONE(nfs_invalidate_mapping_exit);
DEFINE_NFS_INODE_EVENT(nfs_getattr_enter);
DEFINE_NFS_INODE_EVENT_DONE(nfs_getattr_exit);
DEFINE_NFS_INODE_EVENT(nfs_setattr_enter);
DEFINE_NFS_INODE_EVENT_DONE(nfs_setattr_exit);
DEFINE_NFS_INODE_EVENT(nfs_writeback_page_enter);
DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_page_exit);
DEFINE_NFS_INODE_EVENT(nfs_writeback_inode_enter);
DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_inode_exit);
DEFINE_NFS_INODE_EVENT(nfs_fsync_enter);
DEFINE_NFS_INODE_EVENT_DONE(nfs_fsync_exit);
DEFINE_NFS_INODE_EVENT(nfs_access_enter);
DEFINE_NFS_INODE_EVENT_DONE(nfs_access_exit);

#endif /* _TRACE_NFS_H */

#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH .
#define TRACE_INCLUDE_FILE nfstrace
/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
f4ce1299 TM	1	/*
	2	* Copyright (c) 2013 Trond Myklebust <Trond.Myklebust@netapp.com>
	3	*/
	4	#undef TRACE_SYSTEM
	5	#define TRACE_SYSTEM nfs
	6
	7	#if !defined(_TRACE_NFS_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	8	#define _TRACE_NFS_H
	9
	10	#include <linux/tracepoint.h>
	11
	12	#define nfs_show_file_type(ftype) \
	13	__print_symbolic(ftype, \
	14	{ DT_UNKNOWN, "UNKNOWN" }, \
	15	{ DT_FIFO, "FIFO" }, \
	16	{ DT_CHR, "CHR" }, \
	17	{ DT_DIR, "DIR" }, \
	18	{ DT_BLK, "BLK" }, \
	19	{ DT_REG, "REG" }, \
	20	{ DT_LNK, "LNK" }, \
	21	{ DT_SOCK, "SOCK" }, \
	22	{ DT_WHT, "WHT" })
	23
	24	#define nfs_show_cache_validity(v) \
	25	__print_flags(v, "\|", \
	26	{ NFS_INO_INVALID_ATTR, "INVALID_ATTR" }, \
	27	{ NFS_INO_INVALID_DATA, "INVALID_DATA" }, \
	28	{ NFS_INO_INVALID_ATIME, "INVALID_ATIME" }, \
	29	{ NFS_INO_INVALID_ACCESS, "INVALID_ACCESS" }, \
	30	{ NFS_INO_INVALID_ACL, "INVALID_ACL" }, \
	31	{ NFS_INO_REVAL_PAGECACHE, "REVAL_PAGECACHE" }, \
	32	{ NFS_INO_REVAL_FORCED, "REVAL_FORCED" }, \
	33	{ NFS_INO_INVALID_LABEL, "INVALID_LABEL" })
	34
	35	#define nfs_show_nfsi_flags(v) \
	36	__print_flags(v, "\|", \
	37	{ 1 << NFS_INO_ADVISE_RDPLUS, "ADVISE_RDPLUS" }, \
	38	{ 1 << NFS_INO_STALE, "STALE" }, \
	39	{ 1 << NFS_INO_FLUSHING, "FLUSHING" }, \
	40	{ 1 << NFS_INO_FSCACHE, "FSCACHE" }, \
	41	{ 1 << NFS_INO_COMMIT, "COMMIT" }, \
	42	{ 1 << NFS_INO_LAYOUTCOMMIT, "NEED_LAYOUTCOMMIT" }, \
	43	{ 1 << NFS_INO_LAYOUTCOMMITTING, "LAYOUTCOMMIT" })
	44
	45	DECLARE_EVENT_CLASS(nfs_inode_event,
	46	TP_PROTO(
	47	const struct inode *inode
	48	),
	49
	50	TP_ARGS(inode),
	51
	52	TP_STRUCT__entry(
	53	__field(dev_t, dev)
	54	__field(u32, fhandle)
	55	__field(u64, fileid)
	56	__field(u64, version)
	57	),
	58
	59	TP_fast_assign(
	60	const struct nfs_inode *nfsi = NFS_I(inode);
	61	__entry->dev = inode->i_sb->s_dev;
	62	__entry->fileid = nfsi->fileid;
	63	__entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
	64	__entry->version = inode->i_version;
65	),
66
67	TP_printk(
68	"fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu ",
69	MAJOR(__entry->dev), MINOR(__entry->dev),
70	(unsigned long long)__entry->fileid,
71	__entry->fhandle,
72	(unsigned long long)__entry->version
73	)
74	);
75
76	DECLARE_EVENT_CLASS(nfs_inode_event_done,
77	TP_PROTO(
78	const struct inode *inode,
79	int error
80	),
81
82	TP_ARGS(inode, error),
83
84	TP_STRUCT__entry(
85	__field(int, error)
86	__field(dev_t, dev)
87	__field(u32, fhandle)
88	__field(unsigned char, type)
89	__field(u64, fileid)
90	__field(u64, version)
91	__field(loff_t, size)
92	__field(unsigned long, nfsi_flags)
93	__field(unsigned long, cache_validity)
94	),
95
96	TP_fast_assign(
97	const struct nfs_inode *nfsi = NFS_I(inode);
98	__entry->error = error;
99	__entry->dev = inode->i_sb->s_dev;
100	__entry->fileid = nfsi->fileid;
101	__entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
102	__entry->type = nfs_umode_to_dtype(inode->i_mode);
103	__entry->version = inode->i_version;
104	__entry->size = i_size_read(inode);
105	__entry->nfsi_flags = nfsi->flags;
106	__entry->cache_validity = nfsi->cache_validity;
107	),
108
109	TP_printk(
110	"error=%d fileid=%02x:%02x:%llu fhandle=0x%08x "
111	"type=%u (%s) version=%llu size=%lld "
112	"cache_validity=%lu (%s) nfs_flags=%ld (%s)",
113	__entry->error,
114	MAJOR(__entry->dev), MINOR(__entry->dev),
115	(unsigned long long)__entry->fileid,
116	__entry->fhandle,
117	__entry->type,
118	nfs_show_file_type(__entry->type),
119	(unsigned long long)__entry->version,
120	(long long)__entry->size,
121	__entry->cache_validity,
122	nfs_show_cache_validity(__entry->cache_validity),
123	__entry->nfsi_flags,
124	nfs_show_nfsi_flags(__entry->nfsi_flags)
125	)
126	);
127
128	#define DEFINE_NFS_INODE_EVENT(name) \
129	DEFINE_EVENT(nfs_inode_event, name, \
130	TP_PROTO( \
131	const struct inode *inode \
132	), \
133	TP_ARGS(inode))
134	#define DEFINE_NFS_INODE_EVENT_DONE(name) \
135	DEFINE_EVENT(nfs_inode_event_done, name, \
136	TP_PROTO( \
137	const struct inode *inode, \
138	int error \
139	), \
140	TP_ARGS(inode, error))
141	DEFINE_NFS_INODE_EVENT(nfs_refresh_inode_enter);
142	DEFINE_NFS_INODE_EVENT_DONE(nfs_refresh_inode_exit);
143	DEFINE_NFS_INODE_EVENT(nfs_revalidate_inode_enter);
144	DEFINE_NFS_INODE_EVENT_DONE(nfs_revalidate_inode_exit);
145	DEFINE_NFS_INODE_EVENT(nfs_invalidate_mapping_enter);
146	DEFINE_NFS_INODE_EVENT_DONE(nfs_invalidate_mapping_exit);
147	DEFINE_NFS_INODE_EVENT(nfs_getattr_enter);
148	DEFINE_NFS_INODE_EVENT_DONE(nfs_getattr_exit);
149	DEFINE_NFS_INODE_EVENT(nfs_setattr_enter);
150	DEFINE_NFS_INODE_EVENT_DONE(nfs_setattr_exit);
151	DEFINE_NFS_INODE_EVENT(nfs_writeback_page_enter);
152	DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_page_exit);
153	DEFINE_NFS_INODE_EVENT(nfs_writeback_inode_enter);
154	DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_inode_exit);
155	DEFINE_NFS_INODE_EVENT(nfs_fsync_enter);
156	DEFINE_NFS_INODE_EVENT_DONE(nfs_fsync_exit);
157	DEFINE_NFS_INODE_EVENT(nfs_access_enter);
158	DEFINE_NFS_INODE_EVENT_DONE(nfs_access_exit);
159
160	#endif /* _TRACE_NFS_H */
161
162	#undef TRACE_INCLUDE_PATH
163	#define TRACE_INCLUDE_PATH .
164	#define TRACE_INCLUDE_FILE nfstrace
165	/* This part must be outside protection */
166	#include <trace/define_trace.h>