1 /* SPDX-License-Identifier: GPL-2.0 */
3 * Copyright (c) 2013 Trond Myklebust <Trond.Myklebust@netapp.com>
6 #define TRACE_SYSTEM nfs4
8 #if !defined(_TRACE_NFS4_H) || defined(TRACE_HEADER_MULTI_READ)
11 #include <linux/tracepoint.h>
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
);
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
);
158 #define show_nfsv4_errors(error) \
159 __print_symbolic(error, \
161 /* Mapped by nfs4_stat_to_errno() */ \
162 { EPERM, "EPERM" }, \
163 { ENOENT, "ENOENT" }, \
165 { ENXIO, "ENXIO" }, \
166 { EACCES, "EACCES" }, \
167 { EEXIST, "EEXIST" }, \
168 { EXDEV, "EXDEV" }, \
169 { ENOTDIR, "ENOTDIR" }, \
170 { EISDIR, "EISDIR" }, \
171 { EFBIG, "EFBIG" }, \
172 { ENOSPC, "ENOSPC" }, \
173 { EROFS, "EROFS" }, \
174 { EMLINK, "EMLINK" }, \
175 { ENAMETOOLONG, "ENAMETOOLONG" }, \
176 { ENOTEMPTY, "ENOTEMPTY" }, \
177 { EDQUOT, "EDQUOT" }, \
178 { ESTALE, "ESTALE" }, \
179 { EBADHANDLE, "EBADHANDLE" }, \
180 { EBADCOOKIE, "EBADCOOKIE" }, \
181 { ENOTSUPP, "ENOTSUPP" }, \
182 { ETOOSMALL, "ETOOSMALL" }, \
183 { EREMOTEIO, "EREMOTEIO" }, \
184 { EBADTYPE, "EBADTYPE" }, \
185 { EAGAIN, "EAGAIN" }, \
186 { ELOOP, "ELOOP" }, \
187 { EOPNOTSUPP, "EOPNOTSUPP" }, \
188 { EDEADLK, "EDEADLK" }, \
190 { ENOMEM, "ENOMEM" }, \
191 { EKEYEXPIRED, "EKEYEXPIRED" }, \
192 { ETIMEDOUT, "ETIMEDOUT" }, \
193 { ERESTARTSYS, "ERESTARTSYS" }, \
194 { ECONNREFUSED, "ECONNREFUSED" }, \
195 { ECONNRESET, "ECONNRESET" }, \
196 { ENETUNREACH, "ENETUNREACH" }, \
197 { EHOSTUNREACH, "EHOSTUNREACH" }, \
198 { EHOSTDOWN, "EHOSTDOWN" }, \
199 { EPIPE, "EPIPE" }, \
200 { EPFNOSUPPORT, "EPFNOSUPPORT" }, \
201 { EPROTONOSUPPORT, "EPROTONOSUPPORT" }, \
202 /* NFSv4 native errors */ \
203 { NFS4ERR_ACCESS, "ACCESS" }, \
204 { NFS4ERR_ATTRNOTSUPP, "ATTRNOTSUPP" }, \
205 { NFS4ERR_ADMIN_REVOKED, "ADMIN_REVOKED" }, \
206 { NFS4ERR_BACK_CHAN_BUSY, "BACK_CHAN_BUSY" }, \
207 { NFS4ERR_BADCHAR, "BADCHAR" }, \
208 { NFS4ERR_BADHANDLE, "BADHANDLE" }, \
209 { NFS4ERR_BADIOMODE, "BADIOMODE" }, \
210 { NFS4ERR_BADLAYOUT, "BADLAYOUT" }, \
211 { NFS4ERR_BADLABEL, "BADLABEL" }, \
212 { NFS4ERR_BADNAME, "BADNAME" }, \
213 { NFS4ERR_BADOWNER, "BADOWNER" }, \
214 { NFS4ERR_BADSESSION, "BADSESSION" }, \
215 { NFS4ERR_BADSLOT, "BADSLOT" }, \
216 { NFS4ERR_BADTYPE, "BADTYPE" }, \
217 { NFS4ERR_BADXDR, "BADXDR" }, \
218 { NFS4ERR_BAD_COOKIE, "BAD_COOKIE" }, \
219 { NFS4ERR_BAD_HIGH_SLOT, "BAD_HIGH_SLOT" }, \
220 { NFS4ERR_BAD_RANGE, "BAD_RANGE" }, \
221 { NFS4ERR_BAD_SEQID, "BAD_SEQID" }, \
222 { NFS4ERR_BAD_SESSION_DIGEST, "BAD_SESSION_DIGEST" }, \
223 { NFS4ERR_BAD_STATEID, "BAD_STATEID" }, \
224 { NFS4ERR_CB_PATH_DOWN, "CB_PATH_DOWN" }, \
225 { NFS4ERR_CLID_INUSE, "CLID_INUSE" }, \
226 { NFS4ERR_CLIENTID_BUSY, "CLIENTID_BUSY" }, \
227 { NFS4ERR_COMPLETE_ALREADY, "COMPLETE_ALREADY" }, \
228 { NFS4ERR_CONN_NOT_BOUND_TO_SESSION, \
229 "CONN_NOT_BOUND_TO_SESSION" }, \
230 { NFS4ERR_DEADLOCK, "DEADLOCK" }, \
231 { NFS4ERR_DEADSESSION, "DEAD_SESSION" }, \
232 { NFS4ERR_DELAY, "DELAY" }, \
233 { NFS4ERR_DELEG_ALREADY_WANTED, \
234 "DELEG_ALREADY_WANTED" }, \
235 { NFS4ERR_DELEG_REVOKED, "DELEG_REVOKED" }, \
236 { NFS4ERR_DENIED, "DENIED" }, \
237 { NFS4ERR_DIRDELEG_UNAVAIL, "DIRDELEG_UNAVAIL" }, \
238 { NFS4ERR_DQUOT, "DQUOT" }, \
239 { NFS4ERR_ENCR_ALG_UNSUPP, "ENCR_ALG_UNSUPP" }, \
240 { NFS4ERR_EXIST, "EXIST" }, \
241 { NFS4ERR_EXPIRED, "EXPIRED" }, \
242 { NFS4ERR_FBIG, "FBIG" }, \
243 { NFS4ERR_FHEXPIRED, "FHEXPIRED" }, \
244 { NFS4ERR_FILE_OPEN, "FILE_OPEN" }, \
245 { NFS4ERR_GRACE, "GRACE" }, \
246 { NFS4ERR_HASH_ALG_UNSUPP, "HASH_ALG_UNSUPP" }, \
247 { NFS4ERR_INVAL, "INVAL" }, \
248 { NFS4ERR_IO, "IO" }, \
249 { NFS4ERR_ISDIR, "ISDIR" }, \
250 { NFS4ERR_LAYOUTTRYLATER, "LAYOUTTRYLATER" }, \
251 { NFS4ERR_LAYOUTUNAVAILABLE, "LAYOUTUNAVAILABLE" }, \
252 { NFS4ERR_LEASE_MOVED, "LEASE_MOVED" }, \
253 { NFS4ERR_LOCKED, "LOCKED" }, \
254 { NFS4ERR_LOCKS_HELD, "LOCKS_HELD" }, \
255 { NFS4ERR_LOCK_RANGE, "LOCK_RANGE" }, \
256 { NFS4ERR_MINOR_VERS_MISMATCH, "MINOR_VERS_MISMATCH" }, \
257 { NFS4ERR_MLINK, "MLINK" }, \
258 { NFS4ERR_MOVED, "MOVED" }, \
259 { NFS4ERR_NAMETOOLONG, "NAMETOOLONG" }, \
260 { NFS4ERR_NOENT, "NOENT" }, \
261 { NFS4ERR_NOFILEHANDLE, "NOFILEHANDLE" }, \
262 { NFS4ERR_NOMATCHING_LAYOUT, "NOMATCHING_LAYOUT" }, \
263 { NFS4ERR_NOSPC, "NOSPC" }, \
264 { NFS4ERR_NOTDIR, "NOTDIR" }, \
265 { NFS4ERR_NOTEMPTY, "NOTEMPTY" }, \
266 { NFS4ERR_NOTSUPP, "NOTSUPP" }, \
267 { NFS4ERR_NOT_ONLY_OP, "NOT_ONLY_OP" }, \
268 { NFS4ERR_NOT_SAME, "NOT_SAME" }, \
269 { NFS4ERR_NO_GRACE, "NO_GRACE" }, \
270 { NFS4ERR_NXIO, "NXIO" }, \
271 { NFS4ERR_OLD_STATEID, "OLD_STATEID" }, \
272 { NFS4ERR_OPENMODE, "OPENMODE" }, \
273 { NFS4ERR_OP_ILLEGAL, "OP_ILLEGAL" }, \
274 { NFS4ERR_OP_NOT_IN_SESSION, "OP_NOT_IN_SESSION" }, \
275 { NFS4ERR_PERM, "PERM" }, \
276 { NFS4ERR_PNFS_IO_HOLE, "PNFS_IO_HOLE" }, \
277 { NFS4ERR_PNFS_NO_LAYOUT, "PNFS_NO_LAYOUT" }, \
278 { NFS4ERR_RECALLCONFLICT, "RECALLCONFLICT" }, \
279 { NFS4ERR_RECLAIM_BAD, "RECLAIM_BAD" }, \
280 { NFS4ERR_RECLAIM_CONFLICT, "RECLAIM_CONFLICT" }, \
281 { NFS4ERR_REJECT_DELEG, "REJECT_DELEG" }, \
282 { NFS4ERR_REP_TOO_BIG, "REP_TOO_BIG" }, \
283 { NFS4ERR_REP_TOO_BIG_TO_CACHE, \
284 "REP_TOO_BIG_TO_CACHE" }, \
285 { NFS4ERR_REQ_TOO_BIG, "REQ_TOO_BIG" }, \
286 { NFS4ERR_RESOURCE, "RESOURCE" }, \
287 { NFS4ERR_RESTOREFH, "RESTOREFH" }, \
288 { NFS4ERR_RETRY_UNCACHED_REP, "RETRY_UNCACHED_REP" }, \
289 { NFS4ERR_RETURNCONFLICT, "RETURNCONFLICT" }, \
290 { NFS4ERR_ROFS, "ROFS" }, \
291 { NFS4ERR_SAME, "SAME" }, \
292 { NFS4ERR_SHARE_DENIED, "SHARE_DENIED" }, \
293 { NFS4ERR_SEQUENCE_POS, "SEQUENCE_POS" }, \
294 { NFS4ERR_SEQ_FALSE_RETRY, "SEQ_FALSE_RETRY" }, \
295 { NFS4ERR_SEQ_MISORDERED, "SEQ_MISORDERED" }, \
296 { NFS4ERR_SERVERFAULT, "SERVERFAULT" }, \
297 { NFS4ERR_STALE, "STALE" }, \
298 { NFS4ERR_STALE_CLIENTID, "STALE_CLIENTID" }, \
299 { NFS4ERR_STALE_STATEID, "STALE_STATEID" }, \
300 { NFS4ERR_SYMLINK, "SYMLINK" }, \
301 { NFS4ERR_TOOSMALL, "TOOSMALL" }, \
302 { NFS4ERR_TOO_MANY_OPS, "TOO_MANY_OPS" }, \
303 { NFS4ERR_UNKNOWN_LAYOUTTYPE, "UNKNOWN_LAYOUTTYPE" }, \
304 { NFS4ERR_UNSAFE_COMPOUND, "UNSAFE_COMPOUND" }, \
305 { NFS4ERR_WRONGSEC, "WRONGSEC" }, \
306 { NFS4ERR_WRONG_CRED, "WRONG_CRED" }, \
307 { NFS4ERR_WRONG_TYPE, "WRONG_TYPE" }, \
308 { NFS4ERR_XDEV, "XDEV" })
310 #define show_open_flags(flags) \
311 __print_flags(flags, "|", \
312 { O_CREAT, "O_CREAT" }, \
313 { O_EXCL, "O_EXCL" }, \
314 { O_TRUNC, "O_TRUNC" }, \
315 { O_DIRECT, "O_DIRECT" })
317 #define show_fmode_flags(mode) \
318 __print_flags(mode, "|", \
319 { ((__force unsigned long)FMODE_READ), "READ" }, \
320 { ((__force unsigned long)FMODE_WRITE), "WRITE" }, \
321 { ((__force unsigned long)FMODE_EXEC), "EXEC" })
323 #define show_nfs_fattr_flags(valid) \
324 __print_flags((unsigned long)valid, "|", \
325 { NFS_ATTR_FATTR_TYPE, "TYPE" }, \
326 { NFS_ATTR_FATTR_MODE, "MODE" }, \
327 { NFS_ATTR_FATTR_NLINK, "NLINK" }, \
328 { NFS_ATTR_FATTR_OWNER, "OWNER" }, \
329 { NFS_ATTR_FATTR_GROUP, "GROUP" }, \
330 { NFS_ATTR_FATTR_RDEV, "RDEV" }, \
331 { NFS_ATTR_FATTR_SIZE, "SIZE" }, \
332 { NFS_ATTR_FATTR_FSID, "FSID" }, \
333 { NFS_ATTR_FATTR_FILEID, "FILEID" }, \
334 { NFS_ATTR_FATTR_ATIME, "ATIME" }, \
335 { NFS_ATTR_FATTR_MTIME, "MTIME" }, \
336 { NFS_ATTR_FATTR_CTIME, "CTIME" }, \
337 { NFS_ATTR_FATTR_CHANGE, "CHANGE" }, \
338 { NFS_ATTR_FATTR_OWNER_NAME, "OWNER_NAME" }, \
339 { NFS_ATTR_FATTR_GROUP_NAME, "GROUP_NAME" })
341 DECLARE_EVENT_CLASS(nfs4_clientid_event
,
343 const struct nfs_client
*clp
,
350 __string(dstaddr
, clp
->cl_hostname
)
351 __field(unsigned long, error
)
355 __entry
->error
= error
< 0 ? -error
: 0;
356 __assign_str(dstaddr
, clp
->cl_hostname
);
360 "error=%ld (%s) dstaddr=%s",
362 show_nfsv4_errors(__entry
->error
),
366 #define DEFINE_NFS4_CLIENTID_EVENT(name) \
367 DEFINE_EVENT(nfs4_clientid_event, name, \
369 const struct nfs_client *clp, \
373 DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid
);
374 DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid_confirm
);
375 DEFINE_NFS4_CLIENTID_EVENT(nfs4_renew
);
376 DEFINE_NFS4_CLIENTID_EVENT(nfs4_renew_async
);
377 #ifdef CONFIG_NFS_V4_1
378 DEFINE_NFS4_CLIENTID_EVENT(nfs4_exchange_id
);
379 DEFINE_NFS4_CLIENTID_EVENT(nfs4_create_session
);
380 DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_session
);
381 DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_clientid
);
382 DEFINE_NFS4_CLIENTID_EVENT(nfs4_bind_conn_to_session
);
383 DEFINE_NFS4_CLIENTID_EVENT(nfs4_sequence
);
384 DEFINE_NFS4_CLIENTID_EVENT(nfs4_reclaim_complete
);
386 #define show_nfs4_sequence_status_flags(status) \
387 __print_flags((unsigned long)status, "|", \
388 { SEQ4_STATUS_CB_PATH_DOWN, "CB_PATH_DOWN" }, \
389 { SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING, \
390 "CB_GSS_CONTEXTS_EXPIRING" }, \
391 { SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED, \
392 "CB_GSS_CONTEXTS_EXPIRED" }, \
393 { SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED, \
394 "EXPIRED_ALL_STATE_REVOKED" }, \
395 { SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED, \
396 "EXPIRED_SOME_STATE_REVOKED" }, \
397 { SEQ4_STATUS_ADMIN_STATE_REVOKED, \
398 "ADMIN_STATE_REVOKED" }, \
399 { SEQ4_STATUS_RECALLABLE_STATE_REVOKED, \
400 "RECALLABLE_STATE_REVOKED" }, \
401 { SEQ4_STATUS_LEASE_MOVED, "LEASE_MOVED" }, \
402 { SEQ4_STATUS_RESTART_RECLAIM_NEEDED, \
403 "RESTART_RECLAIM_NEEDED" }, \
404 { SEQ4_STATUS_CB_PATH_DOWN_SESSION, \
405 "CB_PATH_DOWN_SESSION" }, \
406 { SEQ4_STATUS_BACKCHANNEL_FAULT, \
407 "BACKCHANNEL_FAULT" })
409 TRACE_EVENT(nfs4_sequence_done
,
411 const struct nfs4_session
*session
,
412 const struct nfs4_sequence_res
*res
414 TP_ARGS(session
, res
),
417 __field(unsigned int, session
)
418 __field(unsigned int, slot_nr
)
419 __field(unsigned int, seq_nr
)
420 __field(unsigned int, highest_slotid
)
421 __field(unsigned int, target_highest_slotid
)
422 __field(unsigned int, status_flags
)
423 __field(unsigned long, error
)
427 const struct nfs4_slot
*sr_slot
= res
->sr_slot
;
428 __entry
->session
= nfs_session_id_hash(&session
->sess_id
);
429 __entry
->slot_nr
= sr_slot
->slot_nr
;
430 __entry
->seq_nr
= sr_slot
->seq_nr
;
431 __entry
->highest_slotid
= res
->sr_highest_slotid
;
432 __entry
->target_highest_slotid
=
433 res
->sr_target_highest_slotid
;
434 __entry
->status_flags
= res
->sr_status_flags
;
435 __entry
->error
= res
->sr_status
< 0 ?
439 "error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
440 "highest_slotid=%u target_highest_slotid=%u "
441 "status_flags=%u (%s)",
443 show_nfsv4_errors(__entry
->error
),
447 __entry
->highest_slotid
,
448 __entry
->target_highest_slotid
,
449 __entry
->status_flags
,
450 show_nfs4_sequence_status_flags(__entry
->status_flags
)
454 struct cb_sequenceargs
;
455 struct cb_sequenceres
;
457 TRACE_EVENT(nfs4_cb_sequence
,
459 const struct cb_sequenceargs
*args
,
460 const struct cb_sequenceres
*res
,
463 TP_ARGS(args
, res
, status
),
466 __field(unsigned int, session
)
467 __field(unsigned int, slot_nr
)
468 __field(unsigned int, seq_nr
)
469 __field(unsigned int, highest_slotid
)
470 __field(unsigned int, cachethis
)
471 __field(unsigned long, error
)
475 __entry
->session
= nfs_session_id_hash(&args
->csa_sessionid
);
476 __entry
->slot_nr
= args
->csa_slotid
;
477 __entry
->seq_nr
= args
->csa_sequenceid
;
478 __entry
->highest_slotid
= args
->csa_highestslotid
;
479 __entry
->cachethis
= args
->csa_cachethis
;
480 __entry
->error
= be32_to_cpu(status
);
484 "error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
487 show_nfsv4_errors(__entry
->error
),
491 __entry
->highest_slotid
495 TRACE_EVENT(nfs4_cb_seqid_err
,
497 const struct cb_sequenceargs
*args
,
500 TP_ARGS(args
, status
),
503 __field(unsigned int, session
)
504 __field(unsigned int, slot_nr
)
505 __field(unsigned int, seq_nr
)
506 __field(unsigned int, highest_slotid
)
507 __field(unsigned int, cachethis
)
508 __field(unsigned long, error
)
512 __entry
->session
= nfs_session_id_hash(&args
->csa_sessionid
);
513 __entry
->slot_nr
= args
->csa_slotid
;
514 __entry
->seq_nr
= args
->csa_sequenceid
;
515 __entry
->highest_slotid
= args
->csa_highestslotid
;
516 __entry
->cachethis
= args
->csa_cachethis
;
517 __entry
->error
= be32_to_cpu(status
);
521 "error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
524 show_nfsv4_errors(__entry
->error
),
528 __entry
->highest_slotid
532 #endif /* CONFIG_NFS_V4_1 */
534 TRACE_EVENT(nfs4_setup_sequence
,
536 const struct nfs4_session
*session
,
537 const struct nfs4_sequence_args
*args
539 TP_ARGS(session
, args
),
542 __field(unsigned int, session
)
543 __field(unsigned int, slot_nr
)
544 __field(unsigned int, seq_nr
)
545 __field(unsigned int, highest_used_slotid
)
549 const struct nfs4_slot
*sa_slot
= args
->sa_slot
;
550 __entry
->session
= session
? nfs_session_id_hash(&session
->sess_id
) : 0;
551 __entry
->slot_nr
= sa_slot
->slot_nr
;
552 __entry
->seq_nr
= sa_slot
->seq_nr
;
553 __entry
->highest_used_slotid
=
554 sa_slot
->table
->highest_used_slotid
;
557 "session=0x%08x slot_nr=%u seq_nr=%u "
558 "highest_used_slotid=%u",
562 __entry
->highest_used_slotid
566 TRACE_EVENT(nfs4_xdr_status
,
568 const struct xdr_stream
*xdr
,
573 TP_ARGS(xdr
, op
, error
),
576 __field(unsigned int, task_id
)
577 __field(unsigned int, client_id
)
580 __field(unsigned long, error
)
584 const struct rpc_rqst
*rqstp
= xdr
->rqst
;
585 const struct rpc_task
*task
= rqstp
->rq_task
;
587 __entry
->task_id
= task
->tk_pid
;
588 __entry
->client_id
= task
->tk_client
->cl_clid
;
589 __entry
->xid
= be32_to_cpu(rqstp
->rq_xid
);
591 __entry
->error
= error
;
595 "task:%u@%d xid=0x%08x error=%ld (%s) operation=%u",
596 __entry
->task_id
, __entry
->client_id
, __entry
->xid
,
597 -__entry
->error
, show_nfsv4_errors(__entry
->error
),
602 DECLARE_EVENT_CLASS(nfs4_open_event
,
604 const struct nfs_open_context
*ctx
,
609 TP_ARGS(ctx
, flags
, error
),
612 __field(unsigned long, error
)
613 __field(unsigned int, flags
)
614 __field(unsigned int, fmode
)
616 __field(u32
, fhandle
)
619 __string(name
, ctx
->dentry
->d_name
.name
)
620 __field(int, stateid_seq
)
621 __field(u32
, stateid_hash
)
622 __field(int, openstateid_seq
)
623 __field(u32
, openstateid_hash
)
627 const struct nfs4_state
*state
= ctx
->state
;
628 const struct inode
*inode
= NULL
;
630 __entry
->error
= -error
;
631 __entry
->flags
= flags
;
632 __entry
->fmode
= (__force
unsigned int)ctx
->mode
;
633 __entry
->dev
= ctx
->dentry
->d_sb
->s_dev
;
634 if (!IS_ERR_OR_NULL(state
)) {
635 inode
= state
->inode
;
636 __entry
->stateid_seq
=
637 be32_to_cpu(state
->stateid
.seqid
);
638 __entry
->stateid_hash
=
639 nfs_stateid_hash(&state
->stateid
);
640 __entry
->openstateid_seq
=
641 be32_to_cpu(state
->open_stateid
.seqid
);
642 __entry
->openstateid_hash
=
643 nfs_stateid_hash(&state
->open_stateid
);
645 __entry
->stateid_seq
= 0;
646 __entry
->stateid_hash
= 0;
647 __entry
->openstateid_seq
= 0;
648 __entry
->openstateid_hash
= 0;
651 __entry
->fileid
= NFS_FILEID(inode
);
652 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
655 __entry
->fhandle
= 0;
657 __entry
->dir
= NFS_FILEID(d_inode(ctx
->dentry
->d_parent
));
658 __assign_str(name
, ctx
->dentry
->d_name
.name
);
662 "error=%ld (%s) flags=%d (%s) fmode=%s "
663 "fileid=%02x:%02x:%llu fhandle=0x%08x "
664 "name=%02x:%02x:%llu/%s stateid=%d:0x%08x "
665 "openstateid=%d:0x%08x",
667 show_nfsv4_errors(__entry
->error
),
669 show_open_flags(__entry
->flags
),
670 show_fmode_flags(__entry
->fmode
),
671 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
672 (unsigned long long)__entry
->fileid
,
674 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
675 (unsigned long long)__entry
->dir
,
677 __entry
->stateid_seq
, __entry
->stateid_hash
,
678 __entry
->openstateid_seq
, __entry
->openstateid_hash
682 #define DEFINE_NFS4_OPEN_EVENT(name) \
683 DEFINE_EVENT(nfs4_open_event, name, \
685 const struct nfs_open_context *ctx, \
689 TP_ARGS(ctx, flags, error))
690 DEFINE_NFS4_OPEN_EVENT(nfs4_open_reclaim
);
691 DEFINE_NFS4_OPEN_EVENT(nfs4_open_expired
);
692 DEFINE_NFS4_OPEN_EVENT(nfs4_open_file
);
694 TRACE_EVENT(nfs4_cached_open
,
696 const struct nfs4_state
*state
701 __field(u32
, fhandle
)
703 __field(unsigned int, fmode
)
704 __field(int, stateid_seq
)
705 __field(u32
, stateid_hash
)
709 const struct inode
*inode
= state
->inode
;
711 __entry
->dev
= inode
->i_sb
->s_dev
;
712 __entry
->fileid
= NFS_FILEID(inode
);
713 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
714 __entry
->fmode
= (__force
unsigned int)state
->state
;
715 __entry
->stateid_seq
=
716 be32_to_cpu(state
->stateid
.seqid
);
717 __entry
->stateid_hash
=
718 nfs_stateid_hash(&state
->stateid
);
722 "fmode=%s fileid=%02x:%02x:%llu "
723 "fhandle=0x%08x stateid=%d:0x%08x",
724 __entry
->fmode
? show_fmode_flags(__entry
->fmode
) :
726 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
727 (unsigned long long)__entry
->fileid
,
729 __entry
->stateid_seq
, __entry
->stateid_hash
733 TRACE_EVENT(nfs4_close
,
735 const struct nfs4_state
*state
,
736 const struct nfs_closeargs
*args
,
737 const struct nfs_closeres
*res
,
741 TP_ARGS(state
, args
, res
, error
),
745 __field(u32
, fhandle
)
747 __field(unsigned int, fmode
)
748 __field(unsigned long, error
)
749 __field(int, stateid_seq
)
750 __field(u32
, stateid_hash
)
754 const struct inode
*inode
= state
->inode
;
756 __entry
->dev
= inode
->i_sb
->s_dev
;
757 __entry
->fileid
= NFS_FILEID(inode
);
758 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
759 __entry
->fmode
= (__force
unsigned int)state
->state
;
760 __entry
->error
= error
< 0 ? -error
: 0;
761 __entry
->stateid_seq
=
762 be32_to_cpu(args
->stateid
.seqid
);
763 __entry
->stateid_hash
=
764 nfs_stateid_hash(&args
->stateid
);
768 "error=%ld (%s) fmode=%s fileid=%02x:%02x:%llu "
769 "fhandle=0x%08x openstateid=%d:0x%08x",
771 show_nfsv4_errors(__entry
->error
),
772 __entry
->fmode
? show_fmode_flags(__entry
->fmode
) :
774 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
775 (unsigned long long)__entry
->fileid
,
777 __entry
->stateid_seq
, __entry
->stateid_hash
781 TRACE_DEFINE_ENUM(F_GETLK
);
782 TRACE_DEFINE_ENUM(F_SETLK
);
783 TRACE_DEFINE_ENUM(F_SETLKW
);
784 TRACE_DEFINE_ENUM(F_RDLCK
);
785 TRACE_DEFINE_ENUM(F_WRLCK
);
786 TRACE_DEFINE_ENUM(F_UNLCK
);
788 #define show_lock_cmd(type) \
789 __print_symbolic((int)type, \
790 { F_GETLK, "GETLK" }, \
791 { F_SETLK, "SETLK" }, \
792 { F_SETLKW, "SETLKW" })
793 #define show_lock_type(type) \
794 __print_symbolic((int)type, \
795 { F_RDLCK, "RDLCK" }, \
796 { F_WRLCK, "WRLCK" }, \
797 { F_UNLCK, "UNLCK" })
799 DECLARE_EVENT_CLASS(nfs4_lock_event
,
801 const struct file_lock
*request
,
802 const struct nfs4_state
*state
,
807 TP_ARGS(request
, state
, cmd
, error
),
810 __field(unsigned long, error
)
813 __field(loff_t
, start
)
816 __field(u32
, fhandle
)
818 __field(int, stateid_seq
)
819 __field(u32
, stateid_hash
)
823 const struct inode
*inode
= state
->inode
;
825 __entry
->error
= error
< 0 ? -error
: 0;
827 __entry
->type
= request
->fl_type
;
828 __entry
->start
= request
->fl_start
;
829 __entry
->end
= request
->fl_end
;
830 __entry
->dev
= inode
->i_sb
->s_dev
;
831 __entry
->fileid
= NFS_FILEID(inode
);
832 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
833 __entry
->stateid_seq
=
834 be32_to_cpu(state
->stateid
.seqid
);
835 __entry
->stateid_hash
=
836 nfs_stateid_hash(&state
->stateid
);
840 "error=%ld (%s) cmd=%s:%s range=%lld:%lld "
841 "fileid=%02x:%02x:%llu fhandle=0x%08x "
844 show_nfsv4_errors(__entry
->error
),
845 show_lock_cmd(__entry
->cmd
),
846 show_lock_type(__entry
->type
),
847 (long long)__entry
->start
,
848 (long long)__entry
->end
,
849 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
850 (unsigned long long)__entry
->fileid
,
852 __entry
->stateid_seq
, __entry
->stateid_hash
856 #define DEFINE_NFS4_LOCK_EVENT(name) \
857 DEFINE_EVENT(nfs4_lock_event, name, \
859 const struct file_lock *request, \
860 const struct nfs4_state *state, \
864 TP_ARGS(request, state, cmd, error))
865 DEFINE_NFS4_LOCK_EVENT(nfs4_get_lock
);
866 DEFINE_NFS4_LOCK_EVENT(nfs4_unlock
);
868 TRACE_EVENT(nfs4_set_lock
,
870 const struct file_lock
*request
,
871 const struct nfs4_state
*state
,
872 const nfs4_stateid
*lockstateid
,
877 TP_ARGS(request
, state
, lockstateid
, cmd
, error
),
880 __field(unsigned long, error
)
883 __field(loff_t
, start
)
886 __field(u32
, fhandle
)
888 __field(int, stateid_seq
)
889 __field(u32
, stateid_hash
)
890 __field(int, lockstateid_seq
)
891 __field(u32
, lockstateid_hash
)
895 const struct inode
*inode
= state
->inode
;
897 __entry
->error
= error
< 0 ? -error
: 0;
899 __entry
->type
= request
->fl_type
;
900 __entry
->start
= request
->fl_start
;
901 __entry
->end
= request
->fl_end
;
902 __entry
->dev
= inode
->i_sb
->s_dev
;
903 __entry
->fileid
= NFS_FILEID(inode
);
904 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
905 __entry
->stateid_seq
=
906 be32_to_cpu(state
->stateid
.seqid
);
907 __entry
->stateid_hash
=
908 nfs_stateid_hash(&state
->stateid
);
909 __entry
->lockstateid_seq
=
910 be32_to_cpu(lockstateid
->seqid
);
911 __entry
->lockstateid_hash
=
912 nfs_stateid_hash(lockstateid
);
916 "error=%ld (%s) cmd=%s:%s range=%lld:%lld "
917 "fileid=%02x:%02x:%llu fhandle=0x%08x "
918 "stateid=%d:0x%08x lockstateid=%d:0x%08x",
920 show_nfsv4_errors(__entry
->error
),
921 show_lock_cmd(__entry
->cmd
),
922 show_lock_type(__entry
->type
),
923 (long long)__entry
->start
,
924 (long long)__entry
->end
,
925 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
926 (unsigned long long)__entry
->fileid
,
928 __entry
->stateid_seq
, __entry
->stateid_hash
,
929 __entry
->lockstateid_seq
, __entry
->lockstateid_hash
933 DECLARE_EVENT_CLASS(nfs4_set_delegation_event
,
935 const struct inode
*inode
,
939 TP_ARGS(inode
, fmode
),
943 __field(u32
, fhandle
)
945 __field(unsigned int, fmode
)
949 __entry
->dev
= inode
->i_sb
->s_dev
;
950 __entry
->fileid
= NFS_FILEID(inode
);
951 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
952 __entry
->fmode
= (__force
unsigned int)fmode
;
956 "fmode=%s fileid=%02x:%02x:%llu fhandle=0x%08x",
957 show_fmode_flags(__entry
->fmode
),
958 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
959 (unsigned long long)__entry
->fileid
,
963 #define DEFINE_NFS4_SET_DELEGATION_EVENT(name) \
964 DEFINE_EVENT(nfs4_set_delegation_event, name, \
966 const struct inode *inode, \
969 TP_ARGS(inode, fmode))
970 DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_set_delegation
);
971 DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_reclaim_delegation
);
973 TRACE_EVENT(nfs4_delegreturn_exit
,
975 const struct nfs4_delegreturnargs
*args
,
976 const struct nfs4_delegreturnres
*res
,
980 TP_ARGS(args
, res
, error
),
984 __field(u32
, fhandle
)
985 __field(unsigned long, error
)
986 __field(int, stateid_seq
)
987 __field(u32
, stateid_hash
)
991 __entry
->dev
= res
->server
->s_dev
;
992 __entry
->fhandle
= nfs_fhandle_hash(args
->fhandle
);
993 __entry
->error
= error
< 0 ? -error
: 0;
994 __entry
->stateid_seq
=
995 be32_to_cpu(args
->stateid
->seqid
);
996 __entry
->stateid_hash
=
997 nfs_stateid_hash(args
->stateid
);
1001 "error=%ld (%s) dev=%02x:%02x fhandle=0x%08x "
1002 "stateid=%d:0x%08x",
1004 show_nfsv4_errors(__entry
->error
),
1005 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1007 __entry
->stateid_seq
, __entry
->stateid_hash
1011 #ifdef CONFIG_NFS_V4_1
1012 DECLARE_EVENT_CLASS(nfs4_test_stateid_event
,
1014 const struct nfs4_state
*state
,
1015 const struct nfs4_lock_state
*lsp
,
1019 TP_ARGS(state
, lsp
, error
),
1022 __field(unsigned long, error
)
1024 __field(u32
, fhandle
)
1025 __field(u64
, fileid
)
1026 __field(int, stateid_seq
)
1027 __field(u32
, stateid_hash
)
1031 const struct inode
*inode
= state
->inode
;
1033 __entry
->error
= error
< 0 ? -error
: 0;
1034 __entry
->dev
= inode
->i_sb
->s_dev
;
1035 __entry
->fileid
= NFS_FILEID(inode
);
1036 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
1037 __entry
->stateid_seq
=
1038 be32_to_cpu(state
->stateid
.seqid
);
1039 __entry
->stateid_hash
=
1040 nfs_stateid_hash(&state
->stateid
);
1044 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1045 "stateid=%d:0x%08x",
1047 show_nfsv4_errors(__entry
->error
),
1048 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1049 (unsigned long long)__entry
->fileid
,
1051 __entry
->stateid_seq
, __entry
->stateid_hash
1055 #define DEFINE_NFS4_TEST_STATEID_EVENT(name) \
1056 DEFINE_EVENT(nfs4_test_stateid_event, name, \
1058 const struct nfs4_state *state, \
1059 const struct nfs4_lock_state *lsp, \
1062 TP_ARGS(state, lsp, error))
1063 DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_delegation_stateid
);
1064 DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_open_stateid
);
1065 DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_lock_stateid
);
1066 #endif /* CONFIG_NFS_V4_1 */
1068 DECLARE_EVENT_CLASS(nfs4_lookup_event
,
1070 const struct inode
*dir
,
1071 const struct qstr
*name
,
1075 TP_ARGS(dir
, name
, error
),
1079 __field(unsigned long, error
)
1081 __string(name
, name
->name
)
1085 __entry
->dev
= dir
->i_sb
->s_dev
;
1086 __entry
->dir
= NFS_FILEID(dir
);
1087 __entry
->error
= -error
;
1088 __assign_str(name
, name
->name
);
1092 "error=%ld (%s) name=%02x:%02x:%llu/%s",
1094 show_nfsv4_errors(__entry
->error
),
1095 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1096 (unsigned long long)__entry
->dir
,
1101 #define DEFINE_NFS4_LOOKUP_EVENT(name) \
1102 DEFINE_EVENT(nfs4_lookup_event, name, \
1104 const struct inode *dir, \
1105 const struct qstr *name, \
1108 TP_ARGS(dir, name, error))
1110 DEFINE_NFS4_LOOKUP_EVENT(nfs4_lookup
);
1111 DEFINE_NFS4_LOOKUP_EVENT(nfs4_symlink
);
1112 DEFINE_NFS4_LOOKUP_EVENT(nfs4_mkdir
);
1113 DEFINE_NFS4_LOOKUP_EVENT(nfs4_mknod
);
1114 DEFINE_NFS4_LOOKUP_EVENT(nfs4_remove
);
1115 DEFINE_NFS4_LOOKUP_EVENT(nfs4_get_fs_locations
);
1116 DEFINE_NFS4_LOOKUP_EVENT(nfs4_secinfo
);
1118 TRACE_EVENT(nfs4_lookupp
,
1120 const struct inode
*inode
,
1124 TP_ARGS(inode
, error
),
1129 __field(unsigned long, error
)
1133 __entry
->dev
= inode
->i_sb
->s_dev
;
1134 __entry
->ino
= NFS_FILEID(inode
);
1135 __entry
->error
= error
< 0 ? -error
: 0;
1139 "error=%ld (%s) inode=%02x:%02x:%llu",
1141 show_nfsv4_errors(__entry
->error
),
1142 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1143 (unsigned long long)__entry
->ino
1147 TRACE_EVENT(nfs4_rename
,
1149 const struct inode
*olddir
,
1150 const struct qstr
*oldname
,
1151 const struct inode
*newdir
,
1152 const struct qstr
*newname
,
1156 TP_ARGS(olddir
, oldname
, newdir
, newname
, error
),
1160 __field(unsigned long, error
)
1161 __field(u64
, olddir
)
1162 __string(oldname
, oldname
->name
)
1163 __field(u64
, newdir
)
1164 __string(newname
, newname
->name
)
1168 __entry
->dev
= olddir
->i_sb
->s_dev
;
1169 __entry
->olddir
= NFS_FILEID(olddir
);
1170 __entry
->newdir
= NFS_FILEID(newdir
);
1171 __entry
->error
= error
< 0 ? -error
: 0;
1172 __assign_str(oldname
, oldname
->name
);
1173 __assign_str(newname
, newname
->name
);
1177 "error=%ld (%s) oldname=%02x:%02x:%llu/%s "
1178 "newname=%02x:%02x:%llu/%s",
1180 show_nfsv4_errors(__entry
->error
),
1181 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1182 (unsigned long long)__entry
->olddir
,
1184 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1185 (unsigned long long)__entry
->newdir
,
1190 DECLARE_EVENT_CLASS(nfs4_inode_event
,
1192 const struct inode
*inode
,
1196 TP_ARGS(inode
, error
),
1200 __field(u32
, fhandle
)
1201 __field(u64
, fileid
)
1202 __field(unsigned long, error
)
1206 __entry
->dev
= inode
->i_sb
->s_dev
;
1207 __entry
->fileid
= NFS_FILEID(inode
);
1208 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
1209 __entry
->error
= error
< 0 ? -error
: 0;
1213 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x",
1215 show_nfsv4_errors(__entry
->error
),
1216 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1217 (unsigned long long)__entry
->fileid
,
1222 #define DEFINE_NFS4_INODE_EVENT(name) \
1223 DEFINE_EVENT(nfs4_inode_event, name, \
1225 const struct inode *inode, \
1228 TP_ARGS(inode, error))
1230 DEFINE_NFS4_INODE_EVENT(nfs4_access
);
1231 DEFINE_NFS4_INODE_EVENT(nfs4_readlink
);
1232 DEFINE_NFS4_INODE_EVENT(nfs4_readdir
);
1233 DEFINE_NFS4_INODE_EVENT(nfs4_get_acl
);
1234 DEFINE_NFS4_INODE_EVENT(nfs4_set_acl
);
1235 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
1236 DEFINE_NFS4_INODE_EVENT(nfs4_get_security_label
);
1237 DEFINE_NFS4_INODE_EVENT(nfs4_set_security_label
);
1238 #endif /* CONFIG_NFS_V4_SECURITY_LABEL */
1240 DECLARE_EVENT_CLASS(nfs4_inode_stateid_event
,
1242 const struct inode
*inode
,
1243 const nfs4_stateid
*stateid
,
1247 TP_ARGS(inode
, stateid
, error
),
1251 __field(u32
, fhandle
)
1252 __field(u64
, fileid
)
1253 __field(unsigned long, error
)
1254 __field(int, stateid_seq
)
1255 __field(u32
, stateid_hash
)
1259 __entry
->dev
= inode
->i_sb
->s_dev
;
1260 __entry
->fileid
= NFS_FILEID(inode
);
1261 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
1262 __entry
->error
= error
< 0 ? -error
: 0;
1263 __entry
->stateid_seq
=
1264 be32_to_cpu(stateid
->seqid
);
1265 __entry
->stateid_hash
=
1266 nfs_stateid_hash(stateid
);
1270 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1271 "stateid=%d:0x%08x",
1273 show_nfsv4_errors(__entry
->error
),
1274 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1275 (unsigned long long)__entry
->fileid
,
1277 __entry
->stateid_seq
, __entry
->stateid_hash
1281 #define DEFINE_NFS4_INODE_STATEID_EVENT(name) \
1282 DEFINE_EVENT(nfs4_inode_stateid_event, name, \
1284 const struct inode *inode, \
1285 const nfs4_stateid *stateid, \
1288 TP_ARGS(inode, stateid, error))
1290 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_setattr
);
1291 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_delegreturn
);
1292 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update
);
1293 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update_wait
);
1294 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_close_stateid_update_wait
);
1296 DECLARE_EVENT_CLASS(nfs4_getattr_event
,
1298 const struct nfs_server
*server
,
1299 const struct nfs_fh
*fhandle
,
1300 const struct nfs_fattr
*fattr
,
1304 TP_ARGS(server
, fhandle
, fattr
, error
),
1308 __field(u32
, fhandle
)
1309 __field(u64
, fileid
)
1310 __field(unsigned int, valid
)
1311 __field(unsigned long, error
)
1315 __entry
->dev
= server
->s_dev
;
1316 __entry
->valid
= fattr
->valid
;
1317 __entry
->fhandle
= nfs_fhandle_hash(fhandle
);
1318 __entry
->fileid
= (fattr
->valid
& NFS_ATTR_FATTR_FILEID
) ? fattr
->fileid
: 0;
1319 __entry
->error
= error
< 0 ? -error
: 0;
1323 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1326 show_nfsv4_errors(__entry
->error
),
1327 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1328 (unsigned long long)__entry
->fileid
,
1330 show_nfs_fattr_flags(__entry
->valid
)
1334 #define DEFINE_NFS4_GETATTR_EVENT(name) \
1335 DEFINE_EVENT(nfs4_getattr_event, name, \
1337 const struct nfs_server *server, \
1338 const struct nfs_fh *fhandle, \
1339 const struct nfs_fattr *fattr, \
1342 TP_ARGS(server, fhandle, fattr, error))
1343 DEFINE_NFS4_GETATTR_EVENT(nfs4_getattr
);
1344 DEFINE_NFS4_GETATTR_EVENT(nfs4_lookup_root
);
1345 DEFINE_NFS4_GETATTR_EVENT(nfs4_fsinfo
);
1347 DECLARE_EVENT_CLASS(nfs4_inode_callback_event
,
1349 const struct nfs_client
*clp
,
1350 const struct nfs_fh
*fhandle
,
1351 const struct inode
*inode
,
1355 TP_ARGS(clp
, fhandle
, inode
, error
),
1358 __field(unsigned long, error
)
1360 __field(u32
, fhandle
)
1361 __field(u64
, fileid
)
1362 __string(dstaddr
, clp
? clp
->cl_hostname
: "unknown")
1366 __entry
->error
= error
< 0 ? -error
: 0;
1367 __entry
->fhandle
= nfs_fhandle_hash(fhandle
);
1368 if (!IS_ERR_OR_NULL(inode
)) {
1369 __entry
->fileid
= NFS_FILEID(inode
);
1370 __entry
->dev
= inode
->i_sb
->s_dev
;
1372 __entry
->fileid
= 0;
1375 __assign_str(dstaddr
, clp
? clp
->cl_hostname
: "unknown")
1379 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1382 show_nfsv4_errors(__entry
->error
),
1383 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1384 (unsigned long long)__entry
->fileid
,
1390 #define DEFINE_NFS4_INODE_CALLBACK_EVENT(name) \
1391 DEFINE_EVENT(nfs4_inode_callback_event, name, \
1393 const struct nfs_client *clp, \
1394 const struct nfs_fh *fhandle, \
1395 const struct inode *inode, \
1398 TP_ARGS(clp, fhandle, inode, error))
1399 DEFINE_NFS4_INODE_CALLBACK_EVENT(nfs4_cb_getattr
);
1401 DECLARE_EVENT_CLASS(nfs4_inode_stateid_callback_event
,
1403 const struct nfs_client
*clp
,
1404 const struct nfs_fh
*fhandle
,
1405 const struct inode
*inode
,
1406 const nfs4_stateid
*stateid
,
1410 TP_ARGS(clp
, fhandle
, inode
, stateid
, error
),
1413 __field(unsigned long, error
)
1415 __field(u32
, fhandle
)
1416 __field(u64
, fileid
)
1417 __string(dstaddr
, clp
? clp
->cl_hostname
: "unknown")
1418 __field(int, stateid_seq
)
1419 __field(u32
, stateid_hash
)
1423 __entry
->error
= error
< 0 ? -error
: 0;
1424 __entry
->fhandle
= nfs_fhandle_hash(fhandle
);
1425 if (!IS_ERR_OR_NULL(inode
)) {
1426 __entry
->fileid
= NFS_FILEID(inode
);
1427 __entry
->dev
= inode
->i_sb
->s_dev
;
1429 __entry
->fileid
= 0;
1432 __assign_str(dstaddr
, clp
? clp
->cl_hostname
: "unknown")
1433 __entry
->stateid_seq
=
1434 be32_to_cpu(stateid
->seqid
);
1435 __entry
->stateid_hash
=
1436 nfs_stateid_hash(stateid
);
1440 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1441 "stateid=%d:0x%08x dstaddr=%s",
1443 show_nfsv4_errors(__entry
->error
),
1444 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1445 (unsigned long long)__entry
->fileid
,
1447 __entry
->stateid_seq
, __entry
->stateid_hash
,
1452 #define DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(name) \
1453 DEFINE_EVENT(nfs4_inode_stateid_callback_event, name, \
1455 const struct nfs_client *clp, \
1456 const struct nfs_fh *fhandle, \
1457 const struct inode *inode, \
1458 const nfs4_stateid *stateid, \
1461 TP_ARGS(clp, fhandle, inode, stateid, error))
1462 DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_recall
);
1463 DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_layoutrecall_file
);
1465 DECLARE_EVENT_CLASS(nfs4_idmap_event
,
1473 TP_ARGS(name
, len
, id
, error
),
1476 __field(unsigned long, error
)
1478 __dynamic_array(char, name
, len
> 0 ? len
+ 1 : 1)
1484 __entry
->error
= error
< 0 ? error
: 0;
1486 memcpy(__get_str(name
), name
, len
);
1487 __get_str(name
)[len
] = 0;
1491 "error=%ld (%s) id=%u name=%s",
1492 -__entry
->error
, show_nfsv4_errors(__entry
->error
),
1497 #define DEFINE_NFS4_IDMAP_EVENT(name) \
1498 DEFINE_EVENT(nfs4_idmap_event, name, \
1505 TP_ARGS(name, len, id, error))
1506 DEFINE_NFS4_IDMAP_EVENT(nfs4_map_name_to_uid
);
1507 DEFINE_NFS4_IDMAP_EVENT(nfs4_map_group_to_gid
);
1508 DEFINE_NFS4_IDMAP_EVENT(nfs4_map_uid_to_name
);
1509 DEFINE_NFS4_IDMAP_EVENT(nfs4_map_gid_to_group
);
1511 DECLARE_EVENT_CLASS(nfs4_read_event
,
1513 const struct nfs_pgio_header
*hdr
,
1517 TP_ARGS(hdr
, error
),
1521 __field(u32
, fhandle
)
1522 __field(u64
, fileid
)
1523 __field(loff_t
, offset
)
1524 __field(size_t, count
)
1525 __field(unsigned long, error
)
1526 __field(int, stateid_seq
)
1527 __field(u32
, stateid_hash
)
1531 const struct inode
*inode
= hdr
->inode
;
1532 const struct nfs4_state
*state
=
1533 hdr
->args
.context
->state
;
1534 __entry
->dev
= inode
->i_sb
->s_dev
;
1535 __entry
->fileid
= NFS_FILEID(inode
);
1536 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
1537 __entry
->offset
= hdr
->args
.offset
;
1538 __entry
->count
= hdr
->args
.count
;
1539 __entry
->error
= error
< 0 ? -error
: 0;
1540 __entry
->stateid_seq
=
1541 be32_to_cpu(state
->stateid
.seqid
);
1542 __entry
->stateid_hash
=
1543 nfs_stateid_hash(&state
->stateid
);
1547 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1548 "offset=%lld count=%zu stateid=%d:0x%08x",
1550 show_nfsv4_errors(__entry
->error
),
1551 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1552 (unsigned long long)__entry
->fileid
,
1554 (long long)__entry
->offset
,
1556 __entry
->stateid_seq
, __entry
->stateid_hash
1559 #define DEFINE_NFS4_READ_EVENT(name) \
1560 DEFINE_EVENT(nfs4_read_event, name, \
1562 const struct nfs_pgio_header *hdr, \
1565 TP_ARGS(hdr, error))
1566 DEFINE_NFS4_READ_EVENT(nfs4_read
);
1567 #ifdef CONFIG_NFS_V4_1
1568 DEFINE_NFS4_READ_EVENT(nfs4_pnfs_read
);
1569 #endif /* CONFIG_NFS_V4_1 */
1571 DECLARE_EVENT_CLASS(nfs4_write_event
,
1573 const struct nfs_pgio_header
*hdr
,
1577 TP_ARGS(hdr
, error
),
1581 __field(u32
, fhandle
)
1582 __field(u64
, fileid
)
1583 __field(loff_t
, offset
)
1584 __field(size_t, count
)
1585 __field(unsigned long, error
)
1586 __field(int, stateid_seq
)
1587 __field(u32
, stateid_hash
)
1591 const struct inode
*inode
= hdr
->inode
;
1592 const struct nfs4_state
*state
=
1593 hdr
->args
.context
->state
;
1594 __entry
->dev
= inode
->i_sb
->s_dev
;
1595 __entry
->fileid
= NFS_FILEID(inode
);
1596 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
1597 __entry
->offset
= hdr
->args
.offset
;
1598 __entry
->count
= hdr
->args
.count
;
1599 __entry
->error
= error
< 0 ? -error
: 0;
1600 __entry
->stateid_seq
=
1601 be32_to_cpu(state
->stateid
.seqid
);
1602 __entry
->stateid_hash
=
1603 nfs_stateid_hash(&state
->stateid
);
1607 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1608 "offset=%lld count=%zu stateid=%d:0x%08x",
1610 show_nfsv4_errors(__entry
->error
),
1611 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1612 (unsigned long long)__entry
->fileid
,
1614 (long long)__entry
->offset
,
1616 __entry
->stateid_seq
, __entry
->stateid_hash
1620 #define DEFINE_NFS4_WRITE_EVENT(name) \
1621 DEFINE_EVENT(nfs4_write_event, name, \
1623 const struct nfs_pgio_header *hdr, \
1626 TP_ARGS(hdr, error))
1627 DEFINE_NFS4_WRITE_EVENT(nfs4_write
);
1628 #ifdef CONFIG_NFS_V4_1
1629 DEFINE_NFS4_WRITE_EVENT(nfs4_pnfs_write
);
1630 #endif /* CONFIG_NFS_V4_1 */
1632 DECLARE_EVENT_CLASS(nfs4_commit_event
,
1634 const struct nfs_commit_data
*data
,
1638 TP_ARGS(data
, error
),
1642 __field(u32
, fhandle
)
1643 __field(u64
, fileid
)
1644 __field(loff_t
, offset
)
1645 __field(size_t, count
)
1646 __field(unsigned long, error
)
1650 const struct inode
*inode
= data
->inode
;
1651 __entry
->dev
= inode
->i_sb
->s_dev
;
1652 __entry
->fileid
= NFS_FILEID(inode
);
1653 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
1654 __entry
->offset
= data
->args
.offset
;
1655 __entry
->count
= data
->args
.count
;
1656 __entry
->error
= error
;
1660 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1661 "offset=%lld count=%zu",
1663 show_nfsv4_errors(__entry
->error
),
1664 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1665 (unsigned long long)__entry
->fileid
,
1667 (long long)__entry
->offset
,
1671 #define DEFINE_NFS4_COMMIT_EVENT(name) \
1672 DEFINE_EVENT(nfs4_commit_event, name, \
1674 const struct nfs_commit_data *data, \
1677 TP_ARGS(data, error))
1678 DEFINE_NFS4_COMMIT_EVENT(nfs4_commit
);
1679 #ifdef CONFIG_NFS_V4_1
1680 DEFINE_NFS4_COMMIT_EVENT(nfs4_pnfs_commit_ds
);
1682 TRACE_DEFINE_ENUM(IOMODE_READ
);
1683 TRACE_DEFINE_ENUM(IOMODE_RW
);
1684 TRACE_DEFINE_ENUM(IOMODE_ANY
);
1686 #define show_pnfs_iomode(iomode) \
1687 __print_symbolic(iomode, \
1688 { IOMODE_READ, "READ" }, \
1689 { IOMODE_RW, "RW" }, \
1690 { IOMODE_ANY, "ANY" })
1692 TRACE_EVENT(nfs4_layoutget
,
1694 const struct nfs_open_context
*ctx
,
1695 const struct pnfs_layout_range
*args
,
1696 const struct pnfs_layout_range
*res
,
1697 const nfs4_stateid
*layout_stateid
,
1701 TP_ARGS(ctx
, args
, res
, layout_stateid
, error
),
1705 __field(u32
, fhandle
)
1706 __field(u64
, fileid
)
1707 __field(u32
, iomode
)
1708 __field(u64
, offset
)
1710 __field(unsigned long, error
)
1711 __field(int, stateid_seq
)
1712 __field(u32
, stateid_hash
)
1713 __field(int, layoutstateid_seq
)
1714 __field(u32
, layoutstateid_hash
)
1718 const struct inode
*inode
= d_inode(ctx
->dentry
);
1719 const struct nfs4_state
*state
= ctx
->state
;
1720 __entry
->dev
= inode
->i_sb
->s_dev
;
1721 __entry
->fileid
= NFS_FILEID(inode
);
1722 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
1723 __entry
->iomode
= args
->iomode
;
1724 __entry
->offset
= args
->offset
;
1725 __entry
->count
= args
->length
;
1726 __entry
->error
= error
< 0 ? -error
: 0;
1727 __entry
->stateid_seq
=
1728 be32_to_cpu(state
->stateid
.seqid
);
1729 __entry
->stateid_hash
=
1730 nfs_stateid_hash(&state
->stateid
);
1732 __entry
->layoutstateid_seq
=
1733 be32_to_cpu(layout_stateid
->seqid
);
1734 __entry
->layoutstateid_hash
=
1735 nfs_stateid_hash(layout_stateid
);
1737 __entry
->layoutstateid_seq
= 0;
1738 __entry
->layoutstateid_hash
= 0;
1743 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1744 "iomode=%s offset=%llu count=%llu stateid=%d:0x%08x "
1745 "layoutstateid=%d:0x%08x",
1747 show_nfsv4_errors(__entry
->error
),
1748 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1749 (unsigned long long)__entry
->fileid
,
1751 show_pnfs_iomode(__entry
->iomode
),
1752 (unsigned long long)__entry
->offset
,
1753 (unsigned long long)__entry
->count
,
1754 __entry
->stateid_seq
, __entry
->stateid_hash
,
1755 __entry
->layoutstateid_seq
, __entry
->layoutstateid_hash
1759 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutcommit
);
1760 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn
);
1761 DEFINE_NFS4_INODE_EVENT(nfs4_layoutreturn_on_close
);
1763 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_UNKNOWN
);
1764 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NO_PNFS
);
1765 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RD_ZEROLEN
);
1766 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_MDSTHRESH
);
1767 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NOMEM
);
1768 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_BULK_RECALL
);
1769 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_IO_TEST_FAIL
);
1770 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_FOUND_CACHED
);
1771 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RETURN
);
1772 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_BLOCKED
);
1773 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_INVALID_OPEN
);
1774 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RETRY
);
1775 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET
);
1776 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_EXIT
);
1778 #define show_pnfs_update_layout_reason(reason) \
1779 __print_symbolic(reason, \
1780 { PNFS_UPDATE_LAYOUT_UNKNOWN, "unknown" }, \
1781 { PNFS_UPDATE_LAYOUT_NO_PNFS, "no pnfs" }, \
1782 { PNFS_UPDATE_LAYOUT_RD_ZEROLEN, "read+zerolen" }, \
1783 { PNFS_UPDATE_LAYOUT_MDSTHRESH, "mdsthresh" }, \
1784 { PNFS_UPDATE_LAYOUT_NOMEM, "nomem" }, \
1785 { PNFS_UPDATE_LAYOUT_BULK_RECALL, "bulk recall" }, \
1786 { PNFS_UPDATE_LAYOUT_IO_TEST_FAIL, "io test fail" }, \
1787 { PNFS_UPDATE_LAYOUT_FOUND_CACHED, "found cached" }, \
1788 { PNFS_UPDATE_LAYOUT_RETURN, "layoutreturn" }, \
1789 { PNFS_UPDATE_LAYOUT_BLOCKED, "layouts blocked" }, \
1790 { PNFS_UPDATE_LAYOUT_INVALID_OPEN, "invalid open" }, \
1791 { PNFS_UPDATE_LAYOUT_RETRY, "retrying" }, \
1792 { PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET, "sent layoutget" }, \
1793 { PNFS_UPDATE_LAYOUT_EXIT, "exit" })
1795 TRACE_EVENT(pnfs_update_layout
,
1796 TP_PROTO(struct inode
*inode
,
1799 enum pnfs_iomode iomode
,
1800 struct pnfs_layout_hdr
*lo
,
1801 struct pnfs_layout_segment
*lseg
,
1802 enum pnfs_update_layout_reason reason
1804 TP_ARGS(inode
, pos
, count
, iomode
, lo
, lseg
, reason
),
1807 __field(u64
, fileid
)
1808 __field(u32
, fhandle
)
1809 __field(loff_t
, pos
)
1811 __field(enum pnfs_iomode
, iomode
)
1812 __field(int, layoutstateid_seq
)
1813 __field(u32
, layoutstateid_hash
)
1815 __field(enum pnfs_update_layout_reason
, reason
)
1818 __entry
->dev
= inode
->i_sb
->s_dev
;
1819 __entry
->fileid
= NFS_FILEID(inode
);
1820 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
1822 __entry
->count
= count
;
1823 __entry
->iomode
= iomode
;
1824 __entry
->reason
= reason
;
1826 __entry
->layoutstateid_seq
=
1827 be32_to_cpu(lo
->plh_stateid
.seqid
);
1828 __entry
->layoutstateid_hash
=
1829 nfs_stateid_hash(&lo
->plh_stateid
);
1831 __entry
->layoutstateid_seq
= 0;
1832 __entry
->layoutstateid_hash
= 0;
1834 __entry
->lseg
= (long)lseg
;
1837 "fileid=%02x:%02x:%llu fhandle=0x%08x "
1838 "iomode=%s pos=%llu count=%llu "
1839 "layoutstateid=%d:0x%08x lseg=0x%lx (%s)",
1840 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1841 (unsigned long long)__entry
->fileid
,
1843 show_pnfs_iomode(__entry
->iomode
),
1844 (unsigned long long)__entry
->pos
,
1845 (unsigned long long)__entry
->count
,
1846 __entry
->layoutstateid_seq
, __entry
->layoutstateid_hash
,
1848 show_pnfs_update_layout_reason(__entry
->reason
)
1852 DECLARE_EVENT_CLASS(pnfs_layout_event
,
1853 TP_PROTO(struct inode
*inode
,
1856 enum pnfs_iomode iomode
,
1857 struct pnfs_layout_hdr
*lo
,
1858 struct pnfs_layout_segment
*lseg
1860 TP_ARGS(inode
, pos
, count
, iomode
, lo
, lseg
),
1863 __field(u64
, fileid
)
1864 __field(u32
, fhandle
)
1865 __field(loff_t
, pos
)
1867 __field(enum pnfs_iomode
, iomode
)
1868 __field(int, layoutstateid_seq
)
1869 __field(u32
, layoutstateid_hash
)
1873 __entry
->dev
= inode
->i_sb
->s_dev
;
1874 __entry
->fileid
= NFS_FILEID(inode
);
1875 __entry
->fhandle
= nfs_fhandle_hash(NFS_FH(inode
));
1877 __entry
->count
= count
;
1878 __entry
->iomode
= iomode
;
1880 __entry
->layoutstateid_seq
=
1881 be32_to_cpu(lo
->plh_stateid
.seqid
);
1882 __entry
->layoutstateid_hash
=
1883 nfs_stateid_hash(&lo
->plh_stateid
);
1885 __entry
->layoutstateid_seq
= 0;
1886 __entry
->layoutstateid_hash
= 0;
1888 __entry
->lseg
= (long)lseg
;
1891 "fileid=%02x:%02x:%llu fhandle=0x%08x "
1892 "iomode=%s pos=%llu count=%llu "
1893 "layoutstateid=%d:0x%08x lseg=0x%lx",
1894 MAJOR(__entry
->dev
), MINOR(__entry
->dev
),
1895 (unsigned long long)__entry
->fileid
,
1897 show_pnfs_iomode(__entry
->iomode
),
1898 (unsigned long long)__entry
->pos
,
1899 (unsigned long long)__entry
->count
,
1900 __entry
->layoutstateid_seq
, __entry
->layoutstateid_hash
,
1905 #define DEFINE_PNFS_LAYOUT_EVENT(name) \
1906 DEFINE_EVENT(pnfs_layout_event, name, \
1907 TP_PROTO(struct inode *inode, \
1910 enum pnfs_iomode iomode, \
1911 struct pnfs_layout_hdr *lo, \
1912 struct pnfs_layout_segment *lseg \
1914 TP_ARGS(inode, pos, count, iomode, lo, lseg))
1916 DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_init_read
);
1917 DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_init_write
);
1918 DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_get_mirror_count
);
1919 DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_read_done
);
1920 DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_write_done
);
1921 DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_read_pagelist
);
1922 DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_write_pagelist
);
1924 #endif /* CONFIG_NFS_V4_1 */
1926 #endif /* _TRACE_NFS4_H */
1928 #undef TRACE_INCLUDE_PATH
1929 #define TRACE_INCLUDE_PATH .
1930 #define TRACE_INCLUDE_FILE nfs4trace
1931 /* This part must be outside protection */
1932 #include <trace/define_trace.h>