1 /* SPDX-License-Identifier: GPL-2.0 */
3 * Copyright (c) 2014 Christoph Hellwig.
6 #define TRACE_SYSTEM nfsd
8 #if !defined(_NFSD_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
11 #include <linux/tracepoint.h>
12 #include <linux/sunrpc/clnt.h>
13 #include <linux/sunrpc/xprt.h>
14 #include <trace/misc/nfs.h>
15 #include <trace/misc/sunrpc.h>
21 #define NFSD_TRACE_PROC_RES_FIELDS \
22 __field(unsigned int, netns_ino) \
24 __field(unsigned long, status) \
25 __array(unsigned char, server, sizeof(struct sockaddr_in6)) \
26 __array(unsigned char, client, sizeof(struct sockaddr_in6))
28 #define NFSD_TRACE_PROC_RES_ASSIGNMENTS(error) \
30 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \
31 __entry->xid = be32_to_cpu(rqstp->rq_xid); \
32 __entry->status = be32_to_cpu(error); \
33 memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \
34 rqstp->rq_xprt->xpt_locallen); \
35 memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \
36 rqstp->rq_xprt->xpt_remotelen); \
39 DECLARE_EVENT_CLASS(nfsd_xdr_err_class,
41 const struct svc_rqst *rqstp
45 __field(unsigned int, netns_ino)
49 __sockaddr(server, rqstp->rq_xprt->xpt_locallen)
50 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
53 const struct svc_xprt *xprt = rqstp->rq_xprt;
55 __entry->netns_ino = xprt->xpt_net->ns.inum;
56 __entry->xid = be32_to_cpu(rqstp->rq_xid);
57 __entry->vers = rqstp->rq_vers;
58 __entry->proc = rqstp->rq_proc;
59 __assign_sockaddr(server, &xprt->xpt_local, xprt->xpt_locallen);
60 __assign_sockaddr(client, &xprt->xpt_remote, xprt->xpt_remotelen);
62 TP_printk("xid=0x%08x vers=%u proc=%u",
63 __entry->xid, __entry->vers, __entry->proc
67 #define DEFINE_NFSD_XDR_ERR_EVENT(name) \
68 DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \
69 TP_PROTO(const struct svc_rqst *rqstp), \
72 DEFINE_NFSD_XDR_ERR_EVENT(garbage_args);
73 DEFINE_NFSD_XDR_ERR_EVENT(cant_encode);
75 #define show_nfsd_may_flags(x) \
76 __print_flags(x, "|", \
77 { NFSD_MAY_EXEC, "EXEC" }, \
78 { NFSD_MAY_WRITE, "WRITE" }, \
79 { NFSD_MAY_READ, "READ" }, \
80 { NFSD_MAY_SATTR, "SATTR" }, \
81 { NFSD_MAY_TRUNC, "TRUNC" }, \
82 { NFSD_MAY_LOCK, "LOCK" }, \
83 { NFSD_MAY_OWNER_OVERRIDE, "OWNER_OVERRIDE" }, \
84 { NFSD_MAY_LOCAL_ACCESS, "LOCAL_ACCESS" }, \
85 { NFSD_MAY_BYPASS_GSS_ON_ROOT, "BYPASS_GSS_ON_ROOT" }, \
86 { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \
87 { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \
88 { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \
89 { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" })
91 TRACE_EVENT(nfsd_compound,
93 const struct svc_rqst *rqst,
98 TP_ARGS(rqst, tag, taglen, opcnt),
102 __string_len(tag, tag, taglen)
105 __entry->xid = be32_to_cpu(rqst->rq_xid);
106 __entry->opcnt = opcnt;
107 __assign_str(tag, tag);
109 TP_printk("xid=0x%08x opcnt=%u tag=%s",
110 __entry->xid, __entry->opcnt, __get_str(tag)
114 TRACE_EVENT(nfsd_compound_status,
115 TP_PROTO(u32 args_opcnt,
119 TP_ARGS(args_opcnt, resp_opcnt, status, name),
121 __field(u32, args_opcnt)
122 __field(u32, resp_opcnt)
127 __entry->args_opcnt = args_opcnt;
128 __entry->resp_opcnt = resp_opcnt;
129 __entry->status = be32_to_cpu(status);
130 __assign_str(name, name);
132 TP_printk("op=%u/%u %s status=%d",
133 __entry->resp_opcnt, __entry->args_opcnt,
134 __get_str(name), __entry->status)
137 TRACE_EVENT(nfsd_compound_decode_err,
139 const struct svc_rqst *rqstp,
145 TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status),
147 NFSD_TRACE_PROC_RES_FIELDS
149 __field(u32, args_opcnt)
150 __field(u32, resp_opcnt)
154 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status)
156 __entry->args_opcnt = args_opcnt;
157 __entry->resp_opcnt = resp_opcnt;
158 __entry->opnum = opnum;
160 TP_printk("op=%u/%u opnum=%u status=%lu",
161 __entry->resp_opcnt, __entry->args_opcnt,
162 __entry->opnum, __entry->status)
165 TRACE_EVENT(nfsd_compound_encode_err,
167 const struct svc_rqst *rqstp,
171 TP_ARGS(rqstp, opnum, status),
173 NFSD_TRACE_PROC_RES_FIELDS
178 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status)
180 __entry->opnum = opnum;
182 TP_printk("opnum=%u status=%lu",
183 __entry->opnum, __entry->status)
186 #define show_fs_file_type(x) \
187 __print_symbolic(x, \
188 { S_IFLNK, "LNK" }, \
189 { S_IFREG, "REG" }, \
190 { S_IFDIR, "DIR" }, \
191 { S_IFCHR, "CHR" }, \
192 { S_IFBLK, "BLK" }, \
193 { S_IFIFO, "FIFO" }, \
194 { S_IFSOCK, "SOCK" })
196 TRACE_EVENT(nfsd_fh_verify,
198 const struct svc_rqst *rqstp,
199 const struct svc_fh *fhp,
203 TP_ARGS(rqstp, fhp, type, access),
205 __field(unsigned int, netns_ino)
206 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen)
207 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
209 __field(u32, fh_hash)
210 __field(const void *, inode)
211 __field(unsigned long, type)
212 __field(unsigned long, access)
215 __entry->netns_ino = SVC_NET(rqstp)->ns.inum;
216 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local,
217 rqstp->rq_xprt->xpt_locallen);
218 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote,
219 rqstp->rq_xprt->xpt_remotelen);
220 __entry->xid = be32_to_cpu(rqstp->rq_xid);
221 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
222 __entry->inode = d_inode(fhp->fh_dentry);
223 __entry->type = type;
224 __entry->access = access;
226 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s",
227 __entry->xid, __entry->fh_hash,
228 show_fs_file_type(__entry->type),
229 show_nfsd_may_flags(__entry->access)
233 TRACE_EVENT_CONDITION(nfsd_fh_verify_err,
235 const struct svc_rqst *rqstp,
236 const struct svc_fh *fhp,
241 TP_ARGS(rqstp, fhp, type, access, error),
244 __field(unsigned int, netns_ino)
245 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen)
246 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
248 __field(u32, fh_hash)
249 __field(const void *, inode)
250 __field(unsigned long, type)
251 __field(unsigned long, access)
255 __entry->netns_ino = SVC_NET(rqstp)->ns.inum;
256 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local,
257 rqstp->rq_xprt->xpt_locallen);
258 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote,
259 rqstp->rq_xprt->xpt_remotelen);
260 __entry->xid = be32_to_cpu(rqstp->rq_xid);
261 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
263 __entry->inode = d_inode(fhp->fh_dentry);
265 __entry->inode = NULL;
266 __entry->type = type;
267 __entry->access = access;
268 __entry->error = be32_to_cpu(error);
270 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s error=%d",
271 __entry->xid, __entry->fh_hash,
272 show_fs_file_type(__entry->type),
273 show_nfsd_may_flags(__entry->access),
278 DECLARE_EVENT_CLASS(nfsd_fh_err_class,
279 TP_PROTO(struct svc_rqst *rqstp,
282 TP_ARGS(rqstp, fhp, status),
285 __field(u32, fh_hash)
289 __entry->xid = be32_to_cpu(rqstp->rq_xid);
290 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
291 __entry->status = status;
293 TP_printk("xid=0x%08x fh_hash=0x%08x status=%d",
294 __entry->xid, __entry->fh_hash,
298 #define DEFINE_NFSD_FH_ERR_EVENT(name) \
299 DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \
300 TP_PROTO(struct svc_rqst *rqstp, \
301 struct svc_fh *fhp, \
303 TP_ARGS(rqstp, fhp, status))
305 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport);
306 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle);
308 TRACE_EVENT(nfsd_exp_find_key,
309 TP_PROTO(const struct svc_expkey *key,
311 TP_ARGS(key, status),
313 __field(int, fsidtype)
314 __array(u32, fsid, 6)
315 __string(auth_domain, key->ek_client->name)
319 __entry->fsidtype = key->ek_fsidtype;
320 memcpy(__entry->fsid, key->ek_fsid, 4*6);
321 __assign_str(auth_domain, key->ek_client->name);
322 __entry->status = status;
324 TP_printk("fsid=%x::%s domain=%s status=%d",
326 __print_array(__entry->fsid, 6, 4),
327 __get_str(auth_domain),
332 TRACE_EVENT(nfsd_expkey_update,
333 TP_PROTO(const struct svc_expkey *key, const char *exp_path),
334 TP_ARGS(key, exp_path),
336 __field(int, fsidtype)
337 __array(u32, fsid, 6)
338 __string(auth_domain, key->ek_client->name)
339 __string(path, exp_path)
343 __entry->fsidtype = key->ek_fsidtype;
344 memcpy(__entry->fsid, key->ek_fsid, 4*6);
345 __assign_str(auth_domain, key->ek_client->name);
346 __assign_str(path, exp_path);
347 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags);
349 TP_printk("fsid=%x::%s domain=%s path=%s cache=%s",
351 __print_array(__entry->fsid, 6, 4),
352 __get_str(auth_domain),
354 __entry->cache ? "pos" : "neg"
358 TRACE_EVENT(nfsd_exp_get_by_name,
359 TP_PROTO(const struct svc_export *key,
361 TP_ARGS(key, status),
363 __string(path, key->ex_path.dentry->d_name.name)
364 __string(auth_domain, key->ex_client->name)
368 __assign_str(path, key->ex_path.dentry->d_name.name);
369 __assign_str(auth_domain, key->ex_client->name);
370 __entry->status = status;
372 TP_printk("path=%s domain=%s status=%d",
374 __get_str(auth_domain),
379 TRACE_EVENT(nfsd_export_update,
380 TP_PROTO(const struct svc_export *key),
383 __string(path, key->ex_path.dentry->d_name.name)
384 __string(auth_domain, key->ex_client->name)
388 __assign_str(path, key->ex_path.dentry->d_name.name);
389 __assign_str(auth_domain, key->ex_client->name);
390 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags);
392 TP_printk("path=%s domain=%s cache=%s",
394 __get_str(auth_domain),
395 __entry->cache ? "pos" : "neg"
399 DECLARE_EVENT_CLASS(nfsd_io_class,
400 TP_PROTO(struct svc_rqst *rqstp,
404 TP_ARGS(rqstp, fhp, offset, len),
407 __field(u32, fh_hash)
412 __entry->xid = be32_to_cpu(rqstp->rq_xid);
413 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
414 __entry->offset = offset;
417 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u",
418 __entry->xid, __entry->fh_hash,
419 __entry->offset, __entry->len)
422 #define DEFINE_NFSD_IO_EVENT(name) \
423 DEFINE_EVENT(nfsd_io_class, nfsd_##name, \
424 TP_PROTO(struct svc_rqst *rqstp, \
425 struct svc_fh *fhp, \
428 TP_ARGS(rqstp, fhp, offset, len))
430 DEFINE_NFSD_IO_EVENT(read_start);
431 DEFINE_NFSD_IO_EVENT(read_splice);
432 DEFINE_NFSD_IO_EVENT(read_vector);
433 DEFINE_NFSD_IO_EVENT(read_io_done);
434 DEFINE_NFSD_IO_EVENT(read_done);
435 DEFINE_NFSD_IO_EVENT(write_start);
436 DEFINE_NFSD_IO_EVENT(write_opened);
437 DEFINE_NFSD_IO_EVENT(write_io_done);
438 DEFINE_NFSD_IO_EVENT(write_done);
440 DECLARE_EVENT_CLASS(nfsd_err_class,
441 TP_PROTO(struct svc_rqst *rqstp,
445 TP_ARGS(rqstp, fhp, offset, status),
448 __field(u32, fh_hash)
449 __field(loff_t, offset)
453 __entry->xid = be32_to_cpu(rqstp->rq_xid);
454 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
455 __entry->offset = offset;
456 __entry->status = status;
458 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d",
459 __entry->xid, __entry->fh_hash,
460 __entry->offset, __entry->status)
463 #define DEFINE_NFSD_ERR_EVENT(name) \
464 DEFINE_EVENT(nfsd_err_class, nfsd_##name, \
465 TP_PROTO(struct svc_rqst *rqstp, \
466 struct svc_fh *fhp, \
469 TP_ARGS(rqstp, fhp, offset, len))
471 DEFINE_NFSD_ERR_EVENT(read_err);
472 DEFINE_NFSD_ERR_EVENT(write_err);
474 TRACE_EVENT(nfsd_dirent,
475 TP_PROTO(struct svc_fh *fhp,
479 TP_ARGS(fhp, ino, name, namlen),
481 __field(u32, fh_hash)
483 __string_len(name, name, namlen)
486 __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0;
488 __assign_str(name, name);
490 TP_printk("fh_hash=0x%08x ino=%llu name=%s",
491 __entry->fh_hash, __entry->ino, __get_str(name)
495 DECLARE_EVENT_CLASS(nfsd_copy_err_class,
496 TP_PROTO(struct svc_rqst *rqstp,
497 struct svc_fh *src_fhp,
499 struct svc_fh *dst_fhp,
503 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status),
506 __field(u32, src_fh_hash)
507 __field(loff_t, src_offset)
508 __field(u32, dst_fh_hash)
509 __field(loff_t, dst_offset)
514 __entry->xid = be32_to_cpu(rqstp->rq_xid);
515 __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle);
516 __entry->src_offset = src_offset;
517 __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle);
518 __entry->dst_offset = dst_offset;
519 __entry->count = count;
520 __entry->status = status;
522 TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld "
523 "dst_fh_hash=0x%08x dst_offset=%lld "
524 "count=%llu status=%d",
525 __entry->xid, __entry->src_fh_hash, __entry->src_offset,
526 __entry->dst_fh_hash, __entry->dst_offset,
527 (unsigned long long)__entry->count,
531 #define DEFINE_NFSD_COPY_ERR_EVENT(name) \
532 DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \
533 TP_PROTO(struct svc_rqst *rqstp, \
534 struct svc_fh *src_fhp, \
536 struct svc_fh *dst_fhp, \
540 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \
543 DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err);
546 #include "filecache.h"
549 TRACE_EVENT(nfsd_delegret_wakeup,
551 const struct svc_rqst *rqstp,
552 const struct inode *inode,
555 TP_ARGS(rqstp, inode, timeo),
558 __field(const void *, inode)
562 __entry->xid = be32_to_cpu(rqstp->rq_xid);
563 __entry->inode = inode;
564 __entry->timeo = timeo;
566 TP_printk("xid=0x%08x inode=%p%s",
567 __entry->xid, __entry->inode,
568 __entry->timeo == 0 ? " (timed out)" : ""
572 DECLARE_EVENT_CLASS(nfsd_stateid_class,
573 TP_PROTO(stateid_t *stp),
576 __field(u32, cl_boot)
579 __field(u32, si_generation)
582 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
583 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
584 __entry->si_id = stp->si_opaque.so_id;
585 __entry->si_generation = stp->si_generation;
587 TP_printk("client %08x:%08x stateid %08x:%08x",
591 __entry->si_generation)
594 #define DEFINE_STATEID_EVENT(name) \
595 DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \
596 TP_PROTO(stateid_t *stp), \
599 DEFINE_STATEID_EVENT(layoutstate_alloc);
600 DEFINE_STATEID_EVENT(layoutstate_unhash);
601 DEFINE_STATEID_EVENT(layoutstate_free);
602 DEFINE_STATEID_EVENT(layout_get_lookup_fail);
603 DEFINE_STATEID_EVENT(layout_commit_lookup_fail);
604 DEFINE_STATEID_EVENT(layout_return_lookup_fail);
605 DEFINE_STATEID_EVENT(layout_recall);
606 DEFINE_STATEID_EVENT(layout_recall_done);
607 DEFINE_STATEID_EVENT(layout_recall_fail);
608 DEFINE_STATEID_EVENT(layout_recall_release);
610 DEFINE_STATEID_EVENT(open);
611 DEFINE_STATEID_EVENT(deleg_read);
612 DEFINE_STATEID_EVENT(deleg_write);
613 DEFINE_STATEID_EVENT(deleg_return);
614 DEFINE_STATEID_EVENT(deleg_recall);
616 DECLARE_EVENT_CLASS(nfsd_stateseqid_class,
617 TP_PROTO(u32 seqid, const stateid_t *stp),
621 __field(u32, cl_boot)
624 __field(u32, si_generation)
627 __entry->seqid = seqid;
628 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
629 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
630 __entry->si_id = stp->si_opaque.so_id;
631 __entry->si_generation = stp->si_generation;
633 TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x",
634 __entry->seqid, __entry->cl_boot, __entry->cl_id,
635 __entry->si_id, __entry->si_generation)
638 #define DEFINE_STATESEQID_EVENT(name) \
639 DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \
640 TP_PROTO(u32 seqid, const stateid_t *stp), \
643 DEFINE_STATESEQID_EVENT(preprocess);
644 DEFINE_STATESEQID_EVENT(open_confirm);
646 #define show_stid_type(x) \
647 __print_flags(x, "|", \
648 { SC_TYPE_OPEN, "OPEN" }, \
649 { SC_TYPE_LOCK, "LOCK" }, \
650 { SC_TYPE_DELEG, "DELEG" }, \
651 { SC_TYPE_LAYOUT, "LAYOUT" })
653 #define show_stid_status(x) \
654 __print_flags(x, "|", \
655 { SC_STATUS_CLOSED, "CLOSED" }, \
656 { SC_STATUS_REVOKED, "REVOKED" }, \
657 { SC_STATUS_ADMIN_REVOKED, "ADMIN_REVOKED" })
659 DECLARE_EVENT_CLASS(nfsd_stid_class,
661 const struct nfs4_stid *stid
665 __field(unsigned long, sc_type)
666 __field(unsigned long, sc_status)
667 __field(int, sc_count)
668 __field(u32, cl_boot)
671 __field(u32, si_generation)
674 const stateid_t *stp = &stid->sc_stateid;
676 __entry->sc_type = stid->sc_type;
677 __entry->sc_status = stid->sc_status;
678 __entry->sc_count = refcount_read(&stid->sc_count);
679 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
680 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
681 __entry->si_id = stp->si_opaque.so_id;
682 __entry->si_generation = stp->si_generation;
684 TP_printk("client %08x:%08x stateid %08x:%08x ref=%d type=%s state=%s",
685 __entry->cl_boot, __entry->cl_id,
686 __entry->si_id, __entry->si_generation,
687 __entry->sc_count, show_stid_type(__entry->sc_type),
688 show_stid_status(__entry->sc_status)
692 #define DEFINE_STID_EVENT(name) \
693 DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name, \
694 TP_PROTO(const struct nfs4_stid *stid), \
697 DEFINE_STID_EVENT(revoke);
699 TRACE_EVENT(nfsd_stateowner_replay,
702 const struct nfs4_replay *rp
706 __field(unsigned long, status)
710 __entry->status = be32_to_cpu(rp->rp_status);
711 __entry->opnum = opnum;
713 TP_printk("opnum=%u status=%lu",
714 __entry->opnum, __entry->status)
717 TRACE_EVENT_CONDITION(nfsd_seq4_status,
719 const struct svc_rqst *rqstp,
720 const struct nfsd4_sequence *sequence
722 TP_ARGS(rqstp, sequence),
723 TP_CONDITION(sequence->status_flags),
725 __field(unsigned int, netns_ino)
727 __field(u32, cl_boot)
730 __field(u32, reserved)
731 __field(unsigned long, status_flags)
734 const struct nfsd4_sessionid *sid =
735 (struct nfsd4_sessionid *)&sequence->sessionid;
737 __entry->netns_ino = SVC_NET(rqstp)->ns.inum;
738 __entry->xid = be32_to_cpu(rqstp->rq_xid);
739 __entry->cl_boot = sid->clientid.cl_boot;
740 __entry->cl_id = sid->clientid.cl_id;
741 __entry->seqno = sid->sequence;
742 __entry->reserved = sid->reserved;
743 __entry->status_flags = sequence->status_flags;
745 TP_printk("xid=0x%08x sessionid=%08x:%08x:%08x:%08x status_flags=%s",
746 __entry->xid, __entry->cl_boot, __entry->cl_id,
747 __entry->seqno, __entry->reserved,
748 show_nfs4_seq4_status(__entry->status_flags)
752 DECLARE_EVENT_CLASS(nfsd_clientid_class,
753 TP_PROTO(const clientid_t *clid),
756 __field(u32, cl_boot)
760 __entry->cl_boot = clid->cl_boot;
761 __entry->cl_id = clid->cl_id;
763 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
766 #define DEFINE_CLIENTID_EVENT(name) \
767 DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \
768 TP_PROTO(const clientid_t *clid), \
771 DEFINE_CLIENTID_EVENT(expire_unconf);
772 DEFINE_CLIENTID_EVENT(reclaim_complete);
773 DEFINE_CLIENTID_EVENT(confirmed);
774 DEFINE_CLIENTID_EVENT(destroyed);
775 DEFINE_CLIENTID_EVENT(admin_expired);
776 DEFINE_CLIENTID_EVENT(replaced);
777 DEFINE_CLIENTID_EVENT(purged);
778 DEFINE_CLIENTID_EVENT(renew);
779 DEFINE_CLIENTID_EVENT(stale);
781 DECLARE_EVENT_CLASS(nfsd_net_class,
782 TP_PROTO(const struct nfsd_net *nn),
785 __field(unsigned long long, boot_time)
788 __entry->boot_time = nn->boot_time;
790 TP_printk("boot_time=%16llx", __entry->boot_time)
793 #define DEFINE_NET_EVENT(name) \
794 DEFINE_EVENT(nfsd_net_class, nfsd_##name, \
795 TP_PROTO(const struct nfsd_net *nn), \
798 DEFINE_NET_EVENT(grace_start);
799 DEFINE_NET_EVENT(grace_complete);
801 TRACE_EVENT(nfsd_writeverf_reset,
803 const struct nfsd_net *nn,
804 const struct svc_rqst *rqstp,
807 TP_ARGS(nn, rqstp, error),
809 __field(unsigned long long, boot_time)
812 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
815 __entry->boot_time = nn->boot_time;
816 __entry->xid = be32_to_cpu(rqstp->rq_xid);
817 __entry->error = error;
819 /* avoid seqlock inside TP_fast_assign */
820 memcpy(__entry->verifier, nn->writeverf,
823 TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s",
824 __entry->boot_time, __entry->xid, __entry->error,
825 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE)
829 TRACE_EVENT(nfsd_clid_cred_mismatch,
831 const struct nfs4_client *clp,
832 const struct svc_rqst *rqstp
836 __field(u32, cl_boot)
838 __field(unsigned long, cl_flavor)
839 __field(unsigned long, new_flavor)
840 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
843 __entry->cl_boot = clp->cl_clientid.cl_boot;
844 __entry->cl_id = clp->cl_clientid.cl_id;
845 __entry->cl_flavor = clp->cl_cred.cr_flavor;
846 __entry->new_flavor = rqstp->rq_cred.cr_flavor;
847 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
848 rqstp->rq_xprt->xpt_remotelen);
850 TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc",
851 __entry->cl_boot, __entry->cl_id,
852 show_nfsd_authflavor(__entry->cl_flavor),
853 show_nfsd_authflavor(__entry->new_flavor),
858 TRACE_EVENT(nfsd_clid_verf_mismatch,
860 const struct nfs4_client *clp,
861 const struct svc_rqst *rqstp,
862 const nfs4_verifier *verf
864 TP_ARGS(clp, rqstp, verf),
866 __field(u32, cl_boot)
868 __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE)
869 __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE)
870 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
873 __entry->cl_boot = clp->cl_clientid.cl_boot;
874 __entry->cl_id = clp->cl_clientid.cl_id;
875 memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier,
877 memcpy(__entry->new_verifier, (void *)verf,
879 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
880 rqstp->rq_xprt->xpt_remotelen);
882 TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc",
883 __entry->cl_boot, __entry->cl_id,
884 __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE),
885 __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE),
890 DECLARE_EVENT_CLASS(nfsd_clid_class,
891 TP_PROTO(const struct nfs4_client *clp),
894 __field(u32, cl_boot)
896 __array(unsigned char, addr, sizeof(struct sockaddr_in6))
897 __field(unsigned long, flavor)
898 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
899 __string_len(name, clp->cl_name.data, clp->cl_name.len)
902 __entry->cl_boot = clp->cl_clientid.cl_boot;
903 __entry->cl_id = clp->cl_clientid.cl_id;
904 memcpy(__entry->addr, &clp->cl_addr,
905 sizeof(struct sockaddr_in6));
906 __entry->flavor = clp->cl_cred.cr_flavor;
907 memcpy(__entry->verifier, (void *)&clp->cl_verifier,
909 __assign_str(name, clp->cl_name.data);
911 TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x",
912 __entry->addr, __get_str(name),
913 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE),
914 show_nfsd_authflavor(__entry->flavor),
915 __entry->cl_boot, __entry->cl_id)
918 #define DEFINE_CLID_EVENT(name) \
919 DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \
920 TP_PROTO(const struct nfs4_client *clp), \
923 DEFINE_CLID_EVENT(fresh);
924 DEFINE_CLID_EVENT(confirmed_r);
927 * from fs/nfsd/filecache.h
929 #define show_nf_flags(val) \
930 __print_flags(val, "|", \
931 { 1 << NFSD_FILE_HASHED, "HASHED" }, \
932 { 1 << NFSD_FILE_PENDING, "PENDING" }, \
933 { 1 << NFSD_FILE_REFERENCED, "REFERENCED" }, \
934 { 1 << NFSD_FILE_GC, "GC" })
936 DECLARE_EVENT_CLASS(nfsd_file_class,
937 TP_PROTO(struct nfsd_file *nf),
940 __field(void *, nf_inode)
942 __field(unsigned long, nf_flags)
943 __field(unsigned char, nf_may)
944 __field(struct file *, nf_file)
947 __entry->nf_inode = nf->nf_inode;
948 __entry->nf_ref = refcount_read(&nf->nf_ref);
949 __entry->nf_flags = nf->nf_flags;
950 __entry->nf_may = nf->nf_may;
951 __entry->nf_file = nf->nf_file;
953 TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p",
956 show_nf_flags(__entry->nf_flags),
957 show_nfsd_may_flags(__entry->nf_may),
961 #define DEFINE_NFSD_FILE_EVENT(name) \
962 DEFINE_EVENT(nfsd_file_class, name, \
963 TP_PROTO(struct nfsd_file *nf), \
966 DEFINE_NFSD_FILE_EVENT(nfsd_file_free);
967 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash);
968 DEFINE_NFSD_FILE_EVENT(nfsd_file_put);
969 DEFINE_NFSD_FILE_EVENT(nfsd_file_closing);
970 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue);
972 TRACE_EVENT(nfsd_file_alloc,
974 const struct nfsd_file *nf
978 __field(const void *, nf_inode)
979 __field(unsigned long, nf_flags)
980 __field(unsigned long, nf_may)
981 __field(unsigned int, nf_ref)
984 __entry->nf_inode = nf->nf_inode;
985 __entry->nf_flags = nf->nf_flags;
986 __entry->nf_ref = refcount_read(&nf->nf_ref);
987 __entry->nf_may = nf->nf_may;
989 TP_printk("inode=%p ref=%u flags=%s may=%s",
990 __entry->nf_inode, __entry->nf_ref,
991 show_nf_flags(__entry->nf_flags),
992 show_nfsd_may_flags(__entry->nf_may)
996 TRACE_EVENT(nfsd_file_acquire,
998 const struct svc_rqst *rqstp,
999 const struct inode *inode,
1000 unsigned int may_flags,
1001 const struct nfsd_file *nf,
1005 TP_ARGS(rqstp, inode, may_flags, nf, status),
1009 __field(const void *, inode)
1010 __field(unsigned long, may_flags)
1011 __field(unsigned int, nf_ref)
1012 __field(unsigned long, nf_flags)
1013 __field(unsigned long, nf_may)
1014 __field(const void *, nf_file)
1015 __field(u32, status)
1019 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1020 __entry->inode = inode;
1021 __entry->may_flags = may_flags;
1022 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0;
1023 __entry->nf_flags = nf ? nf->nf_flags : 0;
1024 __entry->nf_may = nf ? nf->nf_may : 0;
1025 __entry->nf_file = nf ? nf->nf_file : NULL;
1026 __entry->status = be32_to_cpu(status);
1029 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u",
1030 __entry->xid, __entry->inode,
1031 show_nfsd_may_flags(__entry->may_flags),
1032 __entry->nf_ref, show_nf_flags(__entry->nf_flags),
1033 show_nfsd_may_flags(__entry->nf_may),
1034 __entry->nf_file, __entry->status
1038 TRACE_EVENT(nfsd_file_insert_err,
1040 const struct svc_rqst *rqstp,
1041 const struct inode *inode,
1042 unsigned int may_flags,
1045 TP_ARGS(rqstp, inode, may_flags, error),
1048 __field(const void *, inode)
1049 __field(unsigned long, may_flags)
1050 __field(long, error)
1053 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1054 __entry->inode = inode;
1055 __entry->may_flags = may_flags;
1056 __entry->error = error;
1058 TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld",
1059 __entry->xid, __entry->inode,
1060 show_nfsd_may_flags(__entry->may_flags),
1065 TRACE_EVENT(nfsd_file_cons_err,
1067 const struct svc_rqst *rqstp,
1068 const struct inode *inode,
1069 unsigned int may_flags,
1070 const struct nfsd_file *nf
1072 TP_ARGS(rqstp, inode, may_flags, nf),
1075 __field(const void *, inode)
1076 __field(unsigned long, may_flags)
1077 __field(unsigned int, nf_ref)
1078 __field(unsigned long, nf_flags)
1079 __field(unsigned long, nf_may)
1080 __field(const void *, nf_file)
1083 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1084 __entry->inode = inode;
1085 __entry->may_flags = may_flags;
1086 __entry->nf_ref = refcount_read(&nf->nf_ref);
1087 __entry->nf_flags = nf->nf_flags;
1088 __entry->nf_may = nf->nf_may;
1089 __entry->nf_file = nf->nf_file;
1091 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p",
1092 __entry->xid, __entry->inode,
1093 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref,
1094 show_nf_flags(__entry->nf_flags),
1095 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file
1099 DECLARE_EVENT_CLASS(nfsd_file_open_class,
1100 TP_PROTO(const struct nfsd_file *nf, __be32 status),
1101 TP_ARGS(nf, status),
1103 __field(void *, nf_inode) /* cannot be dereferenced */
1104 __field(int, nf_ref)
1105 __field(unsigned long, nf_flags)
1106 __field(unsigned long, nf_may)
1107 __field(void *, nf_file) /* cannot be dereferenced */
1110 __entry->nf_inode = nf->nf_inode;
1111 __entry->nf_ref = refcount_read(&nf->nf_ref);
1112 __entry->nf_flags = nf->nf_flags;
1113 __entry->nf_may = nf->nf_may;
1114 __entry->nf_file = nf->nf_file;
1116 TP_printk("inode=%p ref=%d flags=%s may=%s file=%p",
1119 show_nf_flags(__entry->nf_flags),
1120 show_nfsd_may_flags(__entry->nf_may),
1124 #define DEFINE_NFSD_FILE_OPEN_EVENT(name) \
1125 DEFINE_EVENT(nfsd_file_open_class, name, \
1127 const struct nfsd_file *nf, \
1130 TP_ARGS(nf, status))
1132 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open);
1133 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened);
1135 TRACE_EVENT(nfsd_file_is_cached,
1137 const struct inode *inode,
1140 TP_ARGS(inode, found),
1142 __field(const struct inode *, inode)
1146 __entry->inode = inode;
1147 __entry->found = found;
1149 TP_printk("inode=%p is %scached",
1151 __entry->found ? "" : "not "
1155 TRACE_EVENT(nfsd_file_fsnotify_handle_event,
1156 TP_PROTO(struct inode *inode, u32 mask),
1157 TP_ARGS(inode, mask),
1159 __field(struct inode *, inode)
1160 __field(unsigned int, nlink)
1161 __field(umode_t, mode)
1165 __entry->inode = inode;
1166 __entry->nlink = inode->i_nlink;
1167 __entry->mode = inode->i_mode;
1168 __entry->mask = mask;
1170 TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode,
1171 __entry->nlink, __entry->mode, __entry->mask)
1174 DECLARE_EVENT_CLASS(nfsd_file_gc_class,
1176 const struct nfsd_file *nf
1180 __field(void *, nf_inode)
1181 __field(void *, nf_file)
1182 __field(int, nf_ref)
1183 __field(unsigned long, nf_flags)
1186 __entry->nf_inode = nf->nf_inode;
1187 __entry->nf_file = nf->nf_file;
1188 __entry->nf_ref = refcount_read(&nf->nf_ref);
1189 __entry->nf_flags = nf->nf_flags;
1191 TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p",
1192 __entry->nf_inode, __entry->nf_ref,
1193 show_nf_flags(__entry->nf_flags),
1198 #define DEFINE_NFSD_FILE_GC_EVENT(name) \
1199 DEFINE_EVENT(nfsd_file_gc_class, name, \
1201 const struct nfsd_file *nf \
1205 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add);
1206 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed);
1207 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del);
1208 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed);
1209 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use);
1210 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback);
1211 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced);
1212 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed);
1214 DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class,
1216 unsigned long removed,
1217 unsigned long remaining
1219 TP_ARGS(removed, remaining),
1221 __field(unsigned long, removed)
1222 __field(unsigned long, remaining)
1225 __entry->removed = removed;
1226 __entry->remaining = remaining;
1228 TP_printk("%lu entries removed, %lu remaining",
1229 __entry->removed, __entry->remaining)
1232 #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \
1233 DEFINE_EVENT(nfsd_file_lruwalk_class, name, \
1235 unsigned long removed, \
1236 unsigned long remaining \
1238 TP_ARGS(removed, remaining))
1240 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed);
1241 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed);
1243 TRACE_EVENT(nfsd_file_close,
1245 const struct inode *inode
1249 __field(const void *, inode)
1252 __entry->inode = inode;
1254 TP_printk("inode=%p",
1261 TRACE_DEFINE_ENUM(RC_DROPIT);
1262 TRACE_DEFINE_ENUM(RC_REPLY);
1263 TRACE_DEFINE_ENUM(RC_DOIT);
1265 #define show_drc_retval(x) \
1266 __print_symbolic(x, \
1267 { RC_DROPIT, "DROPIT" }, \
1268 { RC_REPLY, "REPLY" }, \
1269 { RC_DOIT, "DOIT" })
1271 TRACE_EVENT(nfsd_drc_found,
1273 const struct nfsd_net *nn,
1274 const struct svc_rqst *rqstp,
1277 TP_ARGS(nn, rqstp, result),
1279 __field(unsigned long long, boot_time)
1280 __field(unsigned long, result)
1284 __entry->boot_time = nn->boot_time;
1285 __entry->result = result;
1286 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1288 TP_printk("boot_time=%16llx xid=0x%08x result=%s",
1289 __entry->boot_time, __entry->xid,
1290 show_drc_retval(__entry->result))
1294 TRACE_EVENT(nfsd_drc_mismatch,
1296 const struct nfsd_net *nn,
1297 const struct nfsd_cacherep *key,
1298 const struct nfsd_cacherep *rp
1300 TP_ARGS(nn, key, rp),
1302 __field(unsigned long long, boot_time)
1304 __field(u32, cached)
1305 __field(u32, ingress)
1308 __entry->boot_time = nn->boot_time;
1309 __entry->xid = be32_to_cpu(key->c_key.k_xid);
1310 __entry->cached = (__force u32)key->c_key.k_csum;
1311 __entry->ingress = (__force u32)rp->c_key.k_csum;
1313 TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x",
1314 __entry->boot_time, __entry->xid, __entry->cached,
1318 TRACE_EVENT(nfsd_cb_args,
1320 const struct nfs4_client *clp,
1321 const struct nfs4_cb_conn *conn
1325 __field(u32, cl_boot)
1329 __sockaddr(addr, conn->cb_addrlen)
1332 __entry->cl_boot = clp->cl_clientid.cl_boot;
1333 __entry->cl_id = clp->cl_clientid.cl_id;
1334 __entry->prog = conn->cb_prog;
1335 __entry->ident = conn->cb_ident;
1336 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen);
1338 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u",
1339 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1340 __entry->prog, __entry->ident)
1343 TRACE_EVENT(nfsd_cb_nodelegs,
1344 TP_PROTO(const struct nfs4_client *clp),
1347 __field(u32, cl_boot)
1351 __entry->cl_boot = clp->cl_clientid.cl_boot;
1352 __entry->cl_id = clp->cl_clientid.cl_id;
1354 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
1357 #define show_cb_state(val) \
1358 __print_symbolic(val, \
1359 { NFSD4_CB_UP, "UP" }, \
1360 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \
1361 { NFSD4_CB_DOWN, "DOWN" }, \
1362 { NFSD4_CB_FAULT, "FAULT"})
1364 DECLARE_EVENT_CLASS(nfsd_cb_class,
1365 TP_PROTO(const struct nfs4_client *clp),
1368 __field(unsigned long, state)
1369 __field(u32, cl_boot)
1371 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1374 __entry->state = clp->cl_cb_state;
1375 __entry->cl_boot = clp->cl_clientid.cl_boot;
1376 __entry->cl_id = clp->cl_clientid.cl_id;
1377 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1378 clp->cl_cb_conn.cb_addrlen)
1380 TP_printk("addr=%pISpc client %08x:%08x state=%s",
1381 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1382 show_cb_state(__entry->state))
1385 #define DEFINE_NFSD_CB_EVENT(name) \
1386 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \
1387 TP_PROTO(const struct nfs4_client *clp), \
1390 DEFINE_NFSD_CB_EVENT(start);
1391 DEFINE_NFSD_CB_EVENT(new_state);
1392 DEFINE_NFSD_CB_EVENT(probe);
1393 DEFINE_NFSD_CB_EVENT(lost);
1394 DEFINE_NFSD_CB_EVENT(shutdown);
1396 TRACE_DEFINE_ENUM(RPC_AUTH_NULL);
1397 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX);
1398 TRACE_DEFINE_ENUM(RPC_AUTH_GSS);
1399 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5);
1400 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I);
1401 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P);
1403 #define show_nfsd_authflavor(val) \
1404 __print_symbolic(val, \
1405 { RPC_AUTH_NULL, "none" }, \
1406 { RPC_AUTH_UNIX, "sys" }, \
1407 { RPC_AUTH_GSS, "gss" }, \
1408 { RPC_AUTH_GSS_KRB5, "krb5" }, \
1409 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \
1410 { RPC_AUTH_GSS_KRB5P, "krb5p" })
1412 TRACE_EVENT(nfsd_cb_setup,
1413 TP_PROTO(const struct nfs4_client *clp,
1415 rpc_authflavor_t authflavor
1417 TP_ARGS(clp, netid, authflavor),
1419 __field(u32, cl_boot)
1421 __field(unsigned long, authflavor)
1422 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1423 __string(netid, netid)
1426 __entry->cl_boot = clp->cl_clientid.cl_boot;
1427 __entry->cl_id = clp->cl_clientid.cl_id;
1428 __assign_str(netid, netid);
1429 __entry->authflavor = authflavor;
1430 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1431 clp->cl_cb_conn.cb_addrlen)
1433 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s",
1434 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1435 __get_str(netid), show_nfsd_authflavor(__entry->authflavor))
1438 TRACE_EVENT(nfsd_cb_setup_err,
1440 const struct nfs4_client *clp,
1443 TP_ARGS(clp, error),
1445 __field(long, error)
1446 __field(u32, cl_boot)
1448 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1451 __entry->error = error;
1452 __entry->cl_boot = clp->cl_clientid.cl_boot;
1453 __entry->cl_id = clp->cl_clientid.cl_id;
1454 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1455 clp->cl_cb_conn.cb_addrlen)
1457 TP_printk("addr=%pISpc client %08x:%08x error=%ld",
1458 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1462 DECLARE_EVENT_CLASS(nfsd_cb_lifetime_class,
1464 const struct nfs4_client *clp,
1465 const struct nfsd4_callback *cb
1469 __field(u32, cl_boot)
1471 __field(const void *, cb)
1472 __field(bool, need_restart)
1473 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1476 __entry->cl_boot = clp->cl_clientid.cl_boot;
1477 __entry->cl_id = clp->cl_clientid.cl_id;
1479 __entry->need_restart = cb->cb_need_restart;
1480 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1481 clp->cl_cb_conn.cb_addrlen)
1483 TP_printk("addr=%pISpc client %08x:%08x cb=%p%s",
1484 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1485 __entry->cb, __entry->need_restart ?
1486 " (need restart)" : " (first try)"
1490 #define DEFINE_NFSD_CB_LIFETIME_EVENT(name) \
1491 DEFINE_EVENT(nfsd_cb_lifetime_class, nfsd_cb_##name, \
1493 const struct nfs4_client *clp, \
1494 const struct nfsd4_callback *cb \
1498 DEFINE_NFSD_CB_LIFETIME_EVENT(queue);
1499 DEFINE_NFSD_CB_LIFETIME_EVENT(destroy);
1500 DEFINE_NFSD_CB_LIFETIME_EVENT(restart);
1501 DEFINE_NFSD_CB_LIFETIME_EVENT(bc_update);
1502 DEFINE_NFSD_CB_LIFETIME_EVENT(bc_shutdown);
1504 TRACE_EVENT(nfsd_cb_seq_status,
1506 const struct rpc_task *task,
1507 const struct nfsd4_callback *cb
1511 __field(unsigned int, task_id)
1512 __field(unsigned int, client_id)
1513 __field(u32, cl_boot)
1516 __field(u32, reserved)
1517 __field(int, tk_status)
1518 __field(int, seq_status)
1521 const struct nfs4_client *clp = cb->cb_clp;
1522 const struct nfsd4_session *session = clp->cl_cb_session;
1523 const struct nfsd4_sessionid *sid =
1524 (struct nfsd4_sessionid *)&session->se_sessionid;
1526 __entry->task_id = task->tk_pid;
1527 __entry->client_id = task->tk_client ?
1528 task->tk_client->cl_clid : -1;
1529 __entry->cl_boot = sid->clientid.cl_boot;
1530 __entry->cl_id = sid->clientid.cl_id;
1531 __entry->seqno = sid->sequence;
1532 __entry->reserved = sid->reserved;
1533 __entry->tk_status = task->tk_status;
1534 __entry->seq_status = cb->cb_seq_status;
1536 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1537 " sessionid=%08x:%08x:%08x:%08x tk_status=%d seq_status=%d\n",
1538 __entry->task_id, __entry->client_id,
1539 __entry->cl_boot, __entry->cl_id,
1540 __entry->seqno, __entry->reserved,
1541 __entry->tk_status, __entry->seq_status
1545 TRACE_EVENT(nfsd_cb_free_slot,
1547 const struct rpc_task *task,
1548 const struct nfsd4_callback *cb
1552 __field(unsigned int, task_id)
1553 __field(unsigned int, client_id)
1554 __field(u32, cl_boot)
1557 __field(u32, reserved)
1558 __field(u32, slot_seqno)
1561 const struct nfs4_client *clp = cb->cb_clp;
1562 const struct nfsd4_session *session = clp->cl_cb_session;
1563 const struct nfsd4_sessionid *sid =
1564 (struct nfsd4_sessionid *)&session->se_sessionid;
1566 __entry->task_id = task->tk_pid;
1567 __entry->client_id = task->tk_client ?
1568 task->tk_client->cl_clid : -1;
1569 __entry->cl_boot = sid->clientid.cl_boot;
1570 __entry->cl_id = sid->clientid.cl_id;
1571 __entry->seqno = sid->sequence;
1572 __entry->reserved = sid->reserved;
1573 __entry->slot_seqno = session->se_cb_seq_nr;
1575 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1576 " sessionid=%08x:%08x:%08x:%08x new slot seqno=%u\n",
1577 __entry->task_id, __entry->client_id,
1578 __entry->cl_boot, __entry->cl_id,
1579 __entry->seqno, __entry->reserved,
1584 TRACE_EVENT_CONDITION(nfsd_cb_recall,
1586 const struct nfs4_stid *stid
1589 TP_CONDITION(stid->sc_client),
1591 __field(u32, cl_boot)
1594 __field(u32, si_generation)
1595 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen)
1598 const stateid_t *stp = &stid->sc_stateid;
1599 const struct nfs4_client *clp = stid->sc_client;
1601 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1602 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1603 __entry->si_id = stp->si_opaque.so_id;
1604 __entry->si_generation = stp->si_generation;
1605 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1606 clp->cl_cb_conn.cb_addrlen)
1608 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x",
1609 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1610 __entry->si_id, __entry->si_generation)
1613 TRACE_EVENT(nfsd_cb_notify_lock,
1615 const struct nfs4_lockowner *lo,
1616 const struct nfsd4_blocked_lock *nbl
1620 __field(u32, cl_boot)
1622 __field(u32, fh_hash)
1623 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen)
1626 const struct nfs4_client *clp = lo->lo_owner.so_client;
1628 __entry->cl_boot = clp->cl_clientid.cl_boot;
1629 __entry->cl_id = clp->cl_clientid.cl_id;
1630 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh);
1631 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1632 clp->cl_cb_conn.cb_addrlen)
1634 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x",
1635 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1639 TRACE_EVENT(nfsd_cb_offload,
1641 const struct nfs4_client *clp,
1642 const stateid_t *stp,
1643 const struct knfsd_fh *fh,
1647 TP_ARGS(clp, stp, fh, count, status),
1649 __field(u32, cl_boot)
1652 __field(u32, si_generation)
1653 __field(u32, fh_hash)
1654 __field(int, status)
1656 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1659 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1660 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1661 __entry->si_id = stp->si_opaque.so_id;
1662 __entry->si_generation = stp->si_generation;
1663 __entry->fh_hash = knfsd_fh_hash(fh);
1664 __entry->status = be32_to_cpu(status);
1665 __entry->count = count;
1666 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1667 clp->cl_cb_conn.cb_addrlen)
1669 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d",
1670 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1671 __entry->si_id, __entry->si_generation,
1672 __entry->fh_hash, __entry->count, __entry->status)
1675 TRACE_EVENT(nfsd_cb_recall_any,
1677 const struct nfsd4_cb_recall_any *ra
1681 __field(u32, cl_boot)
1684 __field(unsigned long, bmval0)
1685 __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen)
1688 __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot;
1689 __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id;
1690 __entry->keep = ra->ra_keep;
1691 __entry->bmval0 = ra->ra_bmval[0];
1692 __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr,
1693 ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen);
1695 TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s",
1696 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1697 __entry->keep, show_rca_mask(__entry->bmval0)
1701 DECLARE_EVENT_CLASS(nfsd_cb_done_class,
1703 const stateid_t *stp,
1704 const struct rpc_task *task
1708 __field(u32, cl_boot)
1711 __field(u32, si_generation)
1712 __field(int, status)
1715 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1716 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1717 __entry->si_id = stp->si_opaque.so_id;
1718 __entry->si_generation = stp->si_generation;
1719 __entry->status = task->tk_status;
1721 TP_printk("client %08x:%08x stateid %08x:%08x status=%d",
1722 __entry->cl_boot, __entry->cl_id, __entry->si_id,
1723 __entry->si_generation, __entry->status
1727 #define DEFINE_NFSD_CB_DONE_EVENT(name) \
1728 DEFINE_EVENT(nfsd_cb_done_class, name, \
1730 const stateid_t *stp, \
1731 const struct rpc_task *task \
1735 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done);
1736 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done);
1737 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done);
1738 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done);
1740 TRACE_EVENT(nfsd_cb_recall_any_done,
1742 const struct nfsd4_callback *cb,
1743 const struct rpc_task *task
1747 __field(u32, cl_boot)
1749 __field(int, status)
1752 __entry->status = task->tk_status;
1753 __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot;
1754 __entry->cl_id = cb->cb_clp->cl_clientid.cl_id;
1756 TP_printk("client %08x:%08x status=%d",
1757 __entry->cl_boot, __entry->cl_id, __entry->status
1761 TRACE_EVENT(nfsd_ctl_unlock_ip,
1763 const struct net *net,
1766 TP_ARGS(net, address),
1768 __field(unsigned int, netns_ino)
1769 __string(address, address)
1772 __entry->netns_ino = net->ns.inum;
1773 __assign_str(address, address);
1775 TP_printk("address=%s",
1780 TRACE_EVENT(nfsd_ctl_unlock_fs,
1782 const struct net *net,
1787 __field(unsigned int, netns_ino)
1788 __string(path, path)
1791 __entry->netns_ino = net->ns.inum;
1792 __assign_str(path, path);
1794 TP_printk("path=%s",
1799 TRACE_EVENT(nfsd_ctl_filehandle,
1801 const struct net *net,
1806 TP_ARGS(net, domain, path, maxsize),
1808 __field(unsigned int, netns_ino)
1809 __field(int, maxsize)
1810 __string(domain, domain)
1811 __string(path, path)
1814 __entry->netns_ino = net->ns.inum;
1815 __entry->maxsize = maxsize;
1816 __assign_str(domain, domain);
1817 __assign_str(path, path);
1819 TP_printk("domain=%s path=%s maxsize=%d",
1820 __get_str(domain), __get_str(path), __entry->maxsize
1824 TRACE_EVENT(nfsd_ctl_threads,
1826 const struct net *net,
1829 TP_ARGS(net, newthreads),
1831 __field(unsigned int, netns_ino)
1832 __field(int, newthreads)
1835 __entry->netns_ino = net->ns.inum;
1836 __entry->newthreads = newthreads;
1838 TP_printk("newthreads=%d",
1843 TRACE_EVENT(nfsd_ctl_pool_threads,
1845 const struct net *net,
1849 TP_ARGS(net, pool, nrthreads),
1851 __field(unsigned int, netns_ino)
1853 __field(int, nrthreads)
1856 __entry->netns_ino = net->ns.inum;
1857 __entry->pool = pool;
1858 __entry->nrthreads = nrthreads;
1860 TP_printk("pool=%d nrthreads=%d",
1861 __entry->pool, __entry->nrthreads
1865 TRACE_EVENT(nfsd_ctl_version,
1867 const struct net *net,
1872 __field(unsigned int, netns_ino)
1873 __string(mesg, mesg)
1876 __entry->netns_ino = net->ns.inum;
1877 __assign_str(mesg, mesg);
1884 TRACE_EVENT(nfsd_ctl_ports_addfd,
1886 const struct net *net,
1891 __field(unsigned int, netns_ino)
1895 __entry->netns_ino = net->ns.inum;
1903 TRACE_EVENT(nfsd_ctl_ports_addxprt,
1905 const struct net *net,
1906 const char *transport,
1909 TP_ARGS(net, transport, port),
1911 __field(unsigned int, netns_ino)
1913 __string(transport, transport)
1916 __entry->netns_ino = net->ns.inum;
1917 __entry->port = port;
1918 __assign_str(transport, transport);
1920 TP_printk("transport=%s port=%d",
1921 __get_str(transport), __entry->port
1925 TRACE_EVENT(nfsd_ctl_maxblksize,
1927 const struct net *net,
1930 TP_ARGS(net, bsize),
1932 __field(unsigned int, netns_ino)
1936 __entry->netns_ino = net->ns.inum;
1937 __entry->bsize = bsize;
1939 TP_printk("bsize=%d",
1944 TRACE_EVENT(nfsd_ctl_maxconn,
1946 const struct net *net,
1949 TP_ARGS(net, maxconn),
1951 __field(unsigned int, netns_ino)
1952 __field(int, maxconn)
1955 __entry->netns_ino = net->ns.inum;
1956 __entry->maxconn = maxconn;
1958 TP_printk("maxconn=%d",
1963 TRACE_EVENT(nfsd_ctl_time,
1965 const struct net *net,
1970 TP_ARGS(net, name, namelen, time),
1972 __field(unsigned int, netns_ino)
1974 __string_len(name, name, namelen)
1977 __entry->netns_ino = net->ns.inum;
1978 __entry->time = time;
1979 __assign_str(name, name);
1981 TP_printk("file=%s time=%d\n",
1982 __get_str(name), __entry->time
1986 TRACE_EVENT(nfsd_ctl_recoverydir,
1988 const struct net *net,
1991 TP_ARGS(net, recdir),
1993 __field(unsigned int, netns_ino)
1994 __string(recdir, recdir)
1997 __entry->netns_ino = net->ns.inum;
1998 __assign_str(recdir, recdir);
2000 TP_printk("recdir=%s",
2005 TRACE_EVENT(nfsd_end_grace,
2007 const struct net *net
2011 __field(unsigned int, netns_ino)
2014 __entry->netns_ino = net->ns.inum;
2016 TP_printk("nn=%d", __entry->netns_ino
2020 DECLARE_EVENT_CLASS(nfsd_copy_class,
2022 const struct nfsd4_copy *copy
2026 __field(bool, intra)
2027 __field(bool, async)
2028 __field(u32, src_cl_boot)
2029 __field(u32, src_cl_id)
2030 __field(u32, src_so_id)
2031 __field(u32, src_si_generation)
2032 __field(u32, dst_cl_boot)
2033 __field(u32, dst_cl_id)
2034 __field(u32, dst_so_id)
2035 __field(u32, dst_si_generation)
2036 __field(u64, src_cp_pos)
2037 __field(u64, dst_cp_pos)
2038 __field(u64, cp_count)
2039 __sockaddr(addr, sizeof(struct sockaddr_in6))
2042 const stateid_t *src_stp = ©->cp_src_stateid;
2043 const stateid_t *dst_stp = ©->cp_dst_stateid;
2045 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags);
2046 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags);
2047 __entry->src_cl_boot = src_stp->si_opaque.so_clid.cl_boot;
2048 __entry->src_cl_id = src_stp->si_opaque.so_clid.cl_id;
2049 __entry->src_so_id = src_stp->si_opaque.so_id;
2050 __entry->src_si_generation = src_stp->si_generation;
2051 __entry->dst_cl_boot = dst_stp->si_opaque.so_clid.cl_boot;
2052 __entry->dst_cl_id = dst_stp->si_opaque.so_clid.cl_id;
2053 __entry->dst_so_id = dst_stp->si_opaque.so_id;
2054 __entry->dst_si_generation = dst_stp->si_generation;
2055 __entry->src_cp_pos = copy->cp_src_pos;
2056 __entry->dst_cp_pos = copy->cp_dst_pos;
2057 __entry->cp_count = copy->cp_count;
2058 __assign_sockaddr(addr, ©->cp_clp->cl_addr,
2059 sizeof(struct sockaddr_in6));
2061 TP_printk("client=%pISpc intra=%d async=%d "
2062 "src_stateid[si_generation:0x%x cl_boot:0x%x cl_id:0x%x so_id:0x%x] "
2063 "dst_stateid[si_generation:0x%x cl_boot:0x%x cl_id:0x%x so_id:0x%x] "
2064 "cp_src_pos=%llu cp_dst_pos=%llu cp_count=%llu",
2065 __get_sockaddr(addr), __entry->intra, __entry->async,
2066 __entry->src_si_generation, __entry->src_cl_boot,
2067 __entry->src_cl_id, __entry->src_so_id,
2068 __entry->dst_si_generation, __entry->dst_cl_boot,
2069 __entry->dst_cl_id, __entry->dst_so_id,
2070 __entry->src_cp_pos, __entry->dst_cp_pos, __entry->cp_count
2074 #define DEFINE_COPY_EVENT(name) \
2075 DEFINE_EVENT(nfsd_copy_class, nfsd_copy_##name, \
2076 TP_PROTO(const struct nfsd4_copy *copy), \
2079 DEFINE_COPY_EVENT(inter);
2080 DEFINE_COPY_EVENT(intra);
2081 DEFINE_COPY_EVENT(do_async);
2083 TRACE_EVENT(nfsd_copy_done,
2085 const struct nfsd4_copy *copy,
2088 TP_ARGS(copy, status),
2090 __field(int, status)
2091 __field(bool, intra)
2092 __field(bool, async)
2093 __sockaddr(addr, sizeof(struct sockaddr_in6))
2096 __entry->status = be32_to_cpu(status);
2097 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags);
2098 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags);
2099 __assign_sockaddr(addr, ©->cp_clp->cl_addr,
2100 sizeof(struct sockaddr_in6));
2102 TP_printk("addr=%pISpc status=%d intra=%d async=%d ",
2103 __get_sockaddr(addr), __entry->status, __entry->intra, __entry->async
2107 #endif /* _NFSD_TRACE_H */
2109 #undef TRACE_INCLUDE_PATH
2110 #define TRACE_INCLUDE_PATH .
2111 #define TRACE_INCLUDE_FILE trace
2112 #include <trace/define_trace.h>