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); 915*ac3a2585SJeff 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 984be023006SChuck Lever TRACE_EVENT(nfsd_file_create, 985be023006SChuck Lever TP_PROTO( 986be023006SChuck Lever const struct svc_rqst *rqstp, 987be023006SChuck Lever unsigned int may_flags, 988be023006SChuck Lever const struct nfsd_file *nf 989be023006SChuck Lever ), 990be023006SChuck Lever 991be023006SChuck Lever TP_ARGS(rqstp, may_flags, nf), 992be023006SChuck Lever 993be023006SChuck Lever TP_STRUCT__entry( 994be023006SChuck Lever __field(const void *, nf_inode) 995be023006SChuck Lever __field(const void *, nf_file) 996be023006SChuck Lever __field(unsigned long, may_flags) 997be023006SChuck Lever __field(unsigned long, nf_flags) 998be023006SChuck Lever __field(unsigned long, nf_may) 999be023006SChuck Lever __field(unsigned int, nf_ref) 1000be023006SChuck Lever __field(u32, xid) 1001be023006SChuck Lever ), 1002be023006SChuck Lever 1003be023006SChuck Lever TP_fast_assign( 1004be023006SChuck Lever __entry->nf_inode = nf->nf_inode; 1005be023006SChuck Lever __entry->nf_file = nf->nf_file; 1006be023006SChuck Lever __entry->may_flags = may_flags; 1007be023006SChuck Lever __entry->nf_flags = nf->nf_flags; 1008be023006SChuck Lever __entry->nf_may = nf->nf_may; 1009be023006SChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 1010be023006SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 1011be023006SChuck Lever ), 1012be023006SChuck Lever 1013be023006SChuck Lever TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1014be023006SChuck Lever __entry->xid, __entry->nf_inode, 1015be023006SChuck Lever show_nfsd_may_flags(__entry->may_flags), 1016be023006SChuck Lever __entry->nf_ref, show_nf_flags(__entry->nf_flags), 1017be023006SChuck Lever show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1018be023006SChuck Lever ) 101965294c1fSJeff Layton ); 102065294c1fSJeff Layton 1021ce502f81SChuck Lever TRACE_EVENT(nfsd_file_insert_err, 1022ce502f81SChuck Lever TP_PROTO( 1023ce502f81SChuck Lever const struct svc_rqst *rqstp, 1024ce502f81SChuck Lever const struct inode *inode, 1025ce502f81SChuck Lever unsigned int may_flags, 1026ce502f81SChuck Lever long error 1027ce502f81SChuck Lever ), 1028ce502f81SChuck Lever TP_ARGS(rqstp, inode, may_flags, error), 1029ce502f81SChuck Lever TP_STRUCT__entry( 1030ce502f81SChuck Lever __field(u32, xid) 1031ce502f81SChuck Lever __field(const void *, inode) 1032ce502f81SChuck Lever __field(unsigned long, may_flags) 1033ce502f81SChuck Lever __field(long, error) 1034ce502f81SChuck Lever ), 1035ce502f81SChuck Lever TP_fast_assign( 1036ce502f81SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 1037ce502f81SChuck Lever __entry->inode = inode; 1038ce502f81SChuck Lever __entry->may_flags = may_flags; 1039ce502f81SChuck Lever __entry->error = error; 1040ce502f81SChuck Lever ), 1041ce502f81SChuck Lever TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld", 1042ce502f81SChuck Lever __entry->xid, __entry->inode, 1043ce502f81SChuck Lever show_nfsd_may_flags(__entry->may_flags), 1044ce502f81SChuck Lever __entry->error 1045ce502f81SChuck Lever ) 1046ce502f81SChuck Lever ); 1047ce502f81SChuck Lever 1048ce502f81SChuck Lever TRACE_EVENT(nfsd_file_cons_err, 1049ce502f81SChuck Lever TP_PROTO( 1050ce502f81SChuck Lever const struct svc_rqst *rqstp, 1051ce502f81SChuck Lever const struct inode *inode, 1052ce502f81SChuck Lever unsigned int may_flags, 1053ce502f81SChuck Lever const struct nfsd_file *nf 1054ce502f81SChuck Lever ), 1055ce502f81SChuck Lever TP_ARGS(rqstp, inode, may_flags, nf), 1056ce502f81SChuck Lever TP_STRUCT__entry( 1057ce502f81SChuck Lever __field(u32, xid) 1058ce502f81SChuck Lever __field(const void *, inode) 1059ce502f81SChuck Lever __field(unsigned long, may_flags) 1060ce502f81SChuck Lever __field(unsigned int, nf_ref) 1061ce502f81SChuck Lever __field(unsigned long, nf_flags) 1062ce502f81SChuck Lever __field(unsigned long, nf_may) 1063ce502f81SChuck Lever __field(const void *, nf_file) 1064ce502f81SChuck Lever ), 1065ce502f81SChuck Lever TP_fast_assign( 1066ce502f81SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 1067ce502f81SChuck Lever __entry->inode = inode; 1068ce502f81SChuck Lever __entry->may_flags = may_flags; 1069ce502f81SChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 1070ce502f81SChuck Lever __entry->nf_flags = nf->nf_flags; 1071ce502f81SChuck Lever __entry->nf_may = nf->nf_may; 1072ce502f81SChuck Lever __entry->nf_file = nf->nf_file; 1073ce502f81SChuck Lever ), 1074ce502f81SChuck Lever TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1075ce502f81SChuck Lever __entry->xid, __entry->inode, 1076ce502f81SChuck Lever show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref, 1077ce502f81SChuck Lever show_nf_flags(__entry->nf_flags), 1078ce502f81SChuck Lever show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1079ce502f81SChuck Lever ) 1080ce502f81SChuck Lever ); 1081ce502f81SChuck Lever 10820122e882SChuck Lever TRACE_EVENT(nfsd_file_open, 10830122e882SChuck Lever TP_PROTO(struct nfsd_file *nf, __be32 status), 10840122e882SChuck Lever TP_ARGS(nf, status), 10850122e882SChuck Lever TP_STRUCT__entry( 10860122e882SChuck Lever __field(void *, nf_inode) /* cannot be dereferenced */ 10870122e882SChuck Lever __field(int, nf_ref) 10880122e882SChuck Lever __field(unsigned long, nf_flags) 10890122e882SChuck Lever __field(unsigned long, nf_may) 10900122e882SChuck Lever __field(void *, nf_file) /* cannot be dereferenced */ 10910122e882SChuck Lever ), 10920122e882SChuck Lever TP_fast_assign( 10930122e882SChuck Lever __entry->nf_inode = nf->nf_inode; 10940122e882SChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 10950122e882SChuck Lever __entry->nf_flags = nf->nf_flags; 10960122e882SChuck Lever __entry->nf_may = nf->nf_may; 10970122e882SChuck Lever __entry->nf_file = nf->nf_file; 10980122e882SChuck Lever ), 109954f7df70SChuck Lever TP_printk("inode=%p ref=%d flags=%s may=%s file=%p", 11000122e882SChuck Lever __entry->nf_inode, 11010122e882SChuck Lever __entry->nf_ref, 11020122e882SChuck Lever show_nf_flags(__entry->nf_flags), 11030122e882SChuck Lever show_nfsd_may_flags(__entry->nf_may), 11040122e882SChuck Lever __entry->nf_file) 11050122e882SChuck Lever ) 11060122e882SChuck Lever 1107a8455110SChuck Lever TRACE_EVENT(nfsd_file_is_cached, 1108a8455110SChuck Lever TP_PROTO( 1109a8455110SChuck Lever const struct inode *inode, 111054f7df70SChuck Lever int found 111154f7df70SChuck Lever ), 111254f7df70SChuck Lever TP_ARGS(inode, found), 111365294c1fSJeff Layton TP_STRUCT__entry( 1114a8455110SChuck Lever __field(const struct inode *, inode) 111565294c1fSJeff Layton __field(int, found) 111665294c1fSJeff Layton ), 111765294c1fSJeff Layton TP_fast_assign( 111865294c1fSJeff Layton __entry->inode = inode; 111965294c1fSJeff Layton __entry->found = found; 112065294c1fSJeff Layton ), 1121a8455110SChuck Lever TP_printk("inode=%p is %scached", 1122a8455110SChuck Lever __entry->inode, 1123a8455110SChuck Lever __entry->found ? "" : "not " 1124a8455110SChuck Lever ) 112565294c1fSJeff Layton ); 112665294c1fSJeff Layton 112765294c1fSJeff Layton TRACE_EVENT(nfsd_file_fsnotify_handle_event, 112865294c1fSJeff Layton TP_PROTO(struct inode *inode, u32 mask), 112965294c1fSJeff Layton TP_ARGS(inode, mask), 113065294c1fSJeff Layton TP_STRUCT__entry( 113165294c1fSJeff Layton __field(struct inode *, inode) 113265294c1fSJeff Layton __field(unsigned int, nlink) 113365294c1fSJeff Layton __field(umode_t, mode) 113465294c1fSJeff Layton __field(u32, mask) 113565294c1fSJeff Layton ), 113665294c1fSJeff Layton TP_fast_assign( 113765294c1fSJeff Layton __entry->inode = inode; 113865294c1fSJeff Layton __entry->nlink = inode->i_nlink; 113965294c1fSJeff Layton __entry->mode = inode->i_mode; 114065294c1fSJeff Layton __entry->mask = mask; 114165294c1fSJeff Layton ), 11423a90e1dfSChuck Lever TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 114365294c1fSJeff Layton __entry->nlink, __entry->mode, __entry->mask) 114465294c1fSJeff Layton ); 114565294c1fSJeff Layton 1146c46203acSChuck Lever DECLARE_EVENT_CLASS(nfsd_file_gc_class, 1147c46203acSChuck Lever TP_PROTO( 1148c46203acSChuck Lever const struct nfsd_file *nf 1149c46203acSChuck Lever ), 1150c46203acSChuck Lever TP_ARGS(nf), 1151c46203acSChuck Lever TP_STRUCT__entry( 1152c46203acSChuck Lever __field(void *, nf_inode) 1153c46203acSChuck Lever __field(void *, nf_file) 1154c46203acSChuck Lever __field(int, nf_ref) 1155c46203acSChuck Lever __field(unsigned long, nf_flags) 1156c46203acSChuck Lever ), 1157c46203acSChuck Lever TP_fast_assign( 1158c46203acSChuck Lever __entry->nf_inode = nf->nf_inode; 1159c46203acSChuck Lever __entry->nf_file = nf->nf_file; 1160c46203acSChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 1161c46203acSChuck Lever __entry->nf_flags = nf->nf_flags; 1162c46203acSChuck Lever ), 1163c46203acSChuck Lever TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p", 1164c46203acSChuck Lever __entry->nf_inode, __entry->nf_ref, 1165c46203acSChuck Lever show_nf_flags(__entry->nf_flags), 1166c46203acSChuck Lever __entry->nf_file 1167c46203acSChuck Lever ) 1168c46203acSChuck Lever ); 1169c46203acSChuck Lever 1170c46203acSChuck Lever #define DEFINE_NFSD_FILE_GC_EVENT(name) \ 1171c46203acSChuck Lever DEFINE_EVENT(nfsd_file_gc_class, name, \ 1172c46203acSChuck Lever TP_PROTO( \ 1173c46203acSChuck Lever const struct nfsd_file *nf \ 1174c46203acSChuck Lever ), \ 1175c46203acSChuck Lever TP_ARGS(nf)) 1176c46203acSChuck Lever 1177c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 11784a0e73e6SChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed); 1179c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 11804a0e73e6SChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed); 1181c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1182c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1183c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1184c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1185c46203acSChuck Lever 118694660cc1SChuck Lever DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class, 118794660cc1SChuck Lever TP_PROTO( 118894660cc1SChuck Lever unsigned long removed, 118994660cc1SChuck Lever unsigned long remaining 119094660cc1SChuck Lever ), 119194660cc1SChuck Lever TP_ARGS(removed, remaining), 119294660cc1SChuck Lever TP_STRUCT__entry( 119394660cc1SChuck Lever __field(unsigned long, removed) 119494660cc1SChuck Lever __field(unsigned long, remaining) 119594660cc1SChuck Lever ), 119694660cc1SChuck Lever TP_fast_assign( 119794660cc1SChuck Lever __entry->removed = removed; 119894660cc1SChuck Lever __entry->remaining = remaining; 119994660cc1SChuck Lever ), 120094660cc1SChuck Lever TP_printk("%lu entries removed, %lu remaining", 120194660cc1SChuck Lever __entry->removed, __entry->remaining) 120294660cc1SChuck Lever ); 120394660cc1SChuck Lever 120494660cc1SChuck Lever #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \ 120594660cc1SChuck Lever DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 120694660cc1SChuck Lever TP_PROTO( \ 120794660cc1SChuck Lever unsigned long removed, \ 120894660cc1SChuck Lever unsigned long remaining \ 120994660cc1SChuck Lever ), \ 121094660cc1SChuck Lever TP_ARGS(removed, remaining)) 121194660cc1SChuck Lever 121294660cc1SChuck Lever DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 121394660cc1SChuck Lever DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 121494660cc1SChuck Lever 1215*ac3a2585SJeff Layton TRACE_EVENT(nfsd_file_close, 1216*ac3a2585SJeff Layton TP_PROTO( 1217*ac3a2585SJeff Layton const struct inode *inode 1218*ac3a2585SJeff Layton ), 1219*ac3a2585SJeff Layton TP_ARGS(inode), 1220*ac3a2585SJeff Layton TP_STRUCT__entry( 1221*ac3a2585SJeff Layton __field(const void *, inode) 1222*ac3a2585SJeff Layton ), 1223*ac3a2585SJeff Layton TP_fast_assign( 1224*ac3a2585SJeff Layton __entry->inode = inode; 1225*ac3a2585SJeff Layton ), 1226*ac3a2585SJeff Layton TP_printk("inode=%p", 1227*ac3a2585SJeff Layton __entry->inode 1228*ac3a2585SJeff Layton ) 1229*ac3a2585SJeff Layton ); 1230*ac3a2585SJeff Layton 1231d7064eafSChuck Lever TRACE_EVENT(nfsd_file_fsync, 1232d7064eafSChuck Lever TP_PROTO( 1233d7064eafSChuck Lever const struct nfsd_file *nf, 1234d7064eafSChuck Lever int ret 1235d7064eafSChuck Lever ), 1236d7064eafSChuck Lever TP_ARGS(nf, ret), 1237d7064eafSChuck Lever TP_STRUCT__entry( 1238d7064eafSChuck Lever __field(void *, nf_inode) 1239d7064eafSChuck Lever __field(int, nf_ref) 1240d7064eafSChuck Lever __field(int, ret) 1241d7064eafSChuck Lever __field(unsigned long, nf_flags) 1242d7064eafSChuck Lever __field(unsigned char, nf_may) 1243d7064eafSChuck Lever __field(struct file *, nf_file) 1244d7064eafSChuck Lever ), 1245d7064eafSChuck Lever TP_fast_assign( 1246d7064eafSChuck Lever __entry->nf_inode = nf->nf_inode; 1247d7064eafSChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 1248d7064eafSChuck Lever __entry->ret = ret; 1249d7064eafSChuck Lever __entry->nf_flags = nf->nf_flags; 1250d7064eafSChuck Lever __entry->nf_may = nf->nf_may; 1251d7064eafSChuck Lever __entry->nf_file = nf->nf_file; 1252d7064eafSChuck Lever ), 1253d7064eafSChuck Lever TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p ret=%d", 1254d7064eafSChuck Lever __entry->nf_inode, 1255d7064eafSChuck Lever __entry->nf_ref, 1256d7064eafSChuck Lever show_nf_flags(__entry->nf_flags), 1257d7064eafSChuck Lever show_nfsd_may_flags(__entry->nf_may), 1258d7064eafSChuck Lever __entry->nf_file, __entry->ret 1259d7064eafSChuck Lever ) 1260d7064eafSChuck Lever ); 1261d7064eafSChuck Lever 12620b175b18SChuck Lever #include "cache.h" 12630b175b18SChuck Lever 12640b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_DROPIT); 12650b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_REPLY); 12660b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_DOIT); 12670b175b18SChuck Lever 12680b175b18SChuck Lever #define show_drc_retval(x) \ 12690b175b18SChuck Lever __print_symbolic(x, \ 12700b175b18SChuck Lever { RC_DROPIT, "DROPIT" }, \ 12710b175b18SChuck Lever { RC_REPLY, "REPLY" }, \ 12720b175b18SChuck Lever { RC_DOIT, "DOIT" }) 12730b175b18SChuck Lever 12740b175b18SChuck Lever TRACE_EVENT(nfsd_drc_found, 12750b175b18SChuck Lever TP_PROTO( 12760b175b18SChuck Lever const struct nfsd_net *nn, 12770b175b18SChuck Lever const struct svc_rqst *rqstp, 12780b175b18SChuck Lever int result 12790b175b18SChuck Lever ), 12800b175b18SChuck Lever TP_ARGS(nn, rqstp, result), 12810b175b18SChuck Lever TP_STRUCT__entry( 12820b175b18SChuck Lever __field(unsigned long long, boot_time) 12830b175b18SChuck Lever __field(unsigned long, result) 12840b175b18SChuck Lever __field(u32, xid) 12850b175b18SChuck Lever ), 12860b175b18SChuck Lever TP_fast_assign( 12870b175b18SChuck Lever __entry->boot_time = nn->boot_time; 12880b175b18SChuck Lever __entry->result = result; 12890b175b18SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 12900b175b18SChuck Lever ), 12910b175b18SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x result=%s", 12920b175b18SChuck Lever __entry->boot_time, __entry->xid, 12930b175b18SChuck Lever show_drc_retval(__entry->result)) 12940b175b18SChuck Lever 12950b175b18SChuck Lever ); 12960b175b18SChuck Lever 12970b175b18SChuck Lever TRACE_EVENT(nfsd_drc_mismatch, 12980b175b18SChuck Lever TP_PROTO( 12990b175b18SChuck Lever const struct nfsd_net *nn, 13000b175b18SChuck Lever const struct svc_cacherep *key, 13010b175b18SChuck Lever const struct svc_cacherep *rp 13020b175b18SChuck Lever ), 13030b175b18SChuck Lever TP_ARGS(nn, key, rp), 13040b175b18SChuck Lever TP_STRUCT__entry( 13050b175b18SChuck Lever __field(unsigned long long, boot_time) 13060b175b18SChuck Lever __field(u32, xid) 13070b175b18SChuck Lever __field(u32, cached) 13080b175b18SChuck Lever __field(u32, ingress) 13090b175b18SChuck Lever ), 13100b175b18SChuck Lever TP_fast_assign( 13110b175b18SChuck Lever __entry->boot_time = nn->boot_time; 13120b175b18SChuck Lever __entry->xid = be32_to_cpu(key->c_key.k_xid); 13130b175b18SChuck Lever __entry->cached = (__force u32)key->c_key.k_csum; 13140b175b18SChuck Lever __entry->ingress = (__force u32)rp->c_key.k_csum; 13150b175b18SChuck Lever ), 13160b175b18SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 13170b175b18SChuck Lever __entry->boot_time, __entry->xid, __entry->cached, 13180b175b18SChuck Lever __entry->ingress) 13190b175b18SChuck Lever ); 13200b175b18SChuck Lever 13211eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_args, 13221eace0d1SChuck Lever TP_PROTO( 13231eace0d1SChuck Lever const struct nfs4_client *clp, 13241eace0d1SChuck Lever const struct nfs4_cb_conn *conn 13251eace0d1SChuck Lever ), 13261eace0d1SChuck Lever TP_ARGS(clp, conn), 13271eace0d1SChuck Lever TP_STRUCT__entry( 13281eace0d1SChuck Lever __field(u32, cl_boot) 13291eace0d1SChuck Lever __field(u32, cl_id) 13301eace0d1SChuck Lever __field(u32, prog) 13311eace0d1SChuck Lever __field(u32, ident) 13329db0e15fSChuck Lever __sockaddr(addr, conn->cb_addrlen) 13331eace0d1SChuck Lever ), 13341eace0d1SChuck Lever TP_fast_assign( 13351eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 13361eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 13371eace0d1SChuck Lever __entry->prog = conn->cb_prog; 13381eace0d1SChuck Lever __entry->ident = conn->cb_ident; 13399db0e15fSChuck Lever __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 13401eace0d1SChuck Lever ), 1341d6cbe98fSChuck Lever TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 13429db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1343d6cbe98fSChuck Lever __entry->prog, __entry->ident) 13441eace0d1SChuck Lever ); 13451eace0d1SChuck Lever 13461eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_nodelegs, 13471eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), 13481eace0d1SChuck Lever TP_ARGS(clp), 13491eace0d1SChuck Lever TP_STRUCT__entry( 13501eace0d1SChuck Lever __field(u32, cl_boot) 13511eace0d1SChuck Lever __field(u32, cl_id) 13521eace0d1SChuck Lever ), 13531eace0d1SChuck Lever TP_fast_assign( 13541eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 13551eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 13561eace0d1SChuck Lever ), 13571eace0d1SChuck Lever TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 13581eace0d1SChuck Lever ) 13591eace0d1SChuck Lever 13601eace0d1SChuck Lever #define show_cb_state(val) \ 13611eace0d1SChuck Lever __print_symbolic(val, \ 13621eace0d1SChuck Lever { NFSD4_CB_UP, "UP" }, \ 13631eace0d1SChuck Lever { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 13641eace0d1SChuck Lever { NFSD4_CB_DOWN, "DOWN" }, \ 13651eace0d1SChuck Lever { NFSD4_CB_FAULT, "FAULT"}) 13661eace0d1SChuck Lever 13671eace0d1SChuck Lever DECLARE_EVENT_CLASS(nfsd_cb_class, 13681eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), 13691eace0d1SChuck Lever TP_ARGS(clp), 13701eace0d1SChuck Lever TP_STRUCT__entry( 13711eace0d1SChuck Lever __field(unsigned long, state) 13721eace0d1SChuck Lever __field(u32, cl_boot) 13731eace0d1SChuck Lever __field(u32, cl_id) 13749db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 13751eace0d1SChuck Lever ), 13761eace0d1SChuck Lever TP_fast_assign( 13771eace0d1SChuck Lever __entry->state = clp->cl_cb_state; 13781eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 13791eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 13809db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 13819db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 13821eace0d1SChuck Lever ), 13831eace0d1SChuck Lever TP_printk("addr=%pISpc client %08x:%08x state=%s", 13849db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 13851eace0d1SChuck Lever show_cb_state(__entry->state)) 13861eace0d1SChuck Lever ); 13871eace0d1SChuck Lever 13881eace0d1SChuck Lever #define DEFINE_NFSD_CB_EVENT(name) \ 13891eace0d1SChuck Lever DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 13901eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), \ 13911eace0d1SChuck Lever TP_ARGS(clp)) 13921eace0d1SChuck Lever 13931eace0d1SChuck Lever DEFINE_NFSD_CB_EVENT(state); 13944ade892aSChuck Lever DEFINE_NFSD_CB_EVENT(probe); 1395806d65b6SChuck Lever DEFINE_NFSD_CB_EVENT(lost); 13961eace0d1SChuck Lever DEFINE_NFSD_CB_EVENT(shutdown); 13971eace0d1SChuck Lever 139887b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 139987b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 140087b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 140187b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 140287b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 140387b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 140487b2394dSChuck Lever 140587b2394dSChuck Lever #define show_nfsd_authflavor(val) \ 140687b2394dSChuck Lever __print_symbolic(val, \ 140787b2394dSChuck Lever { RPC_AUTH_NULL, "none" }, \ 140887b2394dSChuck Lever { RPC_AUTH_UNIX, "sys" }, \ 140987b2394dSChuck Lever { RPC_AUTH_GSS, "gss" }, \ 141087b2394dSChuck Lever { RPC_AUTH_GSS_KRB5, "krb5" }, \ 141187b2394dSChuck Lever { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 141287b2394dSChuck Lever { RPC_AUTH_GSS_KRB5P, "krb5p" }) 141387b2394dSChuck Lever 14143c92fba5SChuck Lever TRACE_EVENT(nfsd_cb_setup, 14153c92fba5SChuck Lever TP_PROTO(const struct nfs4_client *clp, 14163c92fba5SChuck Lever const char *netid, 14173c92fba5SChuck Lever rpc_authflavor_t authflavor 14183c92fba5SChuck Lever ), 14193c92fba5SChuck Lever TP_ARGS(clp, netid, authflavor), 14203c92fba5SChuck Lever TP_STRUCT__entry( 14213c92fba5SChuck Lever __field(u32, cl_boot) 14223c92fba5SChuck Lever __field(u32, cl_id) 14233c92fba5SChuck Lever __field(unsigned long, authflavor) 14249db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 14253c92fba5SChuck Lever __array(unsigned char, netid, 8) 14263c92fba5SChuck Lever ), 14273c92fba5SChuck Lever TP_fast_assign( 14283c92fba5SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 14293c92fba5SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 14303c92fba5SChuck Lever strlcpy(__entry->netid, netid, sizeof(__entry->netid)); 14313c92fba5SChuck Lever __entry->authflavor = authflavor; 14329db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 14339db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 14343c92fba5SChuck Lever ), 14353c92fba5SChuck Lever TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 14369db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 14373c92fba5SChuck Lever __entry->netid, show_nfsd_authflavor(__entry->authflavor)) 14383c92fba5SChuck Lever ); 14393c92fba5SChuck Lever 14401eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_setup_err, 14411eace0d1SChuck Lever TP_PROTO( 14421eace0d1SChuck Lever const struct nfs4_client *clp, 14431eace0d1SChuck Lever long error 14441eace0d1SChuck Lever ), 14451eace0d1SChuck Lever TP_ARGS(clp, error), 14461eace0d1SChuck Lever TP_STRUCT__entry( 14471eace0d1SChuck Lever __field(long, error) 14481eace0d1SChuck Lever __field(u32, cl_boot) 14491eace0d1SChuck Lever __field(u32, cl_id) 14509db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 14511eace0d1SChuck Lever ), 14521eace0d1SChuck Lever TP_fast_assign( 14531eace0d1SChuck Lever __entry->error = error; 14541eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 14551eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 14569db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 14579db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 14581eace0d1SChuck Lever ), 14591eace0d1SChuck Lever TP_printk("addr=%pISpc client %08x:%08x error=%ld", 14609db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 14619db0e15fSChuck Lever __entry->error) 14621eace0d1SChuck Lever ); 14631eace0d1SChuck Lever 14649db0e15fSChuck Lever TRACE_EVENT_CONDITION(nfsd_cb_recall, 146517d76ddfSChuck Lever TP_PROTO( 146617d76ddfSChuck Lever const struct nfs4_stid *stid 146717d76ddfSChuck Lever ), 146817d76ddfSChuck Lever TP_ARGS(stid), 14699db0e15fSChuck Lever TP_CONDITION(stid->sc_client), 147017d76ddfSChuck Lever TP_STRUCT__entry( 147117d76ddfSChuck Lever __field(u32, cl_boot) 147217d76ddfSChuck Lever __field(u32, cl_id) 147317d76ddfSChuck Lever __field(u32, si_id) 147417d76ddfSChuck Lever __field(u32, si_generation) 14759db0e15fSChuck Lever __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 147617d76ddfSChuck Lever ), 147717d76ddfSChuck Lever TP_fast_assign( 147817d76ddfSChuck Lever const stateid_t *stp = &stid->sc_stateid; 147917d76ddfSChuck Lever const struct nfs4_client *clp = stid->sc_client; 148017d76ddfSChuck Lever 148117d76ddfSChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 148217d76ddfSChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 148317d76ddfSChuck Lever __entry->si_id = stp->si_opaque.so_id; 148417d76ddfSChuck Lever __entry->si_generation = stp->si_generation; 14859db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 14869db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 148717d76ddfSChuck Lever ), 148817d76ddfSChuck Lever TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 14899db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 149017d76ddfSChuck Lever __entry->si_id, __entry->si_generation) 149117d76ddfSChuck Lever ); 149217d76ddfSChuck Lever 14932cde7f81SChuck Lever TRACE_EVENT(nfsd_cb_notify_lock, 14942cde7f81SChuck Lever TP_PROTO( 14952cde7f81SChuck Lever const struct nfs4_lockowner *lo, 14962cde7f81SChuck Lever const struct nfsd4_blocked_lock *nbl 14972cde7f81SChuck Lever ), 14982cde7f81SChuck Lever TP_ARGS(lo, nbl), 14992cde7f81SChuck Lever TP_STRUCT__entry( 15002cde7f81SChuck Lever __field(u32, cl_boot) 15012cde7f81SChuck Lever __field(u32, cl_id) 15022cde7f81SChuck Lever __field(u32, fh_hash) 15039db0e15fSChuck Lever __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 15042cde7f81SChuck Lever ), 15052cde7f81SChuck Lever TP_fast_assign( 15062cde7f81SChuck Lever const struct nfs4_client *clp = lo->lo_owner.so_client; 15072cde7f81SChuck Lever 15082cde7f81SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 15092cde7f81SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 15102cde7f81SChuck Lever __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 15119db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 15129db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 15132cde7f81SChuck Lever ), 15142cde7f81SChuck Lever TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 15159db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 15162cde7f81SChuck Lever __entry->fh_hash) 15172cde7f81SChuck Lever ); 15182cde7f81SChuck Lever 151987512386SChuck Lever TRACE_EVENT(nfsd_cb_offload, 152087512386SChuck Lever TP_PROTO( 152187512386SChuck Lever const struct nfs4_client *clp, 152287512386SChuck Lever const stateid_t *stp, 152387512386SChuck Lever const struct knfsd_fh *fh, 152487512386SChuck Lever u64 count, 152587512386SChuck Lever __be32 status 152687512386SChuck Lever ), 152787512386SChuck Lever TP_ARGS(clp, stp, fh, count, status), 152887512386SChuck Lever TP_STRUCT__entry( 152987512386SChuck Lever __field(u32, cl_boot) 153087512386SChuck Lever __field(u32, cl_id) 153187512386SChuck Lever __field(u32, si_id) 153287512386SChuck Lever __field(u32, si_generation) 153387512386SChuck Lever __field(u32, fh_hash) 153487512386SChuck Lever __field(int, status) 153587512386SChuck Lever __field(u64, count) 15369db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 153787512386SChuck Lever ), 153887512386SChuck Lever TP_fast_assign( 153987512386SChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 154087512386SChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 154187512386SChuck Lever __entry->si_id = stp->si_opaque.so_id; 154287512386SChuck Lever __entry->si_generation = stp->si_generation; 154387512386SChuck Lever __entry->fh_hash = knfsd_fh_hash(fh); 154487512386SChuck Lever __entry->status = be32_to_cpu(status); 154587512386SChuck Lever __entry->count = count; 15469db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 15479db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 154887512386SChuck Lever ), 154987512386SChuck Lever TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 15509db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 155187512386SChuck Lever __entry->si_id, __entry->si_generation, 155287512386SChuck Lever __entry->fh_hash, __entry->count, __entry->status) 155387512386SChuck Lever ); 155487512386SChuck Lever 1555638593beSDai Ngo TRACE_EVENT(nfsd_cb_recall_any, 1556638593beSDai Ngo TP_PROTO( 1557638593beSDai Ngo const struct nfsd4_cb_recall_any *ra 1558638593beSDai Ngo ), 1559638593beSDai Ngo TP_ARGS(ra), 1560638593beSDai Ngo TP_STRUCT__entry( 1561638593beSDai Ngo __field(u32, cl_boot) 1562638593beSDai Ngo __field(u32, cl_id) 1563638593beSDai Ngo __field(u32, keep) 1564638593beSDai Ngo __field(unsigned long, bmval0) 1565638593beSDai Ngo __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen) 1566638593beSDai Ngo ), 1567638593beSDai Ngo TP_fast_assign( 1568638593beSDai Ngo __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot; 1569638593beSDai Ngo __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id; 1570638593beSDai Ngo __entry->keep = ra->ra_keep; 1571638593beSDai Ngo __entry->bmval0 = ra->ra_bmval[0]; 1572638593beSDai Ngo __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr, 1573638593beSDai Ngo ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen); 1574638593beSDai Ngo ), 1575638593beSDai Ngo TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s", 1576638593beSDai Ngo __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1577638593beSDai Ngo __entry->keep, show_rca_mask(__entry->bmval0) 1578638593beSDai Ngo ) 1579638593beSDai Ngo ); 1580638593beSDai Ngo 15811035d654SChuck Lever DECLARE_EVENT_CLASS(nfsd_cb_done_class, 15821035d654SChuck Lever TP_PROTO( 15831035d654SChuck Lever const stateid_t *stp, 15841035d654SChuck Lever const struct rpc_task *task 15851035d654SChuck Lever ), 15861035d654SChuck Lever TP_ARGS(stp, task), 15871035d654SChuck Lever TP_STRUCT__entry( 15881035d654SChuck Lever __field(u32, cl_boot) 15891035d654SChuck Lever __field(u32, cl_id) 15901035d654SChuck Lever __field(u32, si_id) 15911035d654SChuck Lever __field(u32, si_generation) 15921035d654SChuck Lever __field(int, status) 15931035d654SChuck Lever ), 15941035d654SChuck Lever TP_fast_assign( 15951035d654SChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 15961035d654SChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 15971035d654SChuck Lever __entry->si_id = stp->si_opaque.so_id; 15981035d654SChuck Lever __entry->si_generation = stp->si_generation; 15991035d654SChuck Lever __entry->status = task->tk_status; 16001035d654SChuck Lever ), 16011035d654SChuck Lever TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 16021035d654SChuck Lever __entry->cl_boot, __entry->cl_id, __entry->si_id, 16031035d654SChuck Lever __entry->si_generation, __entry->status 16041035d654SChuck Lever ) 16051035d654SChuck Lever ); 16061035d654SChuck Lever 16071035d654SChuck Lever #define DEFINE_NFSD_CB_DONE_EVENT(name) \ 16081035d654SChuck Lever DEFINE_EVENT(nfsd_cb_done_class, name, \ 16091035d654SChuck Lever TP_PROTO( \ 16101035d654SChuck Lever const stateid_t *stp, \ 16111035d654SChuck Lever const struct rpc_task *task \ 16121035d654SChuck Lever ), \ 16131035d654SChuck Lever TP_ARGS(stp, task)) 16141035d654SChuck Lever 16151035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 16161035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 16171035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 16181035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 16191035d654SChuck Lever 1620638593beSDai Ngo TRACE_EVENT(nfsd_cb_recall_any_done, 1621638593beSDai Ngo TP_PROTO( 1622638593beSDai Ngo const struct nfsd4_callback *cb, 1623638593beSDai Ngo const struct rpc_task *task 1624638593beSDai Ngo ), 1625638593beSDai Ngo TP_ARGS(cb, task), 1626638593beSDai Ngo TP_STRUCT__entry( 1627638593beSDai Ngo __field(u32, cl_boot) 1628638593beSDai Ngo __field(u32, cl_id) 1629638593beSDai Ngo __field(int, status) 1630638593beSDai Ngo ), 1631638593beSDai Ngo TP_fast_assign( 1632638593beSDai Ngo __entry->status = task->tk_status; 1633638593beSDai Ngo __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot; 1634638593beSDai Ngo __entry->cl_id = cb->cb_clp->cl_clientid.cl_id; 1635638593beSDai Ngo ), 1636638593beSDai Ngo TP_printk("client %08x:%08x status=%d", 1637638593beSDai Ngo __entry->cl_boot, __entry->cl_id, __entry->status 1638638593beSDai Ngo ) 1639638593beSDai Ngo ); 1640638593beSDai Ngo 164131ef83dcSChristoph Hellwig #endif /* _NFSD_TRACE_H */ 164231ef83dcSChristoph Hellwig 164331ef83dcSChristoph Hellwig #undef TRACE_INCLUDE_PATH 164431ef83dcSChristoph Hellwig #define TRACE_INCLUDE_PATH . 164531ef83dcSChristoph Hellwig #define TRACE_INCLUDE_FILE trace 164631ef83dcSChristoph Hellwig #include <trace/define_trace.h> 1647