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#include <trace/misc/fs.h>
15#include <trace/misc/nfs.h>
16#include <trace/misc/sunrpc.h>
17
18#define nfs_show_cache_validity(v) \
19 __print_flags(v, "|", \
20 { NFS_INO_INVALID_DATA, "INVALID_DATA" }, \
21 { NFS_INO_INVALID_ATIME, "INVALID_ATIME" }, \
22 { NFS_INO_INVALID_ACCESS, "INVALID_ACCESS" }, \
23 { NFS_INO_INVALID_ACL, "INVALID_ACL" }, \
24 { NFS_INO_REVAL_FORCED, "REVAL_FORCED" }, \
25 { NFS_INO_INVALID_LABEL, "INVALID_LABEL" }, \
26 { NFS_INO_INVALID_CHANGE, "INVALID_CHANGE" }, \
27 { NFS_INO_INVALID_CTIME, "INVALID_CTIME" }, \
28 { NFS_INO_INVALID_MTIME, "INVALID_MTIME" }, \
29 { NFS_INO_INVALID_SIZE, "INVALID_SIZE" }, \
30 { NFS_INO_INVALID_OTHER, "INVALID_OTHER" }, \
31 { NFS_INO_DATA_INVAL_DEFER, "DATA_INVAL_DEFER" }, \
32 { NFS_INO_INVALID_BLOCKS, "INVALID_BLOCKS" }, \
33 { NFS_INO_INVALID_XATTR, "INVALID_XATTR" }, \
34 { NFS_INO_INVALID_NLINK, "INVALID_NLINK" }, \
35 { NFS_INO_INVALID_MODE, "INVALID_MODE" })
36
37#define nfs_show_nfsi_flags(v) \
38 __print_flags(v, "|", \
39 { BIT(NFS_INO_STALE), "STALE" }, \
40 { BIT(NFS_INO_ACL_LRU_SET), "ACL_LRU_SET" }, \
41 { BIT(NFS_INO_INVALIDATING), "INVALIDATING" }, \
42 { BIT(NFS_INO_LAYOUTCOMMIT), "NEED_LAYOUTCOMMIT" }, \
43 { BIT(NFS_INO_LAYOUTCOMMITTING), "LAYOUTCOMMIT" }, \
44 { BIT(NFS_INO_LAYOUTSTATS), "LAYOUTSTATS" }, \
45 { BIT(NFS_INO_ODIRECT), "ODIRECT" })
46
47DECLARE_EVENT_CLASS(nfs_inode_event,
48 TP_PROTO(
49 const struct inode *inode
50 ),
51
52 TP_ARGS(inode),
53
54 TP_STRUCT__entry(
55 __field(dev_t, dev)
56 __field(u32, fhandle)
57 __field(u64, fileid)
58 __field(u64, version)
59 ),
60
61 TP_fast_assign(
62 const struct nfs_inode *nfsi = NFS_I(inode);
63 __entry->dev = inode->i_sb->s_dev;
64 __entry->fileid = nfsi->fileid;
65 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
66 __entry->version = inode_peek_iversion_raw(inode);
67 ),
68
69 TP_printk(
70 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu ",
71 MAJOR(__entry->dev), MINOR(__entry->dev),
72 (unsigned long long)__entry->fileid,
73 __entry->fhandle,
74 (unsigned long long)__entry->version
75 )
76);
77
78DECLARE_EVENT_CLASS(nfs_inode_event_done,
79 TP_PROTO(
80 const struct inode *inode,
81 int error
82 ),
83
84 TP_ARGS(inode, error),
85
86 TP_STRUCT__entry(
87 __field(unsigned long, error)
88 __field(dev_t, dev)
89 __field(u32, fhandle)
90 __field(unsigned char, type)
91 __field(u64, fileid)
92 __field(u64, version)
93 __field(loff_t, size)
94 __field(unsigned long, nfsi_flags)
95 __field(unsigned long, cache_validity)
96 ),
97
98 TP_fast_assign(
99 const struct nfs_inode *nfsi = NFS_I(inode);
100 __entry->error = error < 0 ? -error : 0;
101 __entry->dev = inode->i_sb->s_dev;
102 __entry->fileid = nfsi->fileid;
103 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
104 __entry->type = nfs_umode_to_dtype(inode->i_mode);
105 __entry->version = inode_peek_iversion_raw(inode);
106 __entry->size = i_size_read(inode);
107 __entry->nfsi_flags = nfsi->flags;
108 __entry->cache_validity = nfsi->cache_validity;
109 ),
110
111 TP_printk(
112 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
113 "type=%u (%s) version=%llu size=%lld "
114 "cache_validity=0x%lx (%s) nfs_flags=0x%lx (%s)",
115 -__entry->error, show_nfs_status(__entry->error),
116 MAJOR(__entry->dev), MINOR(__entry->dev),
117 (unsigned long long)__entry->fileid,
118 __entry->fhandle,
119 __entry->type,
120 show_fs_dirent_type(__entry->type),
121 (unsigned long long)__entry->version,
122 (long long)__entry->size,
123 __entry->cache_validity,
124 nfs_show_cache_validity(__entry->cache_validity),
125 __entry->nfsi_flags,
126 nfs_show_nfsi_flags(__entry->nfsi_flags)
127 )
128);
129
130#define DEFINE_NFS_INODE_EVENT(name) \
131 DEFINE_EVENT(nfs_inode_event, name, \
132 TP_PROTO( \
133 const struct inode *inode \
134 ), \
135 TP_ARGS(inode))
136#define DEFINE_NFS_INODE_EVENT_DONE(name) \
137 DEFINE_EVENT(nfs_inode_event_done, name, \
138 TP_PROTO( \
139 const struct inode *inode, \
140 int error \
141 ), \
142 TP_ARGS(inode, error))
143DEFINE_NFS_INODE_EVENT(nfs_set_inode_stale);
144DEFINE_NFS_INODE_EVENT(nfs_refresh_inode_enter);
145DEFINE_NFS_INODE_EVENT_DONE(nfs_refresh_inode_exit);
146DEFINE_NFS_INODE_EVENT(nfs_revalidate_inode_enter);
147DEFINE_NFS_INODE_EVENT_DONE(nfs_revalidate_inode_exit);
148DEFINE_NFS_INODE_EVENT(nfs_invalidate_mapping_enter);
149DEFINE_NFS_INODE_EVENT_DONE(nfs_invalidate_mapping_exit);
150DEFINE_NFS_INODE_EVENT(nfs_getattr_enter);
151DEFINE_NFS_INODE_EVENT_DONE(nfs_getattr_exit);
152DEFINE_NFS_INODE_EVENT(nfs_setattr_enter);
153DEFINE_NFS_INODE_EVENT_DONE(nfs_setattr_exit);
154DEFINE_NFS_INODE_EVENT(nfs_writeback_inode_enter);
155DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_inode_exit);
156DEFINE_NFS_INODE_EVENT(nfs_fsync_enter);
157DEFINE_NFS_INODE_EVENT_DONE(nfs_fsync_exit);
158DEFINE_NFS_INODE_EVENT(nfs_access_enter);
159DEFINE_NFS_INODE_EVENT_DONE(nfs_set_cache_invalid);
160DEFINE_NFS_INODE_EVENT(nfs_readdir_force_readdirplus);
161DEFINE_NFS_INODE_EVENT_DONE(nfs_readdir_cache_fill_done);
162DEFINE_NFS_INODE_EVENT_DONE(nfs_readdir_uncached_done);
163
164TRACE_EVENT(nfs_access_exit,
165 TP_PROTO(
166 const struct inode *inode,
167 unsigned int mask,
168 unsigned int permitted,
169 int error
170 ),
171
172 TP_ARGS(inode, mask, permitted, error),
173
174 TP_STRUCT__entry(
175 __field(unsigned long, error)
176 __field(dev_t, dev)
177 __field(u32, fhandle)
178 __field(unsigned char, type)
179 __field(u64, fileid)
180 __field(u64, version)
181 __field(loff_t, size)
182 __field(unsigned long, nfsi_flags)
183 __field(unsigned long, cache_validity)
184 __field(unsigned int, mask)
185 __field(unsigned int, permitted)
186 ),
187
188 TP_fast_assign(
189 const struct nfs_inode *nfsi = NFS_I(inode);
190 __entry->error = error < 0 ? -error : 0;
191 __entry->dev = inode->i_sb->s_dev;
192 __entry->fileid = nfsi->fileid;
193 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
194 __entry->type = nfs_umode_to_dtype(inode->i_mode);
195 __entry->version = inode_peek_iversion_raw(inode);
196 __entry->size = i_size_read(inode);
197 __entry->nfsi_flags = nfsi->flags;
198 __entry->cache_validity = nfsi->cache_validity;
199 __entry->mask = mask;
200 __entry->permitted = permitted;
201 ),
202
203 TP_printk(
204 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
205 "type=%u (%s) version=%llu size=%lld "
206 "cache_validity=0x%lx (%s) nfs_flags=0x%lx (%s) "
207 "mask=0x%x permitted=0x%x",
208 -__entry->error, show_nfs_status(__entry->error),
209 MAJOR(__entry->dev), MINOR(__entry->dev),
210 (unsigned long long)__entry->fileid,
211 __entry->fhandle,
212 __entry->type,
213 show_fs_dirent_type(__entry->type),
214 (unsigned long long)__entry->version,
215 (long long)__entry->size,
216 __entry->cache_validity,
217 nfs_show_cache_validity(__entry->cache_validity),
218 __entry->nfsi_flags,
219 nfs_show_nfsi_flags(__entry->nfsi_flags),
220 __entry->mask, __entry->permitted
221 )
222);
223
224DECLARE_EVENT_CLASS(nfs_update_size_class,
225 TP_PROTO(
226 const struct inode *inode,
227 loff_t new_size
228 ),
229
230 TP_ARGS(inode, new_size),
231
232 TP_STRUCT__entry(
233 __field(dev_t, dev)
234 __field(u32, fhandle)
235 __field(u64, fileid)
236 __field(u64, version)
237 __field(loff_t, cur_size)
238 __field(loff_t, new_size)
239 ),
240
241 TP_fast_assign(
242 const struct nfs_inode *nfsi = NFS_I(inode);
243
244 __entry->dev = inode->i_sb->s_dev;
245 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
246 __entry->fileid = nfsi->fileid;
247 __entry->version = inode_peek_iversion_raw(inode);
248 __entry->cur_size = i_size_read(inode);
249 __entry->new_size = new_size;
250 ),
251
252 TP_printk(
253 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu cursize=%lld newsize=%lld",
254 MAJOR(__entry->dev), MINOR(__entry->dev),
255 (unsigned long long)__entry->fileid,
256 __entry->fhandle, __entry->version,
257 __entry->cur_size, __entry->new_size
258 )
259);
260
261#define DEFINE_NFS_UPDATE_SIZE_EVENT(name) \
262 DEFINE_EVENT(nfs_update_size_class, nfs_size_##name, \
263 TP_PROTO( \
264 const struct inode *inode, \
265 loff_t new_size \
266 ), \
267 TP_ARGS(inode, new_size))
268
269DEFINE_NFS_UPDATE_SIZE_EVENT(truncate);
270DEFINE_NFS_UPDATE_SIZE_EVENT(wcc);
271DEFINE_NFS_UPDATE_SIZE_EVENT(update);
272DEFINE_NFS_UPDATE_SIZE_EVENT(grow);
273
274DECLARE_EVENT_CLASS(nfs_inode_range_event,
275 TP_PROTO(
276 const struct inode *inode,
277 loff_t range_start,
278 loff_t range_end
279 ),
280
281 TP_ARGS(inode, range_start, range_end),
282
283 TP_STRUCT__entry(
284 __field(dev_t, dev)
285 __field(u32, fhandle)
286 __field(u64, fileid)
287 __field(u64, version)
288 __field(loff_t, range_start)
289 __field(loff_t, range_end)
290 ),
291
292 TP_fast_assign(
293 const struct nfs_inode *nfsi = NFS_I(inode);
294
295 __entry->dev = inode->i_sb->s_dev;
296 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
297 __entry->fileid = nfsi->fileid;
298 __entry->version = inode_peek_iversion_raw(inode);
299 __entry->range_start = range_start;
300 __entry->range_end = range_end;
301 ),
302
303 TP_printk(
304 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu "
305 "range=[%lld, %lld]",
306 MAJOR(__entry->dev), MINOR(__entry->dev),
307 (unsigned long long)__entry->fileid,
308 __entry->fhandle, __entry->version,
309 __entry->range_start, __entry->range_end
310 )
311);
312
313#define DEFINE_NFS_INODE_RANGE_EVENT(name) \
314 DEFINE_EVENT(nfs_inode_range_event, name, \
315 TP_PROTO( \
316 const struct inode *inode, \
317 loff_t range_start, \
318 loff_t range_end \
319 ), \
320 TP_ARGS(inode, range_start, range_end))
321
322DEFINE_NFS_INODE_RANGE_EVENT(nfs_readdir_invalidate_cache_range);
323
324DECLARE_EVENT_CLASS(nfs_readdir_event,
325 TP_PROTO(
326 const struct file *file,
327 const __be32 *verifier,
328 u64 cookie,
329 pgoff_t page_index,
330 unsigned int dtsize
331 ),
332
333 TP_ARGS(file, verifier, cookie, page_index, dtsize),
334
335 TP_STRUCT__entry(
336 __field(dev_t, dev)
337 __field(u32, fhandle)
338 __field(u64, fileid)
339 __field(u64, version)
340 __array(char, verifier, NFS4_VERIFIER_SIZE)
341 __field(u64, cookie)
342 __field(pgoff_t, index)
343 __field(unsigned int, dtsize)
344 ),
345
346 TP_fast_assign(
347 const struct inode *dir = file_inode(file);
348 const struct nfs_inode *nfsi = NFS_I(dir);
349
350 __entry->dev = dir->i_sb->s_dev;
351 __entry->fileid = nfsi->fileid;
352 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
353 __entry->version = inode_peek_iversion_raw(dir);
354 if (cookie != 0)
355 memcpy(__entry->verifier, verifier,
356 NFS4_VERIFIER_SIZE);
357 else
358 memset(__entry->verifier, 0,
359 NFS4_VERIFIER_SIZE);
360 __entry->cookie = cookie;
361 __entry->index = page_index;
362 __entry->dtsize = dtsize;
363 ),
364
365 TP_printk(
366 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu "
367 "cookie=%s:0x%llx cache_index=%lu dtsize=%u",
368 MAJOR(__entry->dev), MINOR(__entry->dev),
369 (unsigned long long)__entry->fileid, __entry->fhandle,
370 __entry->version, show_nfs4_verifier(__entry->verifier),
371 (unsigned long long)__entry->cookie, __entry->index,
372 __entry->dtsize
373 )
374);
375
376#define DEFINE_NFS_READDIR_EVENT(name) \
377 DEFINE_EVENT(nfs_readdir_event, name, \
378 TP_PROTO( \
379 const struct file *file, \
380 const __be32 *verifier, \
381 u64 cookie, \
382 pgoff_t page_index, \
383 unsigned int dtsize \
384 ), \
385 TP_ARGS(file, verifier, cookie, page_index, dtsize))
386
387DEFINE_NFS_READDIR_EVENT(nfs_readdir_cache_fill);
388DEFINE_NFS_READDIR_EVENT(nfs_readdir_uncached);
389
390DECLARE_EVENT_CLASS(nfs_lookup_event,
391 TP_PROTO(
392 const struct inode *dir,
393 const struct dentry *dentry,
394 unsigned int flags
395 ),
396
397 TP_ARGS(dir, dentry, flags),
398
399 TP_STRUCT__entry(
400 __field(unsigned long, 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->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 "flags=0x%lx (%s) name=%02x:%02x:%llu/%s",
415 __entry->flags,
416 show_fs_lookup_flags(__entry->flags),
417 MAJOR(__entry->dev), MINOR(__entry->dev),
418 (unsigned long long)__entry->dir,
419 __get_str(name)
420 )
421);
422
423#define DEFINE_NFS_LOOKUP_EVENT(name) \
424 DEFINE_EVENT(nfs_lookup_event, name, \
425 TP_PROTO( \
426 const struct inode *dir, \
427 const struct dentry *dentry, \
428 unsigned int flags \
429 ), \
430 TP_ARGS(dir, dentry, flags))
431
432DECLARE_EVENT_CLASS(nfs_lookup_event_done,
433 TP_PROTO(
434 const struct inode *dir,
435 const struct dentry *dentry,
436 unsigned int flags,
437 int error
438 ),
439
440 TP_ARGS(dir, dentry, flags, error),
441
442 TP_STRUCT__entry(
443 __field(unsigned long, error)
444 __field(unsigned long, flags)
445 __field(dev_t, dev)
446 __field(u64, dir)
447 __string(name, dentry->d_name.name)
448 ),
449
450 TP_fast_assign(
451 __entry->dev = dir->i_sb->s_dev;
452 __entry->dir = NFS_FILEID(dir);
453 __entry->error = error < 0 ? -error : 0;
454 __entry->flags = flags;
455 __assign_str(name, dentry->d_name.name);
456 ),
457
458 TP_printk(
459 "error=%ld (%s) flags=0x%lx (%s) name=%02x:%02x:%llu/%s",
460 -__entry->error, show_nfs_status(__entry->error),
461 __entry->flags,
462 show_fs_lookup_flags(__entry->flags),
463 MAJOR(__entry->dev), MINOR(__entry->dev),
464 (unsigned long long)__entry->dir,
465 __get_str(name)
466 )
467);
468
469#define DEFINE_NFS_LOOKUP_EVENT_DONE(name) \
470 DEFINE_EVENT(nfs_lookup_event_done, name, \
471 TP_PROTO( \
472 const struct inode *dir, \
473 const struct dentry *dentry, \
474 unsigned int flags, \
475 int error \
476 ), \
477 TP_ARGS(dir, dentry, flags, error))
478
479DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_enter);
480DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_exit);
481DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_revalidate_enter);
482DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_revalidate_exit);
483DEFINE_NFS_LOOKUP_EVENT(nfs_readdir_lookup);
484DEFINE_NFS_LOOKUP_EVENT(nfs_readdir_lookup_revalidate_failed);
485DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_readdir_lookup_revalidate);
486
487TRACE_EVENT(nfs_atomic_open_enter,
488 TP_PROTO(
489 const struct inode *dir,
490 const struct nfs_open_context *ctx,
491 unsigned int flags
492 ),
493
494 TP_ARGS(dir, ctx, flags),
495
496 TP_STRUCT__entry(
497 __field(unsigned long, flags)
498 __field(unsigned long, fmode)
499 __field(dev_t, dev)
500 __field(u64, dir)
501 __string(name, ctx->dentry->d_name.name)
502 ),
503
504 TP_fast_assign(
505 __entry->dev = dir->i_sb->s_dev;
506 __entry->dir = NFS_FILEID(dir);
507 __entry->flags = flags;
508 __entry->fmode = (__force unsigned long)ctx->mode;
509 __assign_str(name, ctx->dentry->d_name.name);
510 ),
511
512 TP_printk(
513 "flags=0x%lx (%s) fmode=%s name=%02x:%02x:%llu/%s",
514 __entry->flags,
515 show_fs_fcntl_open_flags(__entry->flags),
516 show_fs_fmode_flags(__entry->fmode),
517 MAJOR(__entry->dev), MINOR(__entry->dev),
518 (unsigned long long)__entry->dir,
519 __get_str(name)
520 )
521);
522
523TRACE_EVENT(nfs_atomic_open_exit,
524 TP_PROTO(
525 const struct inode *dir,
526 const struct nfs_open_context *ctx,
527 unsigned int flags,
528 int error
529 ),
530
531 TP_ARGS(dir, ctx, flags, error),
532
533 TP_STRUCT__entry(
534 __field(unsigned long, error)
535 __field(unsigned long, flags)
536 __field(unsigned long, fmode)
537 __field(dev_t, dev)
538 __field(u64, dir)
539 __string(name, ctx->dentry->d_name.name)
540 ),
541
542 TP_fast_assign(
543 __entry->error = -error;
544 __entry->dev = dir->i_sb->s_dev;
545 __entry->dir = NFS_FILEID(dir);
546 __entry->flags = flags;
547 __entry->fmode = (__force unsigned long)ctx->mode;
548 __assign_str(name, ctx->dentry->d_name.name);
549 ),
550
551 TP_printk(
552 "error=%ld (%s) flags=0x%lx (%s) fmode=%s "
553 "name=%02x:%02x:%llu/%s",
554 -__entry->error, show_nfs_status(__entry->error),
555 __entry->flags,
556 show_fs_fcntl_open_flags(__entry->flags),
557 show_fs_fmode_flags(__entry->fmode),
558 MAJOR(__entry->dev), MINOR(__entry->dev),
559 (unsigned long long)__entry->dir,
560 __get_str(name)
561 )
562);
563
564TRACE_EVENT(nfs_create_enter,
565 TP_PROTO(
566 const struct inode *dir,
567 const struct dentry *dentry,
568 unsigned int flags
569 ),
570
571 TP_ARGS(dir, dentry, flags),
572
573 TP_STRUCT__entry(
574 __field(unsigned long, flags)
575 __field(dev_t, dev)
576 __field(u64, dir)
577 __string(name, dentry->d_name.name)
578 ),
579
580 TP_fast_assign(
581 __entry->dev = dir->i_sb->s_dev;
582 __entry->dir = NFS_FILEID(dir);
583 __entry->flags = flags;
584 __assign_str(name, dentry->d_name.name);
585 ),
586
587 TP_printk(
588 "flags=0x%lx (%s) name=%02x:%02x:%llu/%s",
589 __entry->flags,
590 show_fs_fcntl_open_flags(__entry->flags),
591 MAJOR(__entry->dev), MINOR(__entry->dev),
592 (unsigned long long)__entry->dir,
593 __get_str(name)
594 )
595);
596
597TRACE_EVENT(nfs_create_exit,
598 TP_PROTO(
599 const struct inode *dir,
600 const struct dentry *dentry,
601 unsigned int flags,
602 int error
603 ),
604
605 TP_ARGS(dir, dentry, flags, error),
606
607 TP_STRUCT__entry(
608 __field(unsigned long, error)
609 __field(unsigned long, flags)
610 __field(dev_t, dev)
611 __field(u64, dir)
612 __string(name, dentry->d_name.name)
613 ),
614
615 TP_fast_assign(
616 __entry->error = -error;
617 __entry->dev = dir->i_sb->s_dev;
618 __entry->dir = NFS_FILEID(dir);
619 __entry->flags = flags;
620 __assign_str(name, dentry->d_name.name);
621 ),
622
623 TP_printk(
624 "error=%ld (%s) flags=0x%lx (%s) name=%02x:%02x:%llu/%s",
625 -__entry->error, show_nfs_status(__entry->error),
626 __entry->flags,
627 show_fs_fcntl_open_flags(__entry->flags),
628 MAJOR(__entry->dev), MINOR(__entry->dev),
629 (unsigned long long)__entry->dir,
630 __get_str(name)
631 )
632);
633
634DECLARE_EVENT_CLASS(nfs_directory_event,
635 TP_PROTO(
636 const struct inode *dir,
637 const struct dentry *dentry
638 ),
639
640 TP_ARGS(dir, dentry),
641
642 TP_STRUCT__entry(
643 __field(dev_t, dev)
644 __field(u64, dir)
645 __string(name, dentry->d_name.name)
646 ),
647
648 TP_fast_assign(
649 __entry->dev = dir->i_sb->s_dev;
650 __entry->dir = NFS_FILEID(dir);
651 __assign_str(name, dentry->d_name.name);
652 ),
653
654 TP_printk(
655 "name=%02x:%02x:%llu/%s",
656 MAJOR(__entry->dev), MINOR(__entry->dev),
657 (unsigned long long)__entry->dir,
658 __get_str(name)
659 )
660);
661
662#define DEFINE_NFS_DIRECTORY_EVENT(name) \
663 DEFINE_EVENT(nfs_directory_event, name, \
664 TP_PROTO( \
665 const struct inode *dir, \
666 const struct dentry *dentry \
667 ), \
668 TP_ARGS(dir, dentry))
669
670DECLARE_EVENT_CLASS(nfs_directory_event_done,
671 TP_PROTO(
672 const struct inode *dir,
673 const struct dentry *dentry,
674 int error
675 ),
676
677 TP_ARGS(dir, dentry, error),
678
679 TP_STRUCT__entry(
680 __field(unsigned long, error)
681 __field(dev_t, dev)
682 __field(u64, dir)
683 __string(name, dentry->d_name.name)
684 ),
685
686 TP_fast_assign(
687 __entry->dev = dir->i_sb->s_dev;
688 __entry->dir = NFS_FILEID(dir);
689 __entry->error = error < 0 ? -error : 0;
690 __assign_str(name, dentry->d_name.name);
691 ),
692
693 TP_printk(
694 "error=%ld (%s) name=%02x:%02x:%llu/%s",
695 -__entry->error, show_nfs_status(__entry->error),
696 MAJOR(__entry->dev), MINOR(__entry->dev),
697 (unsigned long long)__entry->dir,
698 __get_str(name)
699 )
700);
701
702#define DEFINE_NFS_DIRECTORY_EVENT_DONE(name) \
703 DEFINE_EVENT(nfs_directory_event_done, name, \
704 TP_PROTO( \
705 const struct inode *dir, \
706 const struct dentry *dentry, \
707 int error \
708 ), \
709 TP_ARGS(dir, dentry, error))
710
711DEFINE_NFS_DIRECTORY_EVENT(nfs_mknod_enter);
712DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mknod_exit);
713DEFINE_NFS_DIRECTORY_EVENT(nfs_mkdir_enter);
714DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mkdir_exit);
715DEFINE_NFS_DIRECTORY_EVENT(nfs_rmdir_enter);
716DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_rmdir_exit);
717DEFINE_NFS_DIRECTORY_EVENT(nfs_remove_enter);
718DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_remove_exit);
719DEFINE_NFS_DIRECTORY_EVENT(nfs_unlink_enter);
720DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_unlink_exit);
721DEFINE_NFS_DIRECTORY_EVENT(nfs_symlink_enter);
722DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_symlink_exit);
723
724TRACE_EVENT(nfs_link_enter,
725 TP_PROTO(
726 const struct inode *inode,
727 const struct inode *dir,
728 const struct dentry *dentry
729 ),
730
731 TP_ARGS(inode, dir, dentry),
732
733 TP_STRUCT__entry(
734 __field(dev_t, dev)
735 __field(u64, fileid)
736 __field(u64, dir)
737 __string(name, dentry->d_name.name)
738 ),
739
740 TP_fast_assign(
741 __entry->dev = inode->i_sb->s_dev;
742 __entry->fileid = NFS_FILEID(inode);
743 __entry->dir = NFS_FILEID(dir);
744 __assign_str(name, dentry->d_name.name);
745 ),
746
747 TP_printk(
748 "fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s",
749 MAJOR(__entry->dev), MINOR(__entry->dev),
750 __entry->fileid,
751 MAJOR(__entry->dev), MINOR(__entry->dev),
752 (unsigned long long)__entry->dir,
753 __get_str(name)
754 )
755);
756
757TRACE_EVENT(nfs_link_exit,
758 TP_PROTO(
759 const struct inode *inode,
760 const struct inode *dir,
761 const struct dentry *dentry,
762 int error
763 ),
764
765 TP_ARGS(inode, dir, dentry, error),
766
767 TP_STRUCT__entry(
768 __field(unsigned long, error)
769 __field(dev_t, dev)
770 __field(u64, fileid)
771 __field(u64, dir)
772 __string(name, dentry->d_name.name)
773 ),
774
775 TP_fast_assign(
776 __entry->dev = inode->i_sb->s_dev;
777 __entry->fileid = NFS_FILEID(inode);
778 __entry->dir = NFS_FILEID(dir);
779 __entry->error = error < 0 ? -error : 0;
780 __assign_str(name, dentry->d_name.name);
781 ),
782
783 TP_printk(
784 "error=%ld (%s) fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s",
785 -__entry->error, show_nfs_status(__entry->error),
786 MAJOR(__entry->dev), MINOR(__entry->dev),
787 __entry->fileid,
788 MAJOR(__entry->dev), MINOR(__entry->dev),
789 (unsigned long long)__entry->dir,
790 __get_str(name)
791 )
792);
793
794DECLARE_EVENT_CLASS(nfs_rename_event,
795 TP_PROTO(
796 const struct inode *old_dir,
797 const struct dentry *old_dentry,
798 const struct inode *new_dir,
799 const struct dentry *new_dentry
800 ),
801
802 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry),
803
804 TP_STRUCT__entry(
805 __field(dev_t, dev)
806 __field(u64, old_dir)
807 __field(u64, new_dir)
808 __string(old_name, old_dentry->d_name.name)
809 __string(new_name, new_dentry->d_name.name)
810 ),
811
812 TP_fast_assign(
813 __entry->dev = old_dir->i_sb->s_dev;
814 __entry->old_dir = NFS_FILEID(old_dir);
815 __entry->new_dir = NFS_FILEID(new_dir);
816 __assign_str(old_name, old_dentry->d_name.name);
817 __assign_str(new_name, new_dentry->d_name.name);
818 ),
819
820 TP_printk(
821 "old_name=%02x:%02x:%llu/%s new_name=%02x:%02x:%llu/%s",
822 MAJOR(__entry->dev), MINOR(__entry->dev),
823 (unsigned long long)__entry->old_dir,
824 __get_str(old_name),
825 MAJOR(__entry->dev), MINOR(__entry->dev),
826 (unsigned long long)__entry->new_dir,
827 __get_str(new_name)
828 )
829);
830#define DEFINE_NFS_RENAME_EVENT(name) \
831 DEFINE_EVENT(nfs_rename_event, name, \
832 TP_PROTO( \
833 const struct inode *old_dir, \
834 const struct dentry *old_dentry, \
835 const struct inode *new_dir, \
836 const struct dentry *new_dentry \
837 ), \
838 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry))
839
840DECLARE_EVENT_CLASS(nfs_rename_event_done,
841 TP_PROTO(
842 const struct inode *old_dir,
843 const struct dentry *old_dentry,
844 const struct inode *new_dir,
845 const struct dentry *new_dentry,
846 int error
847 ),
848
849 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry, error),
850
851 TP_STRUCT__entry(
852 __field(dev_t, dev)
853 __field(unsigned long, error)
854 __field(u64, old_dir)
855 __string(old_name, old_dentry->d_name.name)
856 __field(u64, new_dir)
857 __string(new_name, new_dentry->d_name.name)
858 ),
859
860 TP_fast_assign(
861 __entry->dev = old_dir->i_sb->s_dev;
862 __entry->error = -error;
863 __entry->old_dir = NFS_FILEID(old_dir);
864 __entry->new_dir = NFS_FILEID(new_dir);
865 __assign_str(old_name, old_dentry->d_name.name);
866 __assign_str(new_name, new_dentry->d_name.name);
867 ),
868
869 TP_printk(
870 "error=%ld (%s) old_name=%02x:%02x:%llu/%s "
871 "new_name=%02x:%02x:%llu/%s",
872 -__entry->error, show_nfs_status(__entry->error),
873 MAJOR(__entry->dev), MINOR(__entry->dev),
874 (unsigned long long)__entry->old_dir,
875 __get_str(old_name),
876 MAJOR(__entry->dev), MINOR(__entry->dev),
877 (unsigned long long)__entry->new_dir,
878 __get_str(new_name)
879 )
880);
881#define DEFINE_NFS_RENAME_EVENT_DONE(name) \
882 DEFINE_EVENT(nfs_rename_event_done, name, \
883 TP_PROTO( \
884 const struct inode *old_dir, \
885 const struct dentry *old_dentry, \
886 const struct inode *new_dir, \
887 const struct dentry *new_dentry, \
888 int error \
889 ), \
890 TP_ARGS(old_dir, old_dentry, new_dir, \
891 new_dentry, error))
892
893DEFINE_NFS_RENAME_EVENT(nfs_rename_enter);
894DEFINE_NFS_RENAME_EVENT_DONE(nfs_rename_exit);
895
896DEFINE_NFS_RENAME_EVENT_DONE(nfs_sillyrename_rename);
897
898TRACE_EVENT(nfs_sillyrename_unlink,
899 TP_PROTO(
900 const struct nfs_unlinkdata *data,
901 int error
902 ),
903
904 TP_ARGS(data, error),
905
906 TP_STRUCT__entry(
907 __field(dev_t, dev)
908 __field(unsigned long, error)
909 __field(u64, dir)
910 __dynamic_array(char, name, data->args.name.len + 1)
911 ),
912
913 TP_fast_assign(
914 struct inode *dir = d_inode(data->dentry->d_parent);
915 size_t len = data->args.name.len;
916 __entry->dev = dir->i_sb->s_dev;
917 __entry->dir = NFS_FILEID(dir);
918 __entry->error = -error;
919 memcpy(__get_str(name),
920 data->args.name.name, len);
921 __get_str(name)[len] = 0;
922 ),
923
924 TP_printk(
925 "error=%ld (%s) name=%02x:%02x:%llu/%s",
926 -__entry->error, show_nfs_status(__entry->error),
927 MAJOR(__entry->dev), MINOR(__entry->dev),
928 (unsigned long long)__entry->dir,
929 __get_str(name)
930 )
931);
932
933DECLARE_EVENT_CLASS(nfs_folio_event,
934 TP_PROTO(
935 const struct inode *inode,
936 struct folio *folio
937 ),
938
939 TP_ARGS(inode, folio),
940
941 TP_STRUCT__entry(
942 __field(dev_t, dev)
943 __field(u32, fhandle)
944 __field(u64, fileid)
945 __field(u64, version)
946 __field(loff_t, offset)
947 __field(u32, count)
948 ),
949
950 TP_fast_assign(
951 const struct nfs_inode *nfsi = NFS_I(inode);
952
953 __entry->dev = inode->i_sb->s_dev;
954 __entry->fileid = nfsi->fileid;
955 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
956 __entry->version = inode_peek_iversion_raw(inode);
957 __entry->offset = folio_file_pos(folio);
958 __entry->count = nfs_folio_length(folio);
959 ),
960
961 TP_printk(
962 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu "
963 "offset=%lld count=%u",
964 MAJOR(__entry->dev), MINOR(__entry->dev),
965 (unsigned long long)__entry->fileid,
966 __entry->fhandle, __entry->version,
967 __entry->offset, __entry->count
968 )
969);
970
971#define DEFINE_NFS_FOLIO_EVENT(name) \
972 DEFINE_EVENT(nfs_folio_event, name, \
973 TP_PROTO( \
974 const struct inode *inode, \
975 struct folio *folio \
976 ), \
977 TP_ARGS(inode, folio))
978
979DECLARE_EVENT_CLASS(nfs_folio_event_done,
980 TP_PROTO(
981 const struct inode *inode,
982 struct folio *folio,
983 int ret
984 ),
985
986 TP_ARGS(inode, folio, ret),
987
988 TP_STRUCT__entry(
989 __field(dev_t, dev)
990 __field(u32, fhandle)
991 __field(int, ret)
992 __field(u64, fileid)
993 __field(u64, version)
994 __field(loff_t, offset)
995 __field(u32, count)
996 ),
997
998 TP_fast_assign(
999 const struct nfs_inode *nfsi = NFS_I(inode);
1000
1001 __entry->dev = inode->i_sb->s_dev;
1002 __entry->fileid = nfsi->fileid;
1003 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
1004 __entry->version = inode_peek_iversion_raw(inode);
1005 __entry->offset = folio_file_pos(folio);
1006 __entry->count = nfs_folio_length(folio);
1007 __entry->ret = ret;
1008 ),
1009
1010 TP_printk(
1011 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu "
1012 "offset=%lld count=%u ret=%d",
1013 MAJOR(__entry->dev), MINOR(__entry->dev),
1014 (unsigned long long)__entry->fileid,
1015 __entry->fhandle, __entry->version,
1016 __entry->offset, __entry->count, __entry->ret
1017 )
1018);
1019
1020#define DEFINE_NFS_FOLIO_EVENT_DONE(name) \
1021 DEFINE_EVENT(nfs_folio_event_done, name, \
1022 TP_PROTO( \
1023 const struct inode *inode, \
1024 struct folio *folio, \
1025 int ret \
1026 ), \
1027 TP_ARGS(inode, folio, ret))
1028
1029DEFINE_NFS_FOLIO_EVENT(nfs_aop_readpage);
1030DEFINE_NFS_FOLIO_EVENT_DONE(nfs_aop_readpage_done);
1031
1032DEFINE_NFS_FOLIO_EVENT(nfs_writeback_folio);
1033DEFINE_NFS_FOLIO_EVENT_DONE(nfs_writeback_folio_done);
1034
1035DEFINE_NFS_FOLIO_EVENT(nfs_invalidate_folio);
1036DEFINE_NFS_FOLIO_EVENT_DONE(nfs_launder_folio_done);
1037
1038TRACE_EVENT(nfs_aop_readahead,
1039 TP_PROTO(
1040 const struct inode *inode,
1041 loff_t pos,
1042 unsigned int nr_pages
1043 ),
1044
1045 TP_ARGS(inode, pos, nr_pages),
1046
1047 TP_STRUCT__entry(
1048 __field(dev_t, dev)
1049 __field(u32, fhandle)
1050 __field(u64, fileid)
1051 __field(u64, version)
1052 __field(loff_t, offset)
1053 __field(unsigned int, nr_pages)
1054 ),
1055
1056 TP_fast_assign(
1057 const struct nfs_inode *nfsi = NFS_I(inode);
1058
1059 __entry->dev = inode->i_sb->s_dev;
1060 __entry->fileid = nfsi->fileid;
1061 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
1062 __entry->version = inode_peek_iversion_raw(inode);
1063 __entry->offset = pos;
1064 __entry->nr_pages = nr_pages;
1065 ),
1066
1067 TP_printk(
1068 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu offset=%lld nr_pages=%u",
1069 MAJOR(__entry->dev), MINOR(__entry->dev),
1070 (unsigned long long)__entry->fileid,
1071 __entry->fhandle, __entry->version,
1072 __entry->offset, __entry->nr_pages
1073 )
1074);
1075
1076TRACE_EVENT(nfs_aop_readahead_done,
1077 TP_PROTO(
1078 const struct inode *inode,
1079 unsigned int nr_pages,
1080 int ret
1081 ),
1082
1083 TP_ARGS(inode, nr_pages, ret),
1084
1085 TP_STRUCT__entry(
1086 __field(dev_t, dev)
1087 __field(u32, fhandle)
1088 __field(int, ret)
1089 __field(u64, fileid)
1090 __field(u64, version)
1091 __field(loff_t, offset)
1092 __field(unsigned int, nr_pages)
1093 ),
1094
1095 TP_fast_assign(
1096 const struct nfs_inode *nfsi = NFS_I(inode);
1097
1098 __entry->dev = inode->i_sb->s_dev;
1099 __entry->fileid = nfsi->fileid;
1100 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
1101 __entry->version = inode_peek_iversion_raw(inode);
1102 __entry->nr_pages = nr_pages;
1103 __entry->ret = ret;
1104 ),
1105
1106 TP_printk(
1107 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu nr_pages=%u ret=%d",
1108 MAJOR(__entry->dev), MINOR(__entry->dev),
1109 (unsigned long long)__entry->fileid,
1110 __entry->fhandle, __entry->version,
1111 __entry->nr_pages, __entry->ret
1112 )
1113);
1114
1115TRACE_EVENT(nfs_initiate_read,
1116 TP_PROTO(
1117 const struct nfs_pgio_header *hdr
1118 ),
1119
1120 TP_ARGS(hdr),
1121
1122 TP_STRUCT__entry(
1123 __field(dev_t, dev)
1124 __field(u32, fhandle)
1125 __field(u64, fileid)
1126 __field(loff_t, offset)
1127 __field(u32, count)
1128 ),
1129
1130 TP_fast_assign(
1131 const struct inode *inode = hdr->inode;
1132 const struct nfs_inode *nfsi = NFS_I(inode);
1133 const struct nfs_fh *fh = hdr->args.fh ?
1134 hdr->args.fh : &nfsi->fh;
1135
1136 __entry->offset = hdr->args.offset;
1137 __entry->count = hdr->args.count;
1138 __entry->dev = inode->i_sb->s_dev;
1139 __entry->fileid = nfsi->fileid;
1140 __entry->fhandle = nfs_fhandle_hash(fh);
1141 ),
1142
1143 TP_printk(
1144 "fileid=%02x:%02x:%llu fhandle=0x%08x "
1145 "offset=%lld count=%u",
1146 MAJOR(__entry->dev), MINOR(__entry->dev),
1147 (unsigned long long)__entry->fileid,
1148 __entry->fhandle,
1149 (long long)__entry->offset, __entry->count
1150 )
1151);
1152
1153TRACE_EVENT(nfs_readpage_done,
1154 TP_PROTO(
1155 const struct rpc_task *task,
1156 const struct nfs_pgio_header *hdr
1157 ),
1158
1159 TP_ARGS(task, hdr),
1160
1161 TP_STRUCT__entry(
1162 __field(dev_t, dev)
1163 __field(u32, fhandle)
1164 __field(u64, fileid)
1165 __field(loff_t, offset)
1166 __field(u32, arg_count)
1167 __field(u32, res_count)
1168 __field(bool, eof)
1169 __field(int, error)
1170 ),
1171
1172 TP_fast_assign(
1173 const struct inode *inode = hdr->inode;
1174 const struct nfs_inode *nfsi = NFS_I(inode);
1175 const struct nfs_fh *fh = hdr->args.fh ?
1176 hdr->args.fh : &nfsi->fh;
1177
1178 __entry->error = task->tk_status;
1179 __entry->offset = hdr->args.offset;
1180 __entry->arg_count = hdr->args.count;
1181 __entry->res_count = hdr->res.count;
1182 __entry->eof = hdr->res.eof;
1183 __entry->dev = inode->i_sb->s_dev;
1184 __entry->fileid = nfsi->fileid;
1185 __entry->fhandle = nfs_fhandle_hash(fh);
1186 ),
1187
1188 TP_printk(
1189 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x "
1190 "offset=%lld count=%u res=%u%s", __entry->error,
1191 MAJOR(__entry->dev), MINOR(__entry->dev),
1192 (unsigned long long)__entry->fileid,
1193 __entry->fhandle,
1194 (long long)__entry->offset, __entry->arg_count,
1195 __entry->res_count, __entry->eof ? " eof" : ""
1196 )
1197);
1198
1199TRACE_EVENT(nfs_readpage_short,
1200 TP_PROTO(
1201 const struct rpc_task *task,
1202 const struct nfs_pgio_header *hdr
1203 ),
1204
1205 TP_ARGS(task, hdr),
1206
1207 TP_STRUCT__entry(
1208 __field(dev_t, dev)
1209 __field(u32, fhandle)
1210 __field(u64, fileid)
1211 __field(loff_t, offset)
1212 __field(u32, arg_count)
1213 __field(u32, res_count)
1214 __field(bool, eof)
1215 __field(int, error)
1216 ),
1217
1218 TP_fast_assign(
1219 const struct inode *inode = hdr->inode;
1220 const struct nfs_inode *nfsi = NFS_I(inode);
1221 const struct nfs_fh *fh = hdr->args.fh ?
1222 hdr->args.fh : &nfsi->fh;
1223
1224 __entry->error = task->tk_status;
1225 __entry->offset = hdr->args.offset;
1226 __entry->arg_count = hdr->args.count;
1227 __entry->res_count = hdr->res.count;
1228 __entry->eof = hdr->res.eof;
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 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x "
1236 "offset=%lld count=%u res=%u%s", __entry->error,
1237 MAJOR(__entry->dev), MINOR(__entry->dev),
1238 (unsigned long long)__entry->fileid,
1239 __entry->fhandle,
1240 (long long)__entry->offset, __entry->arg_count,
1241 __entry->res_count, __entry->eof ? " eof" : ""
1242 )
1243);
1244
1245
1246TRACE_EVENT(nfs_pgio_error,
1247 TP_PROTO(
1248 const struct nfs_pgio_header *hdr,
1249 int error,
1250 loff_t pos
1251 ),
1252
1253 TP_ARGS(hdr, error, pos),
1254
1255 TP_STRUCT__entry(
1256 __field(dev_t, dev)
1257 __field(u32, fhandle)
1258 __field(u64, fileid)
1259 __field(loff_t, offset)
1260 __field(u32, arg_count)
1261 __field(u32, res_count)
1262 __field(loff_t, pos)
1263 __field(int, error)
1264 ),
1265
1266 TP_fast_assign(
1267 const struct inode *inode = hdr->inode;
1268 const struct nfs_inode *nfsi = NFS_I(inode);
1269 const struct nfs_fh *fh = hdr->args.fh ?
1270 hdr->args.fh : &nfsi->fh;
1271
1272 __entry->error = error;
1273 __entry->offset = hdr->args.offset;
1274 __entry->arg_count = hdr->args.count;
1275 __entry->res_count = hdr->res.count;
1276 __entry->dev = inode->i_sb->s_dev;
1277 __entry->fileid = nfsi->fileid;
1278 __entry->fhandle = nfs_fhandle_hash(fh);
1279 ),
1280
1281 TP_printk("error=%d fileid=%02x:%02x:%llu fhandle=0x%08x "
1282 "offset=%lld count=%u res=%u pos=%llu", __entry->error,
1283 MAJOR(__entry->dev), MINOR(__entry->dev),
1284 (unsigned long long)__entry->fileid, __entry->fhandle,
1285 (long long)__entry->offset, __entry->arg_count, __entry->res_count,
1286 __entry->pos
1287 )
1288);
1289
1290TRACE_EVENT(nfs_initiate_write,
1291 TP_PROTO(
1292 const struct nfs_pgio_header *hdr
1293 ),
1294
1295 TP_ARGS(hdr),
1296
1297 TP_STRUCT__entry(
1298 __field(dev_t, dev)
1299 __field(u32, fhandle)
1300 __field(u64, fileid)
1301 __field(loff_t, offset)
1302 __field(u32, count)
1303 __field(unsigned long, stable)
1304 ),
1305
1306 TP_fast_assign(
1307 const struct inode *inode = hdr->inode;
1308 const struct nfs_inode *nfsi = NFS_I(inode);
1309 const struct nfs_fh *fh = hdr->args.fh ?
1310 hdr->args.fh : &nfsi->fh;
1311
1312 __entry->offset = hdr->args.offset;
1313 __entry->count = hdr->args.count;
1314 __entry->stable = hdr->args.stable;
1315 __entry->dev = inode->i_sb->s_dev;
1316 __entry->fileid = nfsi->fileid;
1317 __entry->fhandle = nfs_fhandle_hash(fh);
1318 ),
1319
1320 TP_printk(
1321 "fileid=%02x:%02x:%llu fhandle=0x%08x "
1322 "offset=%lld count=%u stable=%s",
1323 MAJOR(__entry->dev), MINOR(__entry->dev),
1324 (unsigned long long)__entry->fileid,
1325 __entry->fhandle,
1326 (long long)__entry->offset, __entry->count,
1327 show_nfs_stable_how(__entry->stable)
1328 )
1329);
1330
1331TRACE_EVENT(nfs_writeback_done,
1332 TP_PROTO(
1333 const struct rpc_task *task,
1334 const struct nfs_pgio_header *hdr
1335 ),
1336
1337 TP_ARGS(task, hdr),
1338
1339 TP_STRUCT__entry(
1340 __field(dev_t, dev)
1341 __field(u32, fhandle)
1342 __field(u64, fileid)
1343 __field(loff_t, offset)
1344 __field(u32, arg_count)
1345 __field(u32, res_count)
1346 __field(int, error)
1347 __field(unsigned long, stable)
1348 __array(char, verifier, NFS4_VERIFIER_SIZE)
1349 ),
1350
1351 TP_fast_assign(
1352 const struct inode *inode = hdr->inode;
1353 const struct nfs_inode *nfsi = NFS_I(inode);
1354 const struct nfs_fh *fh = hdr->args.fh ?
1355 hdr->args.fh : &nfsi->fh;
1356 const struct nfs_writeverf *verf = hdr->res.verf;
1357
1358 __entry->error = task->tk_status;
1359 __entry->offset = hdr->args.offset;
1360 __entry->arg_count = hdr->args.count;
1361 __entry->res_count = hdr->res.count;
1362 __entry->stable = verf->committed;
1363 memcpy(__entry->verifier,
1364 &verf->verifier,
1365 NFS4_VERIFIER_SIZE);
1366 __entry->dev = inode->i_sb->s_dev;
1367 __entry->fileid = nfsi->fileid;
1368 __entry->fhandle = nfs_fhandle_hash(fh);
1369 ),
1370
1371 TP_printk(
1372 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x "
1373 "offset=%lld count=%u res=%u stable=%s "
1374 "verifier=%s", __entry->error,
1375 MAJOR(__entry->dev), MINOR(__entry->dev),
1376 (unsigned long long)__entry->fileid,
1377 __entry->fhandle,
1378 (long long)__entry->offset, __entry->arg_count,
1379 __entry->res_count,
1380 show_nfs_stable_how(__entry->stable),
1381 show_nfs4_verifier(__entry->verifier)
1382 )
1383);
1384
1385DECLARE_EVENT_CLASS(nfs_page_error_class,
1386 TP_PROTO(
1387 const struct inode *inode,
1388 const struct nfs_page *req,
1389 int error
1390 ),
1391
1392 TP_ARGS(inode, req, error),
1393
1394 TP_STRUCT__entry(
1395 __field(dev_t, dev)
1396 __field(u32, fhandle)
1397 __field(u64, fileid)
1398 __field(loff_t, offset)
1399 __field(unsigned int, count)
1400 __field(int, error)
1401 ),
1402
1403 TP_fast_assign(
1404 const struct nfs_inode *nfsi = NFS_I(inode);
1405 __entry->dev = inode->i_sb->s_dev;
1406 __entry->fileid = nfsi->fileid;
1407 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh);
1408 __entry->offset = req_offset(req);
1409 __entry->count = req->wb_bytes;
1410 __entry->error = error;
1411 ),
1412
1413 TP_printk(
1414 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x "
1415 "offset=%lld count=%u", __entry->error,
1416 MAJOR(__entry->dev), MINOR(__entry->dev),
1417 (unsigned long long)__entry->fileid,
1418 __entry->fhandle, __entry->offset,
1419 __entry->count
1420 )
1421);
1422
1423#define DEFINE_NFS_PAGEERR_EVENT(name) \
1424 DEFINE_EVENT(nfs_page_error_class, name, \
1425 TP_PROTO( \
1426 const struct inode *inode, \
1427 const struct nfs_page *req, \
1428 int error \
1429 ), \
1430 TP_ARGS(inode, req, error))
1431
1432DEFINE_NFS_PAGEERR_EVENT(nfs_write_error);
1433DEFINE_NFS_PAGEERR_EVENT(nfs_comp_error);
1434DEFINE_NFS_PAGEERR_EVENT(nfs_commit_error);
1435
1436TRACE_EVENT(nfs_initiate_commit,
1437 TP_PROTO(
1438 const struct nfs_commit_data *data
1439 ),
1440
1441 TP_ARGS(data),
1442
1443 TP_STRUCT__entry(
1444 __field(dev_t, dev)
1445 __field(u32, fhandle)
1446 __field(u64, fileid)
1447 __field(loff_t, offset)
1448 __field(u32, count)
1449 ),
1450
1451 TP_fast_assign(
1452 const struct inode *inode = data->inode;
1453 const struct nfs_inode *nfsi = NFS_I(inode);
1454 const struct nfs_fh *fh = data->args.fh ?
1455 data->args.fh : &nfsi->fh;
1456
1457 __entry->offset = data->args.offset;
1458 __entry->count = data->args.count;
1459 __entry->dev = inode->i_sb->s_dev;
1460 __entry->fileid = nfsi->fileid;
1461 __entry->fhandle = nfs_fhandle_hash(fh);
1462 ),
1463
1464 TP_printk(
1465 "fileid=%02x:%02x:%llu fhandle=0x%08x "
1466 "offset=%lld count=%u",
1467 MAJOR(__entry->dev), MINOR(__entry->dev),
1468 (unsigned long long)__entry->fileid,
1469 __entry->fhandle,
1470 (long long)__entry->offset, __entry->count
1471 )
1472);
1473
1474TRACE_EVENT(nfs_commit_done,
1475 TP_PROTO(
1476 const struct rpc_task *task,
1477 const struct nfs_commit_data *data
1478 ),
1479
1480 TP_ARGS(task, data),
1481
1482 TP_STRUCT__entry(
1483 __field(dev_t, dev)
1484 __field(u32, fhandle)
1485 __field(u64, fileid)
1486 __field(loff_t, offset)
1487 __field(int, error)
1488 __field(unsigned long, stable)
1489 __array(char, verifier, NFS4_VERIFIER_SIZE)
1490 ),
1491
1492 TP_fast_assign(
1493 const struct inode *inode = data->inode;
1494 const struct nfs_inode *nfsi = NFS_I(inode);
1495 const struct nfs_fh *fh = data->args.fh ?
1496 data->args.fh : &nfsi->fh;
1497 const struct nfs_writeverf *verf = data->res.verf;
1498
1499 __entry->error = task->tk_status;
1500 __entry->offset = data->args.offset;
1501 __entry->stable = verf->committed;
1502 memcpy(__entry->verifier,
1503 &verf->verifier,
1504 NFS4_VERIFIER_SIZE);
1505 __entry->dev = inode->i_sb->s_dev;
1506 __entry->fileid = nfsi->fileid;
1507 __entry->fhandle = nfs_fhandle_hash(fh);
1508 ),
1509
1510 TP_printk(
1511 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x "
1512 "offset=%lld stable=%s verifier=%s", __entry->error,
1513 MAJOR(__entry->dev), MINOR(__entry->dev),
1514 (unsigned long long)__entry->fileid,
1515 __entry->fhandle,
1516 (long long)__entry->offset,
1517 show_nfs_stable_how(__entry->stable),
1518 show_nfs4_verifier(__entry->verifier)
1519 )
1520);
1521
1522#define nfs_show_direct_req_flags(v) \
1523 __print_flags(v, "|", \
1524 { NFS_ODIRECT_DO_COMMIT, "DO_COMMIT" }, \
1525 { NFS_ODIRECT_RESCHED_WRITES, "RESCHED_WRITES" }, \
1526 { NFS_ODIRECT_SHOULD_DIRTY, "SHOULD DIRTY" }, \
1527 { NFS_ODIRECT_DONE, "DONE" } )
1528
1529DECLARE_EVENT_CLASS(nfs_direct_req_class,
1530 TP_PROTO(
1531 const struct nfs_direct_req *dreq
1532 ),
1533
1534 TP_ARGS(dreq),
1535
1536 TP_STRUCT__entry(
1537 __field(dev_t, dev)
1538 __field(u64, fileid)
1539 __field(u32, fhandle)
1540 __field(loff_t, offset)
1541 __field(ssize_t, count)
1542 __field(ssize_t, bytes_left)
1543 __field(ssize_t, error)
1544 __field(int, flags)
1545 ),
1546
1547 TP_fast_assign(
1548 const struct inode *inode = dreq->inode;
1549 const struct nfs_inode *nfsi = NFS_I(inode);
1550 const struct nfs_fh *fh = &nfsi->fh;
1551
1552 __entry->dev = inode->i_sb->s_dev;
1553 __entry->fileid = nfsi->fileid;
1554 __entry->fhandle = nfs_fhandle_hash(fh);
1555 __entry->offset = dreq->io_start;
1556 __entry->count = dreq->count;
1557 __entry->bytes_left = dreq->bytes_left;
1558 __entry->error = dreq->error;
1559 __entry->flags = dreq->flags;
1560 ),
1561
1562 TP_printk(
1563 "error=%zd fileid=%02x:%02x:%llu fhandle=0x%08x "
1564 "offset=%lld count=%zd bytes_left=%zd flags=%s",
1565 __entry->error, MAJOR(__entry->dev),
1566 MINOR(__entry->dev),
1567 (unsigned long long)__entry->fileid,
1568 __entry->fhandle, __entry->offset,
1569 __entry->count, __entry->bytes_left,
1570 nfs_show_direct_req_flags(__entry->flags)
1571 )
1572);
1573
1574#define DEFINE_NFS_DIRECT_REQ_EVENT(name) \
1575 DEFINE_EVENT(nfs_direct_req_class, name, \
1576 TP_PROTO( \
1577 const struct nfs_direct_req *dreq \
1578 ), \
1579 TP_ARGS(dreq))
1580
1581DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_commit_complete);
1582DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_resched_write);
1583DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_complete);
1584DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_completion);
1585DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_schedule_iovec);
1586DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_reschedule_io);
1587
1588TRACE_EVENT(nfs_fh_to_dentry,
1589 TP_PROTO(
1590 const struct super_block *sb,
1591 const struct nfs_fh *fh,
1592 u64 fileid,
1593 int error
1594 ),
1595
1596 TP_ARGS(sb, fh, fileid, error),
1597
1598 TP_STRUCT__entry(
1599 __field(int, error)
1600 __field(dev_t, dev)
1601 __field(u32, fhandle)
1602 __field(u64, fileid)
1603 ),
1604
1605 TP_fast_assign(
1606 __entry->error = error;
1607 __entry->dev = sb->s_dev;
1608 __entry->fileid = fileid;
1609 __entry->fhandle = nfs_fhandle_hash(fh);
1610 ),
1611
1612 TP_printk(
1613 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x ",
1614 __entry->error,
1615 MAJOR(__entry->dev), MINOR(__entry->dev),
1616 (unsigned long long)__entry->fileid,
1617 __entry->fhandle
1618 )
1619);
1620
1621TRACE_EVENT(nfs_mount_assign,
1622 TP_PROTO(
1623 const char *option,
1624 const char *value
1625 ),
1626
1627 TP_ARGS(option, value),
1628
1629 TP_STRUCT__entry(
1630 __string(option, option)
1631 __string(value, value)
1632 ),
1633
1634 TP_fast_assign(
1635 __assign_str(option, option);
1636 __assign_str(value, value);
1637 ),
1638
1639 TP_printk("option %s=%s",
1640 __get_str(option), __get_str(value)
1641 )
1642);
1643
1644TRACE_EVENT(nfs_mount_option,
1645 TP_PROTO(
1646 const struct fs_parameter *param
1647 ),
1648
1649 TP_ARGS(param),
1650
1651 TP_STRUCT__entry(
1652 __string(option, param->key)
1653 ),
1654
1655 TP_fast_assign(
1656 __assign_str(option, param->key);
1657 ),
1658
1659 TP_printk("option %s", __get_str(option))
1660);
1661
1662TRACE_EVENT(nfs_mount_path,
1663 TP_PROTO(
1664 const char *path
1665 ),
1666
1667 TP_ARGS(path),
1668
1669 TP_STRUCT__entry(
1670 __string(path, path)
1671 ),
1672
1673 TP_fast_assign(
1674 __assign_str(path, path);
1675 ),
1676
1677 TP_printk("path='%s'", __get_str(path))
1678);
1679
1680DECLARE_EVENT_CLASS(nfs_xdr_event,
1681 TP_PROTO(
1682 const struct xdr_stream *xdr,
1683 int error
1684 ),
1685
1686 TP_ARGS(xdr, error),
1687
1688 TP_STRUCT__entry(
1689 __field(unsigned int, task_id)
1690 __field(unsigned int, client_id)
1691 __field(u32, xid)
1692 __field(int, version)
1693 __field(unsigned long, error)
1694 __string(program,
1695 xdr->rqst->rq_task->tk_client->cl_program->name)
1696 __string(procedure,
1697 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
1698 ),
1699
1700 TP_fast_assign(
1701 const struct rpc_rqst *rqstp = xdr->rqst;
1702 const struct rpc_task *task = rqstp->rq_task;
1703
1704 __entry->task_id = task->tk_pid;
1705 __entry->client_id = task->tk_client->cl_clid;
1706 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1707 __entry->version = task->tk_client->cl_vers;
1708 __entry->error = error;
1709 __assign_str(program,
1710 task->tk_client->cl_program->name);
1711 __assign_str(procedure, task->tk_msg.rpc_proc->p_name);
1712 ),
1713
1714 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1715 " xid=0x%08x %sv%d %s error=%ld (%s)",
1716 __entry->task_id, __entry->client_id, __entry->xid,
1717 __get_str(program), __entry->version,
1718 __get_str(procedure), -__entry->error,
1719 show_nfs_status(__entry->error)
1720 )
1721);
1722#define DEFINE_NFS_XDR_EVENT(name) \
1723 DEFINE_EVENT(nfs_xdr_event, name, \
1724 TP_PROTO( \
1725 const struct xdr_stream *xdr, \
1726 int error \
1727 ), \
1728 TP_ARGS(xdr, error))
1729DEFINE_NFS_XDR_EVENT(nfs_xdr_status);
1730DEFINE_NFS_XDR_EVENT(nfs_xdr_bad_filehandle);
1731
1732#endif /* _TRACE_NFS_H */
1733
1734#undef TRACE_INCLUDE_PATH
1735#define TRACE_INCLUDE_PATH .
1736#define TRACE_INCLUDE_FILE nfstrace
1737/* This part must be outside protection */
1738#include <trace/define_trace.h>
1739

source code of linux/fs/nfs/nfstrace.h