修改led为gpio

hc

2024-10-12 a5969cabbb4660eab42b6ef0412cbbd1200cf14d

 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,176 @@
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_MANAGER_AVAILABLE);
588
+TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_RUNNING);
589
+TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_ANY_LAYOUT_READ);
590
+TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_ANY_LAYOUT_RW);
591
+TRACE_DEFINE_ENUM(NFS4CLNT_DELEGRETURN_DELAYED);
592
+
593
+#define show_nfs4_clp_state(state) \
594
+	__print_flags(state, "|", \
595
+	{ BIT(NFS4CLNT_MANAGER_RUNNING),	"MANAGER_RUNNING" }, \
596
+	{ BIT(NFS4CLNT_CHECK_LEASE),		"CHECK_LEASE" }, \
597
+	{ BIT(NFS4CLNT_LEASE_EXPIRED),	"LEASE_EXPIRED" }, \
598
+	{ BIT(NFS4CLNT_RECLAIM_REBOOT),	"RECLAIM_REBOOT" }, \
599
+	{ BIT(NFS4CLNT_RECLAIM_NOGRACE),	"RECLAIM_NOGRACE" }, \
600
+	{ BIT(NFS4CLNT_DELEGRETURN),		"DELEGRETURN" }, \
601
+	{ BIT(NFS4CLNT_SESSION_RESET),	"SESSION_RESET" }, \
602
+	{ BIT(NFS4CLNT_LEASE_CONFIRM),	"LEASE_CONFIRM" }, \
603
+	{ BIT(NFS4CLNT_SERVER_SCOPE_MISMATCH),	"SERVER_SCOPE_MISMATCH" }, \
604
+	{ BIT(NFS4CLNT_PURGE_STATE),		"PURGE_STATE" }, \
605
+	{ BIT(NFS4CLNT_BIND_CONN_TO_SESSION),	"BIND_CONN_TO_SESSION" }, \
606
+	{ BIT(NFS4CLNT_MOVED),		"MOVED" }, \
607
+	{ BIT(NFS4CLNT_LEASE_MOVED),		"LEASE_MOVED" }, \
608
+	{ BIT(NFS4CLNT_DELEGATION_EXPIRED),	"DELEGATION_EXPIRED" }, \
609
+	{ BIT(NFS4CLNT_RUN_MANAGER),		"RUN_MANAGER" }, \
610
+	{ BIT(NFS4CLNT_MANAGER_AVAILABLE), "MANAGER_AVAILABLE" }, \
611
+	{ BIT(NFS4CLNT_RECALL_RUNNING),	"RECALL_RUNNING" }, \
612
+	{ BIT(NFS4CLNT_RECALL_ANY_LAYOUT_READ), "RECALL_ANY_LAYOUT_READ" }, \
613
+	{ BIT(NFS4CLNT_RECALL_ANY_LAYOUT_RW), "RECALL_ANY_LAYOUT_RW" }, \
614
+	{ BIT(NFS4CLNT_DELEGRETURN_DELAYED), "DELERETURN_DELAYED" })
615
+
616
+TRACE_EVENT(nfs4_state_mgr,
617
+		TP_PROTO(
618
+			const struct nfs_client *clp
619
+		),
620
+
621
+		TP_ARGS(clp),
622
+
623
+		TP_STRUCT__entry(
624
+			__field(unsigned long, state)
625
+			__string(hostname, clp->cl_hostname)
626
+		),
627
+
628
+		TP_fast_assign(
629
+			__entry->state = clp->cl_state;
630
+			__assign_str(hostname, clp->cl_hostname)
631
+		),
632
+
633
+		TP_printk(
634
+			"hostname=%s clp state=%s", __get_str(hostname),
635
+			show_nfs4_clp_state(__entry->state)
636
+		)
637
+)
638
+
639
+TRACE_EVENT(nfs4_state_mgr_failed,
640
+		TP_PROTO(
641
+			const struct nfs_client *clp,
642
+			const char *section,
643
+			int status
644
+		),
645
+
646
+		TP_ARGS(clp, section, status),
647
+
648
+		TP_STRUCT__entry(
649
+			__field(unsigned long, error)
650
+			__field(unsigned long, state)
651
+			__string(hostname, clp->cl_hostname)
652
+			__string(section, section)
653
+		),
654
+
655
+		TP_fast_assign(
656
+			__entry->error = status < 0 ? -status : 0;
657
+			__entry->state = clp->cl_state;
658
+			__assign_str(hostname, clp->cl_hostname);
659
+			__assign_str(section, section);
660
+		),
661
+
662
+		TP_printk(
663
+			"hostname=%s clp state=%s error=%ld (%s) section=%s",
664
+			__get_str(hostname),
665
+			show_nfs4_clp_state(__entry->state), -__entry->error,
666
+			show_nfsv4_errors(__entry->error), __get_str(section)
667
+
668
+		)
669
+)
670
+
671
+TRACE_EVENT(nfs4_xdr_status,
672
+		TP_PROTO(
673
+			const struct xdr_stream *xdr,
674
+			u32 op,
675
+			u32 error
676
+		),
677
+
678
+		TP_ARGS(xdr, op, error),
679
+
680
+		TP_STRUCT__entry(
681
+			__field(unsigned int, task_id)
682
+			__field(unsigned int, client_id)
683
+			__field(u32, xid)
684
+			__field(u32, op)
685
+			__field(unsigned long, error)
686
+		),
687
+
688
+		TP_fast_assign(
689
+			const struct rpc_rqst *rqstp = xdr->rqst;
690
+			const struct rpc_task *task = rqstp->rq_task;
691
+
692
+			__entry->task_id = task->tk_pid;
693
+			__entry->client_id = task->tk_client->cl_clid;
694
+			__entry->xid = be32_to_cpu(rqstp->rq_xid);
695
+			__entry->op = op;
696
+			__entry->error = error;
697
+		),
698
+
699
+		TP_printk(
700
+			"task:%u@%d xid=0x%08x error=%ld (%s) operation=%u",
701
+			__entry->task_id, __entry->client_id, __entry->xid,
702
+			-__entry->error, show_nfsv4_errors(__entry->error),
703
+			__entry->op
704
+		)
705
+);
706
+
707
+DECLARE_EVENT_CLASS(nfs4_cb_error_class,
708
+		TP_PROTO(
709
+			__be32 xid,
710
+			u32 cb_ident
711
+		),
712
+
713
+		TP_ARGS(xid, cb_ident),
714
+
715
+		TP_STRUCT__entry(
716
+			__field(u32, xid)
717
+			__field(u32, cbident)
718
+		),
719
+
720
+		TP_fast_assign(
721
+			__entry->xid = be32_to_cpu(xid);
722
+			__entry->cbident = cb_ident;
723
+		),
724
+
725
+		TP_printk(
726
+			"xid=0x%08x cb_ident=0x%08x",
727
+			__entry->xid, __entry->cbident
728
+		)
729
+);
730
+
731
+#define DEFINE_CB_ERROR_EVENT(name) \
732
+	DEFINE_EVENT(nfs4_cb_error_class, nfs_cb_##name, \
733
+			TP_PROTO( \
734
+				__be32 xid, \
735
+				u32 cb_ident \
736
+			), \
737
+			TP_ARGS(xid, cb_ident))
738
+
739
+DEFINE_CB_ERROR_EVENT(no_clp);
740
+DEFINE_CB_ERROR_EVENT(badprinc);
741
+
382
742
 DECLARE_EVENT_CLASS(nfs4_open_event,
383
743
 		TP_PROTO(
384
744
 			const struct nfs_open_context *ctx,
..
..
@@ -389,7 +749,7 @@
389
749
 		TP_ARGS(ctx, flags, error),
390
750
 
391
751
 		TP_STRUCT__entry(
392
-			__field(int, error)
752
+			__field(unsigned long, error)
393
753
 			__field(unsigned int, flags)
394
754
 			__field(unsigned int, fmode)
395
755
 			__field(dev_t, dev)
..
..
@@ -407,7 +767,7 @@
407
767
 			const struct nfs4_state *state = ctx->state;
408
768
 			const struct inode *inode = NULL;
409
769
 
410
-			__entry->error = error;
770
+			__entry->error = -error;
411
771
 			__entry->flags = flags;
412
772
 			__entry->fmode = (__force unsigned int)ctx->mode;
413
773
 			__entry->dev = ctx->dentry->d_sb->s_dev;
..
..
@@ -439,11 +799,11 @@
439
799
 		),
440
800
 
441
801
 		TP_printk(
442
-			"error=%d (%s) flags=%d (%s) fmode=%s "
802
+			"error=%ld (%s) flags=%d (%s) fmode=%s "
443
803
 			"fileid=%02x:%02x:%llu fhandle=0x%08x "
444
804
 			"name=%02x:%02x:%llu/%s stateid=%d:0x%08x "
445
805
 			"openstateid=%d:0x%08x",
446
-			 __entry->error,
806
+			 -__entry->error,
447
807
 			 show_nfsv4_errors(__entry->error),
448
808
 			 __entry->flags,
449
809
 			 show_open_flags(__entry->flags),
..
..
@@ -525,7 +885,7 @@
525
885
 			__field(u32, fhandle)
526
886
 			__field(u64, fileid)
527
887
 			__field(unsigned int, fmode)
528
-			__field(int, error)
888
+			__field(unsigned long, error)
529
889
 			__field(int, stateid_seq)
530
890
 			__field(u32, stateid_hash)
531
891
 		),
..
..
@@ -537,7 +897,7 @@
537
897
 			__entry->fileid = NFS_FILEID(inode);
538
898
 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
539
899
 			__entry->fmode = (__force unsigned int)state->state;
540
-			__entry->error = error;
900
+			__entry->error = error < 0 ? -error : 0;
541
901
 			__entry->stateid_seq =
542
902
 				be32_to_cpu(args->stateid.seqid);
543
903
 			__entry->stateid_hash =
..
..
@@ -545,9 +905,9 @@
545
905
 		),
546
906
 
547
907
 		TP_printk(
548
-			"error=%d (%s) fmode=%s fileid=%02x:%02x:%llu "
908
+			"error=%ld (%s) fmode=%s fileid=%02x:%02x:%llu "
549
909
 			"fhandle=0x%08x openstateid=%d:0x%08x",
550
-			__entry->error,
910
+			-__entry->error,
551
911
 			show_nfsv4_errors(__entry->error),
552
912
 			__entry->fmode ?  show_fmode_flags(__entry->fmode) :
553
913
 					  "closed",
..
..
@@ -557,6 +917,13 @@
557
917
 			__entry->stateid_seq, __entry->stateid_hash
558
918
 		)
559
919
 );
920
+
921
+TRACE_DEFINE_ENUM(F_GETLK);
922
+TRACE_DEFINE_ENUM(F_SETLK);
923
+TRACE_DEFINE_ENUM(F_SETLKW);
924
+TRACE_DEFINE_ENUM(F_RDLCK);
925
+TRACE_DEFINE_ENUM(F_WRLCK);
926
+TRACE_DEFINE_ENUM(F_UNLCK);
560
927
 
561
928
 #define show_lock_cmd(type) \
562
929
 	__print_symbolic((int)type, \
..
..
@@ -580,7 +947,7 @@
580
947
 		TP_ARGS(request, state, cmd, error),
581
948
 
582
949
 		TP_STRUCT__entry(
583
-			__field(int, error)
950
+			__field(unsigned long, error)
584
951
 			__field(int, cmd)
585
952
 			__field(char, type)
586
953
 			__field(loff_t, start)
..
..
@@ -595,7 +962,7 @@
595
962
 		TP_fast_assign(
596
963
 			const struct inode *inode = state->inode;
597
964
 
598
-			__entry->error = error;
965
+			__entry->error = error < 0 ? -error : 0;
599
966
 			__entry->cmd = cmd;
600
967
 			__entry->type = request->fl_type;
601
968
 			__entry->start = request->fl_start;
..
..
@@ -610,10 +977,10 @@
610
977
 		),
611
978
 
612
979
 		TP_printk(
613
-			"error=%d (%s) cmd=%s:%s range=%lld:%lld "
980
+			"error=%ld (%s) cmd=%s:%s range=%lld:%lld "
614
981
 			"fileid=%02x:%02x:%llu fhandle=0x%08x "
615
982
 			"stateid=%d:0x%08x",
616
-			__entry->error,
983
+			-__entry->error,
617
984
 			show_nfsv4_errors(__entry->error),
618
985
 			show_lock_cmd(__entry->cmd),
619
986
 			show_lock_type(__entry->type),
..
..
@@ -650,7 +1017,7 @@
650
1017
 		TP_ARGS(request, state, lockstateid, cmd, error),
651
1018
 
652
1019
 		TP_STRUCT__entry(
653
-			__field(int, error)
1020
+			__field(unsigned long, error)
654
1021
 			__field(int, cmd)
655
1022
 			__field(char, type)
656
1023
 			__field(loff_t, start)
..
..
@@ -667,7 +1034,7 @@
667
1034
 		TP_fast_assign(
668
1035
 			const struct inode *inode = state->inode;
669
1036
 
670
-			__entry->error = error;
1037
+			__entry->error = error < 0 ? -error : 0;
671
1038
 			__entry->cmd = cmd;
672
1039
 			__entry->type = request->fl_type;
673
1040
 			__entry->start = request->fl_start;
..
..
@@ -686,10 +1053,10 @@
686
1053
 		),
687
1054
 
688
1055
 		TP_printk(
689
-			"error=%d (%s) cmd=%s:%s range=%lld:%lld "
1056
+			"error=%ld (%s) cmd=%s:%s range=%lld:%lld "
690
1057
 			"fileid=%02x:%02x:%llu fhandle=0x%08x "
691
1058
 			"stateid=%d:0x%08x lockstateid=%d:0x%08x",
692
-			__entry->error,
1059
+			-__entry->error,
693
1060
 			show_nfsv4_errors(__entry->error),
694
1061
 			show_lock_cmd(__entry->cmd),
695
1062
 			show_lock_type(__entry->type),
..
..
@@ -702,6 +1069,88 @@
702
1069
 			__entry->lockstateid_seq, __entry->lockstateid_hash
703
1070
 		)
704
1071
 );
1072
+
1073
+TRACE_DEFINE_ENUM(LK_STATE_IN_USE);
1074
+TRACE_DEFINE_ENUM(NFS_DELEGATED_STATE);
1075
+TRACE_DEFINE_ENUM(NFS_OPEN_STATE);
1076
+TRACE_DEFINE_ENUM(NFS_O_RDONLY_STATE);
1077
+TRACE_DEFINE_ENUM(NFS_O_WRONLY_STATE);
1078
+TRACE_DEFINE_ENUM(NFS_O_RDWR_STATE);
1079
+TRACE_DEFINE_ENUM(NFS_STATE_RECLAIM_REBOOT);
1080
+TRACE_DEFINE_ENUM(NFS_STATE_RECLAIM_NOGRACE);
1081
+TRACE_DEFINE_ENUM(NFS_STATE_POSIX_LOCKS);
1082
+TRACE_DEFINE_ENUM(NFS_STATE_RECOVERY_FAILED);
1083
+TRACE_DEFINE_ENUM(NFS_STATE_MAY_NOTIFY_LOCK);
1084
+TRACE_DEFINE_ENUM(NFS_STATE_CHANGE_WAIT);
1085
+TRACE_DEFINE_ENUM(NFS_CLNT_DST_SSC_COPY_STATE);
1086
+TRACE_DEFINE_ENUM(NFS_CLNT_SRC_SSC_COPY_STATE);
1087
+TRACE_DEFINE_ENUM(NFS_SRV_SSC_COPY_STATE);
1088
+
1089
+#define show_nfs4_state_flags(flags) \
1090
+	__print_flags(flags, "|", \
1091
+		{ LK_STATE_IN_USE,		"IN_USE" }, \
1092
+		{ NFS_DELEGATED_STATE,		"DELEGATED" }, \
1093
+		{ NFS_OPEN_STATE,		"OPEN" }, \
1094
+		{ NFS_O_RDONLY_STATE,		"O_RDONLY" }, \
1095
+		{ NFS_O_WRONLY_STATE,		"O_WRONLY" }, \
1096
+		{ NFS_O_RDWR_STATE,		"O_RDWR" }, \
1097
+		{ NFS_STATE_RECLAIM_REBOOT,	"RECLAIM_REBOOT" }, \
1098
+		{ NFS_STATE_RECLAIM_NOGRACE,	"RECLAIM_NOGRACE" }, \
1099
+		{ NFS_STATE_POSIX_LOCKS,	"POSIX_LOCKS" }, \
1100
+		{ NFS_STATE_RECOVERY_FAILED,	"RECOVERY_FAILED" }, \
1101
+		{ NFS_STATE_MAY_NOTIFY_LOCK,	"MAY_NOTIFY_LOCK" }, \
1102
+		{ NFS_STATE_CHANGE_WAIT,	"CHANGE_WAIT" }, \
1103
+		{ NFS_CLNT_DST_SSC_COPY_STATE,	"CLNT_DST_SSC_COPY" }, \
1104
+		{ NFS_CLNT_SRC_SSC_COPY_STATE,	"CLNT_SRC_SSC_COPY" }, \
1105
+		{ NFS_SRV_SSC_COPY_STATE,	"SRV_SSC_COPY" })
1106
+
1107
+#define show_nfs4_lock_flags(flags) \
1108
+	__print_flags(flags, "|", \
1109
+		{ BIT(NFS_LOCK_INITIALIZED),	"INITIALIZED" }, \
1110
+		{ BIT(NFS_LOCK_LOST),		"LOST" })
1111
+
1112
+TRACE_EVENT(nfs4_state_lock_reclaim,
1113
+		TP_PROTO(
1114
+			const struct nfs4_state *state,
1115
+			const struct nfs4_lock_state *lock
1116
+		),
1117
+
1118
+		TP_ARGS(state, lock),
1119
+
1120
+		TP_STRUCT__entry(
1121
+			__field(dev_t, dev)
1122
+			__field(u32, fhandle)
1123
+			__field(u64, fileid)
1124
+			__field(unsigned long, state_flags)
1125
+			__field(unsigned long, lock_flags)
1126
+			__field(int, stateid_seq)
1127
+			__field(u32, stateid_hash)
1128
+		),
1129
+
1130
+		TP_fast_assign(
1131
+			const struct inode *inode = state->inode;
1132
+
1133
+			__entry->dev = inode->i_sb->s_dev;
1134
+			__entry->fileid = NFS_FILEID(inode);
1135
+			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1136
+			__entry->state_flags = state->flags;
1137
+			__entry->lock_flags = lock->ls_flags;
1138
+			__entry->stateid_seq =
1139
+				be32_to_cpu(state->stateid.seqid);
1140
+			__entry->stateid_hash =
1141
+				nfs_stateid_hash(&state->stateid);
1142
+		),
1143
+
1144
+		TP_printk(
1145
+			"fileid=%02x:%02x:%llu fhandle=0x%08x "
1146
+			"stateid=%d:0x%08x state_flags=%s lock_flags=%s",
1147
+			MAJOR(__entry->dev), MINOR(__entry->dev),
1148
+			(unsigned long long)__entry->fileid, __entry->fhandle,
1149
+			__entry->stateid_seq, __entry->stateid_hash,
1150
+			show_nfs4_state_flags(__entry->state_flags),
1151
+			show_nfs4_lock_flags(__entry->lock_flags)
1152
+		)
1153
+)
705
1154
 
706
1155
 DECLARE_EVENT_CLASS(nfs4_set_delegation_event,
707
1156
 		TP_PROTO(
..
..
@@ -755,7 +1204,7 @@
755
1204
 		TP_STRUCT__entry(
756
1205
 			__field(dev_t, dev)
757
1206
 			__field(u32, fhandle)
758
-			__field(int, error)
1207
+			__field(unsigned long, error)
759
1208
 			__field(int, stateid_seq)
760
1209
 			__field(u32, stateid_hash)
761
1210
 		),
..
..
@@ -763,7 +1212,7 @@
763
1212
 		TP_fast_assign(
764
1213
 			__entry->dev = res->server->s_dev;
765
1214
 			__entry->fhandle = nfs_fhandle_hash(args->fhandle);
766
-			__entry->error = error;
1215
+			__entry->error = error < 0 ? -error : 0;
767
1216
 			__entry->stateid_seq =
768
1217
 				be32_to_cpu(args->stateid->seqid);
769
1218
 			__entry->stateid_hash =
..
..
@@ -771,9 +1220,9 @@
771
1220
 		),
772
1221
 
773
1222
 		TP_printk(
774
-			"error=%d (%s) dev=%02x:%02x fhandle=0x%08x "
1223
+			"error=%ld (%s) dev=%02x:%02x fhandle=0x%08x "
775
1224
 			"stateid=%d:0x%08x",
776
-			__entry->error,
1225
+			-__entry->error,
777
1226
 			show_nfsv4_errors(__entry->error),
778
1227
 			MAJOR(__entry->dev), MINOR(__entry->dev),
779
1228
 			__entry->fhandle,
..
..
@@ -792,7 +1241,7 @@
792
1241
 		TP_ARGS(state, lsp, error),
793
1242
 
794
1243
 		TP_STRUCT__entry(
795
-			__field(int, error)
1244
+			__field(unsigned long, error)
796
1245
 			__field(dev_t, dev)
797
1246
 			__field(u32, fhandle)
798
1247
 			__field(u64, fileid)
..
..
@@ -803,7 +1252,7 @@
803
1252
 		TP_fast_assign(
804
1253
 			const struct inode *inode = state->inode;
805
1254
 
806
-			__entry->error = error;
1255
+			__entry->error = error < 0 ? -error : 0;
807
1256
 			__entry->dev = inode->i_sb->s_dev;
808
1257
 			__entry->fileid = NFS_FILEID(inode);
809
1258
 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
..
..
@@ -814,9 +1263,9 @@
814
1263
 		),
815
1264
 
816
1265
 		TP_printk(
817
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1266
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
818
1267
 			"stateid=%d:0x%08x",
819
-			__entry->error,
1268
+			-__entry->error,
820
1269
 			show_nfsv4_errors(__entry->error),
821
1270
 			MAJOR(__entry->dev), MINOR(__entry->dev),
822
1271
 			(unsigned long long)__entry->fileid,
..
..
@@ -849,7 +1298,7 @@
849
1298
 
850
1299
 		TP_STRUCT__entry(
851
1300
 			__field(dev_t, dev)
852
-			__field(int, error)
1301
+			__field(unsigned long, error)
853
1302
 			__field(u64, dir)
854
1303
 			__string(name, name->name)
855
1304
 		),
..
..
@@ -857,13 +1306,13 @@
857
1306
 		TP_fast_assign(
858
1307
 			__entry->dev = dir->i_sb->s_dev;
859
1308
 			__entry->dir = NFS_FILEID(dir);
860
-			__entry->error = error;
1309
+			__entry->error = -error;
861
1310
 			__assign_str(name, name->name);
862
1311
 		),
863
1312
 
864
1313
 		TP_printk(
865
-			"error=%d (%s) name=%02x:%02x:%llu/%s",
866
-			__entry->error,
1314
+			"error=%ld (%s) name=%02x:%02x:%llu/%s",
1315
+			-__entry->error,
867
1316
 			show_nfsv4_errors(__entry->error),
868
1317
 			MAJOR(__entry->dev), MINOR(__entry->dev),
869
1318
 			(unsigned long long)__entry->dir,
..
..
@@ -899,18 +1348,18 @@
899
1348
 		TP_STRUCT__entry(
900
1349
 			__field(dev_t, dev)
901
1350
 			__field(u64, ino)
902
-			__field(int, error)
1351
+			__field(unsigned long, error)
903
1352
 		),
904
1353
 
905
1354
 		TP_fast_assign(
906
1355
 			__entry->dev = inode->i_sb->s_dev;
907
1356
 			__entry->ino = NFS_FILEID(inode);
908
-			__entry->error = error;
1357
+			__entry->error = error < 0 ? -error : 0;
909
1358
 		),
910
1359
 
911
1360
 		TP_printk(
912
-			"error=%d (%s) inode=%02x:%02x:%llu",
913
-			__entry->error,
1361
+			"error=%ld (%s) inode=%02x:%02x:%llu",
1362
+			-__entry->error,
914
1363
 			show_nfsv4_errors(__entry->error),
915
1364
 			MAJOR(__entry->dev), MINOR(__entry->dev),
916
1365
 			(unsigned long long)__entry->ino
..
..
@@ -930,7 +1379,7 @@
930
1379
 
931
1380
 		TP_STRUCT__entry(
932
1381
 			__field(dev_t, dev)
933
-			__field(int, error)
1382
+			__field(unsigned long, error)
934
1383
 			__field(u64, olddir)
935
1384
 			__string(oldname, oldname->name)
936
1385
 			__field(u64, newdir)
..
..
@@ -941,15 +1390,15 @@
941
1390
 			__entry->dev = olddir->i_sb->s_dev;
942
1391
 			__entry->olddir = NFS_FILEID(olddir);
943
1392
 			__entry->newdir = NFS_FILEID(newdir);
944
-			__entry->error = error;
1393
+			__entry->error = error < 0 ? -error : 0;
945
1394
 			__assign_str(oldname, oldname->name);
946
1395
 			__assign_str(newname, newname->name);
947
1396
 		),
948
1397
 
949
1398
 		TP_printk(
950
-			"error=%d (%s) oldname=%02x:%02x:%llu/%s "
1399
+			"error=%ld (%s) oldname=%02x:%02x:%llu/%s "
951
1400
 			"newname=%02x:%02x:%llu/%s",
952
-			__entry->error,
1401
+			-__entry->error,
953
1402
 			show_nfsv4_errors(__entry->error),
954
1403
 			MAJOR(__entry->dev), MINOR(__entry->dev),
955
1404
 			(unsigned long long)__entry->olddir,
..
..
@@ -972,19 +1421,19 @@
972
1421
 			__field(dev_t, dev)
973
1422
 			__field(u32, fhandle)
974
1423
 			__field(u64, fileid)
975
-			__field(int, error)
1424
+			__field(unsigned long, error)
976
1425
 		),
977
1426
 
978
1427
 		TP_fast_assign(
979
1428
 			__entry->dev = inode->i_sb->s_dev;
980
1429
 			__entry->fileid = NFS_FILEID(inode);
981
1430
 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
982
-			__entry->error = error;
1431
+			__entry->error = error < 0 ? -error : 0;
983
1432
 		),
984
1433
 
985
1434
 		TP_printk(
986
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x",
987
-			__entry->error,
1435
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x",
1436
+			-__entry->error,
988
1437
 			show_nfsv4_errors(__entry->error),
989
1438
 			MAJOR(__entry->dev), MINOR(__entry->dev),
990
1439
 			(unsigned long long)__entry->fileid,
..
..
@@ -1023,7 +1472,7 @@
1023
1472
 			__field(dev_t, dev)
1024
1473
 			__field(u32, fhandle)
1025
1474
 			__field(u64, fileid)
1026
-			__field(int, error)
1475
+			__field(unsigned long, error)
1027
1476
 			__field(int, stateid_seq)
1028
1477
 			__field(u32, stateid_hash)
1029
1478
 		),
..
..
@@ -1032,7 +1481,7 @@
1032
1481
 			__entry->dev = inode->i_sb->s_dev;
1033
1482
 			__entry->fileid = NFS_FILEID(inode);
1034
1483
 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1035
-			__entry->error = error;
1484
+			__entry->error = error < 0 ? -error : 0;
1036
1485
 			__entry->stateid_seq =
1037
1486
 				be32_to_cpu(stateid->seqid);
1038
1487
 			__entry->stateid_hash =
..
..
@@ -1040,9 +1489,9 @@
1040
1489
 		),
1041
1490
 
1042
1491
 		TP_printk(
1043
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1492
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1044
1493
 			"stateid=%d:0x%08x",
1045
-			__entry->error,
1494
+			-__entry->error,
1046
1495
 			show_nfsv4_errors(__entry->error),
1047
1496
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1048
1497
 			(unsigned long long)__entry->fileid,
..
..
@@ -1064,6 +1513,7 @@
1064
1513
 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_delegreturn);
1065
1514
 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update);
1066
1515
 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update_wait);
1516
+DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_close_stateid_update_wait);
1067
1517
 
1068
1518
 DECLARE_EVENT_CLASS(nfs4_getattr_event,
1069
1519
 		TP_PROTO(
..
..
@@ -1080,7 +1530,7 @@
1080
1530
 			__field(u32, fhandle)
1081
1531
 			__field(u64, fileid)
1082
1532
 			__field(unsigned int, valid)
1083
-			__field(int, error)
1533
+			__field(unsigned long, error)
1084
1534
 		),
1085
1535
 
1086
1536
 		TP_fast_assign(
..
..
@@ -1088,13 +1538,13 @@
1088
1538
 			__entry->valid = fattr->valid;
1089
1539
 			__entry->fhandle = nfs_fhandle_hash(fhandle);
1090
1540
 			__entry->fileid = (fattr->valid & NFS_ATTR_FATTR_FILEID) ? fattr->fileid : 0;
1091
-			__entry->error = error;
1541
+			__entry->error = error < 0 ? -error : 0;
1092
1542
 		),
1093
1543
 
1094
1544
 		TP_printk(
1095
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1545
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1096
1546
 			"valid=%s",
1097
-			__entry->error,
1547
+			-__entry->error,
1098
1548
 			show_nfsv4_errors(__entry->error),
1099
1549
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1100
1550
 			(unsigned long long)__entry->fileid,
..
..
@@ -1127,7 +1577,7 @@
1127
1577
 		TP_ARGS(clp, fhandle, inode, error),
1128
1578
 
1129
1579
 		TP_STRUCT__entry(
1130
-			__field(int, error)
1580
+			__field(unsigned long, error)
1131
1581
 			__field(dev_t, dev)
1132
1582
 			__field(u32, fhandle)
1133
1583
 			__field(u64, fileid)
..
..
@@ -1135,7 +1585,7 @@
1135
1585
 		),
1136
1586
 
1137
1587
 		TP_fast_assign(
1138
-			__entry->error = error;
1588
+			__entry->error = error < 0 ? -error : 0;
1139
1589
 			__entry->fhandle = nfs_fhandle_hash(fhandle);
1140
1590
 			if (!IS_ERR_OR_NULL(inode)) {
1141
1591
 				__entry->fileid = NFS_FILEID(inode);
..
..
@@ -1148,9 +1598,9 @@
1148
1598
 		),
1149
1599
 
1150
1600
 		TP_printk(
1151
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1601
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1152
1602
 			"dstaddr=%s",
1153
-			__entry->error,
1603
+			-__entry->error,
1154
1604
 			show_nfsv4_errors(__entry->error),
1155
1605
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1156
1606
 			(unsigned long long)__entry->fileid,
..
..
@@ -1182,7 +1632,7 @@
1182
1632
 		TP_ARGS(clp, fhandle, inode, stateid, error),
1183
1633
 
1184
1634
 		TP_STRUCT__entry(
1185
-			__field(int, error)
1635
+			__field(unsigned long, error)
1186
1636
 			__field(dev_t, dev)
1187
1637
 			__field(u32, fhandle)
1188
1638
 			__field(u64, fileid)
..
..
@@ -1192,7 +1642,7 @@
1192
1642
 		),
1193
1643
 
1194
1644
 		TP_fast_assign(
1195
-			__entry->error = error;
1645
+			__entry->error = error < 0 ? -error : 0;
1196
1646
 			__entry->fhandle = nfs_fhandle_hash(fhandle);
1197
1647
 			if (!IS_ERR_OR_NULL(inode)) {
1198
1648
 				__entry->fileid = NFS_FILEID(inode);
..
..
@@ -1209,9 +1659,9 @@
1209
1659
 		),
1210
1660
 
1211
1661
 		TP_printk(
1212
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1662
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1213
1663
 			"stateid=%d:0x%08x dstaddr=%s",
1214
-			__entry->error,
1664
+			-__entry->error,
1215
1665
 			show_nfsv4_errors(__entry->error),
1216
1666
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1217
1667
 			(unsigned long long)__entry->fileid,
..
..
@@ -1245,7 +1695,7 @@
1245
1695
 		TP_ARGS(name, len, id, error),
1246
1696
 
1247
1697
 		TP_STRUCT__entry(
1248
-			__field(int, error)
1698
+			__field(unsigned long, error)
1249
1699
 			__field(u32, id)
1250
1700
 			__dynamic_array(char, name, len > 0 ? len + 1 : 1)
1251
1701
 		),
..
..
@@ -1260,8 +1710,8 @@
1260
1710
 		),
1261
1711
 
1262
1712
 		TP_printk(
1263
-			"error=%d id=%u name=%s",
1264
-			__entry->error,
1713
+			"error=%ld (%s) id=%u name=%s",
1714
+			-__entry->error, show_nfsv4_errors(__entry->error),
1265
1715
 			__entry->id,
1266
1716
 			__get_str(name)
1267
1717
 		)
..
..
@@ -1280,6 +1730,13 @@
1280
1730
 DEFINE_NFS4_IDMAP_EVENT(nfs4_map_uid_to_name);
1281
1731
 DEFINE_NFS4_IDMAP_EVENT(nfs4_map_gid_to_group);
1282
1732
 
1733
+#ifdef CONFIG_NFS_V4_1
1734
+#define NFS4_LSEG_LAYOUT_STATEID_HASH(lseg) \
1735
+	(lseg ? nfs_stateid_hash(&lseg->pls_layout->plh_stateid) : 0)
1736
+#else
1737
+#define NFS4_LSEG_LAYOUT_STATEID_HASH(lseg) (0)
1738
+#endif
1739
+
1283
1740
 DECLARE_EVENT_CLASS(nfs4_read_event,
1284
1741
 		TP_PROTO(
1285
1742
 			const struct nfs_pgio_header *hdr,
..
..
@@ -1293,39 +1750,53 @@
1293
1750
 			__field(u32, fhandle)
1294
1751
 			__field(u64, fileid)
1295
1752
 			__field(loff_t, offset)
1296
-			__field(size_t, count)
1297
-			__field(int, error)
1753
+			__field(u32, arg_count)
1754
+			__field(u32, res_count)
1755
+			__field(unsigned long, error)
1298
1756
 			__field(int, stateid_seq)
1299
1757
 			__field(u32, stateid_hash)
1758
+			__field(int, layoutstateid_seq)
1759
+			__field(u32, layoutstateid_hash)
1300
1760
 		),
1301
1761
 
1302
1762
 		TP_fast_assign(
1303
1763
 			const struct inode *inode = hdr->inode;
1764
+			const struct nfs_inode *nfsi = NFS_I(inode);
1765
+			const struct nfs_fh *fh = hdr->args.fh ?
1766
+						  hdr->args.fh : &nfsi->fh;
1304
1767
 			const struct nfs4_state *state =
1305
1768
 				hdr->args.context->state;
1769
+			const struct pnfs_layout_segment *lseg = hdr->lseg;
1770
+
1306
1771
 			__entry->dev = inode->i_sb->s_dev;
1307
-			__entry->fileid = NFS_FILEID(inode);
1308
-			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1772
+			__entry->fileid = nfsi->fileid;
1773
+			__entry->fhandle = nfs_fhandle_hash(fh);
1309
1774
 			__entry->offset = hdr->args.offset;
1310
-			__entry->count = hdr->args.count;
1311
-			__entry->error = error;
1775
+			__entry->arg_count = hdr->args.count;
1776
+			__entry->res_count = hdr->res.count;
1777
+			__entry->error = error < 0 ? -error : 0;
1312
1778
 			__entry->stateid_seq =
1313
1779
 				be32_to_cpu(state->stateid.seqid);
1314
1780
 			__entry->stateid_hash =
1315
1781
 				nfs_stateid_hash(&state->stateid);
1782
+			__entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
1783
+			__entry->layoutstateid_hash =
1784
+				NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
1316
1785
 		),
1317
1786
 
1318
1787
 		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,
1788
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1789
+			"offset=%lld count=%u res=%u stateid=%d:0x%08x "
1790
+			"layoutstateid=%d:0x%08x",
1791
+			-__entry->error,
1322
1792
 			show_nfsv4_errors(__entry->error),
1323
1793
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1324
1794
 			(unsigned long long)__entry->fileid,
1325
1795
 			__entry->fhandle,
1326
1796
 			(long long)__entry->offset,
1327
-			__entry->count,
1328
-			__entry->stateid_seq, __entry->stateid_hash
1797
+			__entry->arg_count, __entry->res_count,
1798
+			__entry->stateid_seq, __entry->stateid_hash,
1799
+			__entry->layoutstateid_seq, __entry->layoutstateid_hash
1329
1800
 		)
1330
1801
 );
1331
1802
 #define DEFINE_NFS4_READ_EVENT(name) \
..
..
@@ -1353,39 +1824,53 @@
1353
1824
 			__field(u32, fhandle)
1354
1825
 			__field(u64, fileid)
1355
1826
 			__field(loff_t, offset)
1356
-			__field(size_t, count)
1357
-			__field(int, error)
1827
+			__field(u32, arg_count)
1828
+			__field(u32, res_count)
1829
+			__field(unsigned long, error)
1358
1830
 			__field(int, stateid_seq)
1359
1831
 			__field(u32, stateid_hash)
1832
+			__field(int, layoutstateid_seq)
1833
+			__field(u32, layoutstateid_hash)
1360
1834
 		),
1361
1835
 
1362
1836
 		TP_fast_assign(
1363
1837
 			const struct inode *inode = hdr->inode;
1838
+			const struct nfs_inode *nfsi = NFS_I(inode);
1839
+			const struct nfs_fh *fh = hdr->args.fh ?
1840
+						  hdr->args.fh : &nfsi->fh;
1364
1841
 			const struct nfs4_state *state =
1365
1842
 				hdr->args.context->state;
1843
+			const struct pnfs_layout_segment *lseg = hdr->lseg;
1844
+
1366
1845
 			__entry->dev = inode->i_sb->s_dev;
1367
-			__entry->fileid = NFS_FILEID(inode);
1368
-			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1846
+			__entry->fileid = nfsi->fileid;
1847
+			__entry->fhandle = nfs_fhandle_hash(fh);
1369
1848
 			__entry->offset = hdr->args.offset;
1370
-			__entry->count = hdr->args.count;
1371
-			__entry->error = error;
1849
+			__entry->arg_count = hdr->args.count;
1850
+			__entry->res_count = hdr->res.count;
1851
+			__entry->error = error < 0 ? -error : 0;
1372
1852
 			__entry->stateid_seq =
1373
1853
 				be32_to_cpu(state->stateid.seqid);
1374
1854
 			__entry->stateid_hash =
1375
1855
 				nfs_stateid_hash(&state->stateid);
1856
+			__entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
1857
+			__entry->layoutstateid_hash =
1858
+				NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
1376
1859
 		),
1377
1860
 
1378
1861
 		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,
1862
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1863
+			"offset=%lld count=%u res=%u stateid=%d:0x%08x "
1864
+			"layoutstateid=%d:0x%08x",
1865
+			-__entry->error,
1382
1866
 			show_nfsv4_errors(__entry->error),
1383
1867
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1384
1868
 			(unsigned long long)__entry->fileid,
1385
1869
 			__entry->fhandle,
1386
1870
 			(long long)__entry->offset,
1387
-			__entry->count,
1388
-			__entry->stateid_seq, __entry->stateid_hash
1871
+			__entry->arg_count, __entry->res_count,
1872
+			__entry->stateid_seq, __entry->stateid_hash,
1873
+			__entry->layoutstateid_seq, __entry->layoutstateid_hash
1389
1874
 		)
1390
1875
 );
1391
1876
 
..
..
@@ -1413,31 +1898,42 @@
1413
1898
 			__field(dev_t, dev)
1414
1899
 			__field(u32, fhandle)
1415
1900
 			__field(u64, fileid)
1901
+			__field(unsigned long, error)
1416
1902
 			__field(loff_t, offset)
1417
-			__field(size_t, count)
1418
-			__field(int, error)
1903
+			__field(u32, count)
1904
+			__field(int, layoutstateid_seq)
1905
+			__field(u32, layoutstateid_hash)
1419
1906
 		),
1420
1907
 
1421
1908
 		TP_fast_assign(
1422
1909
 			const struct inode *inode = data->inode;
1910
+			const struct nfs_inode *nfsi = NFS_I(inode);
1911
+			const struct nfs_fh *fh = data->args.fh ?
1912
+						  data->args.fh : &nfsi->fh;
1913
+			const struct pnfs_layout_segment *lseg = data->lseg;
1914
+
1423
1915
 			__entry->dev = inode->i_sb->s_dev;
1424
-			__entry->fileid = NFS_FILEID(inode);
1425
-			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1916
+			__entry->fileid = nfsi->fileid;
1917
+			__entry->fhandle = nfs_fhandle_hash(fh);
1426
1918
 			__entry->offset = data->args.offset;
1427
1919
 			__entry->count = data->args.count;
1428
-			__entry->error = error;
1920
+			__entry->error = error < 0 ? -error : 0;
1921
+			__entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
1922
+			__entry->layoutstateid_hash =
1923
+				NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
1429
1924
 		),
1430
1925
 
1431
1926
 		TP_printk(
1432
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1433
-			"offset=%lld count=%zu",
1434
-			__entry->error,
1927
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1928
+			"offset=%lld count=%u layoutstateid=%d:0x%08x",
1929
+			-__entry->error,
1435
1930
 			show_nfsv4_errors(__entry->error),
1436
1931
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1437
1932
 			(unsigned long long)__entry->fileid,
1438
1933
 			__entry->fhandle,
1439
1934
 			(long long)__entry->offset,
1440
-			__entry->count
1935
+			__entry->count,
1936
+			__entry->layoutstateid_seq, __entry->layoutstateid_hash
1441
1937
 		)
1442
1938
 );
1443
1939
 #define DEFINE_NFS4_COMMIT_EVENT(name) \
..
..
@@ -1450,6 +1946,10 @@
1450
1946
 DEFINE_NFS4_COMMIT_EVENT(nfs4_commit);
1451
1947
 #ifdef CONFIG_NFS_V4_1
1452
1948
 DEFINE_NFS4_COMMIT_EVENT(nfs4_pnfs_commit_ds);
1949
+
1950
+TRACE_DEFINE_ENUM(IOMODE_READ);
1951
+TRACE_DEFINE_ENUM(IOMODE_RW);
1952
+TRACE_DEFINE_ENUM(IOMODE_ANY);
1453
1953
 
1454
1954
 #define show_pnfs_iomode(iomode) \
1455
1955
 	__print_symbolic(iomode, \
..
..
@@ -1475,7 +1975,7 @@
1475
1975
 			__field(u32, iomode)
1476
1976
 			__field(u64, offset)
1477
1977
 			__field(u64, count)
1478
-			__field(int, error)
1978
+			__field(unsigned long, error)
1479
1979
 			__field(int, stateid_seq)
1480
1980
 			__field(u32, stateid_hash)
1481
1981
 			__field(int, layoutstateid_seq)
..
..
@@ -1491,7 +1991,7 @@
1491
1991
 			__entry->iomode = args->iomode;
1492
1992
 			__entry->offset = args->offset;
1493
1993
 			__entry->count = args->length;
1494
-			__entry->error = error;
1994
+			__entry->error = error < 0 ? -error : 0;
1495
1995
 			__entry->stateid_seq =
1496
1996
 				be32_to_cpu(state->stateid.seqid);
1497
1997
 			__entry->stateid_hash =
..
..
@@ -1508,10 +2008,10 @@
1508
2008
 		),
1509
2009
 
1510
2010
 		TP_printk(
1511
-			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2011
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1512
2012
 			"iomode=%s offset=%llu count=%llu stateid=%d:0x%08x "
1513
2013
 			"layoutstateid=%d:0x%08x",
1514
-			__entry->error,
2014
+			-__entry->error,
1515
2015
 			show_nfsv4_errors(__entry->error),
1516
2016
 			MAJOR(__entry->dev), MINOR(__entry->dev),
1517
2017
 			(unsigned long long)__entry->fileid,
..
..
@@ -1526,7 +2026,24 @@
1526
2026
 
1527
2027
 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutcommit);
1528
2028
 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn);
1529
-DEFINE_NFS4_INODE_EVENT(nfs4_layoutreturn_on_close);
2029
+DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn_on_close);
2030
+DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layouterror);
2031
+DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutstats);
2032
+
2033
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_UNKNOWN);
2034
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NO_PNFS);
2035
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RD_ZEROLEN);
2036
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_MDSTHRESH);
2037
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NOMEM);
2038
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_BULK_RECALL);
2039
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_IO_TEST_FAIL);
2040
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_FOUND_CACHED);
2041
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RETURN);
2042
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_BLOCKED);
2043
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_INVALID_OPEN);
2044
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RETRY);
2045
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET);
2046
+TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_EXIT);
1530
2047
 
1531
2048
 #define show_pnfs_update_layout_reason(reason)				\
1532
2049
 	__print_symbolic(reason,					\
..
..
@@ -1542,7 +2059,8 @@
1542
2059
 		{ PNFS_UPDATE_LAYOUT_BLOCKED, "layouts blocked" },	\
1543
2060
 		{ PNFS_UPDATE_LAYOUT_INVALID_OPEN, "invalid open" },	\
1544
2061
 		{ PNFS_UPDATE_LAYOUT_RETRY, "retrying" },	\
1545
-		{ PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET, "sent layoutget" })
2062
+		{ PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET, "sent layoutget" }, \
2063
+		{ PNFS_UPDATE_LAYOUT_EXIT, "exit" })
1546
2064
 
1547
2065
 TRACE_EVENT(pnfs_update_layout,
1548
2066
 		TP_PROTO(struct inode *inode,
..
..
@@ -1601,6 +2119,187 @@
1601
2119
 		)
1602
2120
 );
1603
2121
 
2122
+DECLARE_EVENT_CLASS(pnfs_layout_event,
2123
+		TP_PROTO(struct inode *inode,
2124
+			loff_t pos,
2125
+			u64 count,
2126
+			enum pnfs_iomode iomode,
2127
+			struct pnfs_layout_hdr *lo,
2128
+			struct pnfs_layout_segment *lseg
2129
+		),
2130
+		TP_ARGS(inode, pos, count, iomode, lo, lseg),
2131
+		TP_STRUCT__entry(
2132
+			__field(dev_t, dev)
2133
+			__field(u64, fileid)
2134
+			__field(u32, fhandle)
2135
+			__field(loff_t, pos)
2136
+			__field(u64, count)
2137
+			__field(enum pnfs_iomode, iomode)
2138
+			__field(int, layoutstateid_seq)
2139
+			__field(u32, layoutstateid_hash)
2140
+			__field(long, lseg)
2141
+		),
2142
+		TP_fast_assign(
2143
+			__entry->dev = inode->i_sb->s_dev;
2144
+			__entry->fileid = NFS_FILEID(inode);
2145
+			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
2146
+			__entry->pos = pos;
2147
+			__entry->count = count;
2148
+			__entry->iomode = iomode;
2149
+			if (lo != NULL) {
2150
+				__entry->layoutstateid_seq =
2151
+				be32_to_cpu(lo->plh_stateid.seqid);
2152
+				__entry->layoutstateid_hash =
2153
+				nfs_stateid_hash(&lo->plh_stateid);
2154
+			} else {
2155
+				__entry->layoutstateid_seq = 0;
2156
+				__entry->layoutstateid_hash = 0;
2157
+			}
2158
+			__entry->lseg = (long)lseg;
2159
+		),
2160
+		TP_printk(
2161
+			"fileid=%02x:%02x:%llu fhandle=0x%08x "
2162
+			"iomode=%s pos=%llu count=%llu "
2163
+			"layoutstateid=%d:0x%08x lseg=0x%lx",
2164
+			MAJOR(__entry->dev), MINOR(__entry->dev),
2165
+			(unsigned long long)__entry->fileid,
2166
+			__entry->fhandle,
2167
+			show_pnfs_iomode(__entry->iomode),
2168
+			(unsigned long long)__entry->pos,
2169
+			(unsigned long long)__entry->count,
2170
+			__entry->layoutstateid_seq, __entry->layoutstateid_hash,
2171
+			__entry->lseg
2172
+		)
2173
+);
2174
+
2175
+#define DEFINE_PNFS_LAYOUT_EVENT(name) \
2176
+	DEFINE_EVENT(pnfs_layout_event, name, \
2177
+		TP_PROTO(struct inode *inode, \
2178
+			loff_t pos, \
2179
+			u64 count, \
2180
+			enum pnfs_iomode iomode, \
2181
+			struct pnfs_layout_hdr *lo, \
2182
+			struct pnfs_layout_segment *lseg \
2183
+		), \
2184
+		TP_ARGS(inode, pos, count, iomode, lo, lseg))
2185
+
2186
+DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_init_read);
2187
+DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_init_write);
2188
+DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_get_mirror_count);
2189
+DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_read_done);
2190
+DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_write_done);
2191
+DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_read_pagelist);
2192
+DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_write_pagelist);
2193
+
2194
+DECLARE_EVENT_CLASS(nfs4_flexfiles_io_event,
2195
+		TP_PROTO(
2196
+			const struct nfs_pgio_header *hdr
2197
+		),
2198
+
2199
+		TP_ARGS(hdr),
2200
+
2201
+		TP_STRUCT__entry(
2202
+			__field(unsigned long, error)
2203
+			__field(dev_t, dev)
2204
+			__field(u32, fhandle)
2205
+			__field(u64, fileid)
2206
+			__field(loff_t, offset)
2207
+			__field(u32, count)
2208
+			__field(int, stateid_seq)
2209
+			__field(u32, stateid_hash)
2210
+			__string(dstaddr, hdr->ds_clp ?
2211
+				rpc_peeraddr2str(hdr->ds_clp->cl_rpcclient,
2212
+					RPC_DISPLAY_ADDR) : "unknown")
2213
+		),
2214
+
2215
+		TP_fast_assign(
2216
+			const struct inode *inode = hdr->inode;
2217
+
2218
+			__entry->error = hdr->res.op_status;
2219
+			__entry->fhandle = nfs_fhandle_hash(hdr->args.fh);
2220
+			__entry->fileid = NFS_FILEID(inode);
2221
+			__entry->dev = inode->i_sb->s_dev;
2222
+			__entry->offset = hdr->args.offset;
2223
+			__entry->count = hdr->args.count;
2224
+			__entry->stateid_seq =
2225
+				be32_to_cpu(hdr->args.stateid.seqid);
2226
+			__entry->stateid_hash =
2227
+				nfs_stateid_hash(&hdr->args.stateid);
2228
+			__assign_str(dstaddr, hdr->ds_clp ?
2229
+				rpc_peeraddr2str(hdr->ds_clp->cl_rpcclient,
2230
+					RPC_DISPLAY_ADDR) : "unknown");
2231
+		),
2232
+
2233
+		TP_printk(
2234
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2235
+			"offset=%llu count=%u stateid=%d:0x%08x dstaddr=%s",
2236
+			-__entry->error,
2237
+			show_nfsv4_errors(__entry->error),
2238
+			MAJOR(__entry->dev), MINOR(__entry->dev),
2239
+			(unsigned long long)__entry->fileid,
2240
+			__entry->fhandle,
2241
+			__entry->offset, __entry->count,
2242
+			__entry->stateid_seq, __entry->stateid_hash,
2243
+			__get_str(dstaddr)
2244
+		)
2245
+);
2246
+
2247
+#define DEFINE_NFS4_FLEXFILES_IO_EVENT(name) \
2248
+	DEFINE_EVENT(nfs4_flexfiles_io_event, name, \
2249
+			TP_PROTO( \
2250
+				const struct nfs_pgio_header *hdr \
2251
+			), \
2252
+			TP_ARGS(hdr))
2253
+DEFINE_NFS4_FLEXFILES_IO_EVENT(ff_layout_read_error);
2254
+DEFINE_NFS4_FLEXFILES_IO_EVENT(ff_layout_write_error);
2255
+
2256
+TRACE_EVENT(ff_layout_commit_error,
2257
+		TP_PROTO(
2258
+			const struct nfs_commit_data *data
2259
+		),
2260
+
2261
+		TP_ARGS(data),
2262
+
2263
+		TP_STRUCT__entry(
2264
+			__field(unsigned long, error)
2265
+			__field(dev_t, dev)
2266
+			__field(u32, fhandle)
2267
+			__field(u64, fileid)
2268
+			__field(loff_t, offset)
2269
+			__field(u32, count)
2270
+			__string(dstaddr, data->ds_clp ?
2271
+				rpc_peeraddr2str(data->ds_clp->cl_rpcclient,
2272
+					RPC_DISPLAY_ADDR) : "unknown")
2273
+		),
2274
+
2275
+		TP_fast_assign(
2276
+			const struct inode *inode = data->inode;
2277
+
2278
+			__entry->error = data->res.op_status;
2279
+			__entry->fhandle = nfs_fhandle_hash(data->args.fh);
2280
+			__entry->fileid = NFS_FILEID(inode);
2281
+			__entry->dev = inode->i_sb->s_dev;
2282
+			__entry->offset = data->args.offset;
2283
+			__entry->count = data->args.count;
2284
+			__assign_str(dstaddr, data->ds_clp ?
2285
+				rpc_peeraddr2str(data->ds_clp->cl_rpcclient,
2286
+					RPC_DISPLAY_ADDR) : "unknown");
2287
+		),
2288
+
2289
+		TP_printk(
2290
+			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2291
+			"offset=%llu count=%u dstaddr=%s",
2292
+			-__entry->error,
2293
+			show_nfsv4_errors(__entry->error),
2294
+			MAJOR(__entry->dev), MINOR(__entry->dev),
2295
+			(unsigned long long)__entry->fileid,
2296
+			__entry->fhandle,
2297
+			__entry->offset, __entry->count,
2298
+			__get_str(dstaddr)
2299
+		)
2300
+);
2301
+
2302
+
1604
2303
 #endif /* CONFIG_NFS_V4_1 */
1605
2304
 
1606
2305
 #endif /* _TRACE_NFS4_H */