Merge tag 'nfs-for-4.14-2' of git://git.linux-nfs.org/projects/trondmy/linux-nfs
[sfrench/cifs-2.6.git] / fs / nfs / nfstrace.h
1 /*
2  * Copyright (c) 2013 Trond Myklebust <Trond.Myklebust@netapp.com>
3  */
4 #undef TRACE_SYSTEM
5 #define TRACE_SYSTEM nfs
6
7 #if !defined(_TRACE_NFS_H) || defined(TRACE_HEADER_MULTI_READ)
8 #define _TRACE_NFS_H
9
10 #include <linux/tracepoint.h>
11
12 #define nfs_show_file_type(ftype) \
13         __print_symbolic(ftype, \
14                         { DT_UNKNOWN, "UNKNOWN" }, \
15                         { DT_FIFO, "FIFO" }, \
16                         { DT_CHR, "CHR" }, \
17                         { DT_DIR, "DIR" }, \
18                         { DT_BLK, "BLK" }, \
19                         { DT_REG, "REG" }, \
20                         { DT_LNK, "LNK" }, \
21                         { DT_SOCK, "SOCK" }, \
22                         { DT_WHT, "WHT" })
23
24 #define nfs_show_cache_validity(v) \
25         __print_flags(v, "|", \
26                         { NFS_INO_INVALID_ATTR, "INVALID_ATTR" }, \
27                         { NFS_INO_INVALID_DATA, "INVALID_DATA" }, \
28                         { NFS_INO_INVALID_ATIME, "INVALID_ATIME" }, \
29                         { NFS_INO_INVALID_ACCESS, "INVALID_ACCESS" }, \
30                         { NFS_INO_INVALID_ACL, "INVALID_ACL" }, \
31                         { NFS_INO_REVAL_PAGECACHE, "REVAL_PAGECACHE" }, \
32                         { NFS_INO_REVAL_FORCED, "REVAL_FORCED" }, \
33                         { NFS_INO_INVALID_LABEL, "INVALID_LABEL" })
34
35 #define nfs_show_nfsi_flags(v) \
36         __print_flags(v, "|", \
37                         { 1 << NFS_INO_ADVISE_RDPLUS, "ADVISE_RDPLUS" }, \
38                         { 1 << NFS_INO_STALE, "STALE" }, \
39                         { 1 << NFS_INO_INVALIDATING, "INVALIDATING" }, \
40                         { 1 << NFS_INO_FSCACHE, "FSCACHE" }, \
41                         { 1 << NFS_INO_LAYOUTCOMMIT, "NEED_LAYOUTCOMMIT" }, \
42                         { 1 << NFS_INO_LAYOUTCOMMITTING, "LAYOUTCOMMIT" })
43
44 DECLARE_EVENT_CLASS(nfs_inode_event,
45                 TP_PROTO(
46                         const struct inode *inode
47                 ),
48
49                 TP_ARGS(inode),
50
51                 TP_STRUCT__entry(
52                         __field(dev_t, dev)
53                         __field(u32, fhandle)
54                         __field(u64, fileid)
55                         __field(u64, version)
56                 ),
57
58                 TP_fast_assign(
59                         const struct nfs_inode *nfsi = NFS_I(inode);
60                         __entry->dev = inode->i_sb->s_dev;
61                         __entry->fileid = nfsi->fileid;
62                         __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
63                         __entry->version = inode->i_version;
64                 ),
65
66                 TP_printk(
67                         "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu ",
68                         MAJOR(__entry->dev), MINOR(__entry->dev),
69                         (unsigned long long)__entry->fileid,
70                         __entry->fhandle,
71                         (unsigned long long)__entry->version
72                 )
73 );
74
75 DECLARE_EVENT_CLASS(nfs_inode_event_done,
76                 TP_PROTO(
77                         const struct inode *inode,
78                         int error
79                 ),
80
81                 TP_ARGS(inode, error),
82
83                 TP_STRUCT__entry(
84                         __field(int, error)
85                         __field(dev_t, dev)
86                         __field(u32, fhandle)
87                         __field(unsigned char, type)
88                         __field(u64, fileid)
89                         __field(u64, version)
90                         __field(loff_t, size)
91                         __field(unsigned long, nfsi_flags)
92                         __field(unsigned long, cache_validity)
93                 ),
94
95                 TP_fast_assign(
96                         const struct nfs_inode *nfsi = NFS_I(inode);
97                         __entry->error = error;
98                         __entry->dev = inode->i_sb->s_dev;
99                         __entry->fileid = nfsi->fileid;
100                         __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
101                         __entry->type = nfs_umode_to_dtype(inode->i_mode);
102                         __entry->version = inode->i_version;
103                         __entry->size = i_size_read(inode);
104                         __entry->nfsi_flags = nfsi->flags;
105                         __entry->cache_validity = nfsi->cache_validity;
106                 ),
107
108                 TP_printk(
109                         "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x "
110                         "type=%u (%s) version=%llu size=%lld "
111                         "cache_validity=%lu (%s) nfs_flags=%ld (%s)",
112                         __entry->error,
113                         MAJOR(__entry->dev), MINOR(__entry->dev),
114                         (unsigned long long)__entry->fileid,
115                         __entry->fhandle,
116                         __entry->type,
117                         nfs_show_file_type(__entry->type),
118                         (unsigned long long)__entry->version,
119                         (long long)__entry->size,
120                         __entry->cache_validity,
121                         nfs_show_cache_validity(__entry->cache_validity),
122                         __entry->nfsi_flags,
123                         nfs_show_nfsi_flags(__entry->nfsi_flags)
124                 )
125 );
126
127 #define DEFINE_NFS_INODE_EVENT(name) \
128         DEFINE_EVENT(nfs_inode_event, name, \
129                         TP_PROTO( \
130                                 const struct inode *inode \
131                         ), \
132                         TP_ARGS(inode))
133 #define DEFINE_NFS_INODE_EVENT_DONE(name) \
134         DEFINE_EVENT(nfs_inode_event_done, name, \
135                         TP_PROTO( \
136                                 const struct inode *inode, \
137                                 int error \
138                         ), \
139                         TP_ARGS(inode, error))
140 DEFINE_NFS_INODE_EVENT(nfs_refresh_inode_enter);
141 DEFINE_NFS_INODE_EVENT_DONE(nfs_refresh_inode_exit);
142 DEFINE_NFS_INODE_EVENT(nfs_revalidate_inode_enter);
143 DEFINE_NFS_INODE_EVENT_DONE(nfs_revalidate_inode_exit);
144 DEFINE_NFS_INODE_EVENT(nfs_invalidate_mapping_enter);
145 DEFINE_NFS_INODE_EVENT_DONE(nfs_invalidate_mapping_exit);
146 DEFINE_NFS_INODE_EVENT(nfs_getattr_enter);
147 DEFINE_NFS_INODE_EVENT_DONE(nfs_getattr_exit);
148 DEFINE_NFS_INODE_EVENT(nfs_setattr_enter);
149 DEFINE_NFS_INODE_EVENT_DONE(nfs_setattr_exit);
150 DEFINE_NFS_INODE_EVENT(nfs_writeback_page_enter);
151 DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_page_exit);
152 DEFINE_NFS_INODE_EVENT(nfs_writeback_inode_enter);
153 DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_inode_exit);
154 DEFINE_NFS_INODE_EVENT(nfs_fsync_enter);
155 DEFINE_NFS_INODE_EVENT_DONE(nfs_fsync_exit);
156 DEFINE_NFS_INODE_EVENT(nfs_access_enter);
157 DEFINE_NFS_INODE_EVENT_DONE(nfs_access_exit);
158
159 #define show_lookup_flags(flags) \
160         __print_flags((unsigned long)flags, "|", \
161                         { LOOKUP_AUTOMOUNT, "AUTOMOUNT" }, \
162                         { LOOKUP_DIRECTORY, "DIRECTORY" }, \
163                         { LOOKUP_OPEN, "OPEN" }, \
164                         { LOOKUP_CREATE, "CREATE" }, \
165                         { LOOKUP_EXCL, "EXCL" })
166
167 DECLARE_EVENT_CLASS(nfs_lookup_event,
168                 TP_PROTO(
169                         const struct inode *dir,
170                         const struct dentry *dentry,
171                         unsigned int flags
172                 ),
173
174                 TP_ARGS(dir, dentry, flags),
175
176                 TP_STRUCT__entry(
177                         __field(unsigned int, flags)
178                         __field(dev_t, dev)
179                         __field(u64, dir)
180                         __string(name, dentry->d_name.name)
181                 ),
182
183                 TP_fast_assign(
184                         __entry->dev = dir->i_sb->s_dev;
185                         __entry->dir = NFS_FILEID(dir);
186                         __entry->flags = flags;
187                         __assign_str(name, dentry->d_name.name);
188                 ),
189
190                 TP_printk(
191                         "flags=%u (%s) name=%02x:%02x:%llu/%s",
192                         __entry->flags,
193                         show_lookup_flags(__entry->flags),
194                         MAJOR(__entry->dev), MINOR(__entry->dev),
195                         (unsigned long long)__entry->dir,
196                         __get_str(name)
197                 )
198 );
199
200 #define DEFINE_NFS_LOOKUP_EVENT(name) \
201         DEFINE_EVENT(nfs_lookup_event, name, \
202                         TP_PROTO( \
203                                 const struct inode *dir, \
204                                 const struct dentry *dentry, \
205                                 unsigned int flags \
206                         ), \
207                         TP_ARGS(dir, dentry, flags))
208
209 DECLARE_EVENT_CLASS(nfs_lookup_event_done,
210                 TP_PROTO(
211                         const struct inode *dir,
212                         const struct dentry *dentry,
213                         unsigned int flags,
214                         int error
215                 ),
216
217                 TP_ARGS(dir, dentry, flags, error),
218
219                 TP_STRUCT__entry(
220                         __field(int, error)
221                         __field(unsigned int, flags)
222                         __field(dev_t, dev)
223                         __field(u64, dir)
224                         __string(name, dentry->d_name.name)
225                 ),
226
227                 TP_fast_assign(
228                         __entry->dev = dir->i_sb->s_dev;
229                         __entry->dir = NFS_FILEID(dir);
230                         __entry->error = error;
231                         __entry->flags = flags;
232                         __assign_str(name, dentry->d_name.name);
233                 ),
234
235                 TP_printk(
236                         "error=%d flags=%u (%s) name=%02x:%02x:%llu/%s",
237                         __entry->error,
238                         __entry->flags,
239                         show_lookup_flags(__entry->flags),
240                         MAJOR(__entry->dev), MINOR(__entry->dev),
241                         (unsigned long long)__entry->dir,
242                         __get_str(name)
243                 )
244 );
245
246 #define DEFINE_NFS_LOOKUP_EVENT_DONE(name) \
247         DEFINE_EVENT(nfs_lookup_event_done, name, \
248                         TP_PROTO( \
249                                 const struct inode *dir, \
250                                 const struct dentry *dentry, \
251                                 unsigned int flags, \
252                                 int error \
253                         ), \
254                         TP_ARGS(dir, dentry, flags, error))
255
256 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_enter);
257 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_exit);
258 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_revalidate_enter);
259 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_revalidate_exit);
260
261 #define show_open_flags(flags) \
262         __print_flags((unsigned long)flags, "|", \
263                 { O_CREAT, "O_CREAT" }, \
264                 { O_EXCL, "O_EXCL" }, \
265                 { O_TRUNC, "O_TRUNC" }, \
266                 { O_APPEND, "O_APPEND" }, \
267                 { O_DSYNC, "O_DSYNC" }, \
268                 { O_DIRECT, "O_DIRECT" }, \
269                 { O_DIRECTORY, "O_DIRECTORY" })
270
271 #define show_fmode_flags(mode) \
272         __print_flags(mode, "|", \
273                 { ((__force unsigned long)FMODE_READ), "READ" }, \
274                 { ((__force unsigned long)FMODE_WRITE), "WRITE" }, \
275                 { ((__force unsigned long)FMODE_EXEC), "EXEC" })
276
277 TRACE_EVENT(nfs_atomic_open_enter,
278                 TP_PROTO(
279                         const struct inode *dir,
280                         const struct nfs_open_context *ctx,
281                         unsigned int flags
282                 ),
283
284                 TP_ARGS(dir, ctx, flags),
285
286                 TP_STRUCT__entry(
287                         __field(unsigned int, flags)
288                         __field(unsigned int, fmode)
289                         __field(dev_t, dev)
290                         __field(u64, dir)
291                         __string(name, ctx->dentry->d_name.name)
292                 ),
293
294                 TP_fast_assign(
295                         __entry->dev = dir->i_sb->s_dev;
296                         __entry->dir = NFS_FILEID(dir);
297                         __entry->flags = flags;
298                         __entry->fmode = (__force unsigned int)ctx->mode;
299                         __assign_str(name, ctx->dentry->d_name.name);
300                 ),
301
302                 TP_printk(
303                         "flags=%u (%s) fmode=%s name=%02x:%02x:%llu/%s",
304                         __entry->flags,
305                         show_open_flags(__entry->flags),
306                         show_fmode_flags(__entry->fmode),
307                         MAJOR(__entry->dev), MINOR(__entry->dev),
308                         (unsigned long long)__entry->dir,
309                         __get_str(name)
310                 )
311 );
312
313 TRACE_EVENT(nfs_atomic_open_exit,
314                 TP_PROTO(
315                         const struct inode *dir,
316                         const struct nfs_open_context *ctx,
317                         unsigned int flags,
318                         int error
319                 ),
320
321                 TP_ARGS(dir, ctx, flags, error),
322
323                 TP_STRUCT__entry(
324                         __field(int, error)
325                         __field(unsigned int, flags)
326                         __field(unsigned int, fmode)
327                         __field(dev_t, dev)
328                         __field(u64, dir)
329                         __string(name, ctx->dentry->d_name.name)
330                 ),
331
332                 TP_fast_assign(
333                         __entry->error = error;
334                         __entry->dev = dir->i_sb->s_dev;
335                         __entry->dir = NFS_FILEID(dir);
336                         __entry->flags = flags;
337                         __entry->fmode = (__force unsigned int)ctx->mode;
338                         __assign_str(name, ctx->dentry->d_name.name);
339                 ),
340
341                 TP_printk(
342                         "error=%d flags=%u (%s) fmode=%s "
343                         "name=%02x:%02x:%llu/%s",
344                         __entry->error,
345                         __entry->flags,
346                         show_open_flags(__entry->flags),
347                         show_fmode_flags(__entry->fmode),
348                         MAJOR(__entry->dev), MINOR(__entry->dev),
349                         (unsigned long long)__entry->dir,
350                         __get_str(name)
351                 )
352 );
353
354 TRACE_EVENT(nfs_create_enter,
355                 TP_PROTO(
356                         const struct inode *dir,
357                         const struct dentry *dentry,
358                         unsigned int flags
359                 ),
360
361                 TP_ARGS(dir, dentry, flags),
362
363                 TP_STRUCT__entry(
364                         __field(unsigned int, flags)
365                         __field(dev_t, dev)
366                         __field(u64, dir)
367                         __string(name, dentry->d_name.name)
368                 ),
369
370                 TP_fast_assign(
371                         __entry->dev = dir->i_sb->s_dev;
372                         __entry->dir = NFS_FILEID(dir);
373                         __entry->flags = flags;
374                         __assign_str(name, dentry->d_name.name);
375                 ),
376
377                 TP_printk(
378                         "flags=%u (%s) name=%02x:%02x:%llu/%s",
379                         __entry->flags,
380                         show_open_flags(__entry->flags),
381                         MAJOR(__entry->dev), MINOR(__entry->dev),
382                         (unsigned long long)__entry->dir,
383                         __get_str(name)
384                 )
385 );
386
387 TRACE_EVENT(nfs_create_exit,
388                 TP_PROTO(
389                         const struct inode *dir,
390                         const struct dentry *dentry,
391                         unsigned int flags,
392                         int error
393                 ),
394
395                 TP_ARGS(dir, dentry, flags, error),
396
397                 TP_STRUCT__entry(
398                         __field(int, error)
399                         __field(unsigned int, flags)
400                         __field(dev_t, dev)
401                         __field(u64, dir)
402                         __string(name, dentry->d_name.name)
403                 ),
404
405                 TP_fast_assign(
406                         __entry->error = error;
407                         __entry->dev = dir->i_sb->s_dev;
408                         __entry->dir = NFS_FILEID(dir);
409                         __entry->flags = flags;
410                         __assign_str(name, dentry->d_name.name);
411                 ),
412
413                 TP_printk(
414                         "error=%d flags=%u (%s) name=%02x:%02x:%llu/%s",
415                         __entry->error,
416                         __entry->flags,
417                         show_open_flags(__entry->flags),
418                         MAJOR(__entry->dev), MINOR(__entry->dev),
419                         (unsigned long long)__entry->dir,
420                         __get_str(name)
421                 )
422 );
423
424 DECLARE_EVENT_CLASS(nfs_directory_event,
425                 TP_PROTO(
426                         const struct inode *dir,
427                         const struct dentry *dentry
428                 ),
429
430                 TP_ARGS(dir, dentry),
431
432                 TP_STRUCT__entry(
433                         __field(dev_t, dev)
434                         __field(u64, dir)
435                         __string(name, dentry->d_name.name)
436                 ),
437
438                 TP_fast_assign(
439                         __entry->dev = dir->i_sb->s_dev;
440                         __entry->dir = NFS_FILEID(dir);
441                         __assign_str(name, dentry->d_name.name);
442                 ),
443
444                 TP_printk(
445                         "name=%02x:%02x:%llu/%s",
446                         MAJOR(__entry->dev), MINOR(__entry->dev),
447                         (unsigned long long)__entry->dir,
448                         __get_str(name)
449                 )
450 );
451
452 #define DEFINE_NFS_DIRECTORY_EVENT(name) \
453         DEFINE_EVENT(nfs_directory_event, name, \
454                         TP_PROTO( \
455                                 const struct inode *dir, \
456                                 const struct dentry *dentry \
457                         ), \
458                         TP_ARGS(dir, dentry))
459
460 DECLARE_EVENT_CLASS(nfs_directory_event_done,
461                 TP_PROTO(
462                         const struct inode *dir,
463                         const struct dentry *dentry,
464                         int error
465                 ),
466
467                 TP_ARGS(dir, dentry, error),
468
469                 TP_STRUCT__entry(
470                         __field(int, error)
471                         __field(dev_t, dev)
472                         __field(u64, dir)
473                         __string(name, dentry->d_name.name)
474                 ),
475
476                 TP_fast_assign(
477                         __entry->dev = dir->i_sb->s_dev;
478                         __entry->dir = NFS_FILEID(dir);
479                         __entry->error = error;
480                         __assign_str(name, dentry->d_name.name);
481                 ),
482
483                 TP_printk(
484                         "error=%d name=%02x:%02x:%llu/%s",
485                         __entry->error,
486                         MAJOR(__entry->dev), MINOR(__entry->dev),
487                         (unsigned long long)__entry->dir,
488                         __get_str(name)
489                 )
490 );
491
492 #define DEFINE_NFS_DIRECTORY_EVENT_DONE(name) \
493         DEFINE_EVENT(nfs_directory_event_done, name, \
494                         TP_PROTO( \
495                                 const struct inode *dir, \
496                                 const struct dentry *dentry, \
497                                 int error \
498                         ), \
499                         TP_ARGS(dir, dentry, error))
500
501 DEFINE_NFS_DIRECTORY_EVENT(nfs_mknod_enter);
502 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mknod_exit);
503 DEFINE_NFS_DIRECTORY_EVENT(nfs_mkdir_enter);
504 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mkdir_exit);
505 DEFINE_NFS_DIRECTORY_EVENT(nfs_rmdir_enter);
506 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_rmdir_exit);
507 DEFINE_NFS_DIRECTORY_EVENT(nfs_remove_enter);
508 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_remove_exit);
509 DEFINE_NFS_DIRECTORY_EVENT(nfs_unlink_enter);
510 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_unlink_exit);
511 DEFINE_NFS_DIRECTORY_EVENT(nfs_symlink_enter);
512 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_symlink_exit);
513
514 TRACE_EVENT(nfs_link_enter,
515                 TP_PROTO(
516                         const struct inode *inode,
517                         const struct inode *dir,
518                         const struct dentry *dentry
519                 ),
520
521                 TP_ARGS(inode, dir, dentry),
522
523                 TP_STRUCT__entry(
524                         __field(dev_t, dev)
525                         __field(u64, fileid)
526                         __field(u64, dir)
527                         __string(name, dentry->d_name.name)
528                 ),
529
530                 TP_fast_assign(
531                         __entry->dev = inode->i_sb->s_dev;
532                         __entry->fileid = NFS_FILEID(inode);
533                         __entry->dir = NFS_FILEID(dir);
534                         __assign_str(name, dentry->d_name.name);
535                 ),
536
537                 TP_printk(
538                         "fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s",
539                         MAJOR(__entry->dev), MINOR(__entry->dev),
540                         __entry->fileid,
541                         MAJOR(__entry->dev), MINOR(__entry->dev),
542                         (unsigned long long)__entry->dir,
543                         __get_str(name)
544                 )
545 );
546
547 TRACE_EVENT(nfs_link_exit,
548                 TP_PROTO(
549                         const struct inode *inode,
550                         const struct inode *dir,
551                         const struct dentry *dentry,
552                         int error
553                 ),
554
555                 TP_ARGS(inode, dir, dentry, error),
556
557                 TP_STRUCT__entry(
558                         __field(int, error)
559                         __field(dev_t, dev)
560                         __field(u64, fileid)
561                         __field(u64, dir)
562                         __string(name, dentry->d_name.name)
563                 ),
564
565                 TP_fast_assign(
566                         __entry->dev = inode->i_sb->s_dev;
567                         __entry->fileid = NFS_FILEID(inode);
568                         __entry->dir = NFS_FILEID(dir);
569                         __entry->error = error;
570                         __assign_str(name, dentry->d_name.name);
571                 ),
572
573                 TP_printk(
574                         "error=%d fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s",
575                         __entry->error,
576                         MAJOR(__entry->dev), MINOR(__entry->dev),
577                         __entry->fileid,
578                         MAJOR(__entry->dev), MINOR(__entry->dev),
579                         (unsigned long long)__entry->dir,
580                         __get_str(name)
581                 )
582 );
583
584 DECLARE_EVENT_CLASS(nfs_rename_event,
585                 TP_PROTO(
586                         const struct inode *old_dir,
587                         const struct dentry *old_dentry,
588                         const struct inode *new_dir,
589                         const struct dentry *new_dentry
590                 ),
591
592                 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry),
593
594                 TP_STRUCT__entry(
595                         __field(dev_t, dev)
596                         __field(u64, old_dir)
597                         __field(u64, new_dir)
598                         __string(old_name, old_dentry->d_name.name)
599                         __string(new_name, new_dentry->d_name.name)
600                 ),
601
602                 TP_fast_assign(
603                         __entry->dev = old_dir->i_sb->s_dev;
604                         __entry->old_dir = NFS_FILEID(old_dir);
605                         __entry->new_dir = NFS_FILEID(new_dir);
606                         __assign_str(old_name, old_dentry->d_name.name);
607                         __assign_str(new_name, new_dentry->d_name.name);
608                 ),
609
610                 TP_printk(
611                         "old_name=%02x:%02x:%llu/%s new_name=%02x:%02x:%llu/%s",
612                         MAJOR(__entry->dev), MINOR(__entry->dev),
613                         (unsigned long long)__entry->old_dir,
614                         __get_str(old_name),
615                         MAJOR(__entry->dev), MINOR(__entry->dev),
616                         (unsigned long long)__entry->new_dir,
617                         __get_str(new_name)
618                 )
619 );
620 #define DEFINE_NFS_RENAME_EVENT(name) \
621         DEFINE_EVENT(nfs_rename_event, name, \
622                         TP_PROTO( \
623                                 const struct inode *old_dir, \
624                                 const struct dentry *old_dentry, \
625                                 const struct inode *new_dir, \
626                                 const struct dentry *new_dentry \
627                         ), \
628                         TP_ARGS(old_dir, old_dentry, new_dir, new_dentry))
629
630 DECLARE_EVENT_CLASS(nfs_rename_event_done,
631                 TP_PROTO(
632                         const struct inode *old_dir,
633                         const struct dentry *old_dentry,
634                         const struct inode *new_dir,
635                         const struct dentry *new_dentry,
636                         int error
637                 ),
638
639                 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry, error),
640
641                 TP_STRUCT__entry(
642                         __field(dev_t, dev)
643                         __field(int, error)
644                         __field(u64, old_dir)
645                         __string(old_name, old_dentry->d_name.name)
646                         __field(u64, new_dir)
647                         __string(new_name, new_dentry->d_name.name)
648                 ),
649
650                 TP_fast_assign(
651                         __entry->dev = old_dir->i_sb->s_dev;
652                         __entry->old_dir = NFS_FILEID(old_dir);
653                         __entry->new_dir = NFS_FILEID(new_dir);
654                         __entry->error = error;
655                         __assign_str(old_name, old_dentry->d_name.name);
656                         __assign_str(new_name, new_dentry->d_name.name);
657                 ),
658
659                 TP_printk(
660                         "error=%d old_name=%02x:%02x:%llu/%s "
661                         "new_name=%02x:%02x:%llu/%s",
662                         __entry->error,
663                         MAJOR(__entry->dev), MINOR(__entry->dev),
664                         (unsigned long long)__entry->old_dir,
665                         __get_str(old_name),
666                         MAJOR(__entry->dev), MINOR(__entry->dev),
667                         (unsigned long long)__entry->new_dir,
668                         __get_str(new_name)
669                 )
670 );
671 #define DEFINE_NFS_RENAME_EVENT_DONE(name) \
672         DEFINE_EVENT(nfs_rename_event_done, name, \
673                         TP_PROTO( \
674                                 const struct inode *old_dir, \
675                                 const struct dentry *old_dentry, \
676                                 const struct inode *new_dir, \
677                                 const struct dentry *new_dentry, \
678                                 int error \
679                         ), \
680                         TP_ARGS(old_dir, old_dentry, new_dir, \
681                                 new_dentry, error))
682
683 DEFINE_NFS_RENAME_EVENT(nfs_rename_enter);
684 DEFINE_NFS_RENAME_EVENT_DONE(nfs_rename_exit);
685
686 DEFINE_NFS_RENAME_EVENT_DONE(nfs_sillyrename_rename);
687
688 TRACE_EVENT(nfs_sillyrename_unlink,
689                 TP_PROTO(
690                         const struct nfs_unlinkdata *data,
691                         int error
692                 ),
693
694                 TP_ARGS(data, error),
695
696                 TP_STRUCT__entry(
697                         __field(dev_t, dev)
698                         __field(int, error)
699                         __field(u64, dir)
700                         __dynamic_array(char, name, data->args.name.len + 1)
701                 ),
702
703                 TP_fast_assign(
704                         struct inode *dir = d_inode(data->dentry->d_parent);
705                         size_t len = data->args.name.len;
706                         __entry->dev = dir->i_sb->s_dev;
707                         __entry->dir = NFS_FILEID(dir);
708                         __entry->error = error;
709                         memcpy(__get_str(name),
710                                 data->args.name.name, len);
711                         __get_str(name)[len] = 0;
712                 ),
713
714                 TP_printk(
715                         "error=%d name=%02x:%02x:%llu/%s",
716                         __entry->error,
717                         MAJOR(__entry->dev), MINOR(__entry->dev),
718                         (unsigned long long)__entry->dir,
719                         __get_str(name)
720                 )
721 );
722
723 TRACE_EVENT(nfs_initiate_read,
724                 TP_PROTO(
725                         const struct inode *inode,
726                         loff_t offset, unsigned long count
727                 ),
728
729                 TP_ARGS(inode, offset, count),
730
731                 TP_STRUCT__entry(
732                         __field(loff_t, offset)
733                         __field(unsigned long, count)
734                         __field(dev_t, dev)
735                         __field(u32, fhandle)
736                         __field(u64, fileid)
737                 ),
738
739                 TP_fast_assign(
740                         const struct nfs_inode *nfsi = NFS_I(inode);
741
742                         __entry->offset = offset;
743                         __entry->count = count;
744                         __entry->dev = inode->i_sb->s_dev;
745                         __entry->fileid = nfsi->fileid;
746                         __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
747                 ),
748
749                 TP_printk(
750                         "fileid=%02x:%02x:%llu fhandle=0x%08x "
751                         "offset=%lld count=%lu",
752                         MAJOR(__entry->dev), MINOR(__entry->dev),
753                         (unsigned long long)__entry->fileid,
754                         __entry->fhandle,
755                         __entry->offset, __entry->count
756                 )
757 );
758
759 TRACE_EVENT(nfs_readpage_done,
760                 TP_PROTO(
761                         const struct inode *inode,
762                         int status, loff_t offset, bool eof
763                 ),
764
765                 TP_ARGS(inode, status, offset, eof),
766
767                 TP_STRUCT__entry(
768                         __field(int, status)
769                         __field(loff_t, offset)
770                         __field(bool, eof)
771                         __field(dev_t, dev)
772                         __field(u32, fhandle)
773                         __field(u64, fileid)
774                 ),
775
776                 TP_fast_assign(
777                         const struct nfs_inode *nfsi = NFS_I(inode);
778
779                         __entry->status = status;
780                         __entry->offset = offset;
781                         __entry->eof = eof;
782                         __entry->dev = inode->i_sb->s_dev;
783                         __entry->fileid = nfsi->fileid;
784                         __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
785                 ),
786
787                 TP_printk(
788                         "fileid=%02x:%02x:%llu fhandle=0x%08x "
789                         "offset=%lld status=%d%s",
790                         MAJOR(__entry->dev), MINOR(__entry->dev),
791                         (unsigned long long)__entry->fileid,
792                         __entry->fhandle,
793                         __entry->offset, __entry->status,
794                         __entry->eof ? " eof" : ""
795                 )
796 );
797
798 /*
799  * XXX: I tried using NFS_UNSTABLE and friends in this table, but they
800  * all evaluate to 0 for some reason, even if I include linux/nfs.h.
801  */
802 #define nfs_show_stable(stable) \
803         __print_symbolic(stable, \
804                         { 0, " (UNSTABLE)" }, \
805                         { 1, " (DATA_SYNC)" }, \
806                         { 2, " (FILE_SYNC)" })
807
808 TRACE_EVENT(nfs_initiate_write,
809                 TP_PROTO(
810                         const struct inode *inode,
811                         loff_t offset, unsigned long count,
812                         enum nfs3_stable_how stable
813                 ),
814
815                 TP_ARGS(inode, offset, count, stable),
816
817                 TP_STRUCT__entry(
818                         __field(loff_t, offset)
819                         __field(unsigned long, count)
820                         __field(enum nfs3_stable_how, stable)
821                         __field(dev_t, dev)
822                         __field(u32, fhandle)
823                         __field(u64, fileid)
824                 ),
825
826                 TP_fast_assign(
827                         const struct nfs_inode *nfsi = NFS_I(inode);
828
829                         __entry->offset = offset;
830                         __entry->count = count;
831                         __entry->stable = stable;
832                         __entry->dev = inode->i_sb->s_dev;
833                         __entry->fileid = nfsi->fileid;
834                         __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
835                 ),
836
837                 TP_printk(
838                         "fileid=%02x:%02x:%llu fhandle=0x%08x "
839                         "offset=%lld count=%lu stable=%d%s",
840                         MAJOR(__entry->dev), MINOR(__entry->dev),
841                         (unsigned long long)__entry->fileid,
842                         __entry->fhandle,
843                         __entry->offset, __entry->count,
844                         __entry->stable, nfs_show_stable(__entry->stable)
845                 )
846 );
847
848 TRACE_EVENT(nfs_writeback_done,
849                 TP_PROTO(
850                         const struct inode *inode,
851                         int status,
852                         loff_t offset,
853                         struct nfs_writeverf *writeverf
854                 ),
855
856                 TP_ARGS(inode, status, offset, writeverf),
857
858                 TP_STRUCT__entry(
859                         __field(int, status)
860                         __field(loff_t, offset)
861                         __field(enum nfs3_stable_how, stable)
862                         __field(unsigned long long, verifier)
863                         __field(dev_t, dev)
864                         __field(u32, fhandle)
865                         __field(u64, fileid)
866                 ),
867
868                 TP_fast_assign(
869                         const struct nfs_inode *nfsi = NFS_I(inode);
870
871                         __entry->status = status;
872                         __entry->offset = offset;
873                         __entry->stable = writeverf->committed;
874                         memcpy(&__entry->verifier, &writeverf->verifier,
875                                sizeof(__entry->verifier));
876                         __entry->dev = inode->i_sb->s_dev;
877                         __entry->fileid = nfsi->fileid;
878                         __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
879                 ),
880
881                 TP_printk(
882                         "fileid=%02x:%02x:%llu fhandle=0x%08x "
883                         "offset=%lld status=%d stable=%d%s "
884                         "verifier 0x%016llx",
885                         MAJOR(__entry->dev), MINOR(__entry->dev),
886                         (unsigned long long)__entry->fileid,
887                         __entry->fhandle,
888                         __entry->offset, __entry->status,
889                         __entry->stable, nfs_show_stable(__entry->stable),
890                         __entry->verifier
891                 )
892 );
893
894 TRACE_EVENT(nfs_initiate_commit,
895                 TP_PROTO(
896                         const struct nfs_commit_data *data
897                 ),
898
899                 TP_ARGS(data),
900
901                 TP_STRUCT__entry(
902                         __field(loff_t, offset)
903                         __field(unsigned long, count)
904                         __field(dev_t, dev)
905                         __field(u32, fhandle)
906                         __field(u64, fileid)
907                 ),
908
909                 TP_fast_assign(
910                         const struct inode *inode = data->inode;
911                         const struct nfs_inode *nfsi = NFS_I(inode);
912
913                         __entry->offset = data->args.offset;
914                         __entry->count = data->args.count;
915                         __entry->dev = inode->i_sb->s_dev;
916                         __entry->fileid = nfsi->fileid;
917                         __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
918                 ),
919
920                 TP_printk(
921                         "fileid=%02x:%02x:%llu fhandle=0x%08x "
922                         "offset=%lld count=%lu",
923                         MAJOR(__entry->dev), MINOR(__entry->dev),
924                         (unsigned long long)__entry->fileid,
925                         __entry->fhandle,
926                         __entry->offset, __entry->count
927                 )
928 );
929
930 TRACE_EVENT(nfs_commit_done,
931                 TP_PROTO(
932                         const struct nfs_commit_data *data
933                 ),
934
935                 TP_ARGS(data),
936
937                 TP_STRUCT__entry(
938                         __field(int, status)
939                         __field(loff_t, offset)
940                         __field(unsigned long long, verifier)
941                         __field(dev_t, dev)
942                         __field(u32, fhandle)
943                         __field(u64, fileid)
944                 ),
945
946                 TP_fast_assign(
947                         const struct inode *inode = data->inode;
948                         const struct nfs_inode *nfsi = NFS_I(inode);
949
950                         __entry->status = data->res.op_status;
951                         __entry->offset = data->args.offset;
952                         memcpy(&__entry->verifier, &data->verf.verifier,
953                                sizeof(__entry->verifier));
954                         __entry->dev = inode->i_sb->s_dev;
955                         __entry->fileid = nfsi->fileid;
956                         __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
957                 ),
958
959                 TP_printk(
960                         "fileid=%02x:%02x:%llu fhandle=0x%08x "
961                         "offset=%lld status=%d verifier 0x%016llx",
962                         MAJOR(__entry->dev), MINOR(__entry->dev),
963                         (unsigned long long)__entry->fileid,
964                         __entry->fhandle,
965                         __entry->offset, __entry->status,
966                         __entry->verifier
967                 )
968 );
969
970 #endif /* _TRACE_NFS_H */
971
972 #undef TRACE_INCLUDE_PATH
973 #define TRACE_INCLUDE_PATH .
974 #define TRACE_INCLUDE_FILE nfstrace
975 /* This part must be outside protection */
976 #include <trace/define_trace.h>