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