1b2441318SGreg Kroah-Hartman /* SPDX-License-Identifier: GPL-2.0 */ 231ef83dcSChristoph Hellwig /* 331ef83dcSChristoph Hellwig * Copyright (c) 2014 Christoph Hellwig. 431ef83dcSChristoph Hellwig */ 531ef83dcSChristoph Hellwig #undef TRACE_SYSTEM 631ef83dcSChristoph Hellwig #define TRACE_SYSTEM nfsd 731ef83dcSChristoph Hellwig 831ef83dcSChristoph Hellwig #if !defined(_NFSD_TRACE_H) || defined(TRACE_HEADER_MULTI_READ) 931ef83dcSChristoph Hellwig #define _NFSD_TRACE_H 1031ef83dcSChristoph Hellwig 1131ef83dcSChristoph Hellwig #include <linux/tracepoint.h> 12638593beSDai Ngo #include <linux/sunrpc/xprt.h> 13638593beSDai Ngo #include <trace/misc/nfs.h> 148791545eSChuck Lever 15cf749f3cSTrond Myklebust #include "export.h" 166e8b50d1SJeff Layton #include "nfsfh.h" 17638593beSDai Ngo #include "xdr4.h" 186e8b50d1SJeff Layton 1908281341SChuck Lever #define NFSD_TRACE_PROC_RES_FIELDS \ 2008281341SChuck Lever __field(unsigned int, netns_ino) \ 2108281341SChuck Lever __field(u32, xid) \ 2208281341SChuck Lever __field(unsigned long, status) \ 2308281341SChuck Lever __array(unsigned char, server, sizeof(struct sockaddr_in6)) \ 2408281341SChuck Lever __array(unsigned char, client, sizeof(struct sockaddr_in6)) 2508281341SChuck Lever 2608281341SChuck Lever #define NFSD_TRACE_PROC_RES_ASSIGNMENTS(error) \ 2708281341SChuck Lever do { \ 2808281341SChuck Lever __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \ 2908281341SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); \ 3008281341SChuck Lever __entry->status = be32_to_cpu(error); \ 3108281341SChuck Lever memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \ 3208281341SChuck Lever rqstp->rq_xprt->xpt_locallen); \ 3308281341SChuck Lever memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \ 3408281341SChuck Lever rqstp->rq_xprt->xpt_remotelen); \ 3508281341SChuck Lever } while (0); 3608281341SChuck Lever 3770e94d75SChuck Lever DECLARE_EVENT_CLASS(nfsd_xdr_err_class, 380dfdad1cSChuck Lever TP_PROTO( 390dfdad1cSChuck Lever const struct svc_rqst *rqstp 400dfdad1cSChuck Lever ), 410dfdad1cSChuck Lever TP_ARGS(rqstp), 420dfdad1cSChuck Lever TP_STRUCT__entry( 43c1a3f2ceSChuck Lever __field(unsigned int, netns_ino) 44c1a3f2ceSChuck Lever __field(u32, xid) 450dfdad1cSChuck Lever __field(u32, vers) 460dfdad1cSChuck Lever __field(u32, proc) 47c1a3f2ceSChuck Lever __sockaddr(server, rqstp->rq_xprt->xpt_locallen) 48c1a3f2ceSChuck Lever __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 490dfdad1cSChuck Lever ), 500dfdad1cSChuck Lever TP_fast_assign( 51c1a3f2ceSChuck Lever const struct svc_xprt *xprt = rqstp->rq_xprt; 520dfdad1cSChuck Lever 53c1a3f2ceSChuck Lever __entry->netns_ino = xprt->xpt_net->ns.inum; 54c1a3f2ceSChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 550dfdad1cSChuck Lever __entry->vers = rqstp->rq_vers; 560dfdad1cSChuck Lever __entry->proc = rqstp->rq_proc; 57c1a3f2ceSChuck Lever __assign_sockaddr(server, &xprt->xpt_local, xprt->xpt_locallen); 58c1a3f2ceSChuck Lever __assign_sockaddr(client, &xprt->xpt_remote, xprt->xpt_remotelen); 590dfdad1cSChuck Lever ), 600dfdad1cSChuck Lever TP_printk("xid=0x%08x vers=%u proc=%u", 610dfdad1cSChuck Lever __entry->xid, __entry->vers, __entry->proc 620dfdad1cSChuck Lever ) 630dfdad1cSChuck Lever ); 640dfdad1cSChuck Lever 6570e94d75SChuck Lever #define DEFINE_NFSD_XDR_ERR_EVENT(name) \ 6670e94d75SChuck Lever DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \ 6770e94d75SChuck Lever TP_PROTO(const struct svc_rqst *rqstp), \ 6870e94d75SChuck Lever TP_ARGS(rqstp)) 690dfdad1cSChuck Lever 7070e94d75SChuck Lever DEFINE_NFSD_XDR_ERR_EVENT(garbage_args); 7170e94d75SChuck Lever DEFINE_NFSD_XDR_ERR_EVENT(cant_encode); 720dfdad1cSChuck Lever 73b76278aeSChuck Lever #define show_nfsd_may_flags(x) \ 74b76278aeSChuck Lever __print_flags(x, "|", \ 75b76278aeSChuck Lever { NFSD_MAY_EXEC, "EXEC" }, \ 76b76278aeSChuck Lever { NFSD_MAY_WRITE, "WRITE" }, \ 77b76278aeSChuck Lever { NFSD_MAY_READ, "READ" }, \ 78b76278aeSChuck Lever { NFSD_MAY_SATTR, "SATTR" }, \ 79b76278aeSChuck Lever { NFSD_MAY_TRUNC, "TRUNC" }, \ 80b76278aeSChuck Lever { NFSD_MAY_LOCK, "LOCK" }, \ 81b76278aeSChuck Lever { NFSD_MAY_OWNER_OVERRIDE, "OWNER_OVERRIDE" }, \ 82b76278aeSChuck Lever { NFSD_MAY_LOCAL_ACCESS, "LOCAL_ACCESS" }, \ 83b76278aeSChuck Lever { NFSD_MAY_BYPASS_GSS_ON_ROOT, "BYPASS_GSS_ON_ROOT" }, \ 84b76278aeSChuck Lever { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \ 85b76278aeSChuck Lever { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \ 86b76278aeSChuck Lever { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \ 87b76278aeSChuck Lever { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" }) 88b76278aeSChuck Lever 89fff4080bSChuck Lever TRACE_EVENT(nfsd_compound, 90de29cf7eSChuck Lever TP_PROTO( 91de29cf7eSChuck Lever const struct svc_rqst *rqst, 92de29cf7eSChuck Lever const char *tag, 93de29cf7eSChuck Lever u32 taglen, 94de29cf7eSChuck Lever u32 opcnt 95de29cf7eSChuck Lever ), 96de29cf7eSChuck Lever TP_ARGS(rqst, tag, taglen, opcnt), 97fff4080bSChuck Lever TP_STRUCT__entry( 98fff4080bSChuck Lever __field(u32, xid) 99de29cf7eSChuck Lever __field(u32, opcnt) 100de29cf7eSChuck Lever __string_len(tag, tag, taglen) 101fff4080bSChuck Lever ), 102fff4080bSChuck Lever TP_fast_assign( 103fff4080bSChuck Lever __entry->xid = be32_to_cpu(rqst->rq_xid); 104de29cf7eSChuck Lever __entry->opcnt = opcnt; 105de29cf7eSChuck Lever __assign_str_len(tag, tag, taglen); 106fff4080bSChuck Lever ), 107de29cf7eSChuck Lever TP_printk("xid=0x%08x opcnt=%u tag=%s", 108de29cf7eSChuck Lever __entry->xid, __entry->opcnt, __get_str(tag) 109de29cf7eSChuck Lever ) 110fff4080bSChuck Lever ) 111fff4080bSChuck Lever 112fff4080bSChuck Lever TRACE_EVENT(nfsd_compound_status, 113fff4080bSChuck Lever TP_PROTO(u32 args_opcnt, 114fff4080bSChuck Lever u32 resp_opcnt, 115fff4080bSChuck Lever __be32 status, 116fff4080bSChuck Lever const char *name), 117fff4080bSChuck Lever TP_ARGS(args_opcnt, resp_opcnt, status, name), 118fff4080bSChuck Lever TP_STRUCT__entry( 119fff4080bSChuck Lever __field(u32, args_opcnt) 120fff4080bSChuck Lever __field(u32, resp_opcnt) 121fff4080bSChuck Lever __field(int, status) 122fff4080bSChuck Lever __string(name, name) 123fff4080bSChuck Lever ), 124fff4080bSChuck Lever TP_fast_assign( 125fff4080bSChuck Lever __entry->args_opcnt = args_opcnt; 126fff4080bSChuck Lever __entry->resp_opcnt = resp_opcnt; 127fff4080bSChuck Lever __entry->status = be32_to_cpu(status); 128fff4080bSChuck Lever __assign_str(name, name); 129fff4080bSChuck Lever ), 130fff4080bSChuck Lever TP_printk("op=%u/%u %s status=%d", 131fff4080bSChuck Lever __entry->resp_opcnt, __entry->args_opcnt, 132fff4080bSChuck Lever __get_str(name), __entry->status) 133fff4080bSChuck Lever ) 134fff4080bSChuck Lever 13508281341SChuck Lever TRACE_EVENT(nfsd_compound_decode_err, 13608281341SChuck Lever TP_PROTO( 13708281341SChuck Lever const struct svc_rqst *rqstp, 13808281341SChuck Lever u32 args_opcnt, 13908281341SChuck Lever u32 resp_opcnt, 14008281341SChuck Lever u32 opnum, 14108281341SChuck Lever __be32 status 14208281341SChuck Lever ), 14308281341SChuck Lever TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status), 14408281341SChuck Lever TP_STRUCT__entry( 14508281341SChuck Lever NFSD_TRACE_PROC_RES_FIELDS 14608281341SChuck Lever 14708281341SChuck Lever __field(u32, args_opcnt) 14808281341SChuck Lever __field(u32, resp_opcnt) 14908281341SChuck Lever __field(u32, opnum) 15008281341SChuck Lever ), 15108281341SChuck Lever TP_fast_assign( 15208281341SChuck Lever NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 15308281341SChuck Lever 15408281341SChuck Lever __entry->args_opcnt = args_opcnt; 15508281341SChuck Lever __entry->resp_opcnt = resp_opcnt; 15608281341SChuck Lever __entry->opnum = opnum; 15708281341SChuck Lever ), 15808281341SChuck Lever TP_printk("op=%u/%u opnum=%u status=%lu", 15908281341SChuck Lever __entry->resp_opcnt, __entry->args_opcnt, 16008281341SChuck Lever __entry->opnum, __entry->status) 16108281341SChuck Lever ); 16208281341SChuck Lever 16308281341SChuck Lever TRACE_EVENT(nfsd_compound_encode_err, 16408281341SChuck Lever TP_PROTO( 16508281341SChuck Lever const struct svc_rqst *rqstp, 16608281341SChuck Lever u32 opnum, 16708281341SChuck Lever __be32 status 16808281341SChuck Lever ), 16908281341SChuck Lever TP_ARGS(rqstp, opnum, status), 17008281341SChuck Lever TP_STRUCT__entry( 17108281341SChuck Lever NFSD_TRACE_PROC_RES_FIELDS 17208281341SChuck Lever 17308281341SChuck Lever __field(u32, opnum) 17408281341SChuck Lever ), 17508281341SChuck Lever TP_fast_assign( 17608281341SChuck Lever NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 17708281341SChuck Lever 17808281341SChuck Lever __entry->opnum = opnum; 17908281341SChuck Lever ), 18008281341SChuck Lever TP_printk("opnum=%u status=%lu", 18108281341SChuck Lever __entry->opnum, __entry->status) 18208281341SChuck Lever ); 18308281341SChuck Lever 18405138288SChuck Lever #define show_fs_file_type(x) \ 18505138288SChuck Lever __print_symbolic(x, \ 18605138288SChuck Lever { S_IFLNK, "LNK" }, \ 18705138288SChuck Lever { S_IFREG, "REG" }, \ 18805138288SChuck Lever { S_IFDIR, "DIR" }, \ 18905138288SChuck Lever { S_IFCHR, "CHR" }, \ 19005138288SChuck Lever { S_IFBLK, "BLK" }, \ 19105138288SChuck Lever { S_IFIFO, "FIFO" }, \ 19205138288SChuck Lever { S_IFSOCK, "SOCK" }) 19305138288SChuck Lever 19405138288SChuck Lever TRACE_EVENT(nfsd_fh_verify, 19505138288SChuck Lever TP_PROTO( 19605138288SChuck Lever const struct svc_rqst *rqstp, 19705138288SChuck Lever const struct svc_fh *fhp, 19805138288SChuck Lever umode_t type, 19905138288SChuck Lever int access 20005138288SChuck Lever ), 20105138288SChuck Lever TP_ARGS(rqstp, fhp, type, access), 20205138288SChuck Lever TP_STRUCT__entry( 20305138288SChuck Lever __field(unsigned int, netns_ino) 20405138288SChuck Lever __sockaddr(server, rqstp->rq_xprt->xpt_remotelen) 20505138288SChuck Lever __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 20605138288SChuck Lever __field(u32, xid) 20705138288SChuck Lever __field(u32, fh_hash) 208948755efSChuck Lever __field(const void *, inode) 20905138288SChuck Lever __field(unsigned long, type) 21005138288SChuck Lever __field(unsigned long, access) 21105138288SChuck Lever ), 21205138288SChuck Lever TP_fast_assign( 21305138288SChuck Lever __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 21405138288SChuck Lever __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local, 21505138288SChuck Lever rqstp->rq_xprt->xpt_locallen); 21605138288SChuck Lever __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote, 21705138288SChuck Lever rqstp->rq_xprt->xpt_remotelen); 21805138288SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 21905138288SChuck Lever __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 22005138288SChuck Lever __entry->inode = d_inode(fhp->fh_dentry); 22105138288SChuck Lever __entry->type = type; 22205138288SChuck Lever __entry->access = access; 22305138288SChuck Lever ), 224948755efSChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s", 225948755efSChuck Lever __entry->xid, __entry->fh_hash, 22605138288SChuck Lever show_fs_file_type(__entry->type), 22705138288SChuck Lever show_nfsd_may_flags(__entry->access) 22805138288SChuck Lever ) 22905138288SChuck Lever ); 23008281341SChuck Lever 231948755efSChuck Lever TRACE_EVENT_CONDITION(nfsd_fh_verify_err, 232948755efSChuck Lever TP_PROTO( 233948755efSChuck Lever const struct svc_rqst *rqstp, 234948755efSChuck Lever const struct svc_fh *fhp, 235948755efSChuck Lever umode_t type, 236948755efSChuck Lever int access, 237948755efSChuck Lever __be32 error 238948755efSChuck Lever ), 239948755efSChuck Lever TP_ARGS(rqstp, fhp, type, access, error), 240948755efSChuck Lever TP_CONDITION(error), 241948755efSChuck Lever TP_STRUCT__entry( 242948755efSChuck Lever __field(unsigned int, netns_ino) 243948755efSChuck Lever __sockaddr(server, rqstp->rq_xprt->xpt_remotelen) 244948755efSChuck Lever __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 245948755efSChuck Lever __field(u32, xid) 246948755efSChuck Lever __field(u32, fh_hash) 247948755efSChuck Lever __field(const void *, inode) 248948755efSChuck Lever __field(unsigned long, type) 249948755efSChuck Lever __field(unsigned long, access) 250948755efSChuck Lever __field(int, error) 251948755efSChuck Lever ), 252948755efSChuck Lever TP_fast_assign( 253948755efSChuck Lever __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 254948755efSChuck Lever __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local, 255948755efSChuck Lever rqstp->rq_xprt->xpt_locallen); 256948755efSChuck Lever __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote, 257948755efSChuck Lever rqstp->rq_xprt->xpt_remotelen); 258948755efSChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 259948755efSChuck Lever __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2605a01c805SChuck Lever if (fhp->fh_dentry) 261948755efSChuck Lever __entry->inode = d_inode(fhp->fh_dentry); 2625a01c805SChuck Lever else 2635a01c805SChuck Lever __entry->inode = NULL; 264948755efSChuck Lever __entry->type = type; 265948755efSChuck Lever __entry->access = access; 266948755efSChuck Lever __entry->error = be32_to_cpu(error); 267948755efSChuck Lever ), 268948755efSChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s error=%d", 269948755efSChuck Lever __entry->xid, __entry->fh_hash, 270948755efSChuck Lever show_fs_file_type(__entry->type), 271948755efSChuck Lever show_nfsd_may_flags(__entry->access), 272948755efSChuck Lever __entry->error 273948755efSChuck Lever ) 274948755efSChuck Lever ); 275948755efSChuck Lever 276f01274a9STrond Myklebust DECLARE_EVENT_CLASS(nfsd_fh_err_class, 277f01274a9STrond Myklebust TP_PROTO(struct svc_rqst *rqstp, 278f01274a9STrond Myklebust struct svc_fh *fhp, 279f01274a9STrond Myklebust int status), 280f01274a9STrond Myklebust TP_ARGS(rqstp, fhp, status), 281f01274a9STrond Myklebust TP_STRUCT__entry( 282f01274a9STrond Myklebust __field(u32, xid) 283f01274a9STrond Myklebust __field(u32, fh_hash) 284f01274a9STrond Myklebust __field(int, status) 285f01274a9STrond Myklebust ), 286f01274a9STrond Myklebust TP_fast_assign( 287f01274a9STrond Myklebust __entry->xid = be32_to_cpu(rqstp->rq_xid); 288f01274a9STrond Myklebust __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 289f01274a9STrond Myklebust __entry->status = status; 290f01274a9STrond Myklebust ), 291f01274a9STrond Myklebust TP_printk("xid=0x%08x fh_hash=0x%08x status=%d", 292f01274a9STrond Myklebust __entry->xid, __entry->fh_hash, 293f01274a9STrond Myklebust __entry->status) 294f01274a9STrond Myklebust ) 295f01274a9STrond Myklebust 296f01274a9STrond Myklebust #define DEFINE_NFSD_FH_ERR_EVENT(name) \ 297f01274a9STrond Myklebust DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \ 298f01274a9STrond Myklebust TP_PROTO(struct svc_rqst *rqstp, \ 299f01274a9STrond Myklebust struct svc_fh *fhp, \ 300f01274a9STrond Myklebust int status), \ 301f01274a9STrond Myklebust TP_ARGS(rqstp, fhp, status)) 302f01274a9STrond Myklebust 303f01274a9STrond Myklebust DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport); 304f01274a9STrond Myklebust DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle); 305f01274a9STrond Myklebust 306cf749f3cSTrond Myklebust TRACE_EVENT(nfsd_exp_find_key, 307cf749f3cSTrond Myklebust TP_PROTO(const struct svc_expkey *key, 308cf749f3cSTrond Myklebust int status), 309cf749f3cSTrond Myklebust TP_ARGS(key, status), 310cf749f3cSTrond Myklebust TP_STRUCT__entry( 311cf749f3cSTrond Myklebust __field(int, fsidtype) 312cf749f3cSTrond Myklebust __array(u32, fsid, 6) 313cf749f3cSTrond Myklebust __string(auth_domain, key->ek_client->name) 314cf749f3cSTrond Myklebust __field(int, status) 315cf749f3cSTrond Myklebust ), 316cf749f3cSTrond Myklebust TP_fast_assign( 317cf749f3cSTrond Myklebust __entry->fsidtype = key->ek_fsidtype; 318cf749f3cSTrond Myklebust memcpy(__entry->fsid, key->ek_fsid, 4*6); 319cf749f3cSTrond Myklebust __assign_str(auth_domain, key->ek_client->name); 320cf749f3cSTrond Myklebust __entry->status = status; 321cf749f3cSTrond Myklebust ), 322cf749f3cSTrond Myklebust TP_printk("fsid=%x::%s domain=%s status=%d", 323cf749f3cSTrond Myklebust __entry->fsidtype, 324cf749f3cSTrond Myklebust __print_array(__entry->fsid, 6, 4), 325cf749f3cSTrond Myklebust __get_str(auth_domain), 326cf749f3cSTrond Myklebust __entry->status 327cf749f3cSTrond Myklebust ) 328cf749f3cSTrond Myklebust ); 329cf749f3cSTrond Myklebust 3306a30e47fSTrond Myklebust TRACE_EVENT(nfsd_expkey_update, 3316a30e47fSTrond Myklebust TP_PROTO(const struct svc_expkey *key, const char *exp_path), 3326a30e47fSTrond Myklebust TP_ARGS(key, exp_path), 3336a30e47fSTrond Myklebust TP_STRUCT__entry( 3346a30e47fSTrond Myklebust __field(int, fsidtype) 3356a30e47fSTrond Myklebust __array(u32, fsid, 6) 3366a30e47fSTrond Myklebust __string(auth_domain, key->ek_client->name) 3376a30e47fSTrond Myklebust __string(path, exp_path) 3386a30e47fSTrond Myklebust __field(bool, cache) 3396a30e47fSTrond Myklebust ), 3406a30e47fSTrond Myklebust TP_fast_assign( 3416a30e47fSTrond Myklebust __entry->fsidtype = key->ek_fsidtype; 3426a30e47fSTrond Myklebust memcpy(__entry->fsid, key->ek_fsid, 4*6); 3436a30e47fSTrond Myklebust __assign_str(auth_domain, key->ek_client->name); 3446a30e47fSTrond Myklebust __assign_str(path, exp_path); 3456a30e47fSTrond Myklebust __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 3466a30e47fSTrond Myklebust ), 3476a30e47fSTrond Myklebust TP_printk("fsid=%x::%s domain=%s path=%s cache=%s", 3486a30e47fSTrond Myklebust __entry->fsidtype, 3496a30e47fSTrond Myklebust __print_array(__entry->fsid, 6, 4), 3506a30e47fSTrond Myklebust __get_str(auth_domain), 3516a30e47fSTrond Myklebust __get_str(path), 3526a30e47fSTrond Myklebust __entry->cache ? "pos" : "neg" 3536a30e47fSTrond Myklebust ) 3546a30e47fSTrond Myklebust ); 3556a30e47fSTrond Myklebust 356cf749f3cSTrond Myklebust TRACE_EVENT(nfsd_exp_get_by_name, 357cf749f3cSTrond Myklebust TP_PROTO(const struct svc_export *key, 358cf749f3cSTrond Myklebust int status), 359cf749f3cSTrond Myklebust TP_ARGS(key, status), 360cf749f3cSTrond Myklebust TP_STRUCT__entry( 361cf749f3cSTrond Myklebust __string(path, key->ex_path.dentry->d_name.name) 362cf749f3cSTrond Myklebust __string(auth_domain, key->ex_client->name) 363cf749f3cSTrond Myklebust __field(int, status) 364cf749f3cSTrond Myklebust ), 365cf749f3cSTrond Myklebust TP_fast_assign( 366cf749f3cSTrond Myklebust __assign_str(path, key->ex_path.dentry->d_name.name); 367cf749f3cSTrond Myklebust __assign_str(auth_domain, key->ex_client->name); 368cf749f3cSTrond Myklebust __entry->status = status; 369cf749f3cSTrond Myklebust ), 370cf749f3cSTrond Myklebust TP_printk("path=%s domain=%s status=%d", 371cf749f3cSTrond Myklebust __get_str(path), 372cf749f3cSTrond Myklebust __get_str(auth_domain), 373cf749f3cSTrond Myklebust __entry->status 374cf749f3cSTrond Myklebust ) 375cf749f3cSTrond Myklebust ); 376cf749f3cSTrond Myklebust 3776a30e47fSTrond Myklebust TRACE_EVENT(nfsd_export_update, 3786a30e47fSTrond Myklebust TP_PROTO(const struct svc_export *key), 3796a30e47fSTrond Myklebust TP_ARGS(key), 3806a30e47fSTrond Myklebust TP_STRUCT__entry( 3816a30e47fSTrond Myklebust __string(path, key->ex_path.dentry->d_name.name) 3826a30e47fSTrond Myklebust __string(auth_domain, key->ex_client->name) 3836a30e47fSTrond Myklebust __field(bool, cache) 3846a30e47fSTrond Myklebust ), 3856a30e47fSTrond Myklebust TP_fast_assign( 3866a30e47fSTrond Myklebust __assign_str(path, key->ex_path.dentry->d_name.name); 3876a30e47fSTrond Myklebust __assign_str(auth_domain, key->ex_client->name); 3886a30e47fSTrond Myklebust __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 3896a30e47fSTrond Myklebust ), 3906a30e47fSTrond Myklebust TP_printk("path=%s domain=%s cache=%s", 3916a30e47fSTrond Myklebust __get_str(path), 3926a30e47fSTrond Myklebust __get_str(auth_domain), 3936a30e47fSTrond Myklebust __entry->cache ? "pos" : "neg" 3946a30e47fSTrond Myklebust ) 3956a30e47fSTrond Myklebust ); 3966a30e47fSTrond Myklebust 3976e8b50d1SJeff Layton DECLARE_EVENT_CLASS(nfsd_io_class, 3986e8b50d1SJeff Layton TP_PROTO(struct svc_rqst *rqstp, 3996e8b50d1SJeff Layton struct svc_fh *fhp, 4006a4d333dSChuck Lever u64 offset, 4016a4d333dSChuck Lever u32 len), 4026e8b50d1SJeff Layton TP_ARGS(rqstp, fhp, offset, len), 4036e8b50d1SJeff Layton TP_STRUCT__entry( 404afa720a0SChuck Lever __field(u32, xid) 405afa720a0SChuck Lever __field(u32, fh_hash) 4066a4d333dSChuck Lever __field(u64, offset) 4076a4d333dSChuck Lever __field(u32, len) 4086e8b50d1SJeff Layton ), 4096e8b50d1SJeff Layton TP_fast_assign( 410afa720a0SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 41179e0b4e2SChuck Lever __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 4126e8b50d1SJeff Layton __entry->offset = offset; 4136e8b50d1SJeff Layton __entry->len = len; 4146e8b50d1SJeff Layton ), 4156a4d333dSChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u", 416afa720a0SChuck Lever __entry->xid, __entry->fh_hash, 4176e8b50d1SJeff Layton __entry->offset, __entry->len) 4186e8b50d1SJeff Layton ) 4196e8b50d1SJeff Layton 4206e8b50d1SJeff Layton #define DEFINE_NFSD_IO_EVENT(name) \ 421f394b62bSChuck Lever DEFINE_EVENT(nfsd_io_class, nfsd_##name, \ 4226e8b50d1SJeff Layton TP_PROTO(struct svc_rqst *rqstp, \ 4236e8b50d1SJeff Layton struct svc_fh *fhp, \ 4246a4d333dSChuck Lever u64 offset, \ 4256a4d333dSChuck Lever u32 len), \ 4266e8b50d1SJeff Layton TP_ARGS(rqstp, fhp, offset, len)) 4276e8b50d1SJeff Layton 4286e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_start); 42987c5942eSChuck Lever DEFINE_NFSD_IO_EVENT(read_splice); 43087c5942eSChuck Lever DEFINE_NFSD_IO_EVENT(read_vector); 4316e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_io_done); 4326e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_done); 4336e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_start); 4346e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_opened); 4356e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_io_done); 4366e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_done); 43731ef83dcSChristoph Hellwig 438d890be15SChuck Lever DECLARE_EVENT_CLASS(nfsd_err_class, 439d890be15SChuck Lever TP_PROTO(struct svc_rqst *rqstp, 440d890be15SChuck Lever struct svc_fh *fhp, 441d890be15SChuck Lever loff_t offset, 442d890be15SChuck Lever int status), 443d890be15SChuck Lever TP_ARGS(rqstp, fhp, offset, status), 444d890be15SChuck Lever TP_STRUCT__entry( 445d890be15SChuck Lever __field(u32, xid) 446d890be15SChuck Lever __field(u32, fh_hash) 447d890be15SChuck Lever __field(loff_t, offset) 448d890be15SChuck Lever __field(int, status) 449d890be15SChuck Lever ), 450d890be15SChuck Lever TP_fast_assign( 451d890be15SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 452d890be15SChuck Lever __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 453d890be15SChuck Lever __entry->offset = offset; 454d890be15SChuck Lever __entry->status = status; 455d890be15SChuck Lever ), 456d890be15SChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d", 457d890be15SChuck Lever __entry->xid, __entry->fh_hash, 458d890be15SChuck Lever __entry->offset, __entry->status) 459d890be15SChuck Lever ) 460d890be15SChuck Lever 461d890be15SChuck Lever #define DEFINE_NFSD_ERR_EVENT(name) \ 462d890be15SChuck Lever DEFINE_EVENT(nfsd_err_class, nfsd_##name, \ 463d890be15SChuck Lever TP_PROTO(struct svc_rqst *rqstp, \ 464d890be15SChuck Lever struct svc_fh *fhp, \ 465d890be15SChuck Lever loff_t offset, \ 466d890be15SChuck Lever int len), \ 467d890be15SChuck Lever TP_ARGS(rqstp, fhp, offset, len)) 468d890be15SChuck Lever 46987c5942eSChuck Lever DEFINE_NFSD_ERR_EVENT(read_err); 470d890be15SChuck Lever DEFINE_NFSD_ERR_EVENT(write_err); 471d890be15SChuck Lever 4726019ce07SChuck Lever TRACE_EVENT(nfsd_dirent, 4736019ce07SChuck Lever TP_PROTO(struct svc_fh *fhp, 4746019ce07SChuck Lever u64 ino, 4756019ce07SChuck Lever const char *name, 4766019ce07SChuck Lever int namlen), 4776019ce07SChuck Lever TP_ARGS(fhp, ino, name, namlen), 4786019ce07SChuck Lever TP_STRUCT__entry( 4796019ce07SChuck Lever __field(u32, fh_hash) 4806019ce07SChuck Lever __field(u64, ino) 481408c0de7SChuck Lever __string_len(name, name, namlen) 4826019ce07SChuck Lever ), 4836019ce07SChuck Lever TP_fast_assign( 4846019ce07SChuck Lever __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0; 4856019ce07SChuck Lever __entry->ino = ino; 486408c0de7SChuck Lever __assign_str_len(name, name, namlen) 4876019ce07SChuck Lever ), 488408c0de7SChuck Lever TP_printk("fh_hash=0x%08x ino=%llu name=%s", 489408c0de7SChuck Lever __entry->fh_hash, __entry->ino, __get_str(name) 490408c0de7SChuck Lever ) 4916019ce07SChuck Lever ) 4926019ce07SChuck Lever 493a2f4c3faSTrond Myklebust DECLARE_EVENT_CLASS(nfsd_copy_err_class, 494a2f4c3faSTrond Myklebust TP_PROTO(struct svc_rqst *rqstp, 495a2f4c3faSTrond Myklebust struct svc_fh *src_fhp, 496a2f4c3faSTrond Myklebust loff_t src_offset, 497a2f4c3faSTrond Myklebust struct svc_fh *dst_fhp, 498a2f4c3faSTrond Myklebust loff_t dst_offset, 499a2f4c3faSTrond Myklebust u64 count, 500a2f4c3faSTrond Myklebust int status), 501a2f4c3faSTrond Myklebust TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status), 502a2f4c3faSTrond Myklebust TP_STRUCT__entry( 503a2f4c3faSTrond Myklebust __field(u32, xid) 504a2f4c3faSTrond Myklebust __field(u32, src_fh_hash) 505a2f4c3faSTrond Myklebust __field(loff_t, src_offset) 506a2f4c3faSTrond Myklebust __field(u32, dst_fh_hash) 507a2f4c3faSTrond Myklebust __field(loff_t, dst_offset) 508a2f4c3faSTrond Myklebust __field(u64, count) 509a2f4c3faSTrond Myklebust __field(int, status) 510a2f4c3faSTrond Myklebust ), 511a2f4c3faSTrond Myklebust TP_fast_assign( 512a2f4c3faSTrond Myklebust __entry->xid = be32_to_cpu(rqstp->rq_xid); 513a2f4c3faSTrond Myklebust __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle); 514a2f4c3faSTrond Myklebust __entry->src_offset = src_offset; 515a2f4c3faSTrond Myklebust __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle); 516a2f4c3faSTrond Myklebust __entry->dst_offset = dst_offset; 517a2f4c3faSTrond Myklebust __entry->count = count; 518a2f4c3faSTrond Myklebust __entry->status = status; 519a2f4c3faSTrond Myklebust ), 520a2f4c3faSTrond Myklebust TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld " 521a2f4c3faSTrond Myklebust "dst_fh_hash=0x%08x dst_offset=%lld " 522a2f4c3faSTrond Myklebust "count=%llu status=%d", 523a2f4c3faSTrond Myklebust __entry->xid, __entry->src_fh_hash, __entry->src_offset, 524a2f4c3faSTrond Myklebust __entry->dst_fh_hash, __entry->dst_offset, 525a2f4c3faSTrond Myklebust (unsigned long long)__entry->count, 526a2f4c3faSTrond Myklebust __entry->status) 527a2f4c3faSTrond Myklebust ) 528a2f4c3faSTrond Myklebust 529a2f4c3faSTrond Myklebust #define DEFINE_NFSD_COPY_ERR_EVENT(name) \ 530a2f4c3faSTrond Myklebust DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \ 531a2f4c3faSTrond Myklebust TP_PROTO(struct svc_rqst *rqstp, \ 532a2f4c3faSTrond Myklebust struct svc_fh *src_fhp, \ 533a2f4c3faSTrond Myklebust loff_t src_offset, \ 534a2f4c3faSTrond Myklebust struct svc_fh *dst_fhp, \ 535a2f4c3faSTrond Myklebust loff_t dst_offset, \ 536a2f4c3faSTrond Myklebust u64 count, \ 537a2f4c3faSTrond Myklebust int status), \ 538a2f4c3faSTrond Myklebust TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \ 539a2f4c3faSTrond Myklebust count, status)) 540a2f4c3faSTrond Myklebust 541a2f4c3faSTrond Myklebust DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err); 542a2f4c3faSTrond Myklebust 543825213e5SJeff Layton #include "state.h" 54465294c1fSJeff Layton #include "filecache.h" 54565294c1fSJeff Layton #include "vfs.h" 546825213e5SJeff Layton 547c035362eSChuck Lever TRACE_EVENT(nfsd_delegret_wakeup, 548c035362eSChuck Lever TP_PROTO( 549c035362eSChuck Lever const struct svc_rqst *rqstp, 550c035362eSChuck Lever const struct inode *inode, 551c035362eSChuck Lever long timeo 552c035362eSChuck Lever ), 553c035362eSChuck Lever TP_ARGS(rqstp, inode, timeo), 554c035362eSChuck Lever TP_STRUCT__entry( 555c035362eSChuck Lever __field(u32, xid) 556c035362eSChuck Lever __field(const void *, inode) 557c035362eSChuck Lever __field(long, timeo) 558c035362eSChuck Lever ), 559c035362eSChuck Lever TP_fast_assign( 560c035362eSChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 561c035362eSChuck Lever __entry->inode = inode; 562c035362eSChuck Lever __entry->timeo = timeo; 563c035362eSChuck Lever ), 564c035362eSChuck Lever TP_printk("xid=0x%08x inode=%p%s", 565c035362eSChuck Lever __entry->xid, __entry->inode, 566c035362eSChuck Lever __entry->timeo == 0 ? " (timed out)" : "" 567c035362eSChuck Lever ) 568c035362eSChuck Lever ); 569c035362eSChuck Lever 57031ef83dcSChristoph Hellwig DECLARE_EVENT_CLASS(nfsd_stateid_class, 57131ef83dcSChristoph Hellwig TP_PROTO(stateid_t *stp), 57231ef83dcSChristoph Hellwig TP_ARGS(stp), 57331ef83dcSChristoph Hellwig TP_STRUCT__entry( 57431ef83dcSChristoph Hellwig __field(u32, cl_boot) 57531ef83dcSChristoph Hellwig __field(u32, cl_id) 57631ef83dcSChristoph Hellwig __field(u32, si_id) 57731ef83dcSChristoph Hellwig __field(u32, si_generation) 57831ef83dcSChristoph Hellwig ), 57931ef83dcSChristoph Hellwig TP_fast_assign( 58031ef83dcSChristoph Hellwig __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 58131ef83dcSChristoph Hellwig __entry->cl_id = stp->si_opaque.so_clid.cl_id; 58231ef83dcSChristoph Hellwig __entry->si_id = stp->si_opaque.so_id; 58331ef83dcSChristoph Hellwig __entry->si_generation = stp->si_generation; 58431ef83dcSChristoph Hellwig ), 58531ef83dcSChristoph Hellwig TP_printk("client %08x:%08x stateid %08x:%08x", 58631ef83dcSChristoph Hellwig __entry->cl_boot, 58731ef83dcSChristoph Hellwig __entry->cl_id, 58831ef83dcSChristoph Hellwig __entry->si_id, 58931ef83dcSChristoph Hellwig __entry->si_generation) 59031ef83dcSChristoph Hellwig ) 59131ef83dcSChristoph Hellwig 59231ef83dcSChristoph Hellwig #define DEFINE_STATEID_EVENT(name) \ 593f394b62bSChuck Lever DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \ 59431ef83dcSChristoph Hellwig TP_PROTO(stateid_t *stp), \ 59531ef83dcSChristoph Hellwig TP_ARGS(stp)) 596dd5e3fbcSChuck Lever 59731ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_alloc); 59831ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_unhash); 59931ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_free); 60031ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_get_lookup_fail); 60131ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_commit_lookup_fail); 60231ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_return_lookup_fail); 60331ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall); 60431ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_done); 60531ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_fail); 60631ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_release); 60731ef83dcSChristoph Hellwig 6083caf9175SHou Tao DEFINE_STATEID_EVENT(open); 6093caf9175SHou Tao DEFINE_STATEID_EVENT(deleg_read); 61020eee313SChuck Lever DEFINE_STATEID_EVENT(deleg_return); 611dd5e3fbcSChuck Lever DEFINE_STATEID_EVENT(deleg_recall); 612dd5e3fbcSChuck Lever 613dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_stateseqid_class, 614dd5e3fbcSChuck Lever TP_PROTO(u32 seqid, const stateid_t *stp), 615dd5e3fbcSChuck Lever TP_ARGS(seqid, stp), 616dd5e3fbcSChuck Lever TP_STRUCT__entry( 617dd5e3fbcSChuck Lever __field(u32, seqid) 618dd5e3fbcSChuck Lever __field(u32, cl_boot) 619dd5e3fbcSChuck Lever __field(u32, cl_id) 620dd5e3fbcSChuck Lever __field(u32, si_id) 621dd5e3fbcSChuck Lever __field(u32, si_generation) 622dd5e3fbcSChuck Lever ), 623dd5e3fbcSChuck Lever TP_fast_assign( 624dd5e3fbcSChuck Lever __entry->seqid = seqid; 625dd5e3fbcSChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 626dd5e3fbcSChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 627dd5e3fbcSChuck Lever __entry->si_id = stp->si_opaque.so_id; 628dd5e3fbcSChuck Lever __entry->si_generation = stp->si_generation; 629dd5e3fbcSChuck Lever ), 630dd5e3fbcSChuck Lever TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x", 631dd5e3fbcSChuck Lever __entry->seqid, __entry->cl_boot, __entry->cl_id, 632dd5e3fbcSChuck Lever __entry->si_id, __entry->si_generation) 633dd5e3fbcSChuck Lever ) 634dd5e3fbcSChuck Lever 635dd5e3fbcSChuck Lever #define DEFINE_STATESEQID_EVENT(name) \ 636dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \ 637dd5e3fbcSChuck Lever TP_PROTO(u32 seqid, const stateid_t *stp), \ 638dd5e3fbcSChuck Lever TP_ARGS(seqid, stp)) 639dd5e3fbcSChuck Lever 640dd5e3fbcSChuck Lever DEFINE_STATESEQID_EVENT(preprocess); 641dd5e3fbcSChuck Lever DEFINE_STATESEQID_EVENT(open_confirm); 642dd5e3fbcSChuck Lever 643a1c74569SChuck Lever TRACE_DEFINE_ENUM(NFS4_OPEN_STID); 644a1c74569SChuck Lever TRACE_DEFINE_ENUM(NFS4_LOCK_STID); 645a1c74569SChuck Lever TRACE_DEFINE_ENUM(NFS4_DELEG_STID); 646a1c74569SChuck Lever TRACE_DEFINE_ENUM(NFS4_CLOSED_STID); 647a1c74569SChuck Lever TRACE_DEFINE_ENUM(NFS4_REVOKED_DELEG_STID); 648a1c74569SChuck Lever TRACE_DEFINE_ENUM(NFS4_CLOSED_DELEG_STID); 649a1c74569SChuck Lever TRACE_DEFINE_ENUM(NFS4_LAYOUT_STID); 650a1c74569SChuck Lever 651a1c74569SChuck Lever #define show_stid_type(x) \ 652a1c74569SChuck Lever __print_flags(x, "|", \ 653a1c74569SChuck Lever { NFS4_OPEN_STID, "OPEN" }, \ 654a1c74569SChuck Lever { NFS4_LOCK_STID, "LOCK" }, \ 655a1c74569SChuck Lever { NFS4_DELEG_STID, "DELEG" }, \ 656a1c74569SChuck Lever { NFS4_CLOSED_STID, "CLOSED" }, \ 657a1c74569SChuck Lever { NFS4_REVOKED_DELEG_STID, "REVOKED" }, \ 658a1c74569SChuck Lever { NFS4_CLOSED_DELEG_STID, "CLOSED_DELEG" }, \ 659a1c74569SChuck Lever { NFS4_LAYOUT_STID, "LAYOUT" }) 660a1c74569SChuck Lever 661a1c74569SChuck Lever DECLARE_EVENT_CLASS(nfsd_stid_class, 662a1c74569SChuck Lever TP_PROTO( 663a1c74569SChuck Lever const struct nfs4_stid *stid 664a1c74569SChuck Lever ), 665a1c74569SChuck Lever TP_ARGS(stid), 666a1c74569SChuck Lever TP_STRUCT__entry( 667a1c74569SChuck Lever __field(unsigned long, sc_type) 668a1c74569SChuck Lever __field(int, sc_count) 669a1c74569SChuck Lever __field(u32, cl_boot) 670a1c74569SChuck Lever __field(u32, cl_id) 671a1c74569SChuck Lever __field(u32, si_id) 672a1c74569SChuck Lever __field(u32, si_generation) 673a1c74569SChuck Lever ), 674a1c74569SChuck Lever TP_fast_assign( 675a1c74569SChuck Lever const stateid_t *stp = &stid->sc_stateid; 676a1c74569SChuck Lever 677a1c74569SChuck Lever __entry->sc_type = stid->sc_type; 678a1c74569SChuck Lever __entry->sc_count = refcount_read(&stid->sc_count); 679a1c74569SChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 680a1c74569SChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 681a1c74569SChuck Lever __entry->si_id = stp->si_opaque.so_id; 682a1c74569SChuck Lever __entry->si_generation = stp->si_generation; 683a1c74569SChuck Lever ), 684a1c74569SChuck Lever TP_printk("client %08x:%08x stateid %08x:%08x ref=%d type=%s", 685a1c74569SChuck Lever __entry->cl_boot, __entry->cl_id, 686a1c74569SChuck Lever __entry->si_id, __entry->si_generation, 687a1c74569SChuck Lever __entry->sc_count, show_stid_type(__entry->sc_type) 688a1c74569SChuck Lever ) 689a1c74569SChuck Lever ); 690a1c74569SChuck Lever 691a1c74569SChuck Lever #define DEFINE_STID_EVENT(name) \ 692a1c74569SChuck Lever DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name, \ 693a1c74569SChuck Lever TP_PROTO(const struct nfs4_stid *stid), \ 694a1c74569SChuck Lever TP_ARGS(stid)) 695a1c74569SChuck Lever 696a1c74569SChuck Lever DEFINE_STID_EVENT(revoke); 697a1c74569SChuck Lever 698dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_clientid_class, 699dd5e3fbcSChuck Lever TP_PROTO(const clientid_t *clid), 700dd5e3fbcSChuck Lever TP_ARGS(clid), 701dd5e3fbcSChuck Lever TP_STRUCT__entry( 702dd5e3fbcSChuck Lever __field(u32, cl_boot) 703dd5e3fbcSChuck Lever __field(u32, cl_id) 704dd5e3fbcSChuck Lever ), 705dd5e3fbcSChuck Lever TP_fast_assign( 706dd5e3fbcSChuck Lever __entry->cl_boot = clid->cl_boot; 707dd5e3fbcSChuck Lever __entry->cl_id = clid->cl_id; 708dd5e3fbcSChuck Lever ), 709dd5e3fbcSChuck Lever TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 710dd5e3fbcSChuck Lever ) 711dd5e3fbcSChuck Lever 712dd5e3fbcSChuck Lever #define DEFINE_CLIENTID_EVENT(name) \ 713dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 714dd5e3fbcSChuck Lever TP_PROTO(const clientid_t *clid), \ 715dd5e3fbcSChuck Lever TP_ARGS(clid)) 716dd5e3fbcSChuck Lever 717237f91c8SChuck Lever DEFINE_CLIENTID_EVENT(expire_unconf); 718cee8aa07SChuck Lever DEFINE_CLIENTID_EVENT(reclaim_complete); 7197e3b32acSChuck Lever DEFINE_CLIENTID_EVENT(confirmed); 720c41a9b7aSChuck Lever DEFINE_CLIENTID_EVENT(destroyed); 7212958d2eeSChuck Lever DEFINE_CLIENTID_EVENT(admin_expired); 7222958d2eeSChuck Lever DEFINE_CLIENTID_EVENT(replaced); 723dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(purged); 724dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(renew); 725dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(stale); 726dd5e3fbcSChuck Lever 727dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_net_class, 728dd5e3fbcSChuck Lever TP_PROTO(const struct nfsd_net *nn), 729dd5e3fbcSChuck Lever TP_ARGS(nn), 730dd5e3fbcSChuck Lever TP_STRUCT__entry( 731dd5e3fbcSChuck Lever __field(unsigned long long, boot_time) 732dd5e3fbcSChuck Lever ), 733dd5e3fbcSChuck Lever TP_fast_assign( 734dd5e3fbcSChuck Lever __entry->boot_time = nn->boot_time; 735dd5e3fbcSChuck Lever ), 736dd5e3fbcSChuck Lever TP_printk("boot_time=%16llx", __entry->boot_time) 737dd5e3fbcSChuck Lever ) 738dd5e3fbcSChuck Lever 739dd5e3fbcSChuck Lever #define DEFINE_NET_EVENT(name) \ 740dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 741dd5e3fbcSChuck Lever TP_PROTO(const struct nfsd_net *nn), \ 742dd5e3fbcSChuck Lever TP_ARGS(nn)) 743dd5e3fbcSChuck Lever 744dd5e3fbcSChuck Lever DEFINE_NET_EVENT(grace_start); 745dd5e3fbcSChuck Lever DEFINE_NET_EVENT(grace_complete); 746dd5e3fbcSChuck Lever 74775acacb6SChuck Lever TRACE_EVENT(nfsd_writeverf_reset, 74875acacb6SChuck Lever TP_PROTO( 74975acacb6SChuck Lever const struct nfsd_net *nn, 75075acacb6SChuck Lever const struct svc_rqst *rqstp, 75175acacb6SChuck Lever int error 75275acacb6SChuck Lever ), 75375acacb6SChuck Lever TP_ARGS(nn, rqstp, error), 75475acacb6SChuck Lever TP_STRUCT__entry( 75575acacb6SChuck Lever __field(unsigned long long, boot_time) 75675acacb6SChuck Lever __field(u32, xid) 75775acacb6SChuck Lever __field(int, error) 75875acacb6SChuck Lever __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 75975acacb6SChuck Lever ), 76075acacb6SChuck Lever TP_fast_assign( 76175acacb6SChuck Lever __entry->boot_time = nn->boot_time; 76275acacb6SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 76375acacb6SChuck Lever __entry->error = error; 76475acacb6SChuck Lever 76575acacb6SChuck Lever /* avoid seqlock inside TP_fast_assign */ 76675acacb6SChuck Lever memcpy(__entry->verifier, nn->writeverf, 76775acacb6SChuck Lever NFS4_VERIFIER_SIZE); 76875acacb6SChuck Lever ), 76975acacb6SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s", 77075acacb6SChuck Lever __entry->boot_time, __entry->xid, __entry->error, 77175acacb6SChuck Lever __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 77275acacb6SChuck Lever ) 77375acacb6SChuck Lever ); 77475acacb6SChuck Lever 77527787733SChuck Lever TRACE_EVENT(nfsd_clid_cred_mismatch, 77627787733SChuck Lever TP_PROTO( 77727787733SChuck Lever const struct nfs4_client *clp, 77827787733SChuck Lever const struct svc_rqst *rqstp 77927787733SChuck Lever ), 78027787733SChuck Lever TP_ARGS(clp, rqstp), 78127787733SChuck Lever TP_STRUCT__entry( 78227787733SChuck Lever __field(u32, cl_boot) 78327787733SChuck Lever __field(u32, cl_id) 78427787733SChuck Lever __field(unsigned long, cl_flavor) 78527787733SChuck Lever __field(unsigned long, new_flavor) 7869db0e15fSChuck Lever __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 78727787733SChuck Lever ), 78827787733SChuck Lever TP_fast_assign( 78927787733SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 79027787733SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 79127787733SChuck Lever __entry->cl_flavor = clp->cl_cred.cr_flavor; 79227787733SChuck Lever __entry->new_flavor = rqstp->rq_cred.cr_flavor; 7939db0e15fSChuck Lever __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 7949db0e15fSChuck Lever rqstp->rq_xprt->xpt_remotelen); 79527787733SChuck Lever ), 79627787733SChuck Lever TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc", 79727787733SChuck Lever __entry->cl_boot, __entry->cl_id, 79827787733SChuck Lever show_nfsd_authflavor(__entry->cl_flavor), 7999db0e15fSChuck Lever show_nfsd_authflavor(__entry->new_flavor), 8009db0e15fSChuck Lever __get_sockaddr(addr) 80127787733SChuck Lever ) 80227787733SChuck Lever ) 80327787733SChuck Lever 804744ea54cSChuck Lever TRACE_EVENT(nfsd_clid_verf_mismatch, 805744ea54cSChuck Lever TP_PROTO( 806744ea54cSChuck Lever const struct nfs4_client *clp, 807744ea54cSChuck Lever const struct svc_rqst *rqstp, 808744ea54cSChuck Lever const nfs4_verifier *verf 809744ea54cSChuck Lever ), 810744ea54cSChuck Lever TP_ARGS(clp, rqstp, verf), 811744ea54cSChuck Lever TP_STRUCT__entry( 812744ea54cSChuck Lever __field(u32, cl_boot) 813744ea54cSChuck Lever __field(u32, cl_id) 814744ea54cSChuck Lever __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE) 815744ea54cSChuck Lever __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE) 8169db0e15fSChuck Lever __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 817744ea54cSChuck Lever ), 818744ea54cSChuck Lever TP_fast_assign( 819744ea54cSChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 820744ea54cSChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 821744ea54cSChuck Lever memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier, 822744ea54cSChuck Lever NFS4_VERIFIER_SIZE); 823744ea54cSChuck Lever memcpy(__entry->new_verifier, (void *)verf, 824744ea54cSChuck Lever NFS4_VERIFIER_SIZE); 8259db0e15fSChuck Lever __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 8269db0e15fSChuck Lever rqstp->rq_xprt->xpt_remotelen); 827744ea54cSChuck Lever ), 828744ea54cSChuck Lever TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc", 829744ea54cSChuck Lever __entry->cl_boot, __entry->cl_id, 830744ea54cSChuck Lever __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE), 831744ea54cSChuck Lever __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE), 8329db0e15fSChuck Lever __get_sockaddr(addr) 833744ea54cSChuck Lever ) 834744ea54cSChuck Lever ); 835744ea54cSChuck Lever 836237f91c8SChuck Lever DECLARE_EVENT_CLASS(nfsd_clid_class, 837237f91c8SChuck Lever TP_PROTO(const struct nfs4_client *clp), 838237f91c8SChuck Lever TP_ARGS(clp), 839237f91c8SChuck Lever TP_STRUCT__entry( 840237f91c8SChuck Lever __field(u32, cl_boot) 841237f91c8SChuck Lever __field(u32, cl_id) 842237f91c8SChuck Lever __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 843237f91c8SChuck Lever __field(unsigned long, flavor) 844237f91c8SChuck Lever __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 845d27b74a8SChuck Lever __string_len(name, name, clp->cl_name.len) 846237f91c8SChuck Lever ), 847237f91c8SChuck Lever TP_fast_assign( 848237f91c8SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 849237f91c8SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 850237f91c8SChuck Lever memcpy(__entry->addr, &clp->cl_addr, 851237f91c8SChuck Lever sizeof(struct sockaddr_in6)); 852237f91c8SChuck Lever __entry->flavor = clp->cl_cred.cr_flavor; 853237f91c8SChuck Lever memcpy(__entry->verifier, (void *)&clp->cl_verifier, 854237f91c8SChuck Lever NFS4_VERIFIER_SIZE); 855d27b74a8SChuck Lever __assign_str_len(name, clp->cl_name.data, clp->cl_name.len); 856237f91c8SChuck Lever ), 857237f91c8SChuck Lever TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x", 858237f91c8SChuck Lever __entry->addr, __get_str(name), 859237f91c8SChuck Lever __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE), 860237f91c8SChuck Lever show_nfsd_authflavor(__entry->flavor), 861237f91c8SChuck Lever __entry->cl_boot, __entry->cl_id) 862237f91c8SChuck Lever ); 863237f91c8SChuck Lever 864237f91c8SChuck Lever #define DEFINE_CLID_EVENT(name) \ 865237f91c8SChuck Lever DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 866237f91c8SChuck Lever TP_PROTO(const struct nfs4_client *clp), \ 867237f91c8SChuck Lever TP_ARGS(clp)) 868237f91c8SChuck Lever 869237f91c8SChuck Lever DEFINE_CLID_EVENT(fresh); 870e8f80c55SChuck Lever DEFINE_CLID_EVENT(confirmed_r); 871237f91c8SChuck Lever 872b76278aeSChuck Lever /* 873b76278aeSChuck Lever * from fs/nfsd/filecache.h 874b76278aeSChuck Lever */ 87565294c1fSJeff Layton #define show_nf_flags(val) \ 87665294c1fSJeff Layton __print_flags(val, "|", \ 87765294c1fSJeff Layton { 1 << NFSD_FILE_HASHED, "HASHED" }, \ 87865294c1fSJeff Layton { 1 << NFSD_FILE_PENDING, "PENDING" }, \ 8794d1ea845SChuck Lever { 1 << NFSD_FILE_REFERENCED, "REFERENCED" }, \ 8804d1ea845SChuck Lever { 1 << NFSD_FILE_GC, "GC" }) 88165294c1fSJeff Layton 88265294c1fSJeff Layton DECLARE_EVENT_CLASS(nfsd_file_class, 88365294c1fSJeff Layton TP_PROTO(struct nfsd_file *nf), 88465294c1fSJeff Layton TP_ARGS(nf), 88565294c1fSJeff Layton TP_STRUCT__entry( 88665294c1fSJeff Layton __field(void *, nf_inode) 88765294c1fSJeff Layton __field(int, nf_ref) 88865294c1fSJeff Layton __field(unsigned long, nf_flags) 88965294c1fSJeff Layton __field(unsigned char, nf_may) 89065294c1fSJeff Layton __field(struct file *, nf_file) 89165294c1fSJeff Layton ), 89265294c1fSJeff Layton TP_fast_assign( 89365294c1fSJeff Layton __entry->nf_inode = nf->nf_inode; 894689827cdSTrond Myklebust __entry->nf_ref = refcount_read(&nf->nf_ref); 89565294c1fSJeff Layton __entry->nf_flags = nf->nf_flags; 89665294c1fSJeff Layton __entry->nf_may = nf->nf_may; 89765294c1fSJeff Layton __entry->nf_file = nf->nf_file; 89865294c1fSJeff Layton ), 89954f7df70SChuck Lever TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p", 90065294c1fSJeff Layton __entry->nf_inode, 90165294c1fSJeff Layton __entry->nf_ref, 90265294c1fSJeff Layton show_nf_flags(__entry->nf_flags), 903b76278aeSChuck Lever show_nfsd_may_flags(__entry->nf_may), 90465294c1fSJeff Layton __entry->nf_file) 90565294c1fSJeff Layton ) 90665294c1fSJeff Layton 90765294c1fSJeff Layton #define DEFINE_NFSD_FILE_EVENT(name) \ 90865294c1fSJeff Layton DEFINE_EVENT(nfsd_file_class, name, \ 90965294c1fSJeff Layton TP_PROTO(struct nfsd_file *nf), \ 91065294c1fSJeff Layton TP_ARGS(nf)) 91165294c1fSJeff Layton 91282141185SJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_free); 91365294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 91465294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 915ac3a2585SJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_closing); 91682141185SJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue); 91765294c1fSJeff Layton 918b40a2839SChuck Lever TRACE_EVENT(nfsd_file_alloc, 919b40a2839SChuck Lever TP_PROTO( 920b40a2839SChuck Lever const struct nfsd_file *nf 921b40a2839SChuck Lever ), 922b40a2839SChuck Lever TP_ARGS(nf), 923b40a2839SChuck Lever TP_STRUCT__entry( 924b40a2839SChuck Lever __field(const void *, nf_inode) 925b40a2839SChuck Lever __field(unsigned long, nf_flags) 926b40a2839SChuck Lever __field(unsigned long, nf_may) 927b40a2839SChuck Lever __field(unsigned int, nf_ref) 928b40a2839SChuck Lever ), 929b40a2839SChuck Lever TP_fast_assign( 930b40a2839SChuck Lever __entry->nf_inode = nf->nf_inode; 931b40a2839SChuck Lever __entry->nf_flags = nf->nf_flags; 932b40a2839SChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 933b40a2839SChuck Lever __entry->nf_may = nf->nf_may; 934b40a2839SChuck Lever ), 935b40a2839SChuck Lever TP_printk("inode=%p ref=%u flags=%s may=%s", 936b40a2839SChuck Lever __entry->nf_inode, __entry->nf_ref, 937b40a2839SChuck Lever show_nf_flags(__entry->nf_flags), 938b40a2839SChuck Lever show_nfsd_may_flags(__entry->nf_may) 939b40a2839SChuck Lever ) 940b40a2839SChuck Lever ); 941b40a2839SChuck Lever 94265294c1fSJeff Layton TRACE_EVENT(nfsd_file_acquire, 94354f7df70SChuck Lever TP_PROTO( 944be023006SChuck Lever const struct svc_rqst *rqstp, 945be023006SChuck Lever const struct inode *inode, 94654f7df70SChuck Lever unsigned int may_flags, 947be023006SChuck Lever const struct nfsd_file *nf, 94854f7df70SChuck Lever __be32 status 94954f7df70SChuck Lever ), 95065294c1fSJeff Layton 95154f7df70SChuck Lever TP_ARGS(rqstp, inode, may_flags, nf, status), 95265294c1fSJeff Layton 95365294c1fSJeff Layton TP_STRUCT__entry( 954a9ceb060STrond Myklebust __field(u32, xid) 955be023006SChuck Lever __field(const void *, inode) 956b76278aeSChuck Lever __field(unsigned long, may_flags) 957be023006SChuck Lever __field(unsigned int, nf_ref) 95865294c1fSJeff Layton __field(unsigned long, nf_flags) 959b76278aeSChuck Lever __field(unsigned long, nf_may) 960be023006SChuck Lever __field(const void *, nf_file) 961a9ceb060STrond Myklebust __field(u32, status) 96265294c1fSJeff Layton ), 96365294c1fSJeff Layton 96465294c1fSJeff Layton TP_fast_assign( 965a9ceb060STrond Myklebust __entry->xid = be32_to_cpu(rqstp->rq_xid); 96665294c1fSJeff Layton __entry->inode = inode; 96765294c1fSJeff Layton __entry->may_flags = may_flags; 968689827cdSTrond Myklebust __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 96965294c1fSJeff Layton __entry->nf_flags = nf ? nf->nf_flags : 0; 97065294c1fSJeff Layton __entry->nf_may = nf ? nf->nf_may : 0; 97165294c1fSJeff Layton __entry->nf_file = nf ? nf->nf_file : NULL; 972a9ceb060STrond Myklebust __entry->status = be32_to_cpu(status); 97365294c1fSJeff Layton ), 97465294c1fSJeff Layton 975be023006SChuck Lever TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u", 97654f7df70SChuck Lever __entry->xid, __entry->inode, 977b76278aeSChuck Lever show_nfsd_may_flags(__entry->may_flags), 978b76278aeSChuck Lever __entry->nf_ref, show_nf_flags(__entry->nf_flags), 979b76278aeSChuck Lever show_nfsd_may_flags(__entry->nf_may), 980be023006SChuck Lever __entry->nf_file, __entry->status 981be023006SChuck Lever ) 982be023006SChuck Lever ); 983be023006SChuck Lever 984ce502f81SChuck Lever TRACE_EVENT(nfsd_file_insert_err, 985ce502f81SChuck Lever TP_PROTO( 986ce502f81SChuck Lever const struct svc_rqst *rqstp, 987ce502f81SChuck Lever const struct inode *inode, 988ce502f81SChuck Lever unsigned int may_flags, 989ce502f81SChuck Lever long error 990ce502f81SChuck Lever ), 991ce502f81SChuck Lever TP_ARGS(rqstp, inode, may_flags, error), 992ce502f81SChuck Lever TP_STRUCT__entry( 993ce502f81SChuck Lever __field(u32, xid) 994ce502f81SChuck Lever __field(const void *, inode) 995ce502f81SChuck Lever __field(unsigned long, may_flags) 996ce502f81SChuck Lever __field(long, error) 997ce502f81SChuck Lever ), 998ce502f81SChuck Lever TP_fast_assign( 999ce502f81SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 1000ce502f81SChuck Lever __entry->inode = inode; 1001ce502f81SChuck Lever __entry->may_flags = may_flags; 1002ce502f81SChuck Lever __entry->error = error; 1003ce502f81SChuck Lever ), 1004ce502f81SChuck Lever TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld", 1005ce502f81SChuck Lever __entry->xid, __entry->inode, 1006ce502f81SChuck Lever show_nfsd_may_flags(__entry->may_flags), 1007ce502f81SChuck Lever __entry->error 1008ce502f81SChuck Lever ) 1009ce502f81SChuck Lever ); 1010ce502f81SChuck Lever 1011ce502f81SChuck Lever TRACE_EVENT(nfsd_file_cons_err, 1012ce502f81SChuck Lever TP_PROTO( 1013ce502f81SChuck Lever const struct svc_rqst *rqstp, 1014ce502f81SChuck Lever const struct inode *inode, 1015ce502f81SChuck Lever unsigned int may_flags, 1016ce502f81SChuck Lever const struct nfsd_file *nf 1017ce502f81SChuck Lever ), 1018ce502f81SChuck Lever TP_ARGS(rqstp, inode, may_flags, nf), 1019ce502f81SChuck Lever TP_STRUCT__entry( 1020ce502f81SChuck Lever __field(u32, xid) 1021ce502f81SChuck Lever __field(const void *, inode) 1022ce502f81SChuck Lever __field(unsigned long, may_flags) 1023ce502f81SChuck Lever __field(unsigned int, nf_ref) 1024ce502f81SChuck Lever __field(unsigned long, nf_flags) 1025ce502f81SChuck Lever __field(unsigned long, nf_may) 1026ce502f81SChuck Lever __field(const void *, nf_file) 1027ce502f81SChuck Lever ), 1028ce502f81SChuck Lever TP_fast_assign( 1029ce502f81SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 1030ce502f81SChuck Lever __entry->inode = inode; 1031ce502f81SChuck Lever __entry->may_flags = may_flags; 1032ce502f81SChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 1033ce502f81SChuck Lever __entry->nf_flags = nf->nf_flags; 1034ce502f81SChuck Lever __entry->nf_may = nf->nf_may; 1035ce502f81SChuck Lever __entry->nf_file = nf->nf_file; 1036ce502f81SChuck Lever ), 1037ce502f81SChuck Lever TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1038ce502f81SChuck Lever __entry->xid, __entry->inode, 1039ce502f81SChuck Lever show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref, 1040ce502f81SChuck Lever show_nf_flags(__entry->nf_flags), 1041ce502f81SChuck Lever show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1042ce502f81SChuck Lever ) 1043ce502f81SChuck Lever ); 1044ce502f81SChuck Lever 10450b3a551fSJeff Layton DECLARE_EVENT_CLASS(nfsd_file_open_class, 10460b3a551fSJeff Layton TP_PROTO(const struct nfsd_file *nf, __be32 status), 10470122e882SChuck Lever TP_ARGS(nf, status), 10480122e882SChuck Lever TP_STRUCT__entry( 10490122e882SChuck Lever __field(void *, nf_inode) /* cannot be dereferenced */ 10500122e882SChuck Lever __field(int, nf_ref) 10510122e882SChuck Lever __field(unsigned long, nf_flags) 10520122e882SChuck Lever __field(unsigned long, nf_may) 10530122e882SChuck Lever __field(void *, nf_file) /* cannot be dereferenced */ 10540122e882SChuck Lever ), 10550122e882SChuck Lever TP_fast_assign( 10560122e882SChuck Lever __entry->nf_inode = nf->nf_inode; 10570122e882SChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 10580122e882SChuck Lever __entry->nf_flags = nf->nf_flags; 10590122e882SChuck Lever __entry->nf_may = nf->nf_may; 10600122e882SChuck Lever __entry->nf_file = nf->nf_file; 10610122e882SChuck Lever ), 106254f7df70SChuck Lever TP_printk("inode=%p ref=%d flags=%s may=%s file=%p", 10630122e882SChuck Lever __entry->nf_inode, 10640122e882SChuck Lever __entry->nf_ref, 10650122e882SChuck Lever show_nf_flags(__entry->nf_flags), 10660122e882SChuck Lever show_nfsd_may_flags(__entry->nf_may), 10670122e882SChuck Lever __entry->nf_file) 10680122e882SChuck Lever ) 10690122e882SChuck Lever 10700b3a551fSJeff Layton #define DEFINE_NFSD_FILE_OPEN_EVENT(name) \ 10710b3a551fSJeff Layton DEFINE_EVENT(nfsd_file_open_class, name, \ 10720b3a551fSJeff Layton TP_PROTO( \ 10730b3a551fSJeff Layton const struct nfsd_file *nf, \ 10740b3a551fSJeff Layton __be32 status \ 10750b3a551fSJeff Layton ), \ 10760b3a551fSJeff Layton TP_ARGS(nf, status)) 10770b3a551fSJeff Layton 10780b3a551fSJeff Layton DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open); 10790b3a551fSJeff Layton DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened); 10800b3a551fSJeff Layton 1081a8455110SChuck Lever TRACE_EVENT(nfsd_file_is_cached, 1082a8455110SChuck Lever TP_PROTO( 1083a8455110SChuck Lever const struct inode *inode, 108454f7df70SChuck Lever int found 108554f7df70SChuck Lever ), 108654f7df70SChuck Lever TP_ARGS(inode, found), 108765294c1fSJeff Layton TP_STRUCT__entry( 1088a8455110SChuck Lever __field(const struct inode *, inode) 108965294c1fSJeff Layton __field(int, found) 109065294c1fSJeff Layton ), 109165294c1fSJeff Layton TP_fast_assign( 109265294c1fSJeff Layton __entry->inode = inode; 109365294c1fSJeff Layton __entry->found = found; 109465294c1fSJeff Layton ), 1095a8455110SChuck Lever TP_printk("inode=%p is %scached", 1096a8455110SChuck Lever __entry->inode, 1097a8455110SChuck Lever __entry->found ? "" : "not " 1098a8455110SChuck Lever ) 109965294c1fSJeff Layton ); 110065294c1fSJeff Layton 110165294c1fSJeff Layton TRACE_EVENT(nfsd_file_fsnotify_handle_event, 110265294c1fSJeff Layton TP_PROTO(struct inode *inode, u32 mask), 110365294c1fSJeff Layton TP_ARGS(inode, mask), 110465294c1fSJeff Layton TP_STRUCT__entry( 110565294c1fSJeff Layton __field(struct inode *, inode) 110665294c1fSJeff Layton __field(unsigned int, nlink) 110765294c1fSJeff Layton __field(umode_t, mode) 110865294c1fSJeff Layton __field(u32, mask) 110965294c1fSJeff Layton ), 111065294c1fSJeff Layton TP_fast_assign( 111165294c1fSJeff Layton __entry->inode = inode; 111265294c1fSJeff Layton __entry->nlink = inode->i_nlink; 111365294c1fSJeff Layton __entry->mode = inode->i_mode; 111465294c1fSJeff Layton __entry->mask = mask; 111565294c1fSJeff Layton ), 11163a90e1dfSChuck Lever TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 111765294c1fSJeff Layton __entry->nlink, __entry->mode, __entry->mask) 111865294c1fSJeff Layton ); 111965294c1fSJeff Layton 1120c46203acSChuck Lever DECLARE_EVENT_CLASS(nfsd_file_gc_class, 1121c46203acSChuck Lever TP_PROTO( 1122c46203acSChuck Lever const struct nfsd_file *nf 1123c46203acSChuck Lever ), 1124c46203acSChuck Lever TP_ARGS(nf), 1125c46203acSChuck Lever TP_STRUCT__entry( 1126c46203acSChuck Lever __field(void *, nf_inode) 1127c46203acSChuck Lever __field(void *, nf_file) 1128c46203acSChuck Lever __field(int, nf_ref) 1129c46203acSChuck Lever __field(unsigned long, nf_flags) 1130c46203acSChuck Lever ), 1131c46203acSChuck Lever TP_fast_assign( 1132c46203acSChuck Lever __entry->nf_inode = nf->nf_inode; 1133c46203acSChuck Lever __entry->nf_file = nf->nf_file; 1134c46203acSChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 1135c46203acSChuck Lever __entry->nf_flags = nf->nf_flags; 1136c46203acSChuck Lever ), 1137c46203acSChuck Lever TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p", 1138c46203acSChuck Lever __entry->nf_inode, __entry->nf_ref, 1139c46203acSChuck Lever show_nf_flags(__entry->nf_flags), 1140c46203acSChuck Lever __entry->nf_file 1141c46203acSChuck Lever ) 1142c46203acSChuck Lever ); 1143c46203acSChuck Lever 1144c46203acSChuck Lever #define DEFINE_NFSD_FILE_GC_EVENT(name) \ 1145c46203acSChuck Lever DEFINE_EVENT(nfsd_file_gc_class, name, \ 1146c46203acSChuck Lever TP_PROTO( \ 1147c46203acSChuck Lever const struct nfsd_file *nf \ 1148c46203acSChuck Lever ), \ 1149c46203acSChuck Lever TP_ARGS(nf)) 1150c46203acSChuck Lever 1151c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 11524a0e73e6SChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed); 1153c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 11544a0e73e6SChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed); 1155c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1156c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1157c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1158c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1159c46203acSChuck Lever 116094660cc1SChuck Lever DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class, 116194660cc1SChuck Lever TP_PROTO( 116294660cc1SChuck Lever unsigned long removed, 116394660cc1SChuck Lever unsigned long remaining 116494660cc1SChuck Lever ), 116594660cc1SChuck Lever TP_ARGS(removed, remaining), 116694660cc1SChuck Lever TP_STRUCT__entry( 116794660cc1SChuck Lever __field(unsigned long, removed) 116894660cc1SChuck Lever __field(unsigned long, remaining) 116994660cc1SChuck Lever ), 117094660cc1SChuck Lever TP_fast_assign( 117194660cc1SChuck Lever __entry->removed = removed; 117294660cc1SChuck Lever __entry->remaining = remaining; 117394660cc1SChuck Lever ), 117494660cc1SChuck Lever TP_printk("%lu entries removed, %lu remaining", 117594660cc1SChuck Lever __entry->removed, __entry->remaining) 117694660cc1SChuck Lever ); 117794660cc1SChuck Lever 117894660cc1SChuck Lever #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \ 117994660cc1SChuck Lever DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 118094660cc1SChuck Lever TP_PROTO( \ 118194660cc1SChuck Lever unsigned long removed, \ 118294660cc1SChuck Lever unsigned long remaining \ 118394660cc1SChuck Lever ), \ 118494660cc1SChuck Lever TP_ARGS(removed, remaining)) 118594660cc1SChuck Lever 118694660cc1SChuck Lever DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 118794660cc1SChuck Lever DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 118894660cc1SChuck Lever 1189ac3a2585SJeff Layton TRACE_EVENT(nfsd_file_close, 1190ac3a2585SJeff Layton TP_PROTO( 1191ac3a2585SJeff Layton const struct inode *inode 1192ac3a2585SJeff Layton ), 1193ac3a2585SJeff Layton TP_ARGS(inode), 1194ac3a2585SJeff Layton TP_STRUCT__entry( 1195ac3a2585SJeff Layton __field(const void *, inode) 1196ac3a2585SJeff Layton ), 1197ac3a2585SJeff Layton TP_fast_assign( 1198ac3a2585SJeff Layton __entry->inode = inode; 1199ac3a2585SJeff Layton ), 1200ac3a2585SJeff Layton TP_printk("inode=%p", 1201ac3a2585SJeff Layton __entry->inode 1202ac3a2585SJeff Layton ) 1203ac3a2585SJeff Layton ); 1204ac3a2585SJeff Layton 12050b175b18SChuck Lever #include "cache.h" 12060b175b18SChuck Lever 12070b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_DROPIT); 12080b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_REPLY); 12090b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_DOIT); 12100b175b18SChuck Lever 12110b175b18SChuck Lever #define show_drc_retval(x) \ 12120b175b18SChuck Lever __print_symbolic(x, \ 12130b175b18SChuck Lever { RC_DROPIT, "DROPIT" }, \ 12140b175b18SChuck Lever { RC_REPLY, "REPLY" }, \ 12150b175b18SChuck Lever { RC_DOIT, "DOIT" }) 12160b175b18SChuck Lever 12170b175b18SChuck Lever TRACE_EVENT(nfsd_drc_found, 12180b175b18SChuck Lever TP_PROTO( 12190b175b18SChuck Lever const struct nfsd_net *nn, 12200b175b18SChuck Lever const struct svc_rqst *rqstp, 12210b175b18SChuck Lever int result 12220b175b18SChuck Lever ), 12230b175b18SChuck Lever TP_ARGS(nn, rqstp, result), 12240b175b18SChuck Lever TP_STRUCT__entry( 12250b175b18SChuck Lever __field(unsigned long long, boot_time) 12260b175b18SChuck Lever __field(unsigned long, result) 12270b175b18SChuck Lever __field(u32, xid) 12280b175b18SChuck Lever ), 12290b175b18SChuck Lever TP_fast_assign( 12300b175b18SChuck Lever __entry->boot_time = nn->boot_time; 12310b175b18SChuck Lever __entry->result = result; 12320b175b18SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 12330b175b18SChuck Lever ), 12340b175b18SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x result=%s", 12350b175b18SChuck Lever __entry->boot_time, __entry->xid, 12360b175b18SChuck Lever show_drc_retval(__entry->result)) 12370b175b18SChuck Lever 12380b175b18SChuck Lever ); 12390b175b18SChuck Lever 12400b175b18SChuck Lever TRACE_EVENT(nfsd_drc_mismatch, 12410b175b18SChuck Lever TP_PROTO( 12420b175b18SChuck Lever const struct nfsd_net *nn, 12430b175b18SChuck Lever const struct svc_cacherep *key, 12440b175b18SChuck Lever const struct svc_cacherep *rp 12450b175b18SChuck Lever ), 12460b175b18SChuck Lever TP_ARGS(nn, key, rp), 12470b175b18SChuck Lever TP_STRUCT__entry( 12480b175b18SChuck Lever __field(unsigned long long, boot_time) 12490b175b18SChuck Lever __field(u32, xid) 12500b175b18SChuck Lever __field(u32, cached) 12510b175b18SChuck Lever __field(u32, ingress) 12520b175b18SChuck Lever ), 12530b175b18SChuck Lever TP_fast_assign( 12540b175b18SChuck Lever __entry->boot_time = nn->boot_time; 12550b175b18SChuck Lever __entry->xid = be32_to_cpu(key->c_key.k_xid); 12560b175b18SChuck Lever __entry->cached = (__force u32)key->c_key.k_csum; 12570b175b18SChuck Lever __entry->ingress = (__force u32)rp->c_key.k_csum; 12580b175b18SChuck Lever ), 12590b175b18SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 12600b175b18SChuck Lever __entry->boot_time, __entry->xid, __entry->cached, 12610b175b18SChuck Lever __entry->ingress) 12620b175b18SChuck Lever ); 12630b175b18SChuck Lever 12641eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_args, 12651eace0d1SChuck Lever TP_PROTO( 12661eace0d1SChuck Lever const struct nfs4_client *clp, 12671eace0d1SChuck Lever const struct nfs4_cb_conn *conn 12681eace0d1SChuck Lever ), 12691eace0d1SChuck Lever TP_ARGS(clp, conn), 12701eace0d1SChuck Lever TP_STRUCT__entry( 12711eace0d1SChuck Lever __field(u32, cl_boot) 12721eace0d1SChuck Lever __field(u32, cl_id) 12731eace0d1SChuck Lever __field(u32, prog) 12741eace0d1SChuck Lever __field(u32, ident) 12759db0e15fSChuck Lever __sockaddr(addr, conn->cb_addrlen) 12761eace0d1SChuck Lever ), 12771eace0d1SChuck Lever TP_fast_assign( 12781eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 12791eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 12801eace0d1SChuck Lever __entry->prog = conn->cb_prog; 12811eace0d1SChuck Lever __entry->ident = conn->cb_ident; 12829db0e15fSChuck Lever __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 12831eace0d1SChuck Lever ), 1284d6cbe98fSChuck Lever TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 12859db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1286d6cbe98fSChuck Lever __entry->prog, __entry->ident) 12871eace0d1SChuck Lever ); 12881eace0d1SChuck Lever 12891eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_nodelegs, 12901eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), 12911eace0d1SChuck Lever TP_ARGS(clp), 12921eace0d1SChuck Lever TP_STRUCT__entry( 12931eace0d1SChuck Lever __field(u32, cl_boot) 12941eace0d1SChuck Lever __field(u32, cl_id) 12951eace0d1SChuck Lever ), 12961eace0d1SChuck Lever TP_fast_assign( 12971eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 12981eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 12991eace0d1SChuck Lever ), 13001eace0d1SChuck Lever TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 13011eace0d1SChuck Lever ) 13021eace0d1SChuck Lever 13031eace0d1SChuck Lever #define show_cb_state(val) \ 13041eace0d1SChuck Lever __print_symbolic(val, \ 13051eace0d1SChuck Lever { NFSD4_CB_UP, "UP" }, \ 13061eace0d1SChuck Lever { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 13071eace0d1SChuck Lever { NFSD4_CB_DOWN, "DOWN" }, \ 13081eace0d1SChuck Lever { NFSD4_CB_FAULT, "FAULT"}) 13091eace0d1SChuck Lever 13101eace0d1SChuck Lever DECLARE_EVENT_CLASS(nfsd_cb_class, 13111eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), 13121eace0d1SChuck Lever TP_ARGS(clp), 13131eace0d1SChuck Lever TP_STRUCT__entry( 13141eace0d1SChuck Lever __field(unsigned long, state) 13151eace0d1SChuck Lever __field(u32, cl_boot) 13161eace0d1SChuck Lever __field(u32, cl_id) 13179db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 13181eace0d1SChuck Lever ), 13191eace0d1SChuck Lever TP_fast_assign( 13201eace0d1SChuck Lever __entry->state = clp->cl_cb_state; 13211eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 13221eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 13239db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 13249db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 13251eace0d1SChuck Lever ), 13261eace0d1SChuck Lever TP_printk("addr=%pISpc client %08x:%08x state=%s", 13279db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 13281eace0d1SChuck Lever show_cb_state(__entry->state)) 13291eace0d1SChuck Lever ); 13301eace0d1SChuck Lever 13311eace0d1SChuck Lever #define DEFINE_NFSD_CB_EVENT(name) \ 13321eace0d1SChuck Lever DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 13331eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), \ 13341eace0d1SChuck Lever TP_ARGS(clp)) 13351eace0d1SChuck Lever 13361eace0d1SChuck Lever DEFINE_NFSD_CB_EVENT(state); 13374ade892aSChuck Lever DEFINE_NFSD_CB_EVENT(probe); 1338806d65b6SChuck Lever DEFINE_NFSD_CB_EVENT(lost); 13391eace0d1SChuck Lever DEFINE_NFSD_CB_EVENT(shutdown); 13401eace0d1SChuck Lever 134187b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 134287b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 134387b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 134487b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 134587b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 134687b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 134787b2394dSChuck Lever 134887b2394dSChuck Lever #define show_nfsd_authflavor(val) \ 134987b2394dSChuck Lever __print_symbolic(val, \ 135087b2394dSChuck Lever { RPC_AUTH_NULL, "none" }, \ 135187b2394dSChuck Lever { RPC_AUTH_UNIX, "sys" }, \ 135287b2394dSChuck Lever { RPC_AUTH_GSS, "gss" }, \ 135387b2394dSChuck Lever { RPC_AUTH_GSS_KRB5, "krb5" }, \ 135487b2394dSChuck Lever { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 135587b2394dSChuck Lever { RPC_AUTH_GSS_KRB5P, "krb5p" }) 135687b2394dSChuck Lever 13573c92fba5SChuck Lever TRACE_EVENT(nfsd_cb_setup, 13583c92fba5SChuck Lever TP_PROTO(const struct nfs4_client *clp, 13593c92fba5SChuck Lever const char *netid, 13603c92fba5SChuck Lever rpc_authflavor_t authflavor 13613c92fba5SChuck Lever ), 13623c92fba5SChuck Lever TP_ARGS(clp, netid, authflavor), 13633c92fba5SChuck Lever TP_STRUCT__entry( 13643c92fba5SChuck Lever __field(u32, cl_boot) 13653c92fba5SChuck Lever __field(u32, cl_id) 13663c92fba5SChuck Lever __field(unsigned long, authflavor) 13679db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1368*21a3f332SAzeem Shaikh __string(netid, netid) 13693c92fba5SChuck Lever ), 13703c92fba5SChuck Lever TP_fast_assign( 13713c92fba5SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 13723c92fba5SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 1373*21a3f332SAzeem Shaikh __assign_str(netid, netid); 13743c92fba5SChuck Lever __entry->authflavor = authflavor; 13759db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 13769db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 13773c92fba5SChuck Lever ), 13783c92fba5SChuck Lever TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 13799db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1380*21a3f332SAzeem Shaikh __get_str(netid), show_nfsd_authflavor(__entry->authflavor)) 13813c92fba5SChuck Lever ); 13823c92fba5SChuck Lever 13831eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_setup_err, 13841eace0d1SChuck Lever TP_PROTO( 13851eace0d1SChuck Lever const struct nfs4_client *clp, 13861eace0d1SChuck Lever long error 13871eace0d1SChuck Lever ), 13881eace0d1SChuck Lever TP_ARGS(clp, error), 13891eace0d1SChuck Lever TP_STRUCT__entry( 13901eace0d1SChuck Lever __field(long, error) 13911eace0d1SChuck Lever __field(u32, cl_boot) 13921eace0d1SChuck Lever __field(u32, cl_id) 13939db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 13941eace0d1SChuck Lever ), 13951eace0d1SChuck Lever TP_fast_assign( 13961eace0d1SChuck Lever __entry->error = error; 13971eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 13981eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 13999db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 14009db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 14011eace0d1SChuck Lever ), 14021eace0d1SChuck Lever TP_printk("addr=%pISpc client %08x:%08x error=%ld", 14039db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 14049db0e15fSChuck Lever __entry->error) 14051eace0d1SChuck Lever ); 14061eace0d1SChuck Lever 14079db0e15fSChuck Lever TRACE_EVENT_CONDITION(nfsd_cb_recall, 140817d76ddfSChuck Lever TP_PROTO( 140917d76ddfSChuck Lever const struct nfs4_stid *stid 141017d76ddfSChuck Lever ), 141117d76ddfSChuck Lever TP_ARGS(stid), 14129db0e15fSChuck Lever TP_CONDITION(stid->sc_client), 141317d76ddfSChuck Lever TP_STRUCT__entry( 141417d76ddfSChuck Lever __field(u32, cl_boot) 141517d76ddfSChuck Lever __field(u32, cl_id) 141617d76ddfSChuck Lever __field(u32, si_id) 141717d76ddfSChuck Lever __field(u32, si_generation) 14189db0e15fSChuck Lever __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 141917d76ddfSChuck Lever ), 142017d76ddfSChuck Lever TP_fast_assign( 142117d76ddfSChuck Lever const stateid_t *stp = &stid->sc_stateid; 142217d76ddfSChuck Lever const struct nfs4_client *clp = stid->sc_client; 142317d76ddfSChuck Lever 142417d76ddfSChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 142517d76ddfSChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 142617d76ddfSChuck Lever __entry->si_id = stp->si_opaque.so_id; 142717d76ddfSChuck Lever __entry->si_generation = stp->si_generation; 14289db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 14299db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 143017d76ddfSChuck Lever ), 143117d76ddfSChuck Lever TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 14329db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 143317d76ddfSChuck Lever __entry->si_id, __entry->si_generation) 143417d76ddfSChuck Lever ); 143517d76ddfSChuck Lever 14362cde7f81SChuck Lever TRACE_EVENT(nfsd_cb_notify_lock, 14372cde7f81SChuck Lever TP_PROTO( 14382cde7f81SChuck Lever const struct nfs4_lockowner *lo, 14392cde7f81SChuck Lever const struct nfsd4_blocked_lock *nbl 14402cde7f81SChuck Lever ), 14412cde7f81SChuck Lever TP_ARGS(lo, nbl), 14422cde7f81SChuck Lever TP_STRUCT__entry( 14432cde7f81SChuck Lever __field(u32, cl_boot) 14442cde7f81SChuck Lever __field(u32, cl_id) 14452cde7f81SChuck Lever __field(u32, fh_hash) 14469db0e15fSChuck Lever __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 14472cde7f81SChuck Lever ), 14482cde7f81SChuck Lever TP_fast_assign( 14492cde7f81SChuck Lever const struct nfs4_client *clp = lo->lo_owner.so_client; 14502cde7f81SChuck Lever 14512cde7f81SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 14522cde7f81SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 14532cde7f81SChuck Lever __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 14549db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 14559db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 14562cde7f81SChuck Lever ), 14572cde7f81SChuck Lever TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 14589db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 14592cde7f81SChuck Lever __entry->fh_hash) 14602cde7f81SChuck Lever ); 14612cde7f81SChuck Lever 146287512386SChuck Lever TRACE_EVENT(nfsd_cb_offload, 146387512386SChuck Lever TP_PROTO( 146487512386SChuck Lever const struct nfs4_client *clp, 146587512386SChuck Lever const stateid_t *stp, 146687512386SChuck Lever const struct knfsd_fh *fh, 146787512386SChuck Lever u64 count, 146887512386SChuck Lever __be32 status 146987512386SChuck Lever ), 147087512386SChuck Lever TP_ARGS(clp, stp, fh, count, status), 147187512386SChuck Lever TP_STRUCT__entry( 147287512386SChuck Lever __field(u32, cl_boot) 147387512386SChuck Lever __field(u32, cl_id) 147487512386SChuck Lever __field(u32, si_id) 147587512386SChuck Lever __field(u32, si_generation) 147687512386SChuck Lever __field(u32, fh_hash) 147787512386SChuck Lever __field(int, status) 147887512386SChuck Lever __field(u64, count) 14799db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 148087512386SChuck Lever ), 148187512386SChuck Lever TP_fast_assign( 148287512386SChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 148387512386SChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 148487512386SChuck Lever __entry->si_id = stp->si_opaque.so_id; 148587512386SChuck Lever __entry->si_generation = stp->si_generation; 148687512386SChuck Lever __entry->fh_hash = knfsd_fh_hash(fh); 148787512386SChuck Lever __entry->status = be32_to_cpu(status); 148887512386SChuck Lever __entry->count = count; 14899db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 14909db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 149187512386SChuck Lever ), 149287512386SChuck Lever TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 14939db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 149487512386SChuck Lever __entry->si_id, __entry->si_generation, 149587512386SChuck Lever __entry->fh_hash, __entry->count, __entry->status) 149687512386SChuck Lever ); 149787512386SChuck Lever 1498638593beSDai Ngo TRACE_EVENT(nfsd_cb_recall_any, 1499638593beSDai Ngo TP_PROTO( 1500638593beSDai Ngo const struct nfsd4_cb_recall_any *ra 1501638593beSDai Ngo ), 1502638593beSDai Ngo TP_ARGS(ra), 1503638593beSDai Ngo TP_STRUCT__entry( 1504638593beSDai Ngo __field(u32, cl_boot) 1505638593beSDai Ngo __field(u32, cl_id) 1506638593beSDai Ngo __field(u32, keep) 1507638593beSDai Ngo __field(unsigned long, bmval0) 1508638593beSDai Ngo __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen) 1509638593beSDai Ngo ), 1510638593beSDai Ngo TP_fast_assign( 1511638593beSDai Ngo __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot; 1512638593beSDai Ngo __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id; 1513638593beSDai Ngo __entry->keep = ra->ra_keep; 1514638593beSDai Ngo __entry->bmval0 = ra->ra_bmval[0]; 1515638593beSDai Ngo __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr, 1516638593beSDai Ngo ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen); 1517638593beSDai Ngo ), 1518638593beSDai Ngo TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s", 1519638593beSDai Ngo __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1520638593beSDai Ngo __entry->keep, show_rca_mask(__entry->bmval0) 1521638593beSDai Ngo ) 1522638593beSDai Ngo ); 1523638593beSDai Ngo 15241035d654SChuck Lever DECLARE_EVENT_CLASS(nfsd_cb_done_class, 15251035d654SChuck Lever TP_PROTO( 15261035d654SChuck Lever const stateid_t *stp, 15271035d654SChuck Lever const struct rpc_task *task 15281035d654SChuck Lever ), 15291035d654SChuck Lever TP_ARGS(stp, task), 15301035d654SChuck Lever TP_STRUCT__entry( 15311035d654SChuck Lever __field(u32, cl_boot) 15321035d654SChuck Lever __field(u32, cl_id) 15331035d654SChuck Lever __field(u32, si_id) 15341035d654SChuck Lever __field(u32, si_generation) 15351035d654SChuck Lever __field(int, status) 15361035d654SChuck Lever ), 15371035d654SChuck Lever TP_fast_assign( 15381035d654SChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 15391035d654SChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 15401035d654SChuck Lever __entry->si_id = stp->si_opaque.so_id; 15411035d654SChuck Lever __entry->si_generation = stp->si_generation; 15421035d654SChuck Lever __entry->status = task->tk_status; 15431035d654SChuck Lever ), 15441035d654SChuck Lever TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 15451035d654SChuck Lever __entry->cl_boot, __entry->cl_id, __entry->si_id, 15461035d654SChuck Lever __entry->si_generation, __entry->status 15471035d654SChuck Lever ) 15481035d654SChuck Lever ); 15491035d654SChuck Lever 15501035d654SChuck Lever #define DEFINE_NFSD_CB_DONE_EVENT(name) \ 15511035d654SChuck Lever DEFINE_EVENT(nfsd_cb_done_class, name, \ 15521035d654SChuck Lever TP_PROTO( \ 15531035d654SChuck Lever const stateid_t *stp, \ 15541035d654SChuck Lever const struct rpc_task *task \ 15551035d654SChuck Lever ), \ 15561035d654SChuck Lever TP_ARGS(stp, task)) 15571035d654SChuck Lever 15581035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 15591035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 15601035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 15611035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 15621035d654SChuck Lever 1563638593beSDai Ngo TRACE_EVENT(nfsd_cb_recall_any_done, 1564638593beSDai Ngo TP_PROTO( 1565638593beSDai Ngo const struct nfsd4_callback *cb, 1566638593beSDai Ngo const struct rpc_task *task 1567638593beSDai Ngo ), 1568638593beSDai Ngo TP_ARGS(cb, task), 1569638593beSDai Ngo TP_STRUCT__entry( 1570638593beSDai Ngo __field(u32, cl_boot) 1571638593beSDai Ngo __field(u32, cl_id) 1572638593beSDai Ngo __field(int, status) 1573638593beSDai Ngo ), 1574638593beSDai Ngo TP_fast_assign( 1575638593beSDai Ngo __entry->status = task->tk_status; 1576638593beSDai Ngo __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot; 1577638593beSDai Ngo __entry->cl_id = cb->cb_clp->cl_clientid.cl_id; 1578638593beSDai Ngo ), 1579638593beSDai Ngo TP_printk("client %08x:%08x status=%d", 1580638593beSDai Ngo __entry->cl_boot, __entry->cl_id, __entry->status 1581638593beSDai Ngo ) 1582638593beSDai Ngo ); 1583638593beSDai Ngo 158431ef83dcSChristoph Hellwig #endif /* _NFSD_TRACE_H */ 158531ef83dcSChristoph Hellwig 158631ef83dcSChristoph Hellwig #undef TRACE_INCLUDE_PATH 158731ef83dcSChristoph Hellwig #define TRACE_INCLUDE_PATH . 158831ef83dcSChristoph Hellwig #define TRACE_INCLUDE_FILE trace 158931ef83dcSChristoph Hellwig #include <trace/define_trace.h> 1590