~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfs/nfstrace.h

Version: ~ [ linux-5.14-rc3 ] ~ [ linux-5.13.5 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.53 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.135 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.198 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.240 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.276 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.276 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp