~hc/RK356X_SDK_RELEASE.git

..	..	@@ -11,6 +11,16 @@
11	11	#include <linux/tracepoint.h>
12	12	#include <linux/iversion.h>
13	13
	14	+TRACE_DEFINE_ENUM(DT_UNKNOWN);
	15	+TRACE_DEFINE_ENUM(DT_FIFO);
	16	+TRACE_DEFINE_ENUM(DT_CHR);
	17	+TRACE_DEFINE_ENUM(DT_DIR);
	18	+TRACE_DEFINE_ENUM(DT_BLK);
	19	+TRACE_DEFINE_ENUM(DT_REG);
	20	+TRACE_DEFINE_ENUM(DT_LNK);
	21	+TRACE_DEFINE_ENUM(DT_SOCK);
	22	+TRACE_DEFINE_ENUM(DT_WHT);
	23	+
14	24	#define nfs_show_file_type(ftype) \
15	25	__print_symbolic(ftype, \
16	26	{ DT_UNKNOWN, "UNKNOWN" }, \
..	..	@@ -23,25 +33,58 @@
23	33	{ DT_SOCK, "SOCK" }, \
24	34	{ DT_WHT, "WHT" })
25	35
	36	+TRACE_DEFINE_ENUM(NFS_INO_INVALID_DATA);
	37	+TRACE_DEFINE_ENUM(NFS_INO_INVALID_ATIME);
	38	+TRACE_DEFINE_ENUM(NFS_INO_INVALID_ACCESS);
	39	+TRACE_DEFINE_ENUM(NFS_INO_INVALID_ACL);
	40	+TRACE_DEFINE_ENUM(NFS_INO_REVAL_PAGECACHE);
	41	+TRACE_DEFINE_ENUM(NFS_INO_REVAL_FORCED);
	42	+TRACE_DEFINE_ENUM(NFS_INO_INVALID_LABEL);
	43	+TRACE_DEFINE_ENUM(NFS_INO_INVALID_CHANGE);
	44	+TRACE_DEFINE_ENUM(NFS_INO_INVALID_CTIME);
	45	+TRACE_DEFINE_ENUM(NFS_INO_INVALID_MTIME);
	46	+TRACE_DEFINE_ENUM(NFS_INO_INVALID_SIZE);
	47	+TRACE_DEFINE_ENUM(NFS_INO_INVALID_OTHER);
	48	+
26	49	#define nfs_show_cache_validity(v) \
27	50	__print_flags(v, "\|", \
28		- { NFS_INO_INVALID_ATTR, "INVALID_ATTR" }, \
29	51	{ NFS_INO_INVALID_DATA, "INVALID_DATA" }, \
30	52	{ NFS_INO_INVALID_ATIME, "INVALID_ATIME" }, \
31	53	{ NFS_INO_INVALID_ACCESS, "INVALID_ACCESS" }, \
32	54	{ NFS_INO_INVALID_ACL, "INVALID_ACL" }, \
33	55	{ NFS_INO_REVAL_PAGECACHE, "REVAL_PAGECACHE" }, \
34	56	{ NFS_INO_REVAL_FORCED, "REVAL_FORCED" }, \
35		- { NFS_INO_INVALID_LABEL, "INVALID_LABEL" })
	57	+ { NFS_INO_INVALID_LABEL, "INVALID_LABEL" }, \
	58	+ { NFS_INO_INVALID_CHANGE, "INVALID_CHANGE" }, \
	59	+ { NFS_INO_INVALID_CTIME, "INVALID_CTIME" }, \
	60	+ { NFS_INO_INVALID_MTIME, "INVALID_MTIME" }, \
	61	+ { NFS_INO_INVALID_SIZE, "INVALID_SIZE" }, \
	62	+ { NFS_INO_INVALID_OTHER, "INVALID_OTHER" }, \
	63	+ { NFS_INO_INVALID_XATTR, "INVALID_XATTR" })
	64	+
	65	+TRACE_DEFINE_ENUM(NFS_INO_ADVISE_RDPLUS);
	66	+TRACE_DEFINE_ENUM(NFS_INO_STALE);
	67	+TRACE_DEFINE_ENUM(NFS_INO_ACL_LRU_SET);
	68	+TRACE_DEFINE_ENUM(NFS_INO_INVALIDATING);
	69	+TRACE_DEFINE_ENUM(NFS_INO_FSCACHE);
	70	+TRACE_DEFINE_ENUM(NFS_INO_FSCACHE_LOCK);
	71	+TRACE_DEFINE_ENUM(NFS_INO_LAYOUTCOMMIT);
	72	+TRACE_DEFINE_ENUM(NFS_INO_LAYOUTCOMMITTING);
	73	+TRACE_DEFINE_ENUM(NFS_INO_LAYOUTSTATS);
	74	+TRACE_DEFINE_ENUM(NFS_INO_ODIRECT);
36	75
37	76	#define nfs_show_nfsi_flags(v) \
38	77	__print_flags(v, "\|", \
39		- { 1 << NFS_INO_ADVISE_RDPLUS, "ADVISE_RDPLUS" }, \
40		- { 1 << NFS_INO_STALE, "STALE" }, \
41		- { 1 << NFS_INO_INVALIDATING, "INVALIDATING" }, \
42		- { 1 << NFS_INO_FSCACHE, "FSCACHE" }, \
43		- { 1 << NFS_INO_LAYOUTCOMMIT, "NEED_LAYOUTCOMMIT" }, \
44		- { 1 << NFS_INO_LAYOUTCOMMITTING, "LAYOUTCOMMIT" })
	78	+ { BIT(NFS_INO_ADVISE_RDPLUS), "ADVISE_RDPLUS" }, \
	79	+ { BIT(NFS_INO_STALE), "STALE" }, \
	80	+ { BIT(NFS_INO_ACL_LRU_SET), "ACL_LRU_SET" }, \
	81	+ { BIT(NFS_INO_INVALIDATING), "INVALIDATING" }, \
	82	+ { BIT(NFS_INO_FSCACHE), "FSCACHE" }, \
	83	+ { BIT(NFS_INO_FSCACHE_LOCK), "FSCACHE_LOCK" }, \
	84	+ { BIT(NFS_INO_LAYOUTCOMMIT), "NEED_LAYOUTCOMMIT" }, \
	85	+ { BIT(NFS_INO_LAYOUTCOMMITTING), "LAYOUTCOMMIT" }, \
	86	+ { BIT(NFS_INO_LAYOUTSTATS), "LAYOUTSTATS" }, \
	87	+ { BIT(NFS_INO_ODIRECT), "ODIRECT" })
45	88
46	89	DECLARE_EVENT_CLASS(nfs_inode_event,
47	90	TP_PROTO(
..	..	@@ -83,7 +126,7 @@
83	126	TP_ARGS(inode, error),
84	127
85	128	TP_STRUCT__entry(
86		- __field(int, error)
	129	+ __field(unsigned long, error)
87	130	__field(dev_t, dev)
88	131	__field(u32, fhandle)
89	132	__field(unsigned char, type)
..	..	@@ -96,7 +139,7 @@
96	139
97	140	TP_fast_assign(
98	141	const struct nfs_inode *nfsi = NFS_I(inode);
99		- __entry->error = error;
	142	+ __entry->error = error < 0 ? -error : 0;
100	143	__entry->dev = inode->i_sb->s_dev;
101	144	__entry->fileid = nfsi->fileid;
102	145	__entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
..	..	@@ -108,10 +151,10 @@
108	151	),
109	152
110	153	TP_printk(
111		- "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x "
	154	+ "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
112	155	"type=%u (%s) version=%llu size=%lld "
113		- "cache_validity=%lu (%s) nfs_flags=%ld (%s)",
114		- __entry->error,
	156	+ "cache_validity=0x%lx (%s) nfs_flags=0x%lx (%s)",
	157	+ -__entry->error, nfs_show_status(__entry->error),
115	158	MAJOR(__entry->dev), MINOR(__entry->dev),
116	159	(unsigned long long)__entry->fileid,
117	160	__entry->fhandle,
..	..	@@ -139,6 +182,7 @@
139	182	int error \
140	183	), \
141	184	TP_ARGS(inode, error))
	185	+DEFINE_NFS_INODE_EVENT(nfs_set_inode_stale);
142	186	DEFINE_NFS_INODE_EVENT(nfs_refresh_inode_enter);
143	187	DEFINE_NFS_INODE_EVENT_DONE(nfs_refresh_inode_exit);
144	188	DEFINE_NFS_INODE_EVENT(nfs_revalidate_inode_enter);
..	..	@@ -156,15 +200,98 @@
156	200	DEFINE_NFS_INODE_EVENT(nfs_fsync_enter);
157	201	DEFINE_NFS_INODE_EVENT_DONE(nfs_fsync_exit);
158	202	DEFINE_NFS_INODE_EVENT(nfs_access_enter);
159		-DEFINE_NFS_INODE_EVENT_DONE(nfs_access_exit);
	203	+
	204	+TRACE_EVENT(nfs_access_exit,
	205	+ TP_PROTO(
	206	+ const struct inode *inode,
	207	+ unsigned int mask,
	208	+ unsigned int permitted,
	209	+ int error
	210	+ ),
	211	+
	212	+ TP_ARGS(inode, mask, permitted, error),
	213	+
	214	+ TP_STRUCT__entry(
	215	+ __field(unsigned long, error)
	216	+ __field(dev_t, dev)
	217	+ __field(u32, fhandle)
	218	+ __field(unsigned char, type)
	219	+ __field(u64, fileid)
	220	+ __field(u64, version)
	221	+ __field(loff_t, size)
	222	+ __field(unsigned long, nfsi_flags)
	223	+ __field(unsigned long, cache_validity)
	224	+ __field(unsigned int, mask)
	225	+ __field(unsigned int, permitted)
	226	+ ),
	227	+
	228	+ TP_fast_assign(
	229	+ const struct nfs_inode *nfsi = NFS_I(inode);
	230	+ __entry->error = error < 0 ? -error : 0;
	231	+ __entry->dev = inode->i_sb->s_dev;
	232	+ __entry->fileid = nfsi->fileid;
	233	+ __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
	234	+ __entry->type = nfs_umode_to_dtype(inode->i_mode);
	235	+ __entry->version = inode_peek_iversion_raw(inode);
	236	+ __entry->size = i_size_read(inode);
	237	+ __entry->nfsi_flags = nfsi->flags;
	238	+ __entry->cache_validity = nfsi->cache_validity;
	239	+ __entry->mask = mask;
	240	+ __entry->permitted = permitted;
	241	+ ),
	242	+
	243	+ TP_printk(
	244	+ "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
	245	+ "type=%u (%s) version=%llu size=%lld "
	246	+ "cache_validity=0x%lx (%s) nfs_flags=0x%lx (%s) "
	247	+ "mask=0x%x permitted=0x%x",
	248	+ -__entry->error, nfs_show_status(__entry->error),
	249	+ MAJOR(__entry->dev), MINOR(__entry->dev),
	250	+ (unsigned long long)__entry->fileid,
	251	+ __entry->fhandle,
	252	+ __entry->type,
	253	+ nfs_show_file_type(__entry->type),
	254	+ (unsigned long long)__entry->version,
	255	+ (long long)__entry->size,
	256	+ __entry->cache_validity,
	257	+ nfs_show_cache_validity(__entry->cache_validity),
	258	+ __entry->nfsi_flags,
	259	+ nfs_show_nfsi_flags(__entry->nfsi_flags),
	260	+ __entry->mask, __entry->permitted
	261	+ )
	262	+);
	263	+
	264	+TRACE_DEFINE_ENUM(LOOKUP_FOLLOW);
	265	+TRACE_DEFINE_ENUM(LOOKUP_DIRECTORY);
	266	+TRACE_DEFINE_ENUM(LOOKUP_AUTOMOUNT);
	267	+TRACE_DEFINE_ENUM(LOOKUP_PARENT);
	268	+TRACE_DEFINE_ENUM(LOOKUP_REVAL);
	269	+TRACE_DEFINE_ENUM(LOOKUP_RCU);
	270	+TRACE_DEFINE_ENUM(LOOKUP_OPEN);
	271	+TRACE_DEFINE_ENUM(LOOKUP_CREATE);
	272	+TRACE_DEFINE_ENUM(LOOKUP_EXCL);
	273	+TRACE_DEFINE_ENUM(LOOKUP_RENAME_TARGET);
	274	+TRACE_DEFINE_ENUM(LOOKUP_JUMPED);
	275	+TRACE_DEFINE_ENUM(LOOKUP_ROOT);
	276	+TRACE_DEFINE_ENUM(LOOKUP_EMPTY);
	277	+TRACE_DEFINE_ENUM(LOOKUP_DOWN);
160	278
161	279	#define show_lookup_flags(flags) \
162		- __print_flags((unsigned long)flags, "\|", \
163		- { LOOKUP_AUTOMOUNT, "AUTOMOUNT" }, \
	280	+ __print_flags(flags, "\|", \
	281	+ { LOOKUP_FOLLOW, "FOLLOW" }, \
164	282	{ LOOKUP_DIRECTORY, "DIRECTORY" }, \
	283	+ { LOOKUP_AUTOMOUNT, "AUTOMOUNT" }, \
	284	+ { LOOKUP_PARENT, "PARENT" }, \
	285	+ { LOOKUP_REVAL, "REVAL" }, \
	286	+ { LOOKUP_RCU, "RCU" }, \
165	287	{ LOOKUP_OPEN, "OPEN" }, \
166	288	{ LOOKUP_CREATE, "CREATE" }, \
167		- { LOOKUP_EXCL, "EXCL" })
	289	+ { LOOKUP_EXCL, "EXCL" }, \
	290	+ { LOOKUP_RENAME_TARGET, "RENAME_TARGET" }, \
	291	+ { LOOKUP_JUMPED, "JUMPED" }, \
	292	+ { LOOKUP_ROOT, "ROOT" }, \
	293	+ { LOOKUP_EMPTY, "EMPTY" }, \
	294	+ { LOOKUP_DOWN, "DOWN" })
168	295
169	296	DECLARE_EVENT_CLASS(nfs_lookup_event,
170	297	TP_PROTO(
..	..	@@ -176,7 +303,7 @@
176	303	TP_ARGS(dir, dentry, flags),
177	304
178	305	TP_STRUCT__entry(
179		- __field(unsigned int, flags)
	306	+ __field(unsigned long, flags)
180	307	__field(dev_t, dev)
181	308	__field(u64, dir)
182	309	__string(name, dentry->d_name.name)
..	..	@@ -190,7 +317,7 @@
190	317	),
191	318
192	319	TP_printk(
193		- "flags=%u (%s) name=%02x:%02x:%llu/%s",
	320	+ "flags=0x%lx (%s) name=%02x:%02x:%llu/%s",
194	321	__entry->flags,
195	322	show_lookup_flags(__entry->flags),
196	323	MAJOR(__entry->dev), MINOR(__entry->dev),
..	..	@@ -219,8 +346,8 @@
219	346	TP_ARGS(dir, dentry, flags, error),
220	347
221	348	TP_STRUCT__entry(
222		- __field(int, error)
223		- __field(unsigned int, flags)
	349	+ __field(unsigned long, error)
	350	+ __field(unsigned long, flags)
224	351	__field(dev_t, dev)
225	352	__field(u64, dir)
226	353	__string(name, dentry->d_name.name)
..	..	@@ -229,14 +356,14 @@
229	356	TP_fast_assign(
230	357	__entry->dev = dir->i_sb->s_dev;
231	358	__entry->dir = NFS_FILEID(dir);
232		- __entry->error = error;
	359	+ __entry->error = error < 0 ? -error : 0;
233	360	__entry->flags = flags;
234	361	__assign_str(name, dentry->d_name.name);
235	362	),
236	363
237	364	TP_printk(
238		- "error=%d flags=%u (%s) name=%02x:%02x:%llu/%s",
239		- __entry->error,
	365	+ "error=%ld (%s) flags=0x%lx (%s) name=%02x:%02x:%llu/%s",
	366	+ -__entry->error, nfs_show_status(__entry->error),
240	367	__entry->flags,
241	368	show_lookup_flags(__entry->flags),
242	369	MAJOR(__entry->dev), MINOR(__entry->dev),
..	..	@@ -260,15 +387,43 @@
260	387	DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_revalidate_enter);
261	388	DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_revalidate_exit);
262	389
	390	+TRACE_DEFINE_ENUM(O_WRONLY);
	391	+TRACE_DEFINE_ENUM(O_RDWR);
	392	+TRACE_DEFINE_ENUM(O_CREAT);
	393	+TRACE_DEFINE_ENUM(O_EXCL);
	394	+TRACE_DEFINE_ENUM(O_NOCTTY);
	395	+TRACE_DEFINE_ENUM(O_TRUNC);
	396	+TRACE_DEFINE_ENUM(O_APPEND);
	397	+TRACE_DEFINE_ENUM(O_NONBLOCK);
	398	+TRACE_DEFINE_ENUM(O_DSYNC);
	399	+TRACE_DEFINE_ENUM(O_DIRECT);
	400	+TRACE_DEFINE_ENUM(O_LARGEFILE);
	401	+TRACE_DEFINE_ENUM(O_DIRECTORY);
	402	+TRACE_DEFINE_ENUM(O_NOFOLLOW);
	403	+TRACE_DEFINE_ENUM(O_NOATIME);
	404	+TRACE_DEFINE_ENUM(O_CLOEXEC);
	405	+
263	406	#define show_open_flags(flags) \
264		- __print_flags((unsigned long)flags, "\|", \
	407	+ __print_flags(flags, "\|", \
	408	+ { O_WRONLY, "O_WRONLY" }, \
	409	+ { O_RDWR, "O_RDWR" }, \
265	410	{ O_CREAT, "O_CREAT" }, \
266	411	{ O_EXCL, "O_EXCL" }, \
	412	+ { O_NOCTTY, "O_NOCTTY" }, \
267	413	{ O_TRUNC, "O_TRUNC" }, \
268	414	{ O_APPEND, "O_APPEND" }, \
	415	+ { O_NONBLOCK, "O_NONBLOCK" }, \
269	416	{ O_DSYNC, "O_DSYNC" }, \
270	417	{ O_DIRECT, "O_DIRECT" }, \
271		- { O_DIRECTORY, "O_DIRECTORY" })
	418	+ { O_LARGEFILE, "O_LARGEFILE" }, \
	419	+ { O_DIRECTORY, "O_DIRECTORY" }, \
	420	+ { O_NOFOLLOW, "O_NOFOLLOW" }, \
	421	+ { O_NOATIME, "O_NOATIME" }, \
	422	+ { O_CLOEXEC, "O_CLOEXEC" })
	423	+
	424	+TRACE_DEFINE_ENUM(FMODE_READ);
	425	+TRACE_DEFINE_ENUM(FMODE_WRITE);
	426	+TRACE_DEFINE_ENUM(FMODE_EXEC);
272	427
273	428	#define show_fmode_flags(mode) \
274	429	__print_flags(mode, "\|", \
..	..	@@ -286,7 +441,7 @@
286	441	TP_ARGS(dir, ctx, flags),
287	442
288	443	TP_STRUCT__entry(
289		- __field(unsigned int, flags)
	444	+ __field(unsigned long, flags)
290	445	__field(unsigned int, fmode)
291	446	__field(dev_t, dev)
292	447	__field(u64, dir)
..	..	@@ -302,7 +457,7 @@
302	457	),
303	458
304	459	TP_printk(
305		- "flags=%u (%s) fmode=%s name=%02x:%02x:%llu/%s",
	460	+ "flags=0x%lx (%s) fmode=%s name=%02x:%02x:%llu/%s",
306	461	__entry->flags,
307	462	show_open_flags(__entry->flags),
308	463	show_fmode_flags(__entry->fmode),
..	..	@@ -323,8 +478,8 @@
323	478	TP_ARGS(dir, ctx, flags, error),
324	479
325	480	TP_STRUCT__entry(
326		- __field(int, error)
327		- __field(unsigned int, flags)
	481	+ __field(unsigned long, error)
	482	+ __field(unsigned long, flags)
328	483	__field(unsigned int, fmode)
329	484	__field(dev_t, dev)
330	485	__field(u64, dir)
..	..	@@ -332,7 +487,7 @@
332	487	),
333	488
334	489	TP_fast_assign(
335		- __entry->error = error;
	490	+ __entry->error = -error;
336	491	__entry->dev = dir->i_sb->s_dev;
337	492	__entry->dir = NFS_FILEID(dir);
338	493	__entry->flags = flags;
..	..	@@ -341,9 +496,9 @@
341	496	),
342	497
343	498	TP_printk(
344		- "error=%d flags=%u (%s) fmode=%s "
	499	+ "error=%ld (%s) flags=0x%lx (%s) fmode=%s "
345	500	"name=%02x:%02x:%llu/%s",
346		- __entry->error,
	501	+ -__entry->error, nfs_show_status(__entry->error),
347	502	__entry->flags,
348	503	show_open_flags(__entry->flags),
349	504	show_fmode_flags(__entry->fmode),
..	..	@@ -363,7 +518,7 @@
363	518	TP_ARGS(dir, dentry, flags),
364	519
365	520	TP_STRUCT__entry(
366		- __field(unsigned int, flags)
	521	+ __field(unsigned long, flags)
367	522	__field(dev_t, dev)
368	523	__field(u64, dir)
369	524	__string(name, dentry->d_name.name)
..	..	@@ -377,7 +532,7 @@
377	532	),
378	533
379	534	TP_printk(
380		- "flags=%u (%s) name=%02x:%02x:%llu/%s",
	535	+ "flags=0x%lx (%s) name=%02x:%02x:%llu/%s",
381	536	__entry->flags,
382	537	show_open_flags(__entry->flags),
383	538	MAJOR(__entry->dev), MINOR(__entry->dev),
..	..	@@ -397,15 +552,15 @@
397	552	TP_ARGS(dir, dentry, flags, error),
398	553
399	554	TP_STRUCT__entry(
400		- __field(int, error)
401		- __field(unsigned int, flags)
	555	+ __field(unsigned long, error)
	556	+ __field(unsigned long, flags)
402	557	__field(dev_t, dev)
403	558	__field(u64, dir)
404	559	__string(name, dentry->d_name.name)
405	560	),
406	561
407	562	TP_fast_assign(
408		- __entry->error = error;
	563	+ __entry->error = -error;
409	564	__entry->dev = dir->i_sb->s_dev;
410	565	__entry->dir = NFS_FILEID(dir);
411	566	__entry->flags = flags;
..	..	@@ -413,8 +568,8 @@
413	568	),
414	569
415	570	TP_printk(
416		- "error=%d flags=%u (%s) name=%02x:%02x:%llu/%s",
417		- __entry->error,
	571	+ "error=%ld (%s) flags=0x%lx (%s) name=%02x:%02x:%llu/%s",
	572	+ -__entry->error, nfs_show_status(__entry->error),
418	573	__entry->flags,
419	574	show_open_flags(__entry->flags),
420	575	MAJOR(__entry->dev), MINOR(__entry->dev),
..	..	@@ -469,7 +624,7 @@
469	624	TP_ARGS(dir, dentry, error),
470	625
471	626	TP_STRUCT__entry(
472		- __field(int, error)
	627	+ __field(unsigned long, error)
473	628	__field(dev_t, dev)
474	629	__field(u64, dir)
475	630	__string(name, dentry->d_name.name)
..	..	@@ -478,13 +633,13 @@
478	633	TP_fast_assign(
479	634	__entry->dev = dir->i_sb->s_dev;
480	635	__entry->dir = NFS_FILEID(dir);
481		- __entry->error = error;
	636	+ __entry->error = error < 0 ? -error : 0;
482	637	__assign_str(name, dentry->d_name.name);
483	638	),
484	639
485	640	TP_printk(
486		- "error=%d name=%02x:%02x:%llu/%s",
487		- __entry->error,
	641	+ "error=%ld (%s) name=%02x:%02x:%llu/%s",
	642	+ -__entry->error, nfs_show_status(__entry->error),
488	643	MAJOR(__entry->dev), MINOR(__entry->dev),
489	644	(unsigned long long)__entry->dir,
490	645	__get_str(name)
..	..	@@ -557,7 +712,7 @@
557	712	TP_ARGS(inode, dir, dentry, error),
558	713
559	714	TP_STRUCT__entry(
560		- __field(int, error)
	715	+ __field(unsigned long, error)
561	716	__field(dev_t, dev)
562	717	__field(u64, fileid)
563	718	__field(u64, dir)
..	..	@@ -568,13 +723,13 @@
568	723	__entry->dev = inode->i_sb->s_dev;
569	724	__entry->fileid = NFS_FILEID(inode);
570	725	__entry->dir = NFS_FILEID(dir);
571		- __entry->error = error;
	726	+ __entry->error = error < 0 ? -error : 0;
572	727	__assign_str(name, dentry->d_name.name);
573	728	),
574	729
575	730	TP_printk(
576		- "error=%d fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s",
577		- __entry->error,
	731	+ "error=%ld (%s) fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s",
	732	+ -__entry->error, nfs_show_status(__entry->error),
578	733	MAJOR(__entry->dev), MINOR(__entry->dev),
579	734	__entry->fileid,
580	735	MAJOR(__entry->dev), MINOR(__entry->dev),
..	..	@@ -642,7 +797,7 @@
642	797
643	798	TP_STRUCT__entry(
644	799	__field(dev_t, dev)
645		- __field(int, error)
	800	+ __field(unsigned long, error)
646	801	__field(u64, old_dir)
647	802	__string(old_name, old_dentry->d_name.name)
648	803	__field(u64, new_dir)
..	..	@@ -651,17 +806,17 @@
651	806
652	807	TP_fast_assign(
653	808	__entry->dev = old_dir->i_sb->s_dev;
	809	+ __entry->error = -error;
654	810	__entry->old_dir = NFS_FILEID(old_dir);
655	811	__entry->new_dir = NFS_FILEID(new_dir);
656		- __entry->error = error;
657	812	__assign_str(old_name, old_dentry->d_name.name);
658	813	__assign_str(new_name, new_dentry->d_name.name);
659	814	),
660	815
661	816	TP_printk(
662		- "error=%d old_name=%02x:%02x:%llu/%s "
	817	+ "error=%ld (%s) old_name=%02x:%02x:%llu/%s "
663	818	"new_name=%02x:%02x:%llu/%s",
664		- __entry->error,
	819	+ -__entry->error, nfs_show_status(__entry->error),
665	820	MAJOR(__entry->dev), MINOR(__entry->dev),
666	821	(unsigned long long)__entry->old_dir,
667	822	__get_str(old_name),
..	..	@@ -697,7 +852,7 @@
697	852
698	853	TP_STRUCT__entry(
699	854	__field(dev_t, dev)
700		- __field(int, error)
	855	+ __field(unsigned long, error)
701	856	__field(u64, dir)
702	857	__dynamic_array(char, name, data->args.name.len + 1)
703	858	),
..	..	@@ -707,15 +862,15 @@
707	862	size_t len = data->args.name.len;
708	863	__entry->dev = dir->i_sb->s_dev;
709	864	__entry->dir = NFS_FILEID(dir);
710		- __entry->error = error;
	865	+ __entry->error = -error;
711	866	memcpy(__get_str(name),
712	867	data->args.name.name, len);
713	868	__get_str(name)[len] = 0;
714	869	),
715	870
716	871	TP_printk(
717		- "error=%d name=%02x:%02x:%llu/%s",
718		- __entry->error,
	872	+ "error=%ld (%s) name=%02x:%02x:%llu/%s",
	873	+ -__entry->error, nfs_show_status(__entry->error),
719	874	MAJOR(__entry->dev), MINOR(__entry->dev),
720	875	(unsigned long long)__entry->dir,
721	876	__get_str(name)
..	..	@@ -724,77 +879,178 @@
724	879
725	880	TRACE_EVENT(nfs_initiate_read,
726	881	TP_PROTO(
727		- const struct inode *inode,
728		- loff_t offset, unsigned long count
	882	+ const struct nfs_pgio_header *hdr
729	883	),
730	884
731		- TP_ARGS(inode, offset, count),
	885	+ TP_ARGS(hdr),
732	886
733	887	TP_STRUCT__entry(
734		- __field(loff_t, offset)
735		- __field(unsigned long, count)
736	888	__field(dev_t, dev)
737	889	__field(u32, fhandle)
738	890	__field(u64, fileid)
	891	+ __field(loff_t, offset)
	892	+ __field(u32, count)
739	893	),
740	894
741	895	TP_fast_assign(
	896	+ const struct inode *inode = hdr->inode;
742	897	const struct nfs_inode *nfsi = NFS_I(inode);
	898	+ const struct nfs_fh *fh = hdr->args.fh ?
	899	+ hdr->args.fh : &nfsi->fh;
743	900
744		- __entry->offset = offset;
745		- __entry->count = count;
	901	+ __entry->offset = hdr->args.offset;
	902	+ __entry->count = hdr->args.count;
746	903	__entry->dev = inode->i_sb->s_dev;
747	904	__entry->fileid = nfsi->fileid;
748		- __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
	905	+ __entry->fhandle = nfs_fhandle_hash(fh);
749	906	),
750	907
751	908	TP_printk(
752	909	"fileid=%02x:%02x:%llu fhandle=0x%08x "
753		- "offset=%lld count=%lu",
	910	+ "offset=%lld count=%u",
754	911	MAJOR(__entry->dev), MINOR(__entry->dev),
755	912	(unsigned long long)__entry->fileid,
756	913	__entry->fhandle,
757		- __entry->offset, __entry->count
	914	+ (long long)__entry->offset, __entry->count
758	915	)
759	916	);
760	917
761	918	TRACE_EVENT(nfs_readpage_done,
762	919	TP_PROTO(
763		- const struct inode *inode,
764		- int status, loff_t offset, bool eof
	920	+ const struct rpc_task *task,
	921	+ const struct nfs_pgio_header *hdr
765	922	),
766	923
767		- TP_ARGS(inode, status, offset, eof),
	924	+ TP_ARGS(task, hdr),
768	925
769	926	TP_STRUCT__entry(
770		- __field(int, status)
771		- __field(loff_t, offset)
772		- __field(bool, eof)
773	927	__field(dev_t, dev)
774	928	__field(u32, fhandle)
775	929	__field(u64, fileid)
	930	+ __field(loff_t, offset)
	931	+ __field(u32, arg_count)
	932	+ __field(u32, res_count)
	933	+ __field(bool, eof)
	934	+ __field(int, status)
776	935	),
777	936
778	937	TP_fast_assign(
	938	+ const struct inode *inode = hdr->inode;
779	939	const struct nfs_inode *nfsi = NFS_I(inode);
	940	+ const struct nfs_fh *fh = hdr->args.fh ?
	941	+ hdr->args.fh : &nfsi->fh;
780	942
781		- __entry->status = status;
782		- __entry->offset = offset;
783		- __entry->eof = eof;
	943	+ __entry->status = task->tk_status;
	944	+ __entry->offset = hdr->args.offset;
	945	+ __entry->arg_count = hdr->args.count;
	946	+ __entry->res_count = hdr->res.count;
	947	+ __entry->eof = hdr->res.eof;
784	948	__entry->dev = inode->i_sb->s_dev;
785	949	__entry->fileid = nfsi->fileid;
786		- __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
	950	+ __entry->fhandle = nfs_fhandle_hash(fh);
787	951	),
788	952
789	953	TP_printk(
790	954	"fileid=%02x:%02x:%llu fhandle=0x%08x "
791		- "offset=%lld status=%d%s",
	955	+ "offset=%lld count=%u res=%u status=%d%s",
792	956	MAJOR(__entry->dev), MINOR(__entry->dev),
793	957	(unsigned long long)__entry->fileid,
794	958	__entry->fhandle,
795		- __entry->offset, __entry->status,
	959	+ (long long)__entry->offset, __entry->arg_count,
	960	+ __entry->res_count, __entry->status,
796	961	__entry->eof ? " eof" : ""
797	962	)
	963	+);
	964	+
	965	+TRACE_EVENT(nfs_readpage_short,
	966	+ TP_PROTO(
	967	+ const struct rpc_task *task,
	968	+ const struct nfs_pgio_header *hdr
	969	+ ),
	970	+
	971	+ TP_ARGS(task, hdr),
	972	+
	973	+ TP_STRUCT__entry(
	974	+ __field(dev_t, dev)
	975	+ __field(u32, fhandle)
	976	+ __field(u64, fileid)
	977	+ __field(loff_t, offset)
	978	+ __field(u32, arg_count)
	979	+ __field(u32, res_count)
	980	+ __field(bool, eof)
	981	+ __field(int, status)
	982	+ ),
	983	+
	984	+ TP_fast_assign(
	985	+ const struct inode *inode = hdr->inode;
	986	+ const struct nfs_inode *nfsi = NFS_I(inode);
	987	+ const struct nfs_fh *fh = hdr->args.fh ?
	988	+ hdr->args.fh : &nfsi->fh;
	989	+
	990	+ __entry->status = task->tk_status;
	991	+ __entry->offset = hdr->args.offset;
	992	+ __entry->arg_count = hdr->args.count;
	993	+ __entry->res_count = hdr->res.count;
	994	+ __entry->eof = hdr->res.eof;
	995	+ __entry->dev = inode->i_sb->s_dev;
	996	+ __entry->fileid = nfsi->fileid;
	997	+ __entry->fhandle = nfs_fhandle_hash(fh);
	998	+ ),
	999	+
	1000	+ TP_printk(
	1001	+ "fileid=%02x:%02x:%llu fhandle=0x%08x "
	1002	+ "offset=%lld count=%u res=%u status=%d%s",
	1003	+ MAJOR(__entry->dev), MINOR(__entry->dev),
	1004	+ (unsigned long long)__entry->fileid,
	1005	+ __entry->fhandle,
	1006	+ (long long)__entry->offset, __entry->arg_count,
	1007	+ __entry->res_count, __entry->status,
	1008	+ __entry->eof ? " eof" : ""
	1009	+ )
	1010	+);
	1011	+
	1012	+TRACE_EVENT(nfs_pgio_error,
	1013	+ TP_PROTO(
	1014	+ const struct nfs_pgio_header *hdr,
	1015	+ int error,
	1016	+ loff_t pos
	1017	+ ),
	1018	+
	1019	+ TP_ARGS(hdr, error, pos),
	1020	+
	1021	+ TP_STRUCT__entry(
	1022	+ __field(dev_t, dev)
	1023	+ __field(u32, fhandle)
	1024	+ __field(u64, fileid)
	1025	+ __field(loff_t, offset)
	1026	+ __field(u32, arg_count)
	1027	+ __field(u32, res_count)
	1028	+ __field(loff_t, pos)
	1029	+ __field(int, status)
	1030	+ ),
	1031	+
	1032	+ TP_fast_assign(
	1033	+ const struct inode *inode = hdr->inode;
	1034	+ const struct nfs_inode *nfsi = NFS_I(inode);
	1035	+ const struct nfs_fh *fh = hdr->args.fh ?
	1036	+ hdr->args.fh : &nfsi->fh;
	1037	+
	1038	+ __entry->status = error;
	1039	+ __entry->offset = hdr->args.offset;
	1040	+ __entry->arg_count = hdr->args.count;
	1041	+ __entry->res_count = hdr->res.count;
	1042	+ __entry->dev = inode->i_sb->s_dev;
	1043	+ __entry->fileid = nfsi->fileid;
	1044	+ __entry->fhandle = nfs_fhandle_hash(fh);
	1045	+ ),
	1046	+
	1047	+ TP_printk("fileid=%02x:%02x:%llu fhandle=0x%08x "
	1048	+ "offset=%lld count=%u res=%u pos=%llu status=%d",
	1049	+ MAJOR(__entry->dev), MINOR(__entry->dev),
	1050	+ (unsigned long long)__entry->fileid, __entry->fhandle,
	1051	+ (long long)__entry->offset, __entry->arg_count, __entry->res_count,
	1052	+ __entry->pos, __entry->status
	1053	+ )
798	1054	);
799	1055
800	1056	TRACE_DEFINE_ENUM(NFS_UNSTABLE);
..	..	@@ -809,89 +1065,143 @@
809	1065
810	1066	TRACE_EVENT(nfs_initiate_write,
811	1067	TP_PROTO(
812		- const struct inode *inode,
813		- loff_t offset, unsigned long count,
814		- enum nfs3_stable_how stable
	1068	+ const struct nfs_pgio_header *hdr
815	1069	),
816	1070
817		- TP_ARGS(inode, offset, count, stable),
	1071	+ TP_ARGS(hdr),
818	1072
819	1073	TP_STRUCT__entry(
820		- __field(loff_t, offset)
821		- __field(unsigned long, count)
822		- __field(enum nfs3_stable_how, stable)
823	1074	__field(dev_t, dev)
824	1075	__field(u32, fhandle)
825	1076	__field(u64, fileid)
	1077	+ __field(loff_t, offset)
	1078	+ __field(u32, count)
	1079	+ __field(enum nfs3_stable_how, stable)
826	1080	),
827	1081
828	1082	TP_fast_assign(
	1083	+ const struct inode *inode = hdr->inode;
829	1084	const struct nfs_inode *nfsi = NFS_I(inode);
	1085	+ const struct nfs_fh *fh = hdr->args.fh ?
	1086	+ hdr->args.fh : &nfsi->fh;
830	1087
831		- __entry->offset = offset;
832		- __entry->count = count;
833		- __entry->stable = stable;
	1088	+ __entry->offset = hdr->args.offset;
	1089	+ __entry->count = hdr->args.count;
	1090	+ __entry->stable = hdr->args.stable;
834	1091	__entry->dev = inode->i_sb->s_dev;
835	1092	__entry->fileid = nfsi->fileid;
836		- __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
	1093	+ __entry->fhandle = nfs_fhandle_hash(fh);
837	1094	),
838	1095
839	1096	TP_printk(
840	1097	"fileid=%02x:%02x:%llu fhandle=0x%08x "
841		- "offset=%lld count=%lu stable=%s",
	1098	+ "offset=%lld count=%u stable=%s",
842	1099	MAJOR(__entry->dev), MINOR(__entry->dev),
843	1100	(unsigned long long)__entry->fileid,
844	1101	__entry->fhandle,
845		- __entry->offset, __entry->count,
	1102	+ (long long)__entry->offset, __entry->count,
846	1103	nfs_show_stable(__entry->stable)
847	1104	)
848	1105	);
849	1106
850	1107	TRACE_EVENT(nfs_writeback_done,
851	1108	TP_PROTO(
852		- const struct inode *inode,
853		- int status,
854		- loff_t offset,
855		- struct nfs_writeverf *writeverf
	1109	+ const struct rpc_task *task,
	1110	+ const struct nfs_pgio_header *hdr
856	1111	),
857	1112
858		- TP_ARGS(inode, status, offset, writeverf),
	1113	+ TP_ARGS(task, hdr),
859	1114
860	1115	TP_STRUCT__entry(
861		- __field(int, status)
862		- __field(loff_t, offset)
863		- __field(enum nfs3_stable_how, stable)
864		- __field(unsigned long long, verifier)
865	1116	__field(dev_t, dev)
866	1117	__field(u32, fhandle)
867	1118	__field(u64, fileid)
	1119	+ __field(loff_t, offset)
	1120	+ __field(u32, arg_count)
	1121	+ __field(u32, res_count)
	1122	+ __field(int, status)
	1123	+ __field(enum nfs3_stable_how, stable)
	1124	+ __array(char, verifier, NFS4_VERIFIER_SIZE)
868	1125	),
869	1126
870	1127	TP_fast_assign(
	1128	+ const struct inode *inode = hdr->inode;
871	1129	const struct nfs_inode *nfsi = NFS_I(inode);
	1130	+ const struct nfs_fh *fh = hdr->args.fh ?
	1131	+ hdr->args.fh : &nfsi->fh;
	1132	+ const struct nfs_writeverf *verf = hdr->res.verf;
872	1133
873		- __entry->status = status;
874		- __entry->offset = offset;
875		- __entry->stable = writeverf->committed;
876		- memcpy(&__entry->verifier, &writeverf->verifier,
877		- sizeof(__entry->verifier));
	1134	+ __entry->status = task->tk_status;
	1135	+ __entry->offset = hdr->args.offset;
	1136	+ __entry->arg_count = hdr->args.count;
	1137	+ __entry->res_count = hdr->res.count;
	1138	+ __entry->stable = verf->committed;
	1139	+ memcpy(__entry->verifier,
	1140	+ &verf->verifier,
	1141	+ NFS4_VERIFIER_SIZE);
878	1142	__entry->dev = inode->i_sb->s_dev;
879	1143	__entry->fileid = nfsi->fileid;
880		- __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
	1144	+ __entry->fhandle = nfs_fhandle_hash(fh);
881	1145	),
882	1146
883	1147	TP_printk(
884	1148	"fileid=%02x:%02x:%llu fhandle=0x%08x "
885		- "offset=%lld status=%d stable=%s "
886		- "verifier 0x%016llx",
	1149	+ "offset=%lld count=%u res=%u status=%d stable=%s "
	1150	+ "verifier=%s",
887	1151	MAJOR(__entry->dev), MINOR(__entry->dev),
888	1152	(unsigned long long)__entry->fileid,
889	1153	__entry->fhandle,
890		- __entry->offset, __entry->status,
	1154	+ (long long)__entry->offset, __entry->arg_count,
	1155	+ __entry->res_count, __entry->status,
891	1156	nfs_show_stable(__entry->stable),
892		- __entry->verifier
	1157	+ __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE)
893	1158	)
894	1159	);
	1160	+
	1161	+DECLARE_EVENT_CLASS(nfs_page_error_class,
	1162	+ TP_PROTO(
	1163	+ const struct nfs_page *req,
	1164	+ int error
	1165	+ ),
	1166	+
	1167	+ TP_ARGS(req, error),
	1168	+
	1169	+ TP_STRUCT__entry(
	1170	+ __field(const void *, req)
	1171	+ __field(pgoff_t, index)
	1172	+ __field(unsigned int, offset)
	1173	+ __field(unsigned int, pgbase)
	1174	+ __field(unsigned int, bytes)
	1175	+ __field(int, error)
	1176	+ ),
	1177	+
	1178	+ TP_fast_assign(
	1179	+ __entry->req = req;
	1180	+ __entry->index = req->wb_index;
	1181	+ __entry->offset = req->wb_offset;
	1182	+ __entry->pgbase = req->wb_pgbase;
	1183	+ __entry->bytes = req->wb_bytes;
	1184	+ __entry->error = error;
	1185	+ ),
	1186	+
	1187	+ TP_printk(
	1188	+ "req=%p index=%lu offset=%u pgbase=%u bytes=%u error=%d",
	1189	+ __entry->req, __entry->index, __entry->offset,
	1190	+ __entry->pgbase, __entry->bytes, __entry->error
	1191	+ )
	1192	+);
	1193	+
	1194	+#define DEFINE_NFS_PAGEERR_EVENT(name) \
	1195	+ DEFINE_EVENT(nfs_page_error_class, name, \
	1196	+ TP_PROTO( \
	1197	+ const struct nfs_page *req, \
	1198	+ int error \
	1199	+ ), \
	1200	+ TP_ARGS(req, error))
	1201	+
	1202	+DEFINE_NFS_PAGEERR_EVENT(nfs_write_error);
	1203	+DEFINE_NFS_PAGEERR_EVENT(nfs_comp_error);
	1204	+DEFINE_NFS_PAGEERR_EVENT(nfs_commit_error);
895	1205
896	1206	TRACE_EVENT(nfs_initiate_commit,
897	1207	TP_PROTO(
..	..	@@ -901,71 +1211,227 @@
901	1211	TP_ARGS(data),
902	1212
903	1213	TP_STRUCT__entry(
904		- __field(loff_t, offset)
905		- __field(unsigned long, count)
906	1214	__field(dev_t, dev)
907	1215	__field(u32, fhandle)
908	1216	__field(u64, fileid)
	1217	+ __field(loff_t, offset)
	1218	+ __field(u32, count)
909	1219	),
910	1220
911	1221	TP_fast_assign(
912	1222	const struct inode *inode = data->inode;
913	1223	const struct nfs_inode *nfsi = NFS_I(inode);
	1224	+ const struct nfs_fh *fh = data->args.fh ?
	1225	+ data->args.fh : &nfsi->fh;
914	1226
915	1227	__entry->offset = data->args.offset;
916	1228	__entry->count = data->args.count;
917	1229	__entry->dev = inode->i_sb->s_dev;
918	1230	__entry->fileid = nfsi->fileid;
919		- __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
	1231	+ __entry->fhandle = nfs_fhandle_hash(fh);
920	1232	),
921	1233
922	1234	TP_printk(
923	1235	"fileid=%02x:%02x:%llu fhandle=0x%08x "
924		- "offset=%lld count=%lu",
	1236	+ "offset=%lld count=%u",
925	1237	MAJOR(__entry->dev), MINOR(__entry->dev),
926	1238	(unsigned long long)__entry->fileid,
927	1239	__entry->fhandle,
928		- __entry->offset, __entry->count
	1240	+ (long long)__entry->offset, __entry->count
929	1241	)
930	1242	);
931	1243
932	1244	TRACE_EVENT(nfs_commit_done,
933	1245	TP_PROTO(
	1246	+ const struct rpc_task *task,
934	1247	const struct nfs_commit_data *data
935	1248	),
936	1249
937		- TP_ARGS(data),
	1250	+ TP_ARGS(task, data),
938	1251
939	1252	TP_STRUCT__entry(
940		- __field(int, status)
	1253	+ __field(dev_t, dev)
	1254	+ __field(u32, fhandle)
	1255	+ __field(u64, fileid)
941	1256	__field(loff_t, offset)
942		- __field(unsigned long long, verifier)
	1257	+ __field(int, status)
	1258	+ __field(enum nfs3_stable_how, stable)
	1259	+ __array(char, verifier, NFS4_VERIFIER_SIZE)
	1260	+ ),
	1261	+
	1262	+ TP_fast_assign(
	1263	+ const struct inode *inode = data->inode;
	1264	+ const struct nfs_inode *nfsi = NFS_I(inode);
	1265	+ const struct nfs_fh *fh = data->args.fh ?
	1266	+ data->args.fh : &nfsi->fh;
	1267	+ const struct nfs_writeverf *verf = data->res.verf;
	1268	+
	1269	+ __entry->status = task->tk_status;
	1270	+ __entry->offset = data->args.offset;
	1271	+ __entry->stable = verf->committed;
	1272	+ memcpy(__entry->verifier,
	1273	+ &verf->verifier,
	1274	+ NFS4_VERIFIER_SIZE);
	1275	+ __entry->dev = inode->i_sb->s_dev;
	1276	+ __entry->fileid = nfsi->fileid;
	1277	+ __entry->fhandle = nfs_fhandle_hash(fh);
	1278	+ ),
	1279	+
	1280	+ TP_printk(
	1281	+ "fileid=%02x:%02x:%llu fhandle=0x%08x "
	1282	+ "offset=%lld status=%d stable=%s verifier=%s",
	1283	+ MAJOR(__entry->dev), MINOR(__entry->dev),
	1284	+ (unsigned long long)__entry->fileid,
	1285	+ __entry->fhandle,
	1286	+ (long long)__entry->offset, __entry->status,
	1287	+ nfs_show_stable(__entry->stable),
	1288	+ __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE)
	1289	+ )
	1290	+);
	1291	+
	1292	+TRACE_EVENT(nfs_fh_to_dentry,
	1293	+ TP_PROTO(
	1294	+ const struct super_block *sb,
	1295	+ const struct nfs_fh *fh,
	1296	+ u64 fileid,
	1297	+ int error
	1298	+ ),
	1299	+
	1300	+ TP_ARGS(sb, fh, fileid, error),
	1301	+
	1302	+ TP_STRUCT__entry(
	1303	+ __field(int, error)
943	1304	__field(dev_t, dev)
944	1305	__field(u32, fhandle)
945	1306	__field(u64, fileid)
946	1307	),
947	1308
948	1309	TP_fast_assign(
949		- const struct inode *inode = data->inode;
950		- const struct nfs_inode *nfsi = NFS_I(inode);
951		-
952		- __entry->status = data->res.op_status;
953		- __entry->offset = data->args.offset;
954		- memcpy(&__entry->verifier, &data->verf.verifier,
955		- sizeof(__entry->verifier));
956		- __entry->dev = inode->i_sb->s_dev;
957		- __entry->fileid = nfsi->fileid;
958		- __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
	1310	+ __entry->error = error;
	1311	+ __entry->dev = sb->s_dev;
	1312	+ __entry->fileid = fileid;
	1313	+ __entry->fhandle = nfs_fhandle_hash(fh);
959	1314	),
960	1315
961	1316	TP_printk(
962		- "fileid=%02x:%02x:%llu fhandle=0x%08x "
963		- "offset=%lld status=%d verifier 0x%016llx",
	1317	+ "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x ",
	1318	+ __entry->error,
964	1319	MAJOR(__entry->dev), MINOR(__entry->dev),
965	1320	(unsigned long long)__entry->fileid,
966		- __entry->fhandle,
967		- __entry->offset, __entry->status,
968		- __entry->verifier
	1321	+ __entry->fhandle
	1322	+ )
	1323	+);
	1324	+
	1325	+TRACE_DEFINE_ENUM(NFS_OK);
	1326	+TRACE_DEFINE_ENUM(NFSERR_PERM);
	1327	+TRACE_DEFINE_ENUM(NFSERR_NOENT);
	1328	+TRACE_DEFINE_ENUM(NFSERR_IO);
	1329	+TRACE_DEFINE_ENUM(NFSERR_NXIO);
	1330	+TRACE_DEFINE_ENUM(ECHILD);
	1331	+TRACE_DEFINE_ENUM(NFSERR_EAGAIN);
	1332	+TRACE_DEFINE_ENUM(NFSERR_ACCES);
	1333	+TRACE_DEFINE_ENUM(NFSERR_EXIST);
	1334	+TRACE_DEFINE_ENUM(NFSERR_XDEV);
	1335	+TRACE_DEFINE_ENUM(NFSERR_NODEV);
	1336	+TRACE_DEFINE_ENUM(NFSERR_NOTDIR);
	1337	+TRACE_DEFINE_ENUM(NFSERR_ISDIR);
	1338	+TRACE_DEFINE_ENUM(NFSERR_INVAL);
	1339	+TRACE_DEFINE_ENUM(NFSERR_FBIG);
	1340	+TRACE_DEFINE_ENUM(NFSERR_NOSPC);
	1341	+TRACE_DEFINE_ENUM(NFSERR_ROFS);
	1342	+TRACE_DEFINE_ENUM(NFSERR_MLINK);
	1343	+TRACE_DEFINE_ENUM(NFSERR_OPNOTSUPP);
	1344	+TRACE_DEFINE_ENUM(NFSERR_NAMETOOLONG);
	1345	+TRACE_DEFINE_ENUM(NFSERR_NOTEMPTY);
	1346	+TRACE_DEFINE_ENUM(NFSERR_DQUOT);
	1347	+TRACE_DEFINE_ENUM(NFSERR_STALE);
	1348	+TRACE_DEFINE_ENUM(NFSERR_REMOTE);
	1349	+TRACE_DEFINE_ENUM(NFSERR_WFLUSH);
	1350	+TRACE_DEFINE_ENUM(NFSERR_BADHANDLE);
	1351	+TRACE_DEFINE_ENUM(NFSERR_NOT_SYNC);
	1352	+TRACE_DEFINE_ENUM(NFSERR_BAD_COOKIE);
	1353	+TRACE_DEFINE_ENUM(NFSERR_NOTSUPP);
	1354	+TRACE_DEFINE_ENUM(NFSERR_TOOSMALL);
	1355	+TRACE_DEFINE_ENUM(NFSERR_SERVERFAULT);
	1356	+TRACE_DEFINE_ENUM(NFSERR_BADTYPE);
	1357	+TRACE_DEFINE_ENUM(NFSERR_JUKEBOX);
	1358	+
	1359	+#define nfs_show_status(x) \
	1360	+ __print_symbolic(x, \
	1361	+ { NFS_OK, "OK" }, \
	1362	+ { NFSERR_PERM, "PERM" }, \
	1363	+ { NFSERR_NOENT, "NOENT" }, \
	1364	+ { NFSERR_IO, "IO" }, \
	1365	+ { NFSERR_NXIO, "NXIO" }, \
	1366	+ { ECHILD, "CHILD" }, \
	1367	+ { NFSERR_EAGAIN, "AGAIN" }, \
	1368	+ { NFSERR_ACCES, "ACCES" }, \
	1369	+ { NFSERR_EXIST, "EXIST" }, \
	1370	+ { NFSERR_XDEV, "XDEV" }, \
	1371	+ { NFSERR_NODEV, "NODEV" }, \
	1372	+ { NFSERR_NOTDIR, "NOTDIR" }, \
	1373	+ { NFSERR_ISDIR, "ISDIR" }, \
	1374	+ { NFSERR_INVAL, "INVAL" }, \
	1375	+ { NFSERR_FBIG, "FBIG" }, \
	1376	+ { NFSERR_NOSPC, "NOSPC" }, \
	1377	+ { NFSERR_ROFS, "ROFS" }, \
	1378	+ { NFSERR_MLINK, "MLINK" }, \
	1379	+ { NFSERR_OPNOTSUPP, "OPNOTSUPP" }, \
	1380	+ { NFSERR_NAMETOOLONG, "NAMETOOLONG" }, \
	1381	+ { NFSERR_NOTEMPTY, "NOTEMPTY" }, \
	1382	+ { NFSERR_DQUOT, "DQUOT" }, \
	1383	+ { NFSERR_STALE, "STALE" }, \
	1384	+ { NFSERR_REMOTE, "REMOTE" }, \
	1385	+ { NFSERR_WFLUSH, "WFLUSH" }, \
	1386	+ { NFSERR_BADHANDLE, "BADHANDLE" }, \
	1387	+ { NFSERR_NOT_SYNC, "NOTSYNC" }, \
	1388	+ { NFSERR_BAD_COOKIE, "BADCOOKIE" }, \
	1389	+ { NFSERR_NOTSUPP, "NOTSUPP" }, \
	1390	+ { NFSERR_TOOSMALL, "TOOSMALL" }, \
	1391	+ { NFSERR_SERVERFAULT, "REMOTEIO" }, \
	1392	+ { NFSERR_BADTYPE, "BADTYPE" }, \
	1393	+ { NFSERR_JUKEBOX, "JUKEBOX" })
	1394	+
	1395	+TRACE_EVENT(nfs_xdr_status,
	1396	+ TP_PROTO(
	1397	+ const struct xdr_stream *xdr,
	1398	+ int error
	1399	+ ),
	1400	+
	1401	+ TP_ARGS(xdr, error),
	1402	+
	1403	+ TP_STRUCT__entry(
	1404	+ __field(unsigned int, task_id)
	1405	+ __field(unsigned int, client_id)
	1406	+ __field(u32, xid)
	1407	+ __field(int, version)
	1408	+ __field(unsigned long, error)
	1409	+ __string(program,
	1410	+ xdr->rqst->rq_task->tk_client->cl_program->name)
	1411	+ __string(procedure,
	1412	+ xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
	1413	+ ),
	1414	+
	1415	+ TP_fast_assign(
	1416	+ const struct rpc_rqst *rqstp = xdr->rqst;
	1417	+ const struct rpc_task *task = rqstp->rq_task;
	1418	+
	1419	+ __entry->task_id = task->tk_pid;
	1420	+ __entry->client_id = task->tk_client->cl_clid;
	1421	+ __entry->xid = be32_to_cpu(rqstp->rq_xid);
	1422	+ __entry->version = task->tk_client->cl_vers;
	1423	+ __entry->error = error;
	1424	+ __assign_str(program,
	1425	+ task->tk_client->cl_program->name)
	1426	+ __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
	1427	+ ),
	1428	+
	1429	+ TP_printk(
	1430	+ "task:%u@%d xid=0x%08x %sv%d %s error=%ld (%s)",
	1431	+ __entry->task_id, __entry->client_id, __entry->xid,
	1432	+ __get_str(program), __entry->version,
	1433	+ __get_str(procedure), -__entry->error,
	1434	+ nfs_show_status(__entry->error)
969	1435	)
970	1436	);
971	1437