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