add stmac read mac form eeprom

hc

2023-12-09 b22da3d8526a935aa31e086e63f60ff3246cb61c

 kernel/fs/nfs/nfs4trace.h
..
..
@@ -10,157 +10,308 @@
10
10
 
11
11
 #include <linux/tracepoint.h>
12
12
 
13
+TRACE_DEFINE_ENUM(EPERM);
14
+TRACE_DEFINE_ENUM(ENOENT);
15
+TRACE_DEFINE_ENUM(EIO);
16
+TRACE_DEFINE_ENUM(ENXIO);
17
+TRACE_DEFINE_ENUM(EACCES);
18
+TRACE_DEFINE_ENUM(EEXIST);
19
+TRACE_DEFINE_ENUM(EXDEV);
20
+TRACE_DEFINE_ENUM(ENOTDIR);
21
+TRACE_DEFINE_ENUM(EISDIR);
22
+TRACE_DEFINE_ENUM(EFBIG);
23
+TRACE_DEFINE_ENUM(ENOSPC);
24
+TRACE_DEFINE_ENUM(EROFS);
25
+TRACE_DEFINE_ENUM(EMLINK);
26
+TRACE_DEFINE_ENUM(ENAMETOOLONG);
27
+TRACE_DEFINE_ENUM(ENOTEMPTY);
28
+TRACE_DEFINE_ENUM(EDQUOT);
29
+TRACE_DEFINE_ENUM(ESTALE);
30
+TRACE_DEFINE_ENUM(EBADHANDLE);
31
+TRACE_DEFINE_ENUM(EBADCOOKIE);
32
+TRACE_DEFINE_ENUM(ENOTSUPP);
33
+TRACE_DEFINE_ENUM(ETOOSMALL);
34
+TRACE_DEFINE_ENUM(EREMOTEIO);
35
+TRACE_DEFINE_ENUM(EBADTYPE);
36
+TRACE_DEFINE_ENUM(EAGAIN);
37
+TRACE_DEFINE_ENUM(ELOOP);
38
+TRACE_DEFINE_ENUM(EOPNOTSUPP);
39
+TRACE_DEFINE_ENUM(EDEADLK);
40
+TRACE_DEFINE_ENUM(ENOMEM);
41
+TRACE_DEFINE_ENUM(EKEYEXPIRED);
42
+TRACE_DEFINE_ENUM(ETIMEDOUT);
43
+TRACE_DEFINE_ENUM(ERESTARTSYS);
44
+TRACE_DEFINE_ENUM(ECONNREFUSED);
45
+TRACE_DEFINE_ENUM(ECONNRESET);
46
+TRACE_DEFINE_ENUM(ENETUNREACH);
47
+TRACE_DEFINE_ENUM(EHOSTUNREACH);
48
+TRACE_DEFINE_ENUM(EHOSTDOWN);
49
+TRACE_DEFINE_ENUM(EPIPE);
50
+TRACE_DEFINE_ENUM(EPFNOSUPPORT);
51
+TRACE_DEFINE_ENUM(EPROTONOSUPPORT);
52
+
53
+TRACE_DEFINE_ENUM(NFS4_OK);
54
+TRACE_DEFINE_ENUM(NFS4ERR_ACCESS);
55
+TRACE_DEFINE_ENUM(NFS4ERR_ATTRNOTSUPP);
56
+TRACE_DEFINE_ENUM(NFS4ERR_ADMIN_REVOKED);
57
+TRACE_DEFINE_ENUM(NFS4ERR_BACK_CHAN_BUSY);
58
+TRACE_DEFINE_ENUM(NFS4ERR_BADCHAR);
59
+TRACE_DEFINE_ENUM(NFS4ERR_BADHANDLE);
60
+TRACE_DEFINE_ENUM(NFS4ERR_BADIOMODE);
61
+TRACE_DEFINE_ENUM(NFS4ERR_BADLAYOUT);
62
+TRACE_DEFINE_ENUM(NFS4ERR_BADLABEL);
63
+TRACE_DEFINE_ENUM(NFS4ERR_BADNAME);
64
+TRACE_DEFINE_ENUM(NFS4ERR_BADOWNER);
65
+TRACE_DEFINE_ENUM(NFS4ERR_BADSESSION);
66
+TRACE_DEFINE_ENUM(NFS4ERR_BADSLOT);
67
+TRACE_DEFINE_ENUM(NFS4ERR_BADTYPE);
68
+TRACE_DEFINE_ENUM(NFS4ERR_BADXDR);
69
+TRACE_DEFINE_ENUM(NFS4ERR_BAD_COOKIE);
70
+TRACE_DEFINE_ENUM(NFS4ERR_BAD_HIGH_SLOT);
71
+TRACE_DEFINE_ENUM(NFS4ERR_BAD_RANGE);
72
+TRACE_DEFINE_ENUM(NFS4ERR_BAD_SEQID);
73
+TRACE_DEFINE_ENUM(NFS4ERR_BAD_SESSION_DIGEST);
74
+TRACE_DEFINE_ENUM(NFS4ERR_BAD_STATEID);
75
+TRACE_DEFINE_ENUM(NFS4ERR_CB_PATH_DOWN);
76
+TRACE_DEFINE_ENUM(NFS4ERR_CLID_INUSE);
77
+TRACE_DEFINE_ENUM(NFS4ERR_CLIENTID_BUSY);
78
+TRACE_DEFINE_ENUM(NFS4ERR_COMPLETE_ALREADY);
79
+TRACE_DEFINE_ENUM(NFS4ERR_CONN_NOT_BOUND_TO_SESSION);
80
+TRACE_DEFINE_ENUM(NFS4ERR_DEADLOCK);
81
+TRACE_DEFINE_ENUM(NFS4ERR_DEADSESSION);
82
+TRACE_DEFINE_ENUM(NFS4ERR_DELAY);
83
+TRACE_DEFINE_ENUM(NFS4ERR_DELEG_ALREADY_WANTED);
84
+TRACE_DEFINE_ENUM(NFS4ERR_DELEG_REVOKED);
85
+TRACE_DEFINE_ENUM(NFS4ERR_DENIED);
86
+TRACE_DEFINE_ENUM(NFS4ERR_DIRDELEG_UNAVAIL);
87
+TRACE_DEFINE_ENUM(NFS4ERR_DQUOT);
88
+TRACE_DEFINE_ENUM(NFS4ERR_ENCR_ALG_UNSUPP);
89
+TRACE_DEFINE_ENUM(NFS4ERR_EXIST);
90
+TRACE_DEFINE_ENUM(NFS4ERR_EXPIRED);
91
+TRACE_DEFINE_ENUM(NFS4ERR_FBIG);
92
+TRACE_DEFINE_ENUM(NFS4ERR_FHEXPIRED);
93
+TRACE_DEFINE_ENUM(NFS4ERR_FILE_OPEN);
94
+TRACE_DEFINE_ENUM(NFS4ERR_GRACE);
95
+TRACE_DEFINE_ENUM(NFS4ERR_HASH_ALG_UNSUPP);
96
+TRACE_DEFINE_ENUM(NFS4ERR_INVAL);
97
+TRACE_DEFINE_ENUM(NFS4ERR_IO);
98
+TRACE_DEFINE_ENUM(NFS4ERR_ISDIR);
99
+TRACE_DEFINE_ENUM(NFS4ERR_LAYOUTTRYLATER);
100
+TRACE_DEFINE_ENUM(NFS4ERR_LAYOUTUNAVAILABLE);
101
+TRACE_DEFINE_ENUM(NFS4ERR_LEASE_MOVED);
102
+TRACE_DEFINE_ENUM(NFS4ERR_LOCKED);
103
+TRACE_DEFINE_ENUM(NFS4ERR_LOCKS_HELD);
104
+TRACE_DEFINE_ENUM(NFS4ERR_LOCK_RANGE);
105
+TRACE_DEFINE_ENUM(NFS4ERR_MINOR_VERS_MISMATCH);
106
+TRACE_DEFINE_ENUM(NFS4ERR_MLINK);
107
+TRACE_DEFINE_ENUM(NFS4ERR_MOVED);
108
+TRACE_DEFINE_ENUM(NFS4ERR_NAMETOOLONG);
109
+TRACE_DEFINE_ENUM(NFS4ERR_NOENT);
110
+TRACE_DEFINE_ENUM(NFS4ERR_NOFILEHANDLE);
111
+TRACE_DEFINE_ENUM(NFS4ERR_NOMATCHING_LAYOUT);
112
+TRACE_DEFINE_ENUM(NFS4ERR_NOSPC);
113
+TRACE_DEFINE_ENUM(NFS4ERR_NOTDIR);
114
+TRACE_DEFINE_ENUM(NFS4ERR_NOTEMPTY);
115
+TRACE_DEFINE_ENUM(NFS4ERR_NOTSUPP);
116
+TRACE_DEFINE_ENUM(NFS4ERR_NOT_ONLY_OP);
117
+TRACE_DEFINE_ENUM(NFS4ERR_NOT_SAME);
118
+TRACE_DEFINE_ENUM(NFS4ERR_NO_GRACE);
119
+TRACE_DEFINE_ENUM(NFS4ERR_NXIO);
120
+TRACE_DEFINE_ENUM(NFS4ERR_OLD_STATEID);
121
+TRACE_DEFINE_ENUM(NFS4ERR_OPENMODE);
122
+TRACE_DEFINE_ENUM(NFS4ERR_OP_ILLEGAL);
123
+TRACE_DEFINE_ENUM(NFS4ERR_OP_NOT_IN_SESSION);
124
+TRACE_DEFINE_ENUM(NFS4ERR_PERM);
125
+TRACE_DEFINE_ENUM(NFS4ERR_PNFS_IO_HOLE);
126
+TRACE_DEFINE_ENUM(NFS4ERR_PNFS_NO_LAYOUT);
127
+TRACE_DEFINE_ENUM(NFS4ERR_RECALLCONFLICT);
128
+TRACE_DEFINE_ENUM(NFS4ERR_RECLAIM_BAD);
129
+TRACE_DEFINE_ENUM(NFS4ERR_RECLAIM_CONFLICT);
130
+TRACE_DEFINE_ENUM(NFS4ERR_REJECT_DELEG);
131
+TRACE_DEFINE_ENUM(NFS4ERR_REP_TOO_BIG);
132
+TRACE_DEFINE_ENUM(NFS4ERR_REP_TOO_BIG_TO_CACHE);
133
+TRACE_DEFINE_ENUM(NFS4ERR_REQ_TOO_BIG);
134
+TRACE_DEFINE_ENUM(NFS4ERR_RESOURCE);
135
+TRACE_DEFINE_ENUM(NFS4ERR_RESTOREFH);
136
+TRACE_DEFINE_ENUM(NFS4ERR_RETRY_UNCACHED_REP);
137
+TRACE_DEFINE_ENUM(NFS4ERR_RETURNCONFLICT);
138
+TRACE_DEFINE_ENUM(NFS4ERR_ROFS);
139
+TRACE_DEFINE_ENUM(NFS4ERR_SAME);
140
+TRACE_DEFINE_ENUM(NFS4ERR_SHARE_DENIED);
141
+TRACE_DEFINE_ENUM(NFS4ERR_SEQUENCE_POS);
142
+TRACE_DEFINE_ENUM(NFS4ERR_SEQ_FALSE_RETRY);
143
+TRACE_DEFINE_ENUM(NFS4ERR_SEQ_MISORDERED);
144
+TRACE_DEFINE_ENUM(NFS4ERR_SERVERFAULT);
145
+TRACE_DEFINE_ENUM(NFS4ERR_STALE);
146
+TRACE_DEFINE_ENUM(NFS4ERR_STALE_CLIENTID);
147
+TRACE_DEFINE_ENUM(NFS4ERR_STALE_STATEID);
148
+TRACE_DEFINE_ENUM(NFS4ERR_SYMLINK);
149
+TRACE_DEFINE_ENUM(NFS4ERR_TOOSMALL);
150
+TRACE_DEFINE_ENUM(NFS4ERR_TOO_MANY_OPS);
151
+TRACE_DEFINE_ENUM(NFS4ERR_UNKNOWN_LAYOUTTYPE);
152
+TRACE_DEFINE_ENUM(NFS4ERR_UNSAFE_COMPOUND);
153
+TRACE_DEFINE_ENUM(NFS4ERR_WRONGSEC);
154
+TRACE_DEFINE_ENUM(NFS4ERR_WRONG_CRED);
155
+TRACE_DEFINE_ENUM(NFS4ERR_WRONG_TYPE);
156
+TRACE_DEFINE_ENUM(NFS4ERR_XDEV);
157
+
158
+TRACE_DEFINE_ENUM(NFS4ERR_RESET_TO_MDS);
159
+TRACE_DEFINE_ENUM(NFS4ERR_RESET_TO_PNFS);
160
+
13
161
 #define show_nfsv4_errors(error) \
14
162
 	__print_symbolic(error, \
15
163
 		{ NFS4_OK, "OK" }, \
16
164
 		/* Mapped by nfs4_stat_to_errno() */ \
17
-		{ -EPERM, "EPERM" }, \
18
-		{ -ENOENT, "ENOENT" }, \
19
-		{ -EIO, "EIO" }, \
20
-		{ -ENXIO, "ENXIO" }, \
21
-		{ -EACCES, "EACCES" }, \
22
-		{ -EEXIST, "EEXIST" }, \
23
-		{ -EXDEV, "EXDEV" }, \
24
-		{ -ENOTDIR, "ENOTDIR" }, \
25
-		{ -EISDIR, "EISDIR" }, \
26
-		{ -EFBIG, "EFBIG" }, \
27
-		{ -ENOSPC, "ENOSPC" }, \
28
-		{ -EROFS, "EROFS" }, \
29
-		{ -EMLINK, "EMLINK" }, \
30
-		{ -ENAMETOOLONG, "ENAMETOOLONG" }, \
31
-		{ -ENOTEMPTY, "ENOTEMPTY" }, \
32
-		{ -EDQUOT, "EDQUOT" }, \
33
-		{ -ESTALE, "ESTALE" }, \
34
-		{ -EBADHANDLE, "EBADHANDLE" }, \
35
-		{ -EBADCOOKIE, "EBADCOOKIE" }, \
36
-		{ -ENOTSUPP, "ENOTSUPP" }, \
37
-		{ -ETOOSMALL, "ETOOSMALL" }, \
38
-		{ -EREMOTEIO, "EREMOTEIO" }, \
39
-		{ -EBADTYPE, "EBADTYPE" }, \
40
-		{ -EAGAIN, "EAGAIN" }, \
41
-		{ -ELOOP, "ELOOP" }, \
42
-		{ -EOPNOTSUPP, "EOPNOTSUPP" }, \
43
-		{ -EDEADLK, "EDEADLK" }, \
165
+		{ EPERM, "EPERM" }, \
166
+		{ ENOENT, "ENOENT" }, \
167
+		{ EIO, "EIO" }, \
168
+		{ ENXIO, "ENXIO" }, \
169
+		{ EACCES, "EACCES" }, \
170
+		{ EEXIST, "EEXIST" }, \
171
+		{ EXDEV, "EXDEV" }, \
172
+		{ ENOTDIR, "ENOTDIR" }, \
173
+		{ EISDIR, "EISDIR" }, \
174
+		{ EFBIG, "EFBIG" }, \
175
+		{ ENOSPC, "ENOSPC" }, \
176
+		{ EROFS, "EROFS" }, \
177
+		{ EMLINK, "EMLINK" }, \
178
+		{ ENAMETOOLONG, "ENAMETOOLONG" }, \
179
+		{ ENOTEMPTY, "ENOTEMPTY" }, \
180
+		{ EDQUOT, "EDQUOT" }, \
181
+		{ ESTALE, "ESTALE" }, \
182
+		{ EBADHANDLE, "EBADHANDLE" }, \
183
+		{ EBADCOOKIE, "EBADCOOKIE" }, \
184
+		{ ENOTSUPP, "ENOTSUPP" }, \
185
+		{ ETOOSMALL, "ETOOSMALL" }, \
186
+		{ EREMOTEIO, "EREMOTEIO" }, \
187
+		{ EBADTYPE, "EBADTYPE" }, \
188
+		{ EAGAIN, "EAGAIN" }, \
189
+		{ ELOOP, "ELOOP" }, \
190
+		{ EOPNOTSUPP, "EOPNOTSUPP" }, \
191
+		{ EDEADLK, "EDEADLK" }, \
44
192
 		/* RPC errors */ \
45
-		{ -ENOMEM, "ENOMEM" }, \
46
-		{ -EKEYEXPIRED, "EKEYEXPIRED" }, \
47
-		{ -ETIMEDOUT, "ETIMEDOUT" }, \
48
-		{ -ERESTARTSYS, "ERESTARTSYS" }, \
49
-		{ -ECONNREFUSED, "ECONNREFUSED" }, \
50
-		{ -ECONNRESET, "ECONNRESET" }, \
51
-		{ -ENETUNREACH, "ENETUNREACH" }, \
52
-		{ -EHOSTUNREACH, "EHOSTUNREACH" }, \
53
-		{ -EHOSTDOWN, "EHOSTDOWN" }, \
54
-		{ -EPIPE, "EPIPE" }, \
55
-		{ -EPFNOSUPPORT, "EPFNOSUPPORT" }, \
56
-		{ -EPROTONOSUPPORT, "EPROTONOSUPPORT" }, \
193
+		{ ENOMEM, "ENOMEM" }, \
194
+		{ EKEYEXPIRED, "EKEYEXPIRED" }, \
195
+		{ ETIMEDOUT, "ETIMEDOUT" }, \
196
+		{ ERESTARTSYS, "ERESTARTSYS" }, \
197
+		{ ECONNREFUSED, "ECONNREFUSED" }, \
198
+		{ ECONNRESET, "ECONNRESET" }, \
199
+		{ ENETUNREACH, "ENETUNREACH" }, \
200
+		{ EHOSTUNREACH, "EHOSTUNREACH" }, \
201
+		{ EHOSTDOWN, "EHOSTDOWN" }, \
202
+		{ EPIPE, "EPIPE" }, \
203
+		{ EPFNOSUPPORT, "EPFNOSUPPORT" }, \
204
+		{ EPROTONOSUPPORT, "EPROTONOSUPPORT" }, \
57
205
 		/* NFSv4 native errors */ \
58
-		{ -NFS4ERR_ACCESS, "ACCESS" }, \
59
-		{ -NFS4ERR_ATTRNOTSUPP, "ATTRNOTSUPP" }, \
60
-		{ -NFS4ERR_ADMIN_REVOKED, "ADMIN_REVOKED" }, \
61
-		{ -NFS4ERR_BACK_CHAN_BUSY, "BACK_CHAN_BUSY" }, \
62
-		{ -NFS4ERR_BADCHAR, "BADCHAR" }, \
63
-		{ -NFS4ERR_BADHANDLE, "BADHANDLE" }, \
64
-		{ -NFS4ERR_BADIOMODE, "BADIOMODE" }, \
65
-		{ -NFS4ERR_BADLAYOUT, "BADLAYOUT" }, \
66
-		{ -NFS4ERR_BADLABEL, "BADLABEL" }, \
67
-		{ -NFS4ERR_BADNAME, "BADNAME" }, \
68
-		{ -NFS4ERR_BADOWNER, "BADOWNER" }, \
69
-		{ -NFS4ERR_BADSESSION, "BADSESSION" }, \
70
-		{ -NFS4ERR_BADSLOT, "BADSLOT" }, \
71
-		{ -NFS4ERR_BADTYPE, "BADTYPE" }, \
72
-		{ -NFS4ERR_BADXDR, "BADXDR" }, \
73
-		{ -NFS4ERR_BAD_COOKIE, "BAD_COOKIE" }, \
74
-		{ -NFS4ERR_BAD_HIGH_SLOT, "BAD_HIGH_SLOT" }, \
75
-		{ -NFS4ERR_BAD_RANGE, "BAD_RANGE" }, \
76
-		{ -NFS4ERR_BAD_SEQID, "BAD_SEQID" }, \
77
-		{ -NFS4ERR_BAD_SESSION_DIGEST, "BAD_SESSION_DIGEST" }, \
78
-		{ -NFS4ERR_BAD_STATEID, "BAD_STATEID" }, \
79
-		{ -NFS4ERR_CB_PATH_DOWN, "CB_PATH_DOWN" }, \
80
-		{ -NFS4ERR_CLID_INUSE, "CLID_INUSE" }, \
81
-		{ -NFS4ERR_CLIENTID_BUSY, "CLIENTID_BUSY" }, \
82
-		{ -NFS4ERR_COMPLETE_ALREADY, "COMPLETE_ALREADY" }, \
83
-		{ -NFS4ERR_CONN_NOT_BOUND_TO_SESSION, \
206
+		{ NFS4ERR_ACCESS, "ACCESS" }, \
207
+		{ NFS4ERR_ATTRNOTSUPP, "ATTRNOTSUPP" }, \
208
+		{ NFS4ERR_ADMIN_REVOKED, "ADMIN_REVOKED" }, \
209
+		{ NFS4ERR_BACK_CHAN_BUSY, "BACK_CHAN_BUSY" }, \
210
+		{ NFS4ERR_BADCHAR, "BADCHAR" }, \
211
+		{ NFS4ERR_BADHANDLE, "BADHANDLE" }, \
212
+		{ NFS4ERR_BADIOMODE, "BADIOMODE" }, \
213
+		{ NFS4ERR_BADLAYOUT, "BADLAYOUT" }, \
214
+		{ NFS4ERR_BADLABEL, "BADLABEL" }, \
215
+		{ NFS4ERR_BADNAME, "BADNAME" }, \
216
+		{ NFS4ERR_BADOWNER, "BADOWNER" }, \
217
+		{ NFS4ERR_BADSESSION, "BADSESSION" }, \
218
+		{ NFS4ERR_BADSLOT, "BADSLOT" }, \
219
+		{ NFS4ERR_BADTYPE, "BADTYPE" }, \
220
+		{ NFS4ERR_BADXDR, "BADXDR" }, \
221
+		{ NFS4ERR_BAD_COOKIE, "BAD_COOKIE" }, \
222
+		{ NFS4ERR_BAD_HIGH_SLOT, "BAD_HIGH_SLOT" }, \
223
+		{ NFS4ERR_BAD_RANGE, "BAD_RANGE" }, \
224
+		{ NFS4ERR_BAD_SEQID, "BAD_SEQID" }, \
225
+		{ NFS4ERR_BAD_SESSION_DIGEST, "BAD_SESSION_DIGEST" }, \
226
+		{ NFS4ERR_BAD_STATEID, "BAD_STATEID" }, \
227
+		{ NFS4ERR_CB_PATH_DOWN, "CB_PATH_DOWN" }, \
228
+		{ NFS4ERR_CLID_INUSE, "CLID_INUSE" }, \
229
+		{ NFS4ERR_CLIENTID_BUSY, "CLIENTID_BUSY" }, \
230
+		{ NFS4ERR_COMPLETE_ALREADY, "COMPLETE_ALREADY" }, \
231
+		{ NFS4ERR_CONN_NOT_BOUND_TO_SESSION, \
84
232
 			"CONN_NOT_BOUND_TO_SESSION" }, \
85
-		{ -NFS4ERR_DEADLOCK, "DEADLOCK" }, \
86
-		{ -NFS4ERR_DEADSESSION, "DEAD_SESSION" }, \
87
-		{ -NFS4ERR_DELAY, "DELAY" }, \
88
-		{ -NFS4ERR_DELEG_ALREADY_WANTED, \
233
+		{ NFS4ERR_DEADLOCK, "DEADLOCK" }, \
234
+		{ NFS4ERR_DEADSESSION, "DEAD_SESSION" }, \
235
+		{ NFS4ERR_DELAY, "DELAY" }, \
236
+		{ NFS4ERR_DELEG_ALREADY_WANTED, \
89
237
 			"DELEG_ALREADY_WANTED" }, \
90
-		{ -NFS4ERR_DELEG_REVOKED, "DELEG_REVOKED" }, \
91
-		{ -NFS4ERR_DENIED, "DENIED" }, \
92
-		{ -NFS4ERR_DIRDELEG_UNAVAIL, "DIRDELEG_UNAVAIL" }, \
93
-		{ -NFS4ERR_DQUOT, "DQUOT" }, \
94
-		{ -NFS4ERR_ENCR_ALG_UNSUPP, "ENCR_ALG_UNSUPP" }, \
95
-		{ -NFS4ERR_EXIST, "EXIST" }, \
96
-		{ -NFS4ERR_EXPIRED, "EXPIRED" }, \
97
-		{ -NFS4ERR_FBIG, "FBIG" }, \
98
-		{ -NFS4ERR_FHEXPIRED, "FHEXPIRED" }, \
99
-		{ -NFS4ERR_FILE_OPEN, "FILE_OPEN" }, \
100
-		{ -NFS4ERR_GRACE, "GRACE" }, \
101
-		{ -NFS4ERR_HASH_ALG_UNSUPP, "HASH_ALG_UNSUPP" }, \
102
-		{ -NFS4ERR_INVAL, "INVAL" }, \
103
-		{ -NFS4ERR_IO, "IO" }, \
104
-		{ -NFS4ERR_ISDIR, "ISDIR" }, \
105
-		{ -NFS4ERR_LAYOUTTRYLATER, "LAYOUTTRYLATER" }, \
106
-		{ -NFS4ERR_LAYOUTUNAVAILABLE, "LAYOUTUNAVAILABLE" }, \
107
-		{ -NFS4ERR_LEASE_MOVED, "LEASE_MOVED" }, \
108
-		{ -NFS4ERR_LOCKED, "LOCKED" }, \
109
-		{ -NFS4ERR_LOCKS_HELD, "LOCKS_HELD" }, \
110
-		{ -NFS4ERR_LOCK_RANGE, "LOCK_RANGE" }, \
111
-		{ -NFS4ERR_MINOR_VERS_MISMATCH, "MINOR_VERS_MISMATCH" }, \
112
-		{ -NFS4ERR_MLINK, "MLINK" }, \
113
-		{ -NFS4ERR_MOVED, "MOVED" }, \
114
-		{ -NFS4ERR_NAMETOOLONG, "NAMETOOLONG" }, \
115
-		{ -NFS4ERR_NOENT, "NOENT" }, \
116
-		{ -NFS4ERR_NOFILEHANDLE, "NOFILEHANDLE" }, \
117
-		{ -NFS4ERR_NOMATCHING_LAYOUT, "NOMATCHING_LAYOUT" }, \
118
-		{ -NFS4ERR_NOSPC, "NOSPC" }, \
119
-		{ -NFS4ERR_NOTDIR, "NOTDIR" }, \
120
-		{ -NFS4ERR_NOTEMPTY, "NOTEMPTY" }, \
121
-		{ -NFS4ERR_NOTSUPP, "NOTSUPP" }, \
122
-		{ -NFS4ERR_NOT_ONLY_OP, "NOT_ONLY_OP" }, \
123
-		{ -NFS4ERR_NOT_SAME, "NOT_SAME" }, \
124
-		{ -NFS4ERR_NO_GRACE, "NO_GRACE" }, \
125
-		{ -NFS4ERR_NXIO, "NXIO" }, \
126
-		{ -NFS4ERR_OLD_STATEID, "OLD_STATEID" }, \
127
-		{ -NFS4ERR_OPENMODE, "OPENMODE" }, \
128
-		{ -NFS4ERR_OP_ILLEGAL, "OP_ILLEGAL" }, \
129
-		{ -NFS4ERR_OP_NOT_IN_SESSION, "OP_NOT_IN_SESSION" }, \
130
-		{ -NFS4ERR_PERM, "PERM" }, \
131
-		{ -NFS4ERR_PNFS_IO_HOLE, "PNFS_IO_HOLE" }, \
132
-		{ -NFS4ERR_PNFS_NO_LAYOUT, "PNFS_NO_LAYOUT" }, \
133
-		{ -NFS4ERR_RECALLCONFLICT, "RECALLCONFLICT" }, \
134
-		{ -NFS4ERR_RECLAIM_BAD, "RECLAIM_BAD" }, \
135
-		{ -NFS4ERR_RECLAIM_CONFLICT, "RECLAIM_CONFLICT" }, \
136
-		{ -NFS4ERR_REJECT_DELEG, "REJECT_DELEG" }, \
137
-		{ -NFS4ERR_REP_TOO_BIG, "REP_TOO_BIG" }, \
138
-		{ -NFS4ERR_REP_TOO_BIG_TO_CACHE, \
238
+		{ NFS4ERR_DELEG_REVOKED, "DELEG_REVOKED" }, \
239
+		{ NFS4ERR_DENIED, "DENIED" }, \
240
+		{ NFS4ERR_DIRDELEG_UNAVAIL, "DIRDELEG_UNAVAIL" }, \
241
+		{ NFS4ERR_DQUOT, "DQUOT" }, \
242
+		{ NFS4ERR_ENCR_ALG_UNSUPP, "ENCR_ALG_UNSUPP" }, \
243
+		{ NFS4ERR_EXIST, "EXIST" }, \
244
+		{ NFS4ERR_EXPIRED, "EXPIRED" }, \
245
+		{ NFS4ERR_FBIG, "FBIG" }, \
246
+		{ NFS4ERR_FHEXPIRED, "FHEXPIRED" }, \
247
+		{ NFS4ERR_FILE_OPEN, "FILE_OPEN" }, \
248
+		{ NFS4ERR_GRACE, "GRACE" }, \
249
+		{ NFS4ERR_HASH_ALG_UNSUPP, "HASH_ALG_UNSUPP" }, \
250
+		{ NFS4ERR_INVAL, "INVAL" }, \
251
+		{ NFS4ERR_IO, "IO" }, \
252
+		{ NFS4ERR_ISDIR, "ISDIR" }, \
253
+		{ NFS4ERR_LAYOUTTRYLATER, "LAYOUTTRYLATER" }, \
254
+		{ NFS4ERR_LAYOUTUNAVAILABLE, "LAYOUTUNAVAILABLE" }, \
255
+		{ NFS4ERR_LEASE_MOVED, "LEASE_MOVED" }, \
256
+		{ NFS4ERR_LOCKED, "LOCKED" }, \
257
+		{ NFS4ERR_LOCKS_HELD, "LOCKS_HELD" }, \
258
+		{ NFS4ERR_LOCK_RANGE, "LOCK_RANGE" }, \
259
+		{ NFS4ERR_MINOR_VERS_MISMATCH, "MINOR_VERS_MISMATCH" }, \
260
+		{ NFS4ERR_MLINK, "MLINK" }, \
261
+		{ NFS4ERR_MOVED, "MOVED" }, \
262
+		{ NFS4ERR_NAMETOOLONG, "NAMETOOLONG" }, \
263
+		{ NFS4ERR_NOENT, "NOENT" }, \
264
+		{ NFS4ERR_NOFILEHANDLE, "NOFILEHANDLE" }, \
265
+		{ NFS4ERR_NOMATCHING_LAYOUT, "NOMATCHING_LAYOUT" }, \
266
+		{ NFS4ERR_NOSPC, "NOSPC" }, \
267
+		{ NFS4ERR_NOTDIR, "NOTDIR" }, \
268
+		{ NFS4ERR_NOTEMPTY, "NOTEMPTY" }, \
269
+		{ NFS4ERR_NOTSUPP, "NOTSUPP" }, \
270
+		{ NFS4ERR_NOT_ONLY_OP, "NOT_ONLY_OP" }, \
271
+		{ NFS4ERR_NOT_SAME, "NOT_SAME" }, \
272
+		{ NFS4ERR_NO_GRACE, "NO_GRACE" }, \
273
+		{ NFS4ERR_NXIO, "NXIO" }, \
274
+		{ NFS4ERR_OLD_STATEID, "OLD_STATEID" }, \
275
+		{ NFS4ERR_OPENMODE, "OPENMODE" }, \
276
+		{ NFS4ERR_OP_ILLEGAL, "OP_ILLEGAL" }, \
277
+		{ NFS4ERR_OP_NOT_IN_SESSION, "OP_NOT_IN_SESSION" }, \
278
+		{ NFS4ERR_PERM, "PERM" }, \
279
+		{ NFS4ERR_PNFS_IO_HOLE, "PNFS_IO_HOLE" }, \
280
+		{ NFS4ERR_PNFS_NO_LAYOUT, "PNFS_NO_LAYOUT" }, \
281
+		{ NFS4ERR_RECALLCONFLICT, "RECALLCONFLICT" }, \
282
+		{ NFS4ERR_RECLAIM_BAD, "RECLAIM_BAD" }, \
283
+		{ NFS4ERR_RECLAIM_CONFLICT, "RECLAIM_CONFLICT" }, \
284
+		{ NFS4ERR_REJECT_DELEG, "REJECT_DELEG" }, \
285
+		{ NFS4ERR_REP_TOO_BIG, "REP_TOO_BIG" }, \
286
+		{ NFS4ERR_REP_TOO_BIG_TO_CACHE, \
139
287
 			"REP_TOO_BIG_TO_CACHE" }, \
140
-		{ -NFS4ERR_REQ_TOO_BIG, "REQ_TOO_BIG" }, \
141
-		{ -NFS4ERR_RESOURCE, "RESOURCE" }, \
142
-		{ -NFS4ERR_RESTOREFH, "RESTOREFH" }, \
143
-		{ -NFS4ERR_RETRY_UNCACHED_REP, "RETRY_UNCACHED_REP" }, \
144
-		{ -NFS4ERR_RETURNCONFLICT, "RETURNCONFLICT" }, \
145
-		{ -NFS4ERR_ROFS, "ROFS" }, \
146
-		{ -NFS4ERR_SAME, "SAME" }, \
147
-		{ -NFS4ERR_SHARE_DENIED, "SHARE_DENIED" }, \
148
-		{ -NFS4ERR_SEQUENCE_POS, "SEQUENCE_POS" }, \
149
-		{ -NFS4ERR_SEQ_FALSE_RETRY, "SEQ_FALSE_RETRY" }, \
150
-		{ -NFS4ERR_SEQ_MISORDERED, "SEQ_MISORDERED" }, \
151
-		{ -NFS4ERR_SERVERFAULT, "SERVERFAULT" }, \
152
-		{ -NFS4ERR_STALE, "STALE" }, \
153
-		{ -NFS4ERR_STALE_CLIENTID, "STALE_CLIENTID" }, \
154
-		{ -NFS4ERR_STALE_STATEID, "STALE_STATEID" }, \
155
-		{ -NFS4ERR_SYMLINK, "SYMLINK" }, \
156
-		{ -NFS4ERR_TOOSMALL, "TOOSMALL" }, \
157
-		{ -NFS4ERR_TOO_MANY_OPS, "TOO_MANY_OPS" }, \
158
-		{ -NFS4ERR_UNKNOWN_LAYOUTTYPE, "UNKNOWN_LAYOUTTYPE" }, \
159
-		{ -NFS4ERR_UNSAFE_COMPOUND, "UNSAFE_COMPOUND" }, \
160
-		{ -NFS4ERR_WRONGSEC, "WRONGSEC" }, \
161
-		{ -NFS4ERR_WRONG_CRED, "WRONG_CRED" }, \
162
-		{ -NFS4ERR_WRONG_TYPE, "WRONG_TYPE" }, \
163
-		{ -NFS4ERR_XDEV, "XDEV" })
288
+		{ NFS4ERR_REQ_TOO_BIG, "REQ_TOO_BIG" }, \
289
+		{ NFS4ERR_RESOURCE, "RESOURCE" }, \
290
+		{ NFS4ERR_RESTOREFH, "RESTOREFH" }, \
291
+		{ NFS4ERR_RETRY_UNCACHED_REP, "RETRY_UNCACHED_REP" }, \
292
+		{ NFS4ERR_RETURNCONFLICT, "RETURNCONFLICT" }, \
293
+		{ NFS4ERR_ROFS, "ROFS" }, \
294
+		{ NFS4ERR_SAME, "SAME" }, \
295
+		{ NFS4ERR_SHARE_DENIED, "SHARE_DENIED" }, \
296
+		{ NFS4ERR_SEQUENCE_POS, "SEQUENCE_POS" }, \
297
+		{ NFS4ERR_SEQ_FALSE_RETRY, "SEQ_FALSE_RETRY" }, \
298
+		{ NFS4ERR_SEQ_MISORDERED, "SEQ_MISORDERED" }, \
299
+		{ NFS4ERR_SERVERFAULT, "SERVERFAULT" }, \
300
+		{ NFS4ERR_STALE, "STALE" }, \
301
+		{ NFS4ERR_STALE_CLIENTID, "STALE_CLIENTID" }, \
302
+		{ NFS4ERR_STALE_STATEID, "STALE_STATEID" }, \
303
+		{ NFS4ERR_SYMLINK, "SYMLINK" }, \
304
+		{ NFS4ERR_TOOSMALL, "TOOSMALL" }, \
305
+		{ NFS4ERR_TOO_MANY_OPS, "TOO_MANY_OPS" }, \
306
+		{ NFS4ERR_UNKNOWN_LAYOUTTYPE, "UNKNOWN_LAYOUTTYPE" }, \
307
+		{ NFS4ERR_UNSAFE_COMPOUND, "UNSAFE_COMPOUND" }, \
308
+		{ NFS4ERR_WRONGSEC, "WRONGSEC" }, \
309
+		{ NFS4ERR_WRONG_CRED, "WRONG_CRED" }, \
310
+		{ NFS4ERR_WRONG_TYPE, "WRONG_TYPE" }, \
311
+		{ NFS4ERR_XDEV, "XDEV" }, \
312
+		/* ***** Internal to Linux NFS client ***** */ \
313
+		{ NFS4ERR_RESET_TO_MDS, "RESET_TO_MDS" }, \
314
+		{ NFS4ERR_RESET_TO_PNFS, "RESET_TO_PNFS" })
164
315
 
165
316
 #define show_open_flags(flags) \
166
317
 	__print_flags(flags, "|", \
..
..
@@ -203,17 +354,17 @@
203
354
 
204
355
 		TP_STRUCT__entry(
205
356
 			__string(dstaddr, clp->cl_hostname)
206
-			__field(int, error)
357
+			__field(unsigned long, error)
207
358
 		),
208
359
 
209
360
 		TP_fast_assign(
210
-			__entry->error = error;
361
+			__entry->error = error < 0 ? -error : 0;
211
362
 			__assign_str(dstaddr, clp->cl_hostname);
212
363
 		),
213
364
 
214
365
 		TP_printk(
215
-			"error=%d (%s) dstaddr=%s",
216
-			__entry->error,
366
+			"error=%ld (%s) dstaddr=%s",
367
+			-__entry->error,
217
368
 			show_nfsv4_errors(__entry->error),
218
369
 			__get_str(dstaddr)
219
370
 		)
..
..
@@ -275,7 +426,7 @@
275
426
 			__field(unsigned int, highest_slotid)
276
427
 			__field(unsigned int, target_highest_slotid)
277
428
 			__field(unsigned int, status_flags)
278
-			__field(int, error)
429
+			__field(unsigned long, error)
279
430
 		),
280
431
 
281
432
 		TP_fast_assign(
..
..
@@ -287,13 +438,14 @@
287
438
 			__entry->target_highest_slotid =
288
439
 					res->sr_target_highest_slotid;
289
440
 			__entry->status_flags = res->sr_status_flags;
290
-			__entry->error = res->sr_status;
441
+			__entry->error = res->sr_status < 0 ?
442
+					-res->sr_status : 0;
291
443
 		),
292
444
 		TP_printk(
293
-			"error=%d (%s) session=0x%08x slot_nr=%u seq_nr=%u "
445
+			"error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
294
446
 			"highest_slotid=%u target_highest_slotid=%u "
295
447
 			"status_flags=%u (%s)",
296
-			__entry->error,
448
+			-__entry->error,
297
449
 			show_nfsv4_errors(__entry->error),
298
450
 			__entry->session,
299
451
 			__entry->slot_nr,
..
..
@@ -322,7 +474,7 @@
322
474
 			__field(unsigned int, seq_nr)
323
475
 			__field(unsigned int, highest_slotid)
324
476
 			__field(unsigned int, cachethis)
325
-			__field(int, error)
477
+			__field(unsigned long, error)
326
478
 		),
327
479
 
328
480
 		TP_fast_assign(
..
..
@@ -331,13 +483,13 @@
331
483
 			__entry->seq_nr = args->csa_sequenceid;
332
484
 			__entry->highest_slotid = args->csa_highestslotid;
333
485
 			__entry->cachethis = args->csa_cachethis;
334
-			__entry->error = -be32_to_cpu(status);
486
+			__entry->error = be32_to_cpu(status);
335
487
 		),
336
488
 
337
489
 		TP_printk(
338
-			"error=%d (%s) session=0x%08x slot_nr=%u seq_nr=%u "
490
+			"error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
339
491
 			"highest_slotid=%u",
340
-			__entry->error,
492
+			-__entry->error,
341
493
 			show_nfsv4_errors(__entry->error),
342
494
 			__entry->session,
343
495
 			__entry->slot_nr,
..
..
@@ -345,6 +497,44 @@
345
497
 			__entry->highest_slotid
346
498
 		)
347
499
 );
500
+
501
+TRACE_EVENT(nfs4_cb_seqid_err,
502
+		TP_PROTO(
503
+			const struct cb_sequenceargs *args,
504
+			__be32 status
505
+		),
506
+		TP_ARGS(args, status),
507
+
508
+		TP_STRUCT__entry(
509
+			__field(unsigned int, session)
510
+			__field(unsigned int, slot_nr)
511
+			__field(unsigned int, seq_nr)
512
+			__field(unsigned int, highest_slotid)
513
+			__field(unsigned int, cachethis)
514
+			__field(unsigned long, error)
515
+		),
516
+
517
+		TP_fast_assign(
518
+			__entry->session = nfs_session_id_hash(&args->csa_sessionid);
519
+			__entry->slot_nr = args->csa_slotid;
520
+			__entry->seq_nr = args->csa_sequenceid;
521
+			__entry->highest_slotid = args->csa_highestslotid;
522
+			__entry->cachethis = args->csa_cachethis;
523
+			__entry->error = be32_to_cpu(status);
524
+		),
525
+
526
+		TP_printk(
527
+			"error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
528
+			"highest_slotid=%u",
529
+			-__entry->error,
530
+			show_nfsv4_errors(__entry->error),
531
+			__entry->session,
532
+			__entry->slot_nr,
533
+			__entry->seq_nr,
534
+			__entry->highest_slotid
535
+		)
536
+);
537
+
348
538
 #endif /* CONFIG_NFS_V4_1 */
349
539
 
350
540
 TRACE_EVENT(nfs4_setup_sequence,
..
..
@@ -379,6 +569,174 @@
379
569
 		)
380
570
 );
381
571
 
572
+TRACE_DEFINE_ENUM(NFS4CLNT_MANAGER_RUNNING);
573
+TRACE_DEFINE_ENUM(NFS4CLNT_CHECK_LEASE);
574
+TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_EXPIRED);
575
+TRACE_DEFINE_ENUM(NFS4CLNT_RECLAIM_REBOOT);
576
+TRACE_DEFINE_ENUM(NFS4CLNT_RECLAIM_NOGRACE);
577
+TRACE_DEFINE_ENUM(NFS4CLNT_DELEGRETURN);
578
+TRACE_DEFINE_ENUM(NFS4CLNT_SESSION_RESET);
579
+TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_CONFIRM);
580
+TRACE_DEFINE_ENUM(NFS4CLNT_SERVER_SCOPE_MISMATCH);
581
+TRACE_DEFINE_ENUM(NFS4CLNT_PURGE_STATE);
582
+TRACE_DEFINE_ENUM(NFS4CLNT_BIND_CONN_TO_SESSION);
583
+TRACE_DEFINE_ENUM(NFS4CLNT_MOVED);
584
+TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_MOVED);
585
+TRACE_DEFINE_ENUM(NFS4CLNT_DELEGATION_EXPIRED);
586
+TRACE_DEFINE_ENUM(NFS4CLNT_RUN_MANAGER);
587
+TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_RUNNING);
588
+TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_ANY_LAYOUT_READ);
589
+TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_ANY_LAYOUT_RW);
590
+
591
+#define show_nfs4_clp_state(state) \
592
+	__print_flags(state, "|", \
593
+		{ NFS4CLNT_MANAGER_RUNNING,	"MANAGER_RUNNING" }, \
594
+		{ NFS4CLNT_CHECK_LEASE,		"CHECK_LEASE" }, \
595
+		{ NFS4CLNT_LEASE_EXPIRED,	"LEASE_EXPIRED" }, \
596
+		{ NFS4CLNT_RECLAIM_REBOOT,	"RECLAIM_REBOOT" }, \
597
+		{ NFS4CLNT_RECLAIM_NOGRACE,	"RECLAIM_NOGRACE" }, \
598
+		{ NFS4CLNT_DELEGRETURN,		"DELEGRETURN" }, \
599
+		{ NFS4CLNT_SESSION_RESET,	"SESSION_RESET" }, \
600
+		{ NFS4CLNT_LEASE_CONFIRM,	"LEASE_CONFIRM" }, \
601
+		{ NFS4CLNT_SERVER_SCOPE_MISMATCH, \
602
+						"SERVER_SCOPE_MISMATCH" }, \
603
+		{ NFS4CLNT_PURGE_STATE,		"PURGE_STATE" }, \
604
+		{ NFS4CLNT_BIND_CONN_TO_SESSION, \
605
+						"BIND_CONN_TO_SESSION" }, \
606
+		{ NFS4CLNT_MOVED,		"MOVED" }, \
607
+		{ NFS4CLNT_LEASE_MOVED,		"LEASE_MOVED" }, \
608
+		{ NFS4CLNT_DELEGATION_EXPIRED,	"DELEGATION_EXPIRED" }, \
609
+		{ NFS4CLNT_RUN_MANAGER,		"RUN_MANAGER" }, \
610
+		{ NFS4CLNT_RECALL_RUNNING,	"RECALL_RUNNING" }, \
611
+		{ NFS4CLNT_RECALL_ANY_LAYOUT_READ, "RECALL_ANY_LAYOUT_READ" }, \
612
+		{ NFS4CLNT_RECALL_ANY_LAYOUT_RW, "RECALL_ANY_LAYOUT_RW" })
613
+
614
+TRACE_EVENT(nfs4_state_mgr,
615
+		TP_PROTO(
616
+			const struct nfs_client *clp
617
+		),
618
+
619
+		TP_ARGS(clp),
620
+
621
+		TP_STRUCT__entry(
622
+			__field(unsigned long, state)
623
+			__string(hostname, clp->cl_hostname)
624
+		),
625
+
626
+		TP_fast_assign(
627
+			__entry->state = clp->cl_state;
628
+			__assign_str(hostname, clp->cl_hostname)
629
+		),
630
+
631
+		TP_printk(
632
+			"hostname=%s clp state=%s", __get_str(hostname),
633
+			show_nfs4_clp_state(__entry->state)
634
+		)
635
+)
636
+
637
+TRACE_EVENT(nfs4_state_mgr_failed,
638
+		TP_PROTO(
639
+			const struct nfs_client *clp,
640
+			const char *section,
641
+			int status
642
+		),
643
+
644
+		TP_ARGS(clp, section, status),
645
+
646
+		TP_STRUCT__entry(
647
+			__field(unsigned long, error)
648
+			__field(unsigned long, state)
649
+			__string(hostname, clp->cl_hostname)
650
+			__string(section, section)
651
+		),
652
+
653
+		TP_fast_assign(
654
+			__entry->error = status < 0 ? -status : 0;
655
+			__entry->state = clp->cl_state;
656
+			__assign_str(hostname, clp->cl_hostname);
657
+			__assign_str(section, section);
658
+		),
659
+
660
+		TP_printk(
661
+			"hostname=%s clp state=%s error=%ld (%s) section=%s",
662
+			__get_str(hostname),
663
+			show_nfs4_clp_state(__entry->state), -__entry->error,
664
+			show_nfsv4_errors(__entry->error), __get_str(section)
665
+
666
+		)
667
+)
668
+
669
+TRACE_EVENT(nfs4_xdr_status,
670
+		TP_PROTO(
671
+			const struct xdr_stream *xdr,
672
+			u32 op,
673
+			u32 error
674
+		),
675
+
676
+		TP_ARGS(xdr, op, error),
677
+
678
+		TP_STRUCT__entry(
679
+			__field(unsigned int, task_id)
680
+			__field(unsigned int, client_id)
681
+			__field(u32, xid)
682
+			__field(u32, op)
683
+			__field(unsigned long, error)
684
+		),
685
+
686
+		TP_fast_assign(
687
+			const struct rpc_rqst *rqstp = xdr->rqst;
688
+			const struct rpc_task *task = rqstp->rq_task;
689
+
690
+			__entry->task_id = task->tk_pid;
691
+			__entry->client_id = task->tk_client->cl_clid;
692
+			__entry->xid = be32_to_cpu(rqstp->rq_xid);
693
+			__entry->op = op;
694
+			__entry->error = error;
695
+		),
696
+
697
+		TP_printk(
698
+			"task:%u@%d xid=0x%08x error=%ld (%s) operation=%u",
699
+			__entry->task_id, __entry->client_id, __entry->xid,
700
+			-__entry->error, show_nfsv4_errors(__entry->error),
701
+			__entry->op
702
+		)
703
+);
704
+
705
+DECLARE_EVENT_CLASS(nfs4_cb_error_class,
706
+		TP_PROTO(
707
+			__be32 xid,
708
+			u32 cb_ident
709
+		),
710
+
711
+		TP_ARGS(xid, cb_ident),
712
+
713
+		TP_STRUCT__entry(
714
+			__field(u32, xid)
715
+			__field(u32, cbident)
716
+		),
717
+
718
+		TP_fast_assign(
719
+			__entry->xid = be32_to_cpu(xid);
720
+			__entry->cbident = cb_ident;
721
+		),
722
+
723
+		TP_printk(
724
+			"xid=0x%08x cb_ident=0x%08x",
725
+			__entry->xid, __entry->cbident
726
+		)
727
+);
728
+
729
+#define DEFINE_CB_ERROR_EVENT(name) \
730
+	DEFINE_EVENT(nfs4_cb_error_class, nfs_cb_##name, \
731
+			TP_PROTO( \
732
+				__be32 xid, \
733
+				u32 cb_ident \
734
+			), \
735
+			TP_ARGS(xid, cb_ident))
736
+
737
+DEFINE_CB_ERROR_EVENT(no_clp);
738
+DEFINE_CB_ERROR_EVENT(badprinc);
739
+
382
740
 DECLARE_EVENT_CLASS(nfs4_open_event,
383
741
 		TP_PROTO(
384
742
 			const struct nfs_open_context *ctx,
..
..
@@ -389,7 +747,7 @@
389
747
 		TP_ARGS(ctx, flags, error),
390
748
 
391
749
 		TP_STRUCT__entry(
392
-			__field(int, error)
750
+			__field(unsigned long, error)
393
751
 			__field(unsigned int, flags)
394
752
 			__field(unsigned int, fmode)
395
753
 			__field(dev_t, dev)
..
..
@@ -407,7 +765,7 @@
407
765
 			const struct nfs4_state *state = ctx->state;
408
766
 			const struct inode *inode = NULL;
409
767
 
410
-			__entry->error = error;
768
+			__entry->error = -error;
411
769
 			__entry->flags = flags;
412
770
 			__entry->fmode = (__force unsigned int)ctx->mode;
413
771
 			__entry->dev = ctx->dentry->d_sb->s_dev;
..
..
@@ -439,11 +797,11 @@
439
797
 		),
440
798
 
441
799
 		TP_printk(
442
-			"error=%d (%s) flags=%d (%s) fmode=%s "
800
+			"error=%ld (%s) flags=%d (%s) fmode=%s "
443
801
 			"fileid=%02x:%02x:%llu fhandle=0x%08x "
444
802
 			"name=%02x:%02x:%llu/%s stateid=%d:0x%08x "
445
803
 			"openstateid=%d:0x%08x",
446
-			 __entry->error,
804
+			 -__entry->error,
447
805
 			 show_nfsv4_errors(__entry->error),
448
806
 			 __entry->flags,
449
807
 			 show_open_flags(__entry->flags),
..
..
@@ -525,7 +883,7 @@
525
883
 			__field(u32, fhandle)
526
884
 			__field(u64, fileid)
527
885
 			__field(unsigned int, fmode)
528
-			__field(int, error)
886
+			__field(unsigned long, error)
529
887
 			__field(int, stateid_seq)
530
888
 			__field(u32, stateid_hash)
531
889
 		),
..
..
@@ -537,7 +895,7 @@
537
895
 			__entry->fileid = NFS_FILEID(inode);
538
896
 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
539
897
 			__entry->fmode = (__force unsigned int)state->state;
540
-			__entry->error = error;
898
+			__entry->error = error < 0 ? -error : 0;
541
899
 			__entry->stateid_seq =
542
900
 				be32_to_cpu(args->stateid.seqid);
543
901
 			__entry->stateid_hash =
..
..
@@ -545,9 +903,9 @@
545
903
 		),
546
904
 
547
905
 		TP_printk(
548
-			"error=%d (%s) fmode=%s fileid=%02x:%02x:%llu "
906
+			"error=%ld (%s) fmode=%s fileid=%02x:%02x:%llu "
549
907
 			"fhandle=0x%08x openstateid=%d:0x%08x",
550
-			__entry->error,
908
+			-__entry->error,
551
909
 			show_nfsv4_errors(__entry->error),
552
910
 			__entry->fmode ?  show_fmode_flags(__entry->fmode) :
553
911
 					  "closed",
..
..
@@ -557,6 +915,13 @@
557
915
 			__entry->stateid_seq, __entry->stateid_hash
558
916
 		)
559
917
 );
918
+
919
+TRACE_DEFINE_ENUM(F_GETLK);
920
+TRACE_DEFINE_ENUM(F_SETLK);
921
+TRACE_DEFINE_ENUM(F_SETLKW);
922
+TRACE_DEFINE_ENUM(F_RDLCK);
923
+TRACE_DEFINE_ENUM(F_WRLCK);
924
+TRACE_DEFINE_ENUM(F_UNLCK);
560
925
 
561
926
 #define show_lock_cmd(type) \
562
927
 	__print_symbolic((int)type, \
..
..
@@ -580,7 +945,7 @@
580
945
 		TP_ARGS(request, state, cmd, error),
581
946
 
582
947
 		TP_STRUCT__entry(
583
-			__field(int, error)
948
+			__field(unsigned long, error)
584
949
 			__field(int, cmd)
585
950
 			__field(char, type)
586
951
 			__field(loff_t, start)
..
..
@@ -595,7 +960,7 @@
595
960
 		TP_fast_assign(
596
961
 			const struct inode *inode = state->inode;
597
962
 
598
-			__entry->error = error;
963
+			__entry->error = error < 0 ? -error : 0;
599
964
 			__entry->cmd = cmd;
600
965
 			__entry->type = request->fl_type;
601
966
 			__entry->start = request->fl_start;
..
..
@@ -610,10 +975,10 @@
610
975
 		),
611
976
 
612
977
 		TP_printk(
613
-			"error=%d (%s) cmd=%s:%s range=%lld:%lld "
978
+			"error=%ld (%s) cmd=%s:%s range=%lld:%lld "
614
979
 			"fileid=%02x:%02x:%llu fhandle=0x%08x "
615
980
 			"stateid=%d:0x%08x",
616
-			__entry->error,
981
+			-__entry->error,
617
982
 			show_nfsv4_errors(__entry->error),
618
983
 			show_lock_cmd(__entry->cmd),
619
984
 			show_lock_type(__entry->type),
..
..
@@ -650,7 +1015,7 @@
650
1015
 		TP_ARGS(request, state, lockstateid, cmd, error),
651
1016
 
652
1017
 		TP_STRUCT__entry(
653
-			__field(int, error)
1018
+			__field(unsigned long, error)
654
1019
 			__field(int, cmd)
655
1020
 			__field(char, type)
656
1021
 			__field(loff_t, start)
..
..
@@ -667,7 +1032,7 @@
667
1032
 		TP_fast_assign(
668
1033
 			const struct inode *inode = state->inode;
669
1034
 
670
-			__entry->error = error;
1035
+			__entry->error = error < 0 ? -error : 0;
671
1036
 			__entry->cmd = cmd;
672
1037
 			__entry->type = request->fl_type;
673
1038
 			__entry->start = request->fl_start;
..
..
@@ -686,10 +1051,10 @@
686
1051
 		),
687
1052
 
688
1053
 		TP_printk(
689
-			"error=%d (%s) cmd=%s:%s range=%lld:%lld "
1054
+			"error=%ld (%s) cmd=%s:%s range=%lld:%lld "
690
1055
 			"fileid=%02x:%02x:%llu fhandle=0x%08x "
691
1056
 			"stateid=%d:0x%08x lockstateid=%d:0x%08x",
692
-			__entry->error,
1057
+			-__entry->error,
693
1058
 			show_nfsv4_errors(__entry->error),
694
1059
 			show_lock_cmd(__entry->cmd),
695
1060
 			show_lock_type(__entry->type),
..
..
@@ -702,6 +1067,88 @@
702
1067
 			__entry->lockstateid_seq, __entry->lockstateid_hash
703
1068
 		)
704
1069
 );
1070
+
1071
+TRACE_DEFINE_ENUM(LK_STATE_IN_USE);
1072
+TRACE_DEFINE_ENUM(NFS_DELEGATED_STATE);
1073
+TRACE_DEFINE_ENUM(NFS_OPEN_STATE);
1074
+TRACE_DEFINE_ENUM(NFS_O_RDONLY_STATE);
1075
+TRACE_DEFINE_ENUM(NFS_O_WRONLY_STATE);
1076
+TRACE_DEFINE_ENUM(NFS_O_RDWR_STATE);
1077
+TRACE_DEFINE_ENUM(NFS_STATE_RECLAIM_REBOOT);
1078
+TRACE_DEFINE_ENUM(NFS_STATE_RECLAIM_NOGRACE);
1079
+TRACE_DEFINE_ENUM(NFS_STATE_POSIX_LOCKS);
1080
+TRACE_DEFINE_ENUM(NFS_STATE_RECOVERY_FAILED);
1081
+TRACE_DEFINE_ENUM(NFS_STATE_MAY_NOTIFY_LOCK);
1082
+TRACE_DEFINE_ENUM(NFS_STATE_CHANGE_WAIT);
1083
+TRACE_DEFINE_ENUM(NFS_CLNT_DST_SSC_COPY_STATE);
1084
+TRACE_DEFINE_ENUM(NFS_CLNT_SRC_SSC_COPY_STATE);
1085
+TRACE_DEFINE_ENUM(NFS_SRV_SSC_COPY_STATE);
1086
+
1087
+#define show_nfs4_state_flags(flags) \
1088
+	__print_flags(flags, "|", \
1089
+		{ LK_STATE_IN_USE,		"IN_USE" }, \
1090
+		{ NFS_DELEGATED_STATE,		"DELEGATED" }, \
1091
+		{ NFS_OPEN_STATE,		"OPEN" }, \
1092
+		{ NFS_O_RDONLY_STATE,		"O_RDONLY" }, \
1093
+		{ NFS_O_WRONLY_STATE,		"O_WRONLY" }, \
1094
+		{ NFS_O_RDWR_STATE,		"O_RDWR" }, \
1095
+		{ NFS_STATE_RECLAIM_REBOOT,	"RECLAIM_REBOOT" }, \
1096
+		{ NFS_STATE_RECLAIM_NOGRACE,	"RECLAIM_NOGRACE" }, \
1097
+		{ NFS_STATE_POSIX_LOCKS,	"POSIX_LOCKS" }, \
1098
+		{ NFS_STATE_RECOVERY_FAILED,	"RECOVERY_FAILED" }, \
1099
+		{ NFS_STATE_MAY_NOTIFY_LOCK,	"MAY_NOTIFY_LOCK" }, \
1100
+		{ NFS_STATE_CHANGE_WAIT,	"CHANGE_WAIT" }, \
1101
+		{ NFS_CLNT_DST_SSC_COPY_STATE,	"CLNT_DST_SSC_COPY" }, \
1102
+		{ NFS_CLNT_SRC_SSC_COPY_STATE,	"CLNT_SRC_SSC_COPY" }, \
1103
+		{ NFS_SRV_SSC_COPY_STATE,	"SRV_SSC_COPY" })
1104
+
1105
+#define show_nfs4_lock_flags(flags) \
1106
+	__print_flags(flags, "|", \
1107
+		{ BIT(NFS_LOCK_INITIALIZED),	"INITIALIZED" }, \
1108
+		{ BIT(NFS_LOCK_LOST),		"LOST" })
1109
+
1110
+TRACE_EVENT(nfs4_state_lock_reclaim,
1111
+		TP_PROTO(
1112
+			const struct nfs4_state *state,
1113
+			const struct nfs4_lock_state *lock
1114
+		),
1115
+
1116
+		TP_ARGS(state, lock),
1117
+
1118
+		TP_STRUCT__entry(
1119
+			__field(dev_t, dev)
1120
+			__field(u32, fhandle)
1121
+			__field(u64, fileid)
1122
+			__field(unsigned long, state_flags)
1123
+			__field(unsigned long, lock_flags)
1124
+			__field(int, stateid_seq)
1125
+			__field(u32, stateid_hash)
1126
+		),
1127
+
1128
+		TP_fast_assign(
1129
+			const struct inode *inode = state->inode;
1130
+
1131
+			__entry->dev = inode->i_sb->s_dev;
1132
+			__entry->fileid = NFS_FILEID(inode);
1133
+			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1134
+			__entry->state_flags = state->flags;
1135
+			__entry->lock_flags = lock->ls_flags;
1136
+			__entry->stateid_seq =
1137
+				be32_to_cpu(state->stateid.seqid);
1138
+			__entry->stateid_hash =
1139
+				nfs_stateid_hash(&state->stateid);
1140
+		),
1141
+
1142
+		TP_printk(
1143
+			"fileid=%02x:%02x:%llu fhandle=0x%08x "
1144
+			"stateid=%d:0x%08x state_flags=%s lock_flags=%s",
1145
+			MAJOR(__entry->dev), MINOR(__entry->dev),
1146
+			(unsigned long long)__entry->fileid, __entry->fhandle,
1147
+			__entry->stateid_seq, __entry->stateid_hash,
1148
+			show_nfs4_state_flags(__entry->state_flags),
1149
+			show_nfs4_lock_flags(__entry->lock_flags)
1150
+		)
1151
+)
705
1152
 
706
1153
 DECLARE_EVENT_CLASS(nfs4_set_delegation_event,
707
1154
 		TP_PROTO(
..
..
@@ -755,7 +1202,7 @@
755
1202
 		TP_STRUCT__entry(
756
1203
 			__field(dev_t, dev)
757
1204
 			__field(u32, fhandle)
758
-			__field(int, error)
1205
+			__field(unsigned long, error)
759
1206
 			__field(int, stateid_seq)
760
1207
 			__field(u32, stateid_hash)
761
1208
 		),
..
..
@@ -763,7 +1210,7 @@
763
1210
 		TP_fast_assign(
764
1211
 			__entry->dev = res->server->s_dev;
765
1212
 			__entry->fhandle = nfs_fhandle_hash(args->fhandle);
766
-			__entry->error = error;
1213
+			__entry->error = error < 0 ? -error : 0;
767
1214
 			__entry->stateid_seq =
768
1215
 				be32_to_cpu(args->stateid->seqid);
769
1216
 			__entry->stateid_hash =
..
..
@@ -771,9 +1218,9 @@
771
1218
 		),
772
1219
 
773
1220
 		TP_printk(
774
-			"error=%d (%s) dev=%02x:%02x fhandle=0x%08x "
1221
+			"error=%ld (%s) dev=%02x:%02x fhandle=0x%08x "
775
1222
 			"stateid=%d:0x%08x",
776
-			__entry->error,
1223
+			-__entry->error,
777
1224
 			show_nfsv4_errors(__entry->error),
778
1225
 			MAJOR(__entry->dev), MINOR(__entry->dev),
779
1226
 			__entry->fhandle,
..
..
@@ -792,7 +1239,7 @@
792
1239
 		TP_ARGS(state, lsp, error),
793
1240
 
794
1241
 		TP_STRUCT__entry(
795
-			__field(int, error)
1242
+			__field(unsigned long, error)
796
1243
 			__field(dev_t, dev)
797
1244
 			__field(u32, fhandle)
798
1245
 			__field(u64, fileid)
..
..
@@ -803,7 +1250,7 @@
803
1250
 		TP_fast_assign(
804
1251
 			const struct inode *inode = state->inode;
805
1252
 
806
-			__entry->error = error;
1253
+			__entry->error = error < 0 ? -error : 0;
807
1254
 			__entry->dev = inode->i_sb->s_dev;
808
1255
 			__entry->fileid = NFS_FILEID(inode);
809
1256
 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
..
..
@@ -814,9 +1261,9 @@
814
1261
 		),
815
1262
 
816
1263
 		TP_printk(
817
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1264
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
818
1265
 			"stateid=%d:0x%08x",
819
-			__entry->error,
1266
+			-__entry->error,
820
1267
 			show_nfsv4_errors(__entry->error),
821
1268
 			MAJOR(__entry->dev), MINOR(__entry->dev),
822
1269
 			(unsigned long long)__entry->fileid,
..
..
@@ -849,7 +1296,7 @@
849
1296
 
850
1297
 		TP_STRUCT__entry(
851
1298
 			__field(dev_t, dev)
852
-			__field(int, error)
1299
+			__field(unsigned long, error)
853
1300
 			__field(u64, dir)
854
1301
 			__string(name, name->name)
855
1302
 		),
..
..
@@ -857,13 +1304,13 @@
857
1304
 		TP_fast_assign(
858
1305
 			__entry->dev = dir->i_sb->s_dev;
859
1306
 			__entry->dir = NFS_FILEID(dir);
860
-			__entry->error = error;
1307
+			__entry->error = -error;
861
1308
 			__assign_str(name, name->name);
862
1309
 		),
863
1310
 
864
1311
 		TP_printk(
865
-			"error=%d (%s) name=%02x:%02x:%llu/%s",
866
-			__entry->error,
1312
+			"error=%ld (%s) name=%02x:%02x:%llu/%s",
1313
+			-__entry->error,
867
1314
 			show_nfsv4_errors(__entry->error),
868
1315
 			MAJOR(__entry->dev), MINOR(__entry->dev),
869
1316
 			(unsigned long long)__entry->dir,
..
..
@@ -899,18 +1346,18 @@
899
1346
 		TP_STRUCT__entry(
900
1347
 			__field(dev_t, dev)
901
1348
 			__field(u64, ino)
902
-			__field(int, error)
1349
+			__field(unsigned long, error)
903
1350
 		),
904
1351
 
905
1352
 		TP_fast_assign(
906
1353
 			__entry->dev = inode->i_sb->s_dev;
907
1354
 			__entry->ino = NFS_FILEID(inode);
908
-			__entry->error = error;
1355
+			__entry->error = error < 0 ? -error : 0;
909
1356
 		),
910
1357
 
911
1358
 		TP_printk(
912
-			"error=%d (%s) inode=%02x:%02x:%llu",
913
-			__entry->error,
1359
+			"error=%ld (%s) inode=%02x:%02x:%llu",
1360
+			-__entry->error,
914
1361
 			show_nfsv4_errors(__entry->error),
915
1362
 			MAJOR(__entry->dev), MINOR(__entry->dev),
916
1363
 			(unsigned long long)__entry->ino
..
..
@@ -930,7 +1377,7 @@
930
1377
 
931
1378
 		TP_STRUCT__entry(
932
1379
 			__field(dev_t, dev)
933
-			__field(int, error)
1380
+			__field(unsigned long, error)
934
1381
 			__field(u64, olddir)
935
1382
 			__string(oldname, oldname->name)
936
1383
 			__field(u64, newdir)
..
..
@@ -941,15 +1388,15 @@
941
1388
 			__entry->dev = olddir->i_sb->s_dev;
942
1389
 			__entry->olddir = NFS_FILEID(olddir);
943
1390
 			__entry->newdir = NFS_FILEID(newdir);
944
-			__entry->error = error;
1391
+			__entry->error = error < 0 ? -error : 0;
945
1392
 			__assign_str(oldname, oldname->name);
946
1393
 			__assign_str(newname, newname->name);
947
1394
 		),
948
1395
 
949
1396
 		TP_printk(
950
-			"error=%d (%s) oldname=%02x:%02x:%llu/%s "
1397
+			"error=%ld (%s) oldname=%02x:%02x:%llu/%s "
951
1398
 			"newname=%02x:%02x:%llu/%s",
952
-			__entry->error,
1399
+			-__entry->error,
953
1400
 			show_nfsv4_errors(__entry->error),
954
1401
 			MAJOR(__entry->dev), MINOR(__entry->dev),
955
1402
 			(unsigned long long)__entry->olddir,
..
..
@@ -972,19 +1419,19 @@
972
1419
 			__field(dev_t, dev)
973
1420
 			__field(u32, fhandle)
974
1421
 			__field(u64, fileid)
975
-			__field(int, error)
1422
+			__field(unsigned long, error)
976
1423
 		),
977
1424
 
978
1425
 		TP_fast_assign(
979
1426
 			__entry->dev = inode->i_sb->s_dev;
980
1427
 			__entry->fileid = NFS_FILEID(inode);
981
1428
 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
982
-			__entry->error = error;
1429
+			__entry->error = error < 0 ? -error : 0;
983
1430
 		),
984
1431
 
985
1432
 		TP_printk(
986
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x",
987
-			__entry->error,
1433
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x",
1434
+			-__entry->error,
988
1435
 			show_nfsv4_errors(__entry->error),
989
1436
 			MAJOR(__entry->dev), MINOR(__entry->dev),
990
1437
 			(unsigned long long)__entry->fileid,
..
..
@@ -1023,7 +1470,7 @@
1023
1470
 			__field(dev_t, dev)
1024
1471
 			__field(u32, fhandle)
1025
1472
 			__field(u64, fileid)
1026
-			__field(int, error)
1473
+			__field(unsigned long, error)
1027
1474
 			__field(int, stateid_seq)
1028
1475
 			__field(u32, stateid_hash)
1029
1476
 		),
..
..
@@ -1032,7 +1479,7 @@
1032
1479
 			__entry->dev = inode->i_sb->s_dev;
1033
1480
 			__entry->fileid = NFS_FILEID(inode);
1034
1481
 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1035
-			__entry->error = error;
1482
+			__entry->error = error < 0 ? -error : 0;
1036
1483
 			__entry->stateid_seq =
1037
1484
 				be32_to_cpu(stateid->seqid);
1038
1485
 			__entry->stateid_hash =
..
..
@@ -1040,9 +1487,9 @@
1040
1487
 		),
1041
1488
 
1042
1489
 		TP_printk(
1043
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1490
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1044
1491
 			"stateid=%d:0x%08x",
1045
-			__entry->error,
1492
+			-__entry->error,
1046
1493
 			show_nfsv4_errors(__entry->error),
1047
1494
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1048
1495
 			(unsigned long long)__entry->fileid,
..
..
@@ -1064,6 +1511,7 @@
1064
1511
 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_delegreturn);
1065
1512
 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update);
1066
1513
 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update_wait);
1514
+DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_close_stateid_update_wait);
1067
1515
 
1068
1516
 DECLARE_EVENT_CLASS(nfs4_getattr_event,
1069
1517
 		TP_PROTO(
..
..
@@ -1080,7 +1528,7 @@
1080
1528
 			__field(u32, fhandle)
1081
1529
 			__field(u64, fileid)
1082
1530
 			__field(unsigned int, valid)
1083
-			__field(int, error)
1531
+			__field(unsigned long, error)
1084
1532
 		),
1085
1533
 
1086
1534
 		TP_fast_assign(
..
..
@@ -1088,13 +1536,13 @@
1088
1536
 			__entry->valid = fattr->valid;
1089
1537
 			__entry->fhandle = nfs_fhandle_hash(fhandle);
1090
1538
 			__entry->fileid = (fattr->valid & NFS_ATTR_FATTR_FILEID) ? fattr->fileid : 0;
1091
-			__entry->error = error;
1539
+			__entry->error = error < 0 ? -error : 0;
1092
1540
 		),
1093
1541
 
1094
1542
 		TP_printk(
1095
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1543
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1096
1544
 			"valid=%s",
1097
-			__entry->error,
1545
+			-__entry->error,
1098
1546
 			show_nfsv4_errors(__entry->error),
1099
1547
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1100
1548
 			(unsigned long long)__entry->fileid,
..
..
@@ -1127,7 +1575,7 @@
1127
1575
 		TP_ARGS(clp, fhandle, inode, error),
1128
1576
 
1129
1577
 		TP_STRUCT__entry(
1130
-			__field(int, error)
1578
+			__field(unsigned long, error)
1131
1579
 			__field(dev_t, dev)
1132
1580
 			__field(u32, fhandle)
1133
1581
 			__field(u64, fileid)
..
..
@@ -1135,7 +1583,7 @@
1135
1583
 		),
1136
1584
 
1137
1585
 		TP_fast_assign(
1138
-			__entry->error = error;
1586
+			__entry->error = error < 0 ? -error : 0;
1139
1587
 			__entry->fhandle = nfs_fhandle_hash(fhandle);
1140
1588
 			if (!IS_ERR_OR_NULL(inode)) {
1141
1589
 				__entry->fileid = NFS_FILEID(inode);
..
..
@@ -1148,9 +1596,9 @@
1148
1596
 		),
1149
1597
 
1150
1598
 		TP_printk(
1151
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1599
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1152
1600
 			"dstaddr=%s",
1153
-			__entry->error,
1601
+			-__entry->error,
1154
1602
 			show_nfsv4_errors(__entry->error),
1155
1603
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1156
1604
 			(unsigned long long)__entry->fileid,
..
..
@@ -1182,7 +1630,7 @@
1182
1630
 		TP_ARGS(clp, fhandle, inode, stateid, error),
1183
1631
 
1184
1632
 		TP_STRUCT__entry(
1185
-			__field(int, error)
1633
+			__field(unsigned long, error)
1186
1634
 			__field(dev_t, dev)
1187
1635
 			__field(u32, fhandle)
1188
1636
 			__field(u64, fileid)
..
..
@@ -1192,7 +1640,7 @@
1192
1640
 		),
1193
1641
 
1194
1642
 		TP_fast_assign(
1195
-			__entry->error = error;
1643
+			__entry->error = error < 0 ? -error : 0;
1196
1644
 			__entry->fhandle = nfs_fhandle_hash(fhandle);
1197
1645
 			if (!IS_ERR_OR_NULL(inode)) {
1198
1646
 				__entry->fileid = NFS_FILEID(inode);
..
..
@@ -1209,9 +1657,9 @@
1209
1657
 		),
1210
1658
 
1211
1659
 		TP_printk(
1212
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1660
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1213
1661
 			"stateid=%d:0x%08x dstaddr=%s",
1214
-			__entry->error,
1662
+			-__entry->error,
1215
1663
 			show_nfsv4_errors(__entry->error),
1216
1664
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1217
1665
 			(unsigned long long)__entry->fileid,
..
..
@@ -1245,7 +1693,7 @@
1245
1693
 		TP_ARGS(name, len, id, error),
1246
1694
 
1247
1695
 		TP_STRUCT__entry(
1248
-			__field(int, error)
1696
+			__field(unsigned long, error)
1249
1697
 			__field(u32, id)
1250
1698
 			__dynamic_array(char, name, len > 0 ? len + 1 : 1)
1251
1699
 		),
..
..
@@ -1260,8 +1708,8 @@
1260
1708
 		),
1261
1709
 
1262
1710
 		TP_printk(
1263
-			"error=%d id=%u name=%s",
1264
-			__entry->error,
1711
+			"error=%ld (%s) id=%u name=%s",
1712
+			-__entry->error, show_nfsv4_errors(__entry->error),
1265
1713
 			__entry->id,
1266
1714
 			__get_str(name)
1267
1715
 		)
..
..
@@ -1280,6 +1728,13 @@
1280
1728
 DEFINE_NFS4_IDMAP_EVENT(nfs4_map_uid_to_name);
1281
1729
 DEFINE_NFS4_IDMAP_EVENT(nfs4_map_gid_to_group);
1282
1730
 
1731
+#ifdef CONFIG_NFS_V4_1
1732
+#define NFS4_LSEG_LAYOUT_STATEID_HASH(lseg) \
1733
+	(lseg ? nfs_stateid_hash(&lseg->pls_layout->plh_stateid) : 0)
1734
+#else
1735
+#define NFS4_LSEG_LAYOUT_STATEID_HASH(lseg) (0)
1736
+#endif
1737
+
1283
1738
 DECLARE_EVENT_CLASS(nfs4_read_event,
1284
1739
 		TP_PROTO(
1285
1740
 			const struct nfs_pgio_header *hdr,
..
..
@@ -1293,39 +1748,53 @@
1293
1748
 			__field(u32, fhandle)
1294
1749
 			__field(u64, fileid)
1295
1750
 			__field(loff_t, offset)
1296
-			__field(size_t, count)
1297
-			__field(int, error)
1751
+			__field(u32, arg_count)
1752
+			__field(u32, res_count)
1753
+			__field(unsigned long, error)
1298
1754
 			__field(int, stateid_seq)
1299
1755
 			__field(u32, stateid_hash)
1756
+			__field(int, layoutstateid_seq)
1757
+			__field(u32, layoutstateid_hash)
1300
1758
 		),
1301
1759
 
1302
1760
 		TP_fast_assign(
1303
1761
 			const struct inode *inode = hdr->inode;
1762
+			const struct nfs_inode *nfsi = NFS_I(inode);
1763
+			const struct nfs_fh *fh = hdr->args.fh ?
1764
+						  hdr->args.fh : &nfsi->fh;
1304
1765
 			const struct nfs4_state *state =
1305
1766
 				hdr->args.context->state;
1767
+			const struct pnfs_layout_segment *lseg = hdr->lseg;
1768
+
1306
1769
 			__entry->dev = inode->i_sb->s_dev;
1307
-			__entry->fileid = NFS_FILEID(inode);
1308
-			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1770
+			__entry->fileid = nfsi->fileid;
1771
+			__entry->fhandle = nfs_fhandle_hash(fh);
1309
1772
 			__entry->offset = hdr->args.offset;
1310
-			__entry->count = hdr->args.count;
1311
-			__entry->error = error;
1773
+			__entry->arg_count = hdr->args.count;
1774
+			__entry->res_count = hdr->res.count;
1775
+			__entry->error = error < 0 ? -error : 0;
1312
1776
 			__entry->stateid_seq =
1313
1777
 				be32_to_cpu(state->stateid.seqid);
1314
1778
 			__entry->stateid_hash =
1315
1779
 				nfs_stateid_hash(&state->stateid);
1780
+			__entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
1781
+			__entry->layoutstateid_hash =
1782
+				NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
1316
1783
 		),
1317
1784
 
1318
1785
 		TP_printk(
1319
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1320
-			"offset=%lld count=%zu stateid=%d:0x%08x",
1321
-			__entry->error,
1786
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1787
+			"offset=%lld count=%u res=%u stateid=%d:0x%08x "
1788
+			"layoutstateid=%d:0x%08x",
1789
+			-__entry->error,
1322
1790
 			show_nfsv4_errors(__entry->error),
1323
1791
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1324
1792
 			(unsigned long long)__entry->fileid,
1325
1793
 			__entry->fhandle,
1326
1794
 			(long long)__entry->offset,
1327
-			__entry->count,
1328
-			__entry->stateid_seq, __entry->stateid_hash
1795
+			__entry->arg_count, __entry->res_count,
1796
+			__entry->stateid_seq, __entry->stateid_hash,
1797
+			__entry->layoutstateid_seq, __entry->layoutstateid_hash
1329
1798
 		)
1330
1799
 );
1331
1800
 #define DEFINE_NFS4_READ_EVENT(name) \
..
..
@@ -1353,39 +1822,53 @@
1353
1822
 			__field(u32, fhandle)
1354
1823
 			__field(u64, fileid)
1355
1824
 			__field(loff_t, offset)
1356
-			__field(size_t, count)
1357
-			__field(int, error)
1825
+			__field(u32, arg_count)
1826
+			__field(u32, res_count)
1827
+			__field(unsigned long, error)
1358
1828
 			__field(int, stateid_seq)
1359
1829
 			__field(u32, stateid_hash)
1830
+			__field(int, layoutstateid_seq)
1831
+			__field(u32, layoutstateid_hash)
1360
1832
 		),
1361
1833
 
1362
1834
 		TP_fast_assign(
1363
1835
 			const struct inode *inode = hdr->inode;
1836
+			const struct nfs_inode *nfsi = NFS_I(inode);
1837
+			const struct nfs_fh *fh = hdr->args.fh ?
1838
+						  hdr->args.fh : &nfsi->fh;
1364
1839
 			const struct nfs4_state *state =
1365
1840
 				hdr->args.context->state;
1841
+			const struct pnfs_layout_segment *lseg = hdr->lseg;
1842
+
1366
1843
 			__entry->dev = inode->i_sb->s_dev;
1367
-			__entry->fileid = NFS_FILEID(inode);
1368
-			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1844
+			__entry->fileid = nfsi->fileid;
1845
+			__entry->fhandle = nfs_fhandle_hash(fh);
1369
1846
 			__entry->offset = hdr->args.offset;
1370
-			__entry->count = hdr->args.count;
1371
-			__entry->error = error;
1847
+			__entry->arg_count = hdr->args.count;
1848
+			__entry->res_count = hdr->res.count;
1849
+			__entry->error = error < 0 ? -error : 0;
1372
1850
 			__entry->stateid_seq =
1373
1851
 				be32_to_cpu(state->stateid.seqid);
1374
1852
 			__entry->stateid_hash =
1375
1853
 				nfs_stateid_hash(&state->stateid);
1854
+			__entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
1855
+			__entry->layoutstateid_hash =
1856
+				NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
1376
1857
 		),
1377
1858
 
1378
1859
 		TP_printk(
1379
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1380
-			"offset=%lld count=%zu stateid=%d:0x%08x",
1381
-			__entry->error,
1860
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1861
+			"offset=%lld count=%u res=%u stateid=%d:0x%08x "
1862
+			"layoutstateid=%d:0x%08x",
1863
+			-__entry->error,
1382
1864
 			show_nfsv4_errors(__entry->error),
1383
1865
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1384
1866
 			(unsigned long long)__entry->fileid,
1385
1867
 			__entry->fhandle,
1386
1868
 			(long long)__entry->offset,
1387
-			__entry->count,
1388
-			__entry->stateid_seq, __entry->stateid_hash
1869
+			__entry->arg_count, __entry->res_count,
1870
+			__entry->stateid_seq, __entry->stateid_hash,
1871
+			__entry->layoutstateid_seq, __entry->layoutstateid_hash
1389
1872
 		)
1390
1873
 );
1391
1874
 
..
..
@@ -1413,31 +1896,42 @@
1413
1896
 			__field(dev_t, dev)
1414
1897
 			__field(u32, fhandle)
1415
1898
 			__field(u64, fileid)
1899
+			__field(unsigned long, error)
1416
1900
 			__field(loff_t, offset)
1417
-			__field(size_t, count)
1418
-			__field(int, error)
1901
+			__field(u32, count)
1902
+			__field(int, layoutstateid_seq)
1903
+			__field(u32, layoutstateid_hash)
1419
1904
 		),
1420
1905
 
1421
1906
 		TP_fast_assign(
1422
1907
 			const struct inode *inode = data->inode;
1908
+			const struct nfs_inode *nfsi = NFS_I(inode);
1909
+			const struct nfs_fh *fh = data->args.fh ?
1910
+						  data->args.fh : &nfsi->fh;
1911
+			const struct pnfs_layout_segment *lseg = data->lseg;
1912
+
1423
1913
 			__entry->dev = inode->i_sb->s_dev;
1424
-			__entry->fileid = NFS_FILEID(inode);
1425
-			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1914
+			__entry->fileid = nfsi->fileid;
1915
+			__entry->fhandle = nfs_fhandle_hash(fh);
1426
1916
 			__entry->offset = data->args.offset;
1427
1917
 			__entry->count = data->args.count;
1428
-			__entry->error = error;
1918
+			__entry->error = error < 0 ? -error : 0;
1919
+			__entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
1920
+			__entry->layoutstateid_hash =
1921
+				NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
1429
1922
 		),
1430
1923
 
1431
1924
 		TP_printk(
1432
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1433
-			"offset=%lld count=%zu",
1434
-			__entry->error,
1925
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1926
+			"offset=%lld count=%u layoutstateid=%d:0x%08x",
1927
+			-__entry->error,
1435
1928
 			show_nfsv4_errors(__entry->error),
1436
1929
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1437
1930
 			(unsigned long long)__entry->fileid,
1438
1931
 			__entry->fhandle,
1439
1932
 			(long long)__entry->offset,
1440
-			__entry->count
1933
+			__entry->count,
1934
+			__entry->layoutstateid_seq, __entry->layoutstateid_hash
1441
1935
 		)
1442
1936
 );
1443
1937
 #define DEFINE_NFS4_COMMIT_EVENT(name) \
..
..
@@ -1450,6 +1944,10 @@
1450
1944
 DEFINE_NFS4_COMMIT_EVENT(nfs4_commit);
1451
1945
 #ifdef CONFIG_NFS_V4_1
1452
1946
 DEFINE_NFS4_COMMIT_EVENT(nfs4_pnfs_commit_ds);
1947
+
1948
+TRACE_DEFINE_ENUM(IOMODE_READ);
1949
+TRACE_DEFINE_ENUM(IOMODE_RW);
1950
+TRACE_DEFINE_ENUM(IOMODE_ANY);
1453
1951
 
1454
1952
 #define show_pnfs_iomode(iomode) \
1455
1953
 	__print_symbolic(iomode, \
..
..
@@ -1475,7 +1973,7 @@
1475
1973
 			__field(u32, iomode)
1476
1974
 			__field(u64, offset)
1477
1975
 			__field(u64, count)
1478
-			__field(int, error)
1976
+			__field(unsigned long, error)
1479
1977
 			__field(int, stateid_seq)
1480
1978
 			__field(u32, stateid_hash)
1481
1979
 			__field(int, layoutstateid_seq)
..
..
@@ -1491,7 +1989,7 @@
1491
1989
 			__entry->iomode = args->iomode;
1492
1990
 			__entry->offset = args->offset;
1493
1991
 			__entry->count = args->length;
1494
-			__entry->error = error;
1992
+			__entry->error = error < 0 ? -error : 0;
1495
1993
 			__entry->stateid_seq =
1496
1994
 				be32_to_cpu(state->stateid.seqid);
1497
1995
 			__entry->stateid_hash =
..
..
@@ -1508,10 +2006,10 @@
1508
2006
 		),
1509
2007
 
1510
2008
 		TP_printk(
1511
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2009
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1512
2010
 			"iomode=%s offset=%llu count=%llu stateid=%d:0x%08x "
1513
2011
 			"layoutstateid=%d:0x%08x",
1514
-			__entry->error,
2012
+			-__entry->error,
1515
2013
 			show_nfsv4_errors(__entry->error),
1516
2014
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1517
2015
 			(unsigned long long)__entry->fileid,
..
..
@@ -1526,7 +2024,24 @@
1526
2024
 
1527
2025
 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutcommit);
1528
2026
 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn);
1529
-DEFINE_NFS4_INODE_EVENT(nfs4_layoutreturn_on_close);
2027
+DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn_on_close);
2028
+DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layouterror);
2029
+DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutstats);
2030
+
2031
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_UNKNOWN);
2032
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NO_PNFS);
2033
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RD_ZEROLEN);
2034
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_MDSTHRESH);
2035
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NOMEM);
2036
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_BULK_RECALL);
2037
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_IO_TEST_FAIL);
2038
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_FOUND_CACHED);
2039
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RETURN);
2040
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_BLOCKED);
2041
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_INVALID_OPEN);
2042
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RETRY);
2043
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET);
2044
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_EXIT);
1530
2045
 
1531
2046
 #define show_pnfs_update_layout_reason(reason)				\
1532
2047
 	__print_symbolic(reason,					\
..
..
@@ -1542,7 +2057,8 @@
1542
2057
 		{ PNFS_UPDATE_LAYOUT_BLOCKED, "layouts blocked" },	\
1543
2058
 		{ PNFS_UPDATE_LAYOUT_INVALID_OPEN, "invalid open" },	\
1544
2059
 		{ PNFS_UPDATE_LAYOUT_RETRY, "retrying" },	\
1545
-		{ PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET, "sent layoutget" })
2060
+		{ PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET, "sent layoutget" }, \
2061
+		{ PNFS_UPDATE_LAYOUT_EXIT, "exit" })
1546
2062
 
1547
2063
 TRACE_EVENT(pnfs_update_layout,
1548
2064
 		TP_PROTO(struct inode *inode,
..
..
@@ -1601,6 +2117,187 @@
1601
2117
 		)
1602
2118
 );
1603
2119
 
2120
+DECLARE_EVENT_CLASS(pnfs_layout_event,
2121
+		TP_PROTO(struct inode *inode,
2122
+			loff_t pos,
2123
+			u64 count,
2124
+			enum pnfs_iomode iomode,
2125
+			struct pnfs_layout_hdr *lo,
2126
+			struct pnfs_layout_segment *lseg
2127
+		),
2128
+		TP_ARGS(inode, pos, count, iomode, lo, lseg),
2129
+		TP_STRUCT__entry(
2130
+			__field(dev_t, dev)
2131
+			__field(u64, fileid)
2132
+			__field(u32, fhandle)
2133
+			__field(loff_t, pos)
2134
+			__field(u64, count)
2135
+			__field(enum pnfs_iomode, iomode)
2136
+			__field(int, layoutstateid_seq)
2137
+			__field(u32, layoutstateid_hash)
2138
+			__field(long, lseg)
2139
+		),
2140
+		TP_fast_assign(
2141
+			__entry->dev = inode->i_sb->s_dev;
2142
+			__entry->fileid = NFS_FILEID(inode);
2143
+			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
2144
+			__entry->pos = pos;
2145
+			__entry->count = count;
2146
+			__entry->iomode = iomode;
2147
+			if (lo != NULL) {
2148
+				__entry->layoutstateid_seq =
2149
+				be32_to_cpu(lo->plh_stateid.seqid);
2150
+				__entry->layoutstateid_hash =
2151
+				nfs_stateid_hash(&lo->plh_stateid);
2152
+			} else {
2153
+				__entry->layoutstateid_seq = 0;
2154
+				__entry->layoutstateid_hash = 0;
2155
+			}
2156
+			__entry->lseg = (long)lseg;
2157
+		),
2158
+		TP_printk(
2159
+			"fileid=%02x:%02x:%llu fhandle=0x%08x "
2160
+			"iomode=%s pos=%llu count=%llu "
2161
+			"layoutstateid=%d:0x%08x lseg=0x%lx",
2162
+			MAJOR(__entry->dev), MINOR(__entry->dev),
2163
+			(unsigned long long)__entry->fileid,
2164
+			__entry->fhandle,
2165
+			show_pnfs_iomode(__entry->iomode),
2166
+			(unsigned long long)__entry->pos,
2167
+			(unsigned long long)__entry->count,
2168
+			__entry->layoutstateid_seq, __entry->layoutstateid_hash,
2169
+			__entry->lseg
2170
+		)
2171
+);
2172
+
2173
+#define DEFINE_PNFS_LAYOUT_EVENT(name) \
2174
+	DEFINE_EVENT(pnfs_layout_event, name, \
2175
+		TP_PROTO(struct inode *inode, \
2176
+			loff_t pos, \
2177
+			u64 count, \
2178
+			enum pnfs_iomode iomode, \
2179
+			struct pnfs_layout_hdr *lo, \
2180
+			struct pnfs_layout_segment *lseg \
2181
+		), \
2182
+		TP_ARGS(inode, pos, count, iomode, lo, lseg))
2183
+
2184
+DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_init_read);
2185
+DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_init_write);
2186
+DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_get_mirror_count);
2187
+DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_read_done);
2188
+DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_write_done);
2189
+DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_read_pagelist);
2190
+DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_write_pagelist);
2191
+
2192
+DECLARE_EVENT_CLASS(nfs4_flexfiles_io_event,
2193
+		TP_PROTO(
2194
+			const struct nfs_pgio_header *hdr
2195
+		),
2196
+
2197
+		TP_ARGS(hdr),
2198
+
2199
+		TP_STRUCT__entry(
2200
+			__field(unsigned long, error)
2201
+			__field(dev_t, dev)
2202
+			__field(u32, fhandle)
2203
+			__field(u64, fileid)
2204
+			__field(loff_t, offset)
2205
+			__field(u32, count)
2206
+			__field(int, stateid_seq)
2207
+			__field(u32, stateid_hash)
2208
+			__string(dstaddr, hdr->ds_clp ?
2209
+				rpc_peeraddr2str(hdr->ds_clp->cl_rpcclient,
2210
+					RPC_DISPLAY_ADDR) : "unknown")
2211
+		),
2212
+
2213
+		TP_fast_assign(
2214
+			const struct inode *inode = hdr->inode;
2215
+
2216
+			__entry->error = hdr->res.op_status;
2217
+			__entry->fhandle = nfs_fhandle_hash(hdr->args.fh);
2218
+			__entry->fileid = NFS_FILEID(inode);
2219
+			__entry->dev = inode->i_sb->s_dev;
2220
+			__entry->offset = hdr->args.offset;
2221
+			__entry->count = hdr->args.count;
2222
+			__entry->stateid_seq =
2223
+				be32_to_cpu(hdr->args.stateid.seqid);
2224
+			__entry->stateid_hash =
2225
+				nfs_stateid_hash(&hdr->args.stateid);
2226
+			__assign_str(dstaddr, hdr->ds_clp ?
2227
+				rpc_peeraddr2str(hdr->ds_clp->cl_rpcclient,
2228
+					RPC_DISPLAY_ADDR) : "unknown");
2229
+		),
2230
+
2231
+		TP_printk(
2232
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2233
+			"offset=%llu count=%u stateid=%d:0x%08x dstaddr=%s",
2234
+			-__entry->error,
2235
+			show_nfsv4_errors(__entry->error),
2236
+			MAJOR(__entry->dev), MINOR(__entry->dev),
2237
+			(unsigned long long)__entry->fileid,
2238
+			__entry->fhandle,
2239
+			__entry->offset, __entry->count,
2240
+			__entry->stateid_seq, __entry->stateid_hash,
2241
+			__get_str(dstaddr)
2242
+		)
2243
+);
2244
+
2245
+#define DEFINE_NFS4_FLEXFILES_IO_EVENT(name) \
2246
+	DEFINE_EVENT(nfs4_flexfiles_io_event, name, \
2247
+			TP_PROTO( \
2248
+				const struct nfs_pgio_header *hdr \
2249
+			), \
2250
+			TP_ARGS(hdr))
2251
+DEFINE_NFS4_FLEXFILES_IO_EVENT(ff_layout_read_error);
2252
+DEFINE_NFS4_FLEXFILES_IO_EVENT(ff_layout_write_error);
2253
+
2254
+TRACE_EVENT(ff_layout_commit_error,
2255
+		TP_PROTO(
2256
+			const struct nfs_commit_data *data
2257
+		),
2258
+
2259
+		TP_ARGS(data),
2260
+
2261
+		TP_STRUCT__entry(
2262
+			__field(unsigned long, error)
2263
+			__field(dev_t, dev)
2264
+			__field(u32, fhandle)
2265
+			__field(u64, fileid)
2266
+			__field(loff_t, offset)
2267
+			__field(u32, count)
2268
+			__string(dstaddr, data->ds_clp ?
2269
+				rpc_peeraddr2str(data->ds_clp->cl_rpcclient,
2270
+					RPC_DISPLAY_ADDR) : "unknown")
2271
+		),
2272
+
2273
+		TP_fast_assign(
2274
+			const struct inode *inode = data->inode;
2275
+
2276
+			__entry->error = data->res.op_status;
2277
+			__entry->fhandle = nfs_fhandle_hash(data->args.fh);
2278
+			__entry->fileid = NFS_FILEID(inode);
2279
+			__entry->dev = inode->i_sb->s_dev;
2280
+			__entry->offset = data->args.offset;
2281
+			__entry->count = data->args.count;
2282
+			__assign_str(dstaddr, data->ds_clp ?
2283
+				rpc_peeraddr2str(data->ds_clp->cl_rpcclient,
2284
+					RPC_DISPLAY_ADDR) : "unknown");
2285
+		),
2286
+
2287
+		TP_printk(
2288
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2289
+			"offset=%llu count=%u dstaddr=%s",
2290
+			-__entry->error,
2291
+			show_nfsv4_errors(__entry->error),
2292
+			MAJOR(__entry->dev), MINOR(__entry->dev),
2293
+			(unsigned long long)__entry->fileid,
2294
+			__entry->fhandle,
2295
+			__entry->offset, __entry->count,
2296
+			__get_str(dstaddr)
2297
+		)
2298
+);
2299
+
2300
+
1604
2301
 #endif /* CONFIG_NFS_V4_1 */
1605
2302
 
1606
2303
 #endif /* _TRACE_NFS4_H */