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> 128791545eSChuck Lever 13cf749f3cSTrond Myklebust #include "export.h" 146e8b50d1SJeff Layton #include "nfsfh.h" 156e8b50d1SJeff Layton 1608281341SChuck Lever #define NFSD_TRACE_PROC_RES_FIELDS \ 1708281341SChuck Lever __field(unsigned int, netns_ino) \ 1808281341SChuck Lever __field(u32, xid) \ 1908281341SChuck Lever __field(unsigned long, status) \ 2008281341SChuck Lever __array(unsigned char, server, sizeof(struct sockaddr_in6)) \ 2108281341SChuck Lever __array(unsigned char, client, sizeof(struct sockaddr_in6)) 2208281341SChuck Lever 2308281341SChuck Lever #define NFSD_TRACE_PROC_RES_ASSIGNMENTS(error) \ 2408281341SChuck Lever do { \ 2508281341SChuck Lever __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \ 2608281341SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); \ 2708281341SChuck Lever __entry->status = be32_to_cpu(error); \ 2808281341SChuck Lever memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \ 2908281341SChuck Lever rqstp->rq_xprt->xpt_locallen); \ 3008281341SChuck Lever memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \ 3108281341SChuck Lever rqstp->rq_xprt->xpt_remotelen); \ 3208281341SChuck Lever } while (0); 3308281341SChuck Lever 3470e94d75SChuck Lever DECLARE_EVENT_CLASS(nfsd_xdr_err_class, 350dfdad1cSChuck Lever TP_PROTO( 360dfdad1cSChuck Lever const struct svc_rqst *rqstp 370dfdad1cSChuck Lever ), 380dfdad1cSChuck Lever TP_ARGS(rqstp), 390dfdad1cSChuck Lever TP_STRUCT__entry( 40c1a3f2ceSChuck Lever __field(unsigned int, netns_ino) 41c1a3f2ceSChuck Lever __field(u32, xid) 420dfdad1cSChuck Lever __field(u32, vers) 430dfdad1cSChuck Lever __field(u32, proc) 44c1a3f2ceSChuck Lever __sockaddr(server, rqstp->rq_xprt->xpt_locallen) 45c1a3f2ceSChuck Lever __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 460dfdad1cSChuck Lever ), 470dfdad1cSChuck Lever TP_fast_assign( 48c1a3f2ceSChuck Lever const struct svc_xprt *xprt = rqstp->rq_xprt; 490dfdad1cSChuck Lever 50c1a3f2ceSChuck Lever __entry->netns_ino = xprt->xpt_net->ns.inum; 51c1a3f2ceSChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 520dfdad1cSChuck Lever __entry->vers = rqstp->rq_vers; 530dfdad1cSChuck Lever __entry->proc = rqstp->rq_proc; 54c1a3f2ceSChuck Lever __assign_sockaddr(server, &xprt->xpt_local, xprt->xpt_locallen); 55c1a3f2ceSChuck Lever __assign_sockaddr(client, &xprt->xpt_remote, xprt->xpt_remotelen); 560dfdad1cSChuck Lever ), 570dfdad1cSChuck Lever TP_printk("xid=0x%08x vers=%u proc=%u", 580dfdad1cSChuck Lever __entry->xid, __entry->vers, __entry->proc 590dfdad1cSChuck Lever ) 600dfdad1cSChuck Lever ); 610dfdad1cSChuck Lever 6270e94d75SChuck Lever #define DEFINE_NFSD_XDR_ERR_EVENT(name) \ 6370e94d75SChuck Lever DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \ 6470e94d75SChuck Lever TP_PROTO(const struct svc_rqst *rqstp), \ 6570e94d75SChuck Lever TP_ARGS(rqstp)) 660dfdad1cSChuck Lever 6770e94d75SChuck Lever DEFINE_NFSD_XDR_ERR_EVENT(garbage_args); 6870e94d75SChuck Lever DEFINE_NFSD_XDR_ERR_EVENT(cant_encode); 690dfdad1cSChuck Lever 70b76278aeSChuck Lever #define show_nfsd_may_flags(x) \ 71b76278aeSChuck Lever __print_flags(x, "|", \ 72b76278aeSChuck Lever { NFSD_MAY_EXEC, "EXEC" }, \ 73b76278aeSChuck Lever { NFSD_MAY_WRITE, "WRITE" }, \ 74b76278aeSChuck Lever { NFSD_MAY_READ, "READ" }, \ 75b76278aeSChuck Lever { NFSD_MAY_SATTR, "SATTR" }, \ 76b76278aeSChuck Lever { NFSD_MAY_TRUNC, "TRUNC" }, \ 77b76278aeSChuck Lever { NFSD_MAY_LOCK, "LOCK" }, \ 78b76278aeSChuck Lever { NFSD_MAY_OWNER_OVERRIDE, "OWNER_OVERRIDE" }, \ 79b76278aeSChuck Lever { NFSD_MAY_LOCAL_ACCESS, "LOCAL_ACCESS" }, \ 80b76278aeSChuck Lever { NFSD_MAY_BYPASS_GSS_ON_ROOT, "BYPASS_GSS_ON_ROOT" }, \ 81b76278aeSChuck Lever { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \ 82b76278aeSChuck Lever { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \ 83b76278aeSChuck Lever { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \ 84b76278aeSChuck Lever { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" }) 85b76278aeSChuck Lever 86fff4080bSChuck Lever TRACE_EVENT(nfsd_compound, 87de29cf7eSChuck Lever TP_PROTO( 88de29cf7eSChuck Lever const struct svc_rqst *rqst, 89de29cf7eSChuck Lever const char *tag, 90de29cf7eSChuck Lever u32 taglen, 91de29cf7eSChuck Lever u32 opcnt 92de29cf7eSChuck Lever ), 93de29cf7eSChuck Lever TP_ARGS(rqst, tag, taglen, opcnt), 94fff4080bSChuck Lever TP_STRUCT__entry( 95fff4080bSChuck Lever __field(u32, xid) 96de29cf7eSChuck Lever __field(u32, opcnt) 97de29cf7eSChuck Lever __string_len(tag, tag, taglen) 98fff4080bSChuck Lever ), 99fff4080bSChuck Lever TP_fast_assign( 100fff4080bSChuck Lever __entry->xid = be32_to_cpu(rqst->rq_xid); 101de29cf7eSChuck Lever __entry->opcnt = opcnt; 102de29cf7eSChuck Lever __assign_str_len(tag, tag, taglen); 103fff4080bSChuck Lever ), 104de29cf7eSChuck Lever TP_printk("xid=0x%08x opcnt=%u tag=%s", 105de29cf7eSChuck Lever __entry->xid, __entry->opcnt, __get_str(tag) 106de29cf7eSChuck Lever ) 107fff4080bSChuck Lever ) 108fff4080bSChuck Lever 109fff4080bSChuck Lever TRACE_EVENT(nfsd_compound_status, 110fff4080bSChuck Lever TP_PROTO(u32 args_opcnt, 111fff4080bSChuck Lever u32 resp_opcnt, 112fff4080bSChuck Lever __be32 status, 113fff4080bSChuck Lever const char *name), 114fff4080bSChuck Lever TP_ARGS(args_opcnt, resp_opcnt, status, name), 115fff4080bSChuck Lever TP_STRUCT__entry( 116fff4080bSChuck Lever __field(u32, args_opcnt) 117fff4080bSChuck Lever __field(u32, resp_opcnt) 118fff4080bSChuck Lever __field(int, status) 119fff4080bSChuck Lever __string(name, name) 120fff4080bSChuck Lever ), 121fff4080bSChuck Lever TP_fast_assign( 122fff4080bSChuck Lever __entry->args_opcnt = args_opcnt; 123fff4080bSChuck Lever __entry->resp_opcnt = resp_opcnt; 124fff4080bSChuck Lever __entry->status = be32_to_cpu(status); 125fff4080bSChuck Lever __assign_str(name, name); 126fff4080bSChuck Lever ), 127fff4080bSChuck Lever TP_printk("op=%u/%u %s status=%d", 128fff4080bSChuck Lever __entry->resp_opcnt, __entry->args_opcnt, 129fff4080bSChuck Lever __get_str(name), __entry->status) 130fff4080bSChuck Lever ) 131fff4080bSChuck Lever 13208281341SChuck Lever TRACE_EVENT(nfsd_compound_decode_err, 13308281341SChuck Lever TP_PROTO( 13408281341SChuck Lever const struct svc_rqst *rqstp, 13508281341SChuck Lever u32 args_opcnt, 13608281341SChuck Lever u32 resp_opcnt, 13708281341SChuck Lever u32 opnum, 13808281341SChuck Lever __be32 status 13908281341SChuck Lever ), 14008281341SChuck Lever TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status), 14108281341SChuck Lever TP_STRUCT__entry( 14208281341SChuck Lever NFSD_TRACE_PROC_RES_FIELDS 14308281341SChuck Lever 14408281341SChuck Lever __field(u32, args_opcnt) 14508281341SChuck Lever __field(u32, resp_opcnt) 14608281341SChuck Lever __field(u32, opnum) 14708281341SChuck Lever ), 14808281341SChuck Lever TP_fast_assign( 14908281341SChuck Lever NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 15008281341SChuck Lever 15108281341SChuck Lever __entry->args_opcnt = args_opcnt; 15208281341SChuck Lever __entry->resp_opcnt = resp_opcnt; 15308281341SChuck Lever __entry->opnum = opnum; 15408281341SChuck Lever ), 15508281341SChuck Lever TP_printk("op=%u/%u opnum=%u status=%lu", 15608281341SChuck Lever __entry->resp_opcnt, __entry->args_opcnt, 15708281341SChuck Lever __entry->opnum, __entry->status) 15808281341SChuck Lever ); 15908281341SChuck Lever 16008281341SChuck Lever TRACE_EVENT(nfsd_compound_encode_err, 16108281341SChuck Lever TP_PROTO( 16208281341SChuck Lever const struct svc_rqst *rqstp, 16308281341SChuck Lever u32 opnum, 16408281341SChuck Lever __be32 status 16508281341SChuck Lever ), 16608281341SChuck Lever TP_ARGS(rqstp, opnum, status), 16708281341SChuck Lever TP_STRUCT__entry( 16808281341SChuck Lever NFSD_TRACE_PROC_RES_FIELDS 16908281341SChuck Lever 17008281341SChuck Lever __field(u32, opnum) 17108281341SChuck Lever ), 17208281341SChuck Lever TP_fast_assign( 17308281341SChuck Lever NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 17408281341SChuck Lever 17508281341SChuck Lever __entry->opnum = opnum; 17608281341SChuck Lever ), 17708281341SChuck Lever TP_printk("opnum=%u status=%lu", 17808281341SChuck Lever __entry->opnum, __entry->status) 17908281341SChuck Lever ); 18008281341SChuck Lever 18105138288SChuck Lever #define show_fs_file_type(x) \ 18205138288SChuck Lever __print_symbolic(x, \ 18305138288SChuck Lever { S_IFLNK, "LNK" }, \ 18405138288SChuck Lever { S_IFREG, "REG" }, \ 18505138288SChuck Lever { S_IFDIR, "DIR" }, \ 18605138288SChuck Lever { S_IFCHR, "CHR" }, \ 18705138288SChuck Lever { S_IFBLK, "BLK" }, \ 18805138288SChuck Lever { S_IFIFO, "FIFO" }, \ 18905138288SChuck Lever { S_IFSOCK, "SOCK" }) 19005138288SChuck Lever 19105138288SChuck Lever TRACE_EVENT(nfsd_fh_verify, 19205138288SChuck Lever TP_PROTO( 19305138288SChuck Lever const struct svc_rqst *rqstp, 19405138288SChuck Lever const struct svc_fh *fhp, 19505138288SChuck Lever umode_t type, 19605138288SChuck Lever int access 19705138288SChuck Lever ), 19805138288SChuck Lever TP_ARGS(rqstp, fhp, type, access), 19905138288SChuck Lever TP_STRUCT__entry( 20005138288SChuck Lever __field(unsigned int, netns_ino) 20105138288SChuck Lever __sockaddr(server, rqstp->rq_xprt->xpt_remotelen) 20205138288SChuck Lever __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 20305138288SChuck Lever __field(u32, xid) 20405138288SChuck Lever __field(u32, fh_hash) 205948755efSChuck Lever __field(const void *, inode) 20605138288SChuck Lever __field(unsigned long, type) 20705138288SChuck Lever __field(unsigned long, access) 20805138288SChuck Lever ), 20905138288SChuck Lever TP_fast_assign( 21005138288SChuck Lever __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 21105138288SChuck Lever __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local, 21205138288SChuck Lever rqstp->rq_xprt->xpt_locallen); 21305138288SChuck Lever __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote, 21405138288SChuck Lever rqstp->rq_xprt->xpt_remotelen); 21505138288SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 21605138288SChuck Lever __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 21705138288SChuck Lever __entry->inode = d_inode(fhp->fh_dentry); 21805138288SChuck Lever __entry->type = type; 21905138288SChuck Lever __entry->access = access; 22005138288SChuck Lever ), 221948755efSChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s", 222948755efSChuck Lever __entry->xid, __entry->fh_hash, 22305138288SChuck Lever show_fs_file_type(__entry->type), 22405138288SChuck Lever show_nfsd_may_flags(__entry->access) 22505138288SChuck Lever ) 22605138288SChuck Lever ); 22708281341SChuck Lever 228948755efSChuck Lever TRACE_EVENT_CONDITION(nfsd_fh_verify_err, 229948755efSChuck Lever TP_PROTO( 230948755efSChuck Lever const struct svc_rqst *rqstp, 231948755efSChuck Lever const struct svc_fh *fhp, 232948755efSChuck Lever umode_t type, 233948755efSChuck Lever int access, 234948755efSChuck Lever __be32 error 235948755efSChuck Lever ), 236948755efSChuck Lever TP_ARGS(rqstp, fhp, type, access, error), 237948755efSChuck Lever TP_CONDITION(error), 238948755efSChuck Lever TP_STRUCT__entry( 239948755efSChuck Lever __field(unsigned int, netns_ino) 240948755efSChuck Lever __sockaddr(server, rqstp->rq_xprt->xpt_remotelen) 241948755efSChuck Lever __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 242948755efSChuck Lever __field(u32, xid) 243948755efSChuck Lever __field(u32, fh_hash) 244948755efSChuck Lever __field(const void *, inode) 245948755efSChuck Lever __field(unsigned long, type) 246948755efSChuck Lever __field(unsigned long, access) 247948755efSChuck Lever __field(int, error) 248948755efSChuck Lever ), 249948755efSChuck Lever TP_fast_assign( 250948755efSChuck Lever __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 251948755efSChuck Lever __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local, 252948755efSChuck Lever rqstp->rq_xprt->xpt_locallen); 253948755efSChuck Lever __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote, 254948755efSChuck Lever rqstp->rq_xprt->xpt_remotelen); 255948755efSChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 256948755efSChuck Lever __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2575a01c805SChuck Lever if (fhp->fh_dentry) 258948755efSChuck Lever __entry->inode = d_inode(fhp->fh_dentry); 2595a01c805SChuck Lever else 2605a01c805SChuck Lever __entry->inode = NULL; 261948755efSChuck Lever __entry->type = type; 262948755efSChuck Lever __entry->access = access; 263948755efSChuck Lever __entry->error = be32_to_cpu(error); 264948755efSChuck Lever ), 265948755efSChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s error=%d", 266948755efSChuck Lever __entry->xid, __entry->fh_hash, 267948755efSChuck Lever show_fs_file_type(__entry->type), 268948755efSChuck Lever show_nfsd_may_flags(__entry->access), 269948755efSChuck Lever __entry->error 270948755efSChuck Lever ) 271948755efSChuck Lever ); 272948755efSChuck Lever 273f01274a9STrond Myklebust DECLARE_EVENT_CLASS(nfsd_fh_err_class, 274f01274a9STrond Myklebust TP_PROTO(struct svc_rqst *rqstp, 275f01274a9STrond Myklebust struct svc_fh *fhp, 276f01274a9STrond Myklebust int status), 277f01274a9STrond Myklebust TP_ARGS(rqstp, fhp, status), 278f01274a9STrond Myklebust TP_STRUCT__entry( 279f01274a9STrond Myklebust __field(u32, xid) 280f01274a9STrond Myklebust __field(u32, fh_hash) 281f01274a9STrond Myklebust __field(int, status) 282f01274a9STrond Myklebust ), 283f01274a9STrond Myklebust TP_fast_assign( 284f01274a9STrond Myklebust __entry->xid = be32_to_cpu(rqstp->rq_xid); 285f01274a9STrond Myklebust __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 286f01274a9STrond Myklebust __entry->status = status; 287f01274a9STrond Myklebust ), 288f01274a9STrond Myklebust TP_printk("xid=0x%08x fh_hash=0x%08x status=%d", 289f01274a9STrond Myklebust __entry->xid, __entry->fh_hash, 290f01274a9STrond Myklebust __entry->status) 291f01274a9STrond Myklebust ) 292f01274a9STrond Myklebust 293f01274a9STrond Myklebust #define DEFINE_NFSD_FH_ERR_EVENT(name) \ 294f01274a9STrond Myklebust DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \ 295f01274a9STrond Myklebust TP_PROTO(struct svc_rqst *rqstp, \ 296f01274a9STrond Myklebust struct svc_fh *fhp, \ 297f01274a9STrond Myklebust int status), \ 298f01274a9STrond Myklebust TP_ARGS(rqstp, fhp, status)) 299f01274a9STrond Myklebust 300f01274a9STrond Myklebust DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport); 301f01274a9STrond Myklebust DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle); 302f01274a9STrond Myklebust 303cf749f3cSTrond Myklebust TRACE_EVENT(nfsd_exp_find_key, 304cf749f3cSTrond Myklebust TP_PROTO(const struct svc_expkey *key, 305cf749f3cSTrond Myklebust int status), 306cf749f3cSTrond Myklebust TP_ARGS(key, status), 307cf749f3cSTrond Myklebust TP_STRUCT__entry( 308cf749f3cSTrond Myklebust __field(int, fsidtype) 309cf749f3cSTrond Myklebust __array(u32, fsid, 6) 310cf749f3cSTrond Myklebust __string(auth_domain, key->ek_client->name) 311cf749f3cSTrond Myklebust __field(int, status) 312cf749f3cSTrond Myklebust ), 313cf749f3cSTrond Myklebust TP_fast_assign( 314cf749f3cSTrond Myklebust __entry->fsidtype = key->ek_fsidtype; 315cf749f3cSTrond Myklebust memcpy(__entry->fsid, key->ek_fsid, 4*6); 316cf749f3cSTrond Myklebust __assign_str(auth_domain, key->ek_client->name); 317cf749f3cSTrond Myklebust __entry->status = status; 318cf749f3cSTrond Myklebust ), 319cf749f3cSTrond Myklebust TP_printk("fsid=%x::%s domain=%s status=%d", 320cf749f3cSTrond Myklebust __entry->fsidtype, 321cf749f3cSTrond Myklebust __print_array(__entry->fsid, 6, 4), 322cf749f3cSTrond Myklebust __get_str(auth_domain), 323cf749f3cSTrond Myklebust __entry->status 324cf749f3cSTrond Myklebust ) 325cf749f3cSTrond Myklebust ); 326cf749f3cSTrond Myklebust 3276a30e47fSTrond Myklebust TRACE_EVENT(nfsd_expkey_update, 3286a30e47fSTrond Myklebust TP_PROTO(const struct svc_expkey *key, const char *exp_path), 3296a30e47fSTrond Myklebust TP_ARGS(key, exp_path), 3306a30e47fSTrond Myklebust TP_STRUCT__entry( 3316a30e47fSTrond Myklebust __field(int, fsidtype) 3326a30e47fSTrond Myklebust __array(u32, fsid, 6) 3336a30e47fSTrond Myklebust __string(auth_domain, key->ek_client->name) 3346a30e47fSTrond Myklebust __string(path, exp_path) 3356a30e47fSTrond Myklebust __field(bool, cache) 3366a30e47fSTrond Myklebust ), 3376a30e47fSTrond Myklebust TP_fast_assign( 3386a30e47fSTrond Myklebust __entry->fsidtype = key->ek_fsidtype; 3396a30e47fSTrond Myklebust memcpy(__entry->fsid, key->ek_fsid, 4*6); 3406a30e47fSTrond Myklebust __assign_str(auth_domain, key->ek_client->name); 3416a30e47fSTrond Myklebust __assign_str(path, exp_path); 3426a30e47fSTrond Myklebust __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 3436a30e47fSTrond Myklebust ), 3446a30e47fSTrond Myklebust TP_printk("fsid=%x::%s domain=%s path=%s cache=%s", 3456a30e47fSTrond Myklebust __entry->fsidtype, 3466a30e47fSTrond Myklebust __print_array(__entry->fsid, 6, 4), 3476a30e47fSTrond Myklebust __get_str(auth_domain), 3486a30e47fSTrond Myklebust __get_str(path), 3496a30e47fSTrond Myklebust __entry->cache ? "pos" : "neg" 3506a30e47fSTrond Myklebust ) 3516a30e47fSTrond Myklebust ); 3526a30e47fSTrond Myklebust 353cf749f3cSTrond Myklebust TRACE_EVENT(nfsd_exp_get_by_name, 354cf749f3cSTrond Myklebust TP_PROTO(const struct svc_export *key, 355cf749f3cSTrond Myklebust int status), 356cf749f3cSTrond Myklebust TP_ARGS(key, status), 357cf749f3cSTrond Myklebust TP_STRUCT__entry( 358cf749f3cSTrond Myklebust __string(path, key->ex_path.dentry->d_name.name) 359cf749f3cSTrond Myklebust __string(auth_domain, key->ex_client->name) 360cf749f3cSTrond Myklebust __field(int, status) 361cf749f3cSTrond Myklebust ), 362cf749f3cSTrond Myklebust TP_fast_assign( 363cf749f3cSTrond Myklebust __assign_str(path, key->ex_path.dentry->d_name.name); 364cf749f3cSTrond Myklebust __assign_str(auth_domain, key->ex_client->name); 365cf749f3cSTrond Myklebust __entry->status = status; 366cf749f3cSTrond Myklebust ), 367cf749f3cSTrond Myklebust TP_printk("path=%s domain=%s status=%d", 368cf749f3cSTrond Myklebust __get_str(path), 369cf749f3cSTrond Myklebust __get_str(auth_domain), 370cf749f3cSTrond Myklebust __entry->status 371cf749f3cSTrond Myklebust ) 372cf749f3cSTrond Myklebust ); 373cf749f3cSTrond Myklebust 3746a30e47fSTrond Myklebust TRACE_EVENT(nfsd_export_update, 3756a30e47fSTrond Myklebust TP_PROTO(const struct svc_export *key), 3766a30e47fSTrond Myklebust TP_ARGS(key), 3776a30e47fSTrond Myklebust TP_STRUCT__entry( 3786a30e47fSTrond Myklebust __string(path, key->ex_path.dentry->d_name.name) 3796a30e47fSTrond Myklebust __string(auth_domain, key->ex_client->name) 3806a30e47fSTrond Myklebust __field(bool, cache) 3816a30e47fSTrond Myklebust ), 3826a30e47fSTrond Myklebust TP_fast_assign( 3836a30e47fSTrond Myklebust __assign_str(path, key->ex_path.dentry->d_name.name); 3846a30e47fSTrond Myklebust __assign_str(auth_domain, key->ex_client->name); 3856a30e47fSTrond Myklebust __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 3866a30e47fSTrond Myklebust ), 3876a30e47fSTrond Myklebust TP_printk("path=%s domain=%s cache=%s", 3886a30e47fSTrond Myklebust __get_str(path), 3896a30e47fSTrond Myklebust __get_str(auth_domain), 3906a30e47fSTrond Myklebust __entry->cache ? "pos" : "neg" 3916a30e47fSTrond Myklebust ) 3926a30e47fSTrond Myklebust ); 3936a30e47fSTrond Myklebust 3946e8b50d1SJeff Layton DECLARE_EVENT_CLASS(nfsd_io_class, 3956e8b50d1SJeff Layton TP_PROTO(struct svc_rqst *rqstp, 3966e8b50d1SJeff Layton struct svc_fh *fhp, 3976a4d333dSChuck Lever u64 offset, 3986a4d333dSChuck Lever u32 len), 3996e8b50d1SJeff Layton TP_ARGS(rqstp, fhp, offset, len), 4006e8b50d1SJeff Layton TP_STRUCT__entry( 401afa720a0SChuck Lever __field(u32, xid) 402afa720a0SChuck Lever __field(u32, fh_hash) 4036a4d333dSChuck Lever __field(u64, offset) 4046a4d333dSChuck Lever __field(u32, len) 4056e8b50d1SJeff Layton ), 4066e8b50d1SJeff Layton TP_fast_assign( 407afa720a0SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 40879e0b4e2SChuck Lever __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 4096e8b50d1SJeff Layton __entry->offset = offset; 4106e8b50d1SJeff Layton __entry->len = len; 4116e8b50d1SJeff Layton ), 4126a4d333dSChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u", 413afa720a0SChuck Lever __entry->xid, __entry->fh_hash, 4146e8b50d1SJeff Layton __entry->offset, __entry->len) 4156e8b50d1SJeff Layton ) 4166e8b50d1SJeff Layton 4176e8b50d1SJeff Layton #define DEFINE_NFSD_IO_EVENT(name) \ 418f394b62bSChuck Lever DEFINE_EVENT(nfsd_io_class, nfsd_##name, \ 4196e8b50d1SJeff Layton TP_PROTO(struct svc_rqst *rqstp, \ 4206e8b50d1SJeff Layton struct svc_fh *fhp, \ 4216a4d333dSChuck Lever u64 offset, \ 4226a4d333dSChuck Lever u32 len), \ 4236e8b50d1SJeff Layton TP_ARGS(rqstp, fhp, offset, len)) 4246e8b50d1SJeff Layton 4256e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_start); 42687c5942eSChuck Lever DEFINE_NFSD_IO_EVENT(read_splice); 42787c5942eSChuck Lever DEFINE_NFSD_IO_EVENT(read_vector); 4286e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_io_done); 4296e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_done); 4306e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_start); 4316e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_opened); 4326e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_io_done); 4336e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_done); 43431ef83dcSChristoph Hellwig 435d890be15SChuck Lever DECLARE_EVENT_CLASS(nfsd_err_class, 436d890be15SChuck Lever TP_PROTO(struct svc_rqst *rqstp, 437d890be15SChuck Lever struct svc_fh *fhp, 438d890be15SChuck Lever loff_t offset, 439d890be15SChuck Lever int status), 440d890be15SChuck Lever TP_ARGS(rqstp, fhp, offset, status), 441d890be15SChuck Lever TP_STRUCT__entry( 442d890be15SChuck Lever __field(u32, xid) 443d890be15SChuck Lever __field(u32, fh_hash) 444d890be15SChuck Lever __field(loff_t, offset) 445d890be15SChuck Lever __field(int, status) 446d890be15SChuck Lever ), 447d890be15SChuck Lever TP_fast_assign( 448d890be15SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 449d890be15SChuck Lever __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 450d890be15SChuck Lever __entry->offset = offset; 451d890be15SChuck Lever __entry->status = status; 452d890be15SChuck Lever ), 453d890be15SChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d", 454d890be15SChuck Lever __entry->xid, __entry->fh_hash, 455d890be15SChuck Lever __entry->offset, __entry->status) 456d890be15SChuck Lever ) 457d890be15SChuck Lever 458d890be15SChuck Lever #define DEFINE_NFSD_ERR_EVENT(name) \ 459d890be15SChuck Lever DEFINE_EVENT(nfsd_err_class, nfsd_##name, \ 460d890be15SChuck Lever TP_PROTO(struct svc_rqst *rqstp, \ 461d890be15SChuck Lever struct svc_fh *fhp, \ 462d890be15SChuck Lever loff_t offset, \ 463d890be15SChuck Lever int len), \ 464d890be15SChuck Lever TP_ARGS(rqstp, fhp, offset, len)) 465d890be15SChuck Lever 46687c5942eSChuck Lever DEFINE_NFSD_ERR_EVENT(read_err); 467d890be15SChuck Lever DEFINE_NFSD_ERR_EVENT(write_err); 468d890be15SChuck Lever 4696019ce07SChuck Lever TRACE_EVENT(nfsd_dirent, 4706019ce07SChuck Lever TP_PROTO(struct svc_fh *fhp, 4716019ce07SChuck Lever u64 ino, 4726019ce07SChuck Lever const char *name, 4736019ce07SChuck Lever int namlen), 4746019ce07SChuck Lever TP_ARGS(fhp, ino, name, namlen), 4756019ce07SChuck Lever TP_STRUCT__entry( 4766019ce07SChuck Lever __field(u32, fh_hash) 4776019ce07SChuck Lever __field(u64, ino) 478408c0de7SChuck Lever __string_len(name, name, namlen) 4796019ce07SChuck Lever ), 4806019ce07SChuck Lever TP_fast_assign( 4816019ce07SChuck Lever __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0; 4826019ce07SChuck Lever __entry->ino = ino; 483408c0de7SChuck Lever __assign_str_len(name, name, namlen) 4846019ce07SChuck Lever ), 485408c0de7SChuck Lever TP_printk("fh_hash=0x%08x ino=%llu name=%s", 486408c0de7SChuck Lever __entry->fh_hash, __entry->ino, __get_str(name) 487408c0de7SChuck Lever ) 4886019ce07SChuck Lever ) 4896019ce07SChuck Lever 490a2f4c3faSTrond Myklebust DECLARE_EVENT_CLASS(nfsd_copy_err_class, 491a2f4c3faSTrond Myklebust TP_PROTO(struct svc_rqst *rqstp, 492a2f4c3faSTrond Myklebust struct svc_fh *src_fhp, 493a2f4c3faSTrond Myklebust loff_t src_offset, 494a2f4c3faSTrond Myklebust struct svc_fh *dst_fhp, 495a2f4c3faSTrond Myklebust loff_t dst_offset, 496a2f4c3faSTrond Myklebust u64 count, 497a2f4c3faSTrond Myklebust int status), 498a2f4c3faSTrond Myklebust TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status), 499a2f4c3faSTrond Myklebust TP_STRUCT__entry( 500a2f4c3faSTrond Myklebust __field(u32, xid) 501a2f4c3faSTrond Myklebust __field(u32, src_fh_hash) 502a2f4c3faSTrond Myklebust __field(loff_t, src_offset) 503a2f4c3faSTrond Myklebust __field(u32, dst_fh_hash) 504a2f4c3faSTrond Myklebust __field(loff_t, dst_offset) 505a2f4c3faSTrond Myklebust __field(u64, count) 506a2f4c3faSTrond Myklebust __field(int, status) 507a2f4c3faSTrond Myklebust ), 508a2f4c3faSTrond Myklebust TP_fast_assign( 509a2f4c3faSTrond Myklebust __entry->xid = be32_to_cpu(rqstp->rq_xid); 510a2f4c3faSTrond Myklebust __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle); 511a2f4c3faSTrond Myklebust __entry->src_offset = src_offset; 512a2f4c3faSTrond Myklebust __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle); 513a2f4c3faSTrond Myklebust __entry->dst_offset = dst_offset; 514a2f4c3faSTrond Myklebust __entry->count = count; 515a2f4c3faSTrond Myklebust __entry->status = status; 516a2f4c3faSTrond Myklebust ), 517a2f4c3faSTrond Myklebust TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld " 518a2f4c3faSTrond Myklebust "dst_fh_hash=0x%08x dst_offset=%lld " 519a2f4c3faSTrond Myklebust "count=%llu status=%d", 520a2f4c3faSTrond Myklebust __entry->xid, __entry->src_fh_hash, __entry->src_offset, 521a2f4c3faSTrond Myklebust __entry->dst_fh_hash, __entry->dst_offset, 522a2f4c3faSTrond Myklebust (unsigned long long)__entry->count, 523a2f4c3faSTrond Myklebust __entry->status) 524a2f4c3faSTrond Myklebust ) 525a2f4c3faSTrond Myklebust 526a2f4c3faSTrond Myklebust #define DEFINE_NFSD_COPY_ERR_EVENT(name) \ 527a2f4c3faSTrond Myklebust DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \ 528a2f4c3faSTrond Myklebust TP_PROTO(struct svc_rqst *rqstp, \ 529a2f4c3faSTrond Myklebust struct svc_fh *src_fhp, \ 530a2f4c3faSTrond Myklebust loff_t src_offset, \ 531a2f4c3faSTrond Myklebust struct svc_fh *dst_fhp, \ 532a2f4c3faSTrond Myklebust loff_t dst_offset, \ 533a2f4c3faSTrond Myklebust u64 count, \ 534a2f4c3faSTrond Myklebust int status), \ 535a2f4c3faSTrond Myklebust TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \ 536a2f4c3faSTrond Myklebust count, status)) 537a2f4c3faSTrond Myklebust 538a2f4c3faSTrond Myklebust DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err); 539a2f4c3faSTrond Myklebust 540825213e5SJeff Layton #include "state.h" 54165294c1fSJeff Layton #include "filecache.h" 54265294c1fSJeff Layton #include "vfs.h" 543825213e5SJeff Layton 544c035362eSChuck Lever TRACE_EVENT(nfsd_delegret_wakeup, 545c035362eSChuck Lever TP_PROTO( 546c035362eSChuck Lever const struct svc_rqst *rqstp, 547c035362eSChuck Lever const struct inode *inode, 548c035362eSChuck Lever long timeo 549c035362eSChuck Lever ), 550c035362eSChuck Lever TP_ARGS(rqstp, inode, timeo), 551c035362eSChuck Lever TP_STRUCT__entry( 552c035362eSChuck Lever __field(u32, xid) 553c035362eSChuck Lever __field(const void *, inode) 554c035362eSChuck Lever __field(long, timeo) 555c035362eSChuck Lever ), 556c035362eSChuck Lever TP_fast_assign( 557c035362eSChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 558c035362eSChuck Lever __entry->inode = inode; 559c035362eSChuck Lever __entry->timeo = timeo; 560c035362eSChuck Lever ), 561c035362eSChuck Lever TP_printk("xid=0x%08x inode=%p%s", 562c035362eSChuck Lever __entry->xid, __entry->inode, 563c035362eSChuck Lever __entry->timeo == 0 ? " (timed out)" : "" 564c035362eSChuck Lever ) 565c035362eSChuck Lever ); 566c035362eSChuck Lever 56731ef83dcSChristoph Hellwig DECLARE_EVENT_CLASS(nfsd_stateid_class, 56831ef83dcSChristoph Hellwig TP_PROTO(stateid_t *stp), 56931ef83dcSChristoph Hellwig TP_ARGS(stp), 57031ef83dcSChristoph Hellwig TP_STRUCT__entry( 57131ef83dcSChristoph Hellwig __field(u32, cl_boot) 57231ef83dcSChristoph Hellwig __field(u32, cl_id) 57331ef83dcSChristoph Hellwig __field(u32, si_id) 57431ef83dcSChristoph Hellwig __field(u32, si_generation) 57531ef83dcSChristoph Hellwig ), 57631ef83dcSChristoph Hellwig TP_fast_assign( 57731ef83dcSChristoph Hellwig __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 57831ef83dcSChristoph Hellwig __entry->cl_id = stp->si_opaque.so_clid.cl_id; 57931ef83dcSChristoph Hellwig __entry->si_id = stp->si_opaque.so_id; 58031ef83dcSChristoph Hellwig __entry->si_generation = stp->si_generation; 58131ef83dcSChristoph Hellwig ), 58231ef83dcSChristoph Hellwig TP_printk("client %08x:%08x stateid %08x:%08x", 58331ef83dcSChristoph Hellwig __entry->cl_boot, 58431ef83dcSChristoph Hellwig __entry->cl_id, 58531ef83dcSChristoph Hellwig __entry->si_id, 58631ef83dcSChristoph Hellwig __entry->si_generation) 58731ef83dcSChristoph Hellwig ) 58831ef83dcSChristoph Hellwig 58931ef83dcSChristoph Hellwig #define DEFINE_STATEID_EVENT(name) \ 590f394b62bSChuck Lever DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \ 59131ef83dcSChristoph Hellwig TP_PROTO(stateid_t *stp), \ 59231ef83dcSChristoph Hellwig TP_ARGS(stp)) 593dd5e3fbcSChuck Lever 59431ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_alloc); 59531ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_unhash); 59631ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_free); 59731ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_get_lookup_fail); 59831ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_commit_lookup_fail); 59931ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_return_lookup_fail); 60031ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall); 60131ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_done); 60231ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_fail); 60331ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_release); 60431ef83dcSChristoph Hellwig 6053caf9175SHou Tao DEFINE_STATEID_EVENT(open); 6063caf9175SHou Tao DEFINE_STATEID_EVENT(deleg_read); 60720eee313SChuck Lever DEFINE_STATEID_EVENT(deleg_return); 608dd5e3fbcSChuck Lever DEFINE_STATEID_EVENT(deleg_recall); 609dd5e3fbcSChuck Lever 610dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_stateseqid_class, 611dd5e3fbcSChuck Lever TP_PROTO(u32 seqid, const stateid_t *stp), 612dd5e3fbcSChuck Lever TP_ARGS(seqid, stp), 613dd5e3fbcSChuck Lever TP_STRUCT__entry( 614dd5e3fbcSChuck Lever __field(u32, seqid) 615dd5e3fbcSChuck Lever __field(u32, cl_boot) 616dd5e3fbcSChuck Lever __field(u32, cl_id) 617dd5e3fbcSChuck Lever __field(u32, si_id) 618dd5e3fbcSChuck Lever __field(u32, si_generation) 619dd5e3fbcSChuck Lever ), 620dd5e3fbcSChuck Lever TP_fast_assign( 621dd5e3fbcSChuck Lever __entry->seqid = seqid; 622dd5e3fbcSChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 623dd5e3fbcSChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 624dd5e3fbcSChuck Lever __entry->si_id = stp->si_opaque.so_id; 625dd5e3fbcSChuck Lever __entry->si_generation = stp->si_generation; 626dd5e3fbcSChuck Lever ), 627dd5e3fbcSChuck Lever TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x", 628dd5e3fbcSChuck Lever __entry->seqid, __entry->cl_boot, __entry->cl_id, 629dd5e3fbcSChuck Lever __entry->si_id, __entry->si_generation) 630dd5e3fbcSChuck Lever ) 631dd5e3fbcSChuck Lever 632dd5e3fbcSChuck Lever #define DEFINE_STATESEQID_EVENT(name) \ 633dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \ 634dd5e3fbcSChuck Lever TP_PROTO(u32 seqid, const stateid_t *stp), \ 635dd5e3fbcSChuck Lever TP_ARGS(seqid, stp)) 636dd5e3fbcSChuck Lever 637dd5e3fbcSChuck Lever DEFINE_STATESEQID_EVENT(preprocess); 638dd5e3fbcSChuck Lever DEFINE_STATESEQID_EVENT(open_confirm); 639dd5e3fbcSChuck Lever 640a1c74569SChuck Lever TRACE_DEFINE_ENUM(NFS4_OPEN_STID); 641a1c74569SChuck Lever TRACE_DEFINE_ENUM(NFS4_LOCK_STID); 642a1c74569SChuck Lever TRACE_DEFINE_ENUM(NFS4_DELEG_STID); 643a1c74569SChuck Lever TRACE_DEFINE_ENUM(NFS4_CLOSED_STID); 644a1c74569SChuck Lever TRACE_DEFINE_ENUM(NFS4_REVOKED_DELEG_STID); 645a1c74569SChuck Lever TRACE_DEFINE_ENUM(NFS4_CLOSED_DELEG_STID); 646a1c74569SChuck Lever TRACE_DEFINE_ENUM(NFS4_LAYOUT_STID); 647a1c74569SChuck Lever 648a1c74569SChuck Lever #define show_stid_type(x) \ 649a1c74569SChuck Lever __print_flags(x, "|", \ 650a1c74569SChuck Lever { NFS4_OPEN_STID, "OPEN" }, \ 651a1c74569SChuck Lever { NFS4_LOCK_STID, "LOCK" }, \ 652a1c74569SChuck Lever { NFS4_DELEG_STID, "DELEG" }, \ 653a1c74569SChuck Lever { NFS4_CLOSED_STID, "CLOSED" }, \ 654a1c74569SChuck Lever { NFS4_REVOKED_DELEG_STID, "REVOKED" }, \ 655a1c74569SChuck Lever { NFS4_CLOSED_DELEG_STID, "CLOSED_DELEG" }, \ 656a1c74569SChuck Lever { NFS4_LAYOUT_STID, "LAYOUT" }) 657a1c74569SChuck Lever 658a1c74569SChuck Lever DECLARE_EVENT_CLASS(nfsd_stid_class, 659a1c74569SChuck Lever TP_PROTO( 660a1c74569SChuck Lever const struct nfs4_stid *stid 661a1c74569SChuck Lever ), 662a1c74569SChuck Lever TP_ARGS(stid), 663a1c74569SChuck Lever TP_STRUCT__entry( 664a1c74569SChuck Lever __field(unsigned long, sc_type) 665a1c74569SChuck Lever __field(int, sc_count) 666a1c74569SChuck Lever __field(u32, cl_boot) 667a1c74569SChuck Lever __field(u32, cl_id) 668a1c74569SChuck Lever __field(u32, si_id) 669a1c74569SChuck Lever __field(u32, si_generation) 670a1c74569SChuck Lever ), 671a1c74569SChuck Lever TP_fast_assign( 672a1c74569SChuck Lever const stateid_t *stp = &stid->sc_stateid; 673a1c74569SChuck Lever 674a1c74569SChuck Lever __entry->sc_type = stid->sc_type; 675a1c74569SChuck Lever __entry->sc_count = refcount_read(&stid->sc_count); 676a1c74569SChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 677a1c74569SChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 678a1c74569SChuck Lever __entry->si_id = stp->si_opaque.so_id; 679a1c74569SChuck Lever __entry->si_generation = stp->si_generation; 680a1c74569SChuck Lever ), 681a1c74569SChuck Lever TP_printk("client %08x:%08x stateid %08x:%08x ref=%d type=%s", 682a1c74569SChuck Lever __entry->cl_boot, __entry->cl_id, 683a1c74569SChuck Lever __entry->si_id, __entry->si_generation, 684a1c74569SChuck Lever __entry->sc_count, show_stid_type(__entry->sc_type) 685a1c74569SChuck Lever ) 686a1c74569SChuck Lever ); 687a1c74569SChuck Lever 688a1c74569SChuck Lever #define DEFINE_STID_EVENT(name) \ 689a1c74569SChuck Lever DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name, \ 690a1c74569SChuck Lever TP_PROTO(const struct nfs4_stid *stid), \ 691a1c74569SChuck Lever TP_ARGS(stid)) 692a1c74569SChuck Lever 693a1c74569SChuck Lever DEFINE_STID_EVENT(revoke); 694a1c74569SChuck Lever 695dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_clientid_class, 696dd5e3fbcSChuck Lever TP_PROTO(const clientid_t *clid), 697dd5e3fbcSChuck Lever TP_ARGS(clid), 698dd5e3fbcSChuck Lever TP_STRUCT__entry( 699dd5e3fbcSChuck Lever __field(u32, cl_boot) 700dd5e3fbcSChuck Lever __field(u32, cl_id) 701dd5e3fbcSChuck Lever ), 702dd5e3fbcSChuck Lever TP_fast_assign( 703dd5e3fbcSChuck Lever __entry->cl_boot = clid->cl_boot; 704dd5e3fbcSChuck Lever __entry->cl_id = clid->cl_id; 705dd5e3fbcSChuck Lever ), 706dd5e3fbcSChuck Lever TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 707dd5e3fbcSChuck Lever ) 708dd5e3fbcSChuck Lever 709dd5e3fbcSChuck Lever #define DEFINE_CLIENTID_EVENT(name) \ 710dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 711dd5e3fbcSChuck Lever TP_PROTO(const clientid_t *clid), \ 712dd5e3fbcSChuck Lever TP_ARGS(clid)) 713dd5e3fbcSChuck Lever 714237f91c8SChuck Lever DEFINE_CLIENTID_EVENT(expire_unconf); 715cee8aa07SChuck Lever DEFINE_CLIENTID_EVENT(reclaim_complete); 7167e3b32acSChuck Lever DEFINE_CLIENTID_EVENT(confirmed); 717c41a9b7aSChuck Lever DEFINE_CLIENTID_EVENT(destroyed); 7182958d2eeSChuck Lever DEFINE_CLIENTID_EVENT(admin_expired); 7192958d2eeSChuck Lever DEFINE_CLIENTID_EVENT(replaced); 720dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(purged); 721dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(renew); 722dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(stale); 723dd5e3fbcSChuck Lever 724dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_net_class, 725dd5e3fbcSChuck Lever TP_PROTO(const struct nfsd_net *nn), 726dd5e3fbcSChuck Lever TP_ARGS(nn), 727dd5e3fbcSChuck Lever TP_STRUCT__entry( 728dd5e3fbcSChuck Lever __field(unsigned long long, boot_time) 729dd5e3fbcSChuck Lever ), 730dd5e3fbcSChuck Lever TP_fast_assign( 731dd5e3fbcSChuck Lever __entry->boot_time = nn->boot_time; 732dd5e3fbcSChuck Lever ), 733dd5e3fbcSChuck Lever TP_printk("boot_time=%16llx", __entry->boot_time) 734dd5e3fbcSChuck Lever ) 735dd5e3fbcSChuck Lever 736dd5e3fbcSChuck Lever #define DEFINE_NET_EVENT(name) \ 737dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 738dd5e3fbcSChuck Lever TP_PROTO(const struct nfsd_net *nn), \ 739dd5e3fbcSChuck Lever TP_ARGS(nn)) 740dd5e3fbcSChuck Lever 741dd5e3fbcSChuck Lever DEFINE_NET_EVENT(grace_start); 742dd5e3fbcSChuck Lever DEFINE_NET_EVENT(grace_complete); 743dd5e3fbcSChuck Lever 74475acacb6SChuck Lever TRACE_EVENT(nfsd_writeverf_reset, 74575acacb6SChuck Lever TP_PROTO( 74675acacb6SChuck Lever const struct nfsd_net *nn, 74775acacb6SChuck Lever const struct svc_rqst *rqstp, 74875acacb6SChuck Lever int error 74975acacb6SChuck Lever ), 75075acacb6SChuck Lever TP_ARGS(nn, rqstp, error), 75175acacb6SChuck Lever TP_STRUCT__entry( 75275acacb6SChuck Lever __field(unsigned long long, boot_time) 75375acacb6SChuck Lever __field(u32, xid) 75475acacb6SChuck Lever __field(int, error) 75575acacb6SChuck Lever __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 75675acacb6SChuck Lever ), 75775acacb6SChuck Lever TP_fast_assign( 75875acacb6SChuck Lever __entry->boot_time = nn->boot_time; 75975acacb6SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 76075acacb6SChuck Lever __entry->error = error; 76175acacb6SChuck Lever 76275acacb6SChuck Lever /* avoid seqlock inside TP_fast_assign */ 76375acacb6SChuck Lever memcpy(__entry->verifier, nn->writeverf, 76475acacb6SChuck Lever NFS4_VERIFIER_SIZE); 76575acacb6SChuck Lever ), 76675acacb6SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s", 76775acacb6SChuck Lever __entry->boot_time, __entry->xid, __entry->error, 76875acacb6SChuck Lever __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 76975acacb6SChuck Lever ) 77075acacb6SChuck Lever ); 77175acacb6SChuck Lever 77227787733SChuck Lever TRACE_EVENT(nfsd_clid_cred_mismatch, 77327787733SChuck Lever TP_PROTO( 77427787733SChuck Lever const struct nfs4_client *clp, 77527787733SChuck Lever const struct svc_rqst *rqstp 77627787733SChuck Lever ), 77727787733SChuck Lever TP_ARGS(clp, rqstp), 77827787733SChuck Lever TP_STRUCT__entry( 77927787733SChuck Lever __field(u32, cl_boot) 78027787733SChuck Lever __field(u32, cl_id) 78127787733SChuck Lever __field(unsigned long, cl_flavor) 78227787733SChuck Lever __field(unsigned long, new_flavor) 7839db0e15fSChuck Lever __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 78427787733SChuck Lever ), 78527787733SChuck Lever TP_fast_assign( 78627787733SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 78727787733SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 78827787733SChuck Lever __entry->cl_flavor = clp->cl_cred.cr_flavor; 78927787733SChuck Lever __entry->new_flavor = rqstp->rq_cred.cr_flavor; 7909db0e15fSChuck Lever __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 7919db0e15fSChuck Lever rqstp->rq_xprt->xpt_remotelen); 79227787733SChuck Lever ), 79327787733SChuck Lever TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc", 79427787733SChuck Lever __entry->cl_boot, __entry->cl_id, 79527787733SChuck Lever show_nfsd_authflavor(__entry->cl_flavor), 7969db0e15fSChuck Lever show_nfsd_authflavor(__entry->new_flavor), 7979db0e15fSChuck Lever __get_sockaddr(addr) 79827787733SChuck Lever ) 79927787733SChuck Lever ) 80027787733SChuck Lever 801744ea54cSChuck Lever TRACE_EVENT(nfsd_clid_verf_mismatch, 802744ea54cSChuck Lever TP_PROTO( 803744ea54cSChuck Lever const struct nfs4_client *clp, 804744ea54cSChuck Lever const struct svc_rqst *rqstp, 805744ea54cSChuck Lever const nfs4_verifier *verf 806744ea54cSChuck Lever ), 807744ea54cSChuck Lever TP_ARGS(clp, rqstp, verf), 808744ea54cSChuck Lever TP_STRUCT__entry( 809744ea54cSChuck Lever __field(u32, cl_boot) 810744ea54cSChuck Lever __field(u32, cl_id) 811744ea54cSChuck Lever __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE) 812744ea54cSChuck Lever __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE) 8139db0e15fSChuck Lever __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 814744ea54cSChuck Lever ), 815744ea54cSChuck Lever TP_fast_assign( 816744ea54cSChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 817744ea54cSChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 818744ea54cSChuck Lever memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier, 819744ea54cSChuck Lever NFS4_VERIFIER_SIZE); 820744ea54cSChuck Lever memcpy(__entry->new_verifier, (void *)verf, 821744ea54cSChuck Lever NFS4_VERIFIER_SIZE); 8229db0e15fSChuck Lever __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 8239db0e15fSChuck Lever rqstp->rq_xprt->xpt_remotelen); 824744ea54cSChuck Lever ), 825744ea54cSChuck Lever TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc", 826744ea54cSChuck Lever __entry->cl_boot, __entry->cl_id, 827744ea54cSChuck Lever __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE), 828744ea54cSChuck Lever __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE), 8299db0e15fSChuck Lever __get_sockaddr(addr) 830744ea54cSChuck Lever ) 831744ea54cSChuck Lever ); 832744ea54cSChuck Lever 833237f91c8SChuck Lever DECLARE_EVENT_CLASS(nfsd_clid_class, 834237f91c8SChuck Lever TP_PROTO(const struct nfs4_client *clp), 835237f91c8SChuck Lever TP_ARGS(clp), 836237f91c8SChuck Lever TP_STRUCT__entry( 837237f91c8SChuck Lever __field(u32, cl_boot) 838237f91c8SChuck Lever __field(u32, cl_id) 839237f91c8SChuck Lever __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 840237f91c8SChuck Lever __field(unsigned long, flavor) 841237f91c8SChuck Lever __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 842d27b74a8SChuck Lever __string_len(name, name, clp->cl_name.len) 843237f91c8SChuck Lever ), 844237f91c8SChuck Lever TP_fast_assign( 845237f91c8SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 846237f91c8SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 847237f91c8SChuck Lever memcpy(__entry->addr, &clp->cl_addr, 848237f91c8SChuck Lever sizeof(struct sockaddr_in6)); 849237f91c8SChuck Lever __entry->flavor = clp->cl_cred.cr_flavor; 850237f91c8SChuck Lever memcpy(__entry->verifier, (void *)&clp->cl_verifier, 851237f91c8SChuck Lever NFS4_VERIFIER_SIZE); 852d27b74a8SChuck Lever __assign_str_len(name, clp->cl_name.data, clp->cl_name.len); 853237f91c8SChuck Lever ), 854237f91c8SChuck Lever TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x", 855237f91c8SChuck Lever __entry->addr, __get_str(name), 856237f91c8SChuck Lever __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE), 857237f91c8SChuck Lever show_nfsd_authflavor(__entry->flavor), 858237f91c8SChuck Lever __entry->cl_boot, __entry->cl_id) 859237f91c8SChuck Lever ); 860237f91c8SChuck Lever 861237f91c8SChuck Lever #define DEFINE_CLID_EVENT(name) \ 862237f91c8SChuck Lever DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 863237f91c8SChuck Lever TP_PROTO(const struct nfs4_client *clp), \ 864237f91c8SChuck Lever TP_ARGS(clp)) 865237f91c8SChuck Lever 866237f91c8SChuck Lever DEFINE_CLID_EVENT(fresh); 867e8f80c55SChuck Lever DEFINE_CLID_EVENT(confirmed_r); 868237f91c8SChuck Lever 869b76278aeSChuck Lever /* 870b76278aeSChuck Lever * from fs/nfsd/filecache.h 871b76278aeSChuck Lever */ 87265294c1fSJeff Layton #define show_nf_flags(val) \ 87365294c1fSJeff Layton __print_flags(val, "|", \ 87465294c1fSJeff Layton { 1 << NFSD_FILE_HASHED, "HASHED" }, \ 87565294c1fSJeff Layton { 1 << NFSD_FILE_PENDING, "PENDING" }, \ 8764d1ea845SChuck Lever { 1 << NFSD_FILE_REFERENCED, "REFERENCED"}, \ 8774d1ea845SChuck Lever { 1 << NFSD_FILE_GC, "GC"}) 87865294c1fSJeff Layton 87965294c1fSJeff Layton DECLARE_EVENT_CLASS(nfsd_file_class, 88065294c1fSJeff Layton TP_PROTO(struct nfsd_file *nf), 88165294c1fSJeff Layton TP_ARGS(nf), 88265294c1fSJeff Layton TP_STRUCT__entry( 88365294c1fSJeff Layton __field(void *, nf_inode) 88465294c1fSJeff Layton __field(int, nf_ref) 88565294c1fSJeff Layton __field(unsigned long, nf_flags) 88665294c1fSJeff Layton __field(unsigned char, nf_may) 88765294c1fSJeff Layton __field(struct file *, nf_file) 88865294c1fSJeff Layton ), 88965294c1fSJeff Layton TP_fast_assign( 89065294c1fSJeff Layton __entry->nf_inode = nf->nf_inode; 891689827cdSTrond Myklebust __entry->nf_ref = refcount_read(&nf->nf_ref); 89265294c1fSJeff Layton __entry->nf_flags = nf->nf_flags; 89365294c1fSJeff Layton __entry->nf_may = nf->nf_may; 89465294c1fSJeff Layton __entry->nf_file = nf->nf_file; 89565294c1fSJeff Layton ), 89654f7df70SChuck Lever TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p", 89765294c1fSJeff Layton __entry->nf_inode, 89865294c1fSJeff Layton __entry->nf_ref, 89965294c1fSJeff Layton show_nf_flags(__entry->nf_flags), 900b76278aeSChuck Lever show_nfsd_may_flags(__entry->nf_may), 90165294c1fSJeff Layton __entry->nf_file) 90265294c1fSJeff Layton ) 90365294c1fSJeff Layton 90465294c1fSJeff Layton #define DEFINE_NFSD_FILE_EVENT(name) \ 90565294c1fSJeff Layton DEFINE_EVENT(nfsd_file_class, name, \ 90665294c1fSJeff Layton TP_PROTO(struct nfsd_file *nf), \ 90765294c1fSJeff Layton TP_ARGS(nf)) 90865294c1fSJeff Layton 909*82141185SJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_free); 91065294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 91165294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 912*82141185SJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue); 91365294c1fSJeff Layton 914b40a2839SChuck Lever TRACE_EVENT(nfsd_file_alloc, 915b40a2839SChuck Lever TP_PROTO( 916b40a2839SChuck Lever const struct nfsd_file *nf 917b40a2839SChuck Lever ), 918b40a2839SChuck Lever TP_ARGS(nf), 919b40a2839SChuck Lever TP_STRUCT__entry( 920b40a2839SChuck Lever __field(const void *, nf_inode) 921b40a2839SChuck Lever __field(unsigned long, nf_flags) 922b40a2839SChuck Lever __field(unsigned long, nf_may) 923b40a2839SChuck Lever __field(unsigned int, nf_ref) 924b40a2839SChuck Lever ), 925b40a2839SChuck Lever TP_fast_assign( 926b40a2839SChuck Lever __entry->nf_inode = nf->nf_inode; 927b40a2839SChuck Lever __entry->nf_flags = nf->nf_flags; 928b40a2839SChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 929b40a2839SChuck Lever __entry->nf_may = nf->nf_may; 930b40a2839SChuck Lever ), 931b40a2839SChuck Lever TP_printk("inode=%p ref=%u flags=%s may=%s", 932b40a2839SChuck Lever __entry->nf_inode, __entry->nf_ref, 933b40a2839SChuck Lever show_nf_flags(__entry->nf_flags), 934b40a2839SChuck Lever show_nfsd_may_flags(__entry->nf_may) 935b40a2839SChuck Lever ) 936b40a2839SChuck Lever ); 937b40a2839SChuck Lever 93865294c1fSJeff Layton TRACE_EVENT(nfsd_file_acquire, 93954f7df70SChuck Lever TP_PROTO( 940be023006SChuck Lever const struct svc_rqst *rqstp, 941be023006SChuck Lever const struct inode *inode, 94254f7df70SChuck Lever unsigned int may_flags, 943be023006SChuck Lever const struct nfsd_file *nf, 94454f7df70SChuck Lever __be32 status 94554f7df70SChuck Lever ), 94665294c1fSJeff Layton 94754f7df70SChuck Lever TP_ARGS(rqstp, inode, may_flags, nf, status), 94865294c1fSJeff Layton 94965294c1fSJeff Layton TP_STRUCT__entry( 950a9ceb060STrond Myklebust __field(u32, xid) 951be023006SChuck Lever __field(const void *, inode) 952b76278aeSChuck Lever __field(unsigned long, may_flags) 953be023006SChuck Lever __field(unsigned int, nf_ref) 95465294c1fSJeff Layton __field(unsigned long, nf_flags) 955b76278aeSChuck Lever __field(unsigned long, nf_may) 956be023006SChuck Lever __field(const void *, nf_file) 957a9ceb060STrond Myklebust __field(u32, status) 95865294c1fSJeff Layton ), 95965294c1fSJeff Layton 96065294c1fSJeff Layton TP_fast_assign( 961a9ceb060STrond Myklebust __entry->xid = be32_to_cpu(rqstp->rq_xid); 96265294c1fSJeff Layton __entry->inode = inode; 96365294c1fSJeff Layton __entry->may_flags = may_flags; 964689827cdSTrond Myklebust __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 96565294c1fSJeff Layton __entry->nf_flags = nf ? nf->nf_flags : 0; 96665294c1fSJeff Layton __entry->nf_may = nf ? nf->nf_may : 0; 96765294c1fSJeff Layton __entry->nf_file = nf ? nf->nf_file : NULL; 968a9ceb060STrond Myklebust __entry->status = be32_to_cpu(status); 96965294c1fSJeff Layton ), 97065294c1fSJeff Layton 971be023006SChuck Lever TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u", 97254f7df70SChuck Lever __entry->xid, __entry->inode, 973b76278aeSChuck Lever show_nfsd_may_flags(__entry->may_flags), 974b76278aeSChuck Lever __entry->nf_ref, show_nf_flags(__entry->nf_flags), 975b76278aeSChuck Lever show_nfsd_may_flags(__entry->nf_may), 976be023006SChuck Lever __entry->nf_file, __entry->status 977be023006SChuck Lever ) 978be023006SChuck Lever ); 979be023006SChuck Lever 980be023006SChuck Lever TRACE_EVENT(nfsd_file_create, 981be023006SChuck Lever TP_PROTO( 982be023006SChuck Lever const struct svc_rqst *rqstp, 983be023006SChuck Lever unsigned int may_flags, 984be023006SChuck Lever const struct nfsd_file *nf 985be023006SChuck Lever ), 986be023006SChuck Lever 987be023006SChuck Lever TP_ARGS(rqstp, may_flags, nf), 988be023006SChuck Lever 989be023006SChuck Lever TP_STRUCT__entry( 990be023006SChuck Lever __field(const void *, nf_inode) 991be023006SChuck Lever __field(const void *, nf_file) 992be023006SChuck Lever __field(unsigned long, may_flags) 993be023006SChuck Lever __field(unsigned long, nf_flags) 994be023006SChuck Lever __field(unsigned long, nf_may) 995be023006SChuck Lever __field(unsigned int, nf_ref) 996be023006SChuck Lever __field(u32, xid) 997be023006SChuck Lever ), 998be023006SChuck Lever 999be023006SChuck Lever TP_fast_assign( 1000be023006SChuck Lever __entry->nf_inode = nf->nf_inode; 1001be023006SChuck Lever __entry->nf_file = nf->nf_file; 1002be023006SChuck Lever __entry->may_flags = may_flags; 1003be023006SChuck Lever __entry->nf_flags = nf->nf_flags; 1004be023006SChuck Lever __entry->nf_may = nf->nf_may; 1005be023006SChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 1006be023006SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 1007be023006SChuck Lever ), 1008be023006SChuck Lever 1009be023006SChuck Lever TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1010be023006SChuck Lever __entry->xid, __entry->nf_inode, 1011be023006SChuck Lever show_nfsd_may_flags(__entry->may_flags), 1012be023006SChuck Lever __entry->nf_ref, show_nf_flags(__entry->nf_flags), 1013be023006SChuck Lever show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1014be023006SChuck Lever ) 101565294c1fSJeff Layton ); 101665294c1fSJeff Layton 1017ce502f81SChuck Lever TRACE_EVENT(nfsd_file_insert_err, 1018ce502f81SChuck Lever TP_PROTO( 1019ce502f81SChuck Lever const struct svc_rqst *rqstp, 1020ce502f81SChuck Lever const struct inode *inode, 1021ce502f81SChuck Lever unsigned int may_flags, 1022ce502f81SChuck Lever long error 1023ce502f81SChuck Lever ), 1024ce502f81SChuck Lever TP_ARGS(rqstp, inode, may_flags, error), 1025ce502f81SChuck Lever TP_STRUCT__entry( 1026ce502f81SChuck Lever __field(u32, xid) 1027ce502f81SChuck Lever __field(const void *, inode) 1028ce502f81SChuck Lever __field(unsigned long, may_flags) 1029ce502f81SChuck Lever __field(long, error) 1030ce502f81SChuck Lever ), 1031ce502f81SChuck Lever TP_fast_assign( 1032ce502f81SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 1033ce502f81SChuck Lever __entry->inode = inode; 1034ce502f81SChuck Lever __entry->may_flags = may_flags; 1035ce502f81SChuck Lever __entry->error = error; 1036ce502f81SChuck Lever ), 1037ce502f81SChuck Lever TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld", 1038ce502f81SChuck Lever __entry->xid, __entry->inode, 1039ce502f81SChuck Lever show_nfsd_may_flags(__entry->may_flags), 1040ce502f81SChuck Lever __entry->error 1041ce502f81SChuck Lever ) 1042ce502f81SChuck Lever ); 1043ce502f81SChuck Lever 1044ce502f81SChuck Lever TRACE_EVENT(nfsd_file_cons_err, 1045ce502f81SChuck Lever TP_PROTO( 1046ce502f81SChuck Lever const struct svc_rqst *rqstp, 1047ce502f81SChuck Lever const struct inode *inode, 1048ce502f81SChuck Lever unsigned int may_flags, 1049ce502f81SChuck Lever const struct nfsd_file *nf 1050ce502f81SChuck Lever ), 1051ce502f81SChuck Lever TP_ARGS(rqstp, inode, may_flags, nf), 1052ce502f81SChuck Lever TP_STRUCT__entry( 1053ce502f81SChuck Lever __field(u32, xid) 1054ce502f81SChuck Lever __field(const void *, inode) 1055ce502f81SChuck Lever __field(unsigned long, may_flags) 1056ce502f81SChuck Lever __field(unsigned int, nf_ref) 1057ce502f81SChuck Lever __field(unsigned long, nf_flags) 1058ce502f81SChuck Lever __field(unsigned long, nf_may) 1059ce502f81SChuck Lever __field(const void *, nf_file) 1060ce502f81SChuck Lever ), 1061ce502f81SChuck Lever TP_fast_assign( 1062ce502f81SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 1063ce502f81SChuck Lever __entry->inode = inode; 1064ce502f81SChuck Lever __entry->may_flags = may_flags; 1065ce502f81SChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 1066ce502f81SChuck Lever __entry->nf_flags = nf->nf_flags; 1067ce502f81SChuck Lever __entry->nf_may = nf->nf_may; 1068ce502f81SChuck Lever __entry->nf_file = nf->nf_file; 1069ce502f81SChuck Lever ), 1070ce502f81SChuck Lever TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1071ce502f81SChuck Lever __entry->xid, __entry->inode, 1072ce502f81SChuck Lever show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref, 1073ce502f81SChuck Lever show_nf_flags(__entry->nf_flags), 1074ce502f81SChuck Lever show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1075ce502f81SChuck Lever ) 1076ce502f81SChuck Lever ); 1077ce502f81SChuck Lever 10780122e882SChuck Lever TRACE_EVENT(nfsd_file_open, 10790122e882SChuck Lever TP_PROTO(struct nfsd_file *nf, __be32 status), 10800122e882SChuck Lever TP_ARGS(nf, status), 10810122e882SChuck Lever TP_STRUCT__entry( 10820122e882SChuck Lever __field(void *, nf_inode) /* cannot be dereferenced */ 10830122e882SChuck Lever __field(int, nf_ref) 10840122e882SChuck Lever __field(unsigned long, nf_flags) 10850122e882SChuck Lever __field(unsigned long, nf_may) 10860122e882SChuck Lever __field(void *, nf_file) /* cannot be dereferenced */ 10870122e882SChuck Lever ), 10880122e882SChuck Lever TP_fast_assign( 10890122e882SChuck Lever __entry->nf_inode = nf->nf_inode; 10900122e882SChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 10910122e882SChuck Lever __entry->nf_flags = nf->nf_flags; 10920122e882SChuck Lever __entry->nf_may = nf->nf_may; 10930122e882SChuck Lever __entry->nf_file = nf->nf_file; 10940122e882SChuck Lever ), 109554f7df70SChuck Lever TP_printk("inode=%p ref=%d flags=%s may=%s file=%p", 10960122e882SChuck Lever __entry->nf_inode, 10970122e882SChuck Lever __entry->nf_ref, 10980122e882SChuck Lever show_nf_flags(__entry->nf_flags), 10990122e882SChuck Lever show_nfsd_may_flags(__entry->nf_may), 11000122e882SChuck Lever __entry->nf_file) 11010122e882SChuck Lever ) 11020122e882SChuck Lever 110365294c1fSJeff Layton DECLARE_EVENT_CLASS(nfsd_file_search_class, 110454f7df70SChuck Lever TP_PROTO( 1105a8455110SChuck Lever const struct inode *inode, 1106a8455110SChuck Lever unsigned int count 1107a8455110SChuck Lever ), 1108a8455110SChuck Lever TP_ARGS(inode, count), 1109a8455110SChuck Lever TP_STRUCT__entry( 1110a8455110SChuck Lever __field(const struct inode *, inode) 1111a8455110SChuck Lever __field(unsigned int, count) 1112a8455110SChuck Lever ), 1113a8455110SChuck Lever TP_fast_assign( 1114a8455110SChuck Lever __entry->inode = inode; 1115a8455110SChuck Lever __entry->count = count; 1116a8455110SChuck Lever ), 1117a8455110SChuck Lever TP_printk("inode=%p count=%u", 1118a8455110SChuck Lever __entry->inode, __entry->count) 1119a8455110SChuck Lever ); 1120a8455110SChuck Lever 1121a8455110SChuck Lever #define DEFINE_NFSD_FILE_SEARCH_EVENT(name) \ 1122a8455110SChuck Lever DEFINE_EVENT(nfsd_file_search_class, name, \ 1123a8455110SChuck Lever TP_PROTO( \ 1124a8455110SChuck Lever const struct inode *inode, \ 1125a8455110SChuck Lever unsigned int count \ 1126a8455110SChuck Lever ), \ 1127a8455110SChuck Lever TP_ARGS(inode, count)) 1128a8455110SChuck Lever 1129a8455110SChuck Lever DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode_sync); 1130a8455110SChuck Lever DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode); 1131a8455110SChuck Lever 1132a8455110SChuck Lever TRACE_EVENT(nfsd_file_is_cached, 1133a8455110SChuck Lever TP_PROTO( 1134a8455110SChuck Lever const struct inode *inode, 113554f7df70SChuck Lever int found 113654f7df70SChuck Lever ), 113754f7df70SChuck Lever TP_ARGS(inode, found), 113865294c1fSJeff Layton TP_STRUCT__entry( 1139a8455110SChuck Lever __field(const struct inode *, inode) 114065294c1fSJeff Layton __field(int, found) 114165294c1fSJeff Layton ), 114265294c1fSJeff Layton TP_fast_assign( 114365294c1fSJeff Layton __entry->inode = inode; 114465294c1fSJeff Layton __entry->found = found; 114565294c1fSJeff Layton ), 1146a8455110SChuck Lever TP_printk("inode=%p is %scached", 1147a8455110SChuck Lever __entry->inode, 1148a8455110SChuck Lever __entry->found ? "" : "not " 1149a8455110SChuck Lever ) 115065294c1fSJeff Layton ); 115165294c1fSJeff Layton 115265294c1fSJeff Layton TRACE_EVENT(nfsd_file_fsnotify_handle_event, 115365294c1fSJeff Layton TP_PROTO(struct inode *inode, u32 mask), 115465294c1fSJeff Layton TP_ARGS(inode, mask), 115565294c1fSJeff Layton TP_STRUCT__entry( 115665294c1fSJeff Layton __field(struct inode *, inode) 115765294c1fSJeff Layton __field(unsigned int, nlink) 115865294c1fSJeff Layton __field(umode_t, mode) 115965294c1fSJeff Layton __field(u32, mask) 116065294c1fSJeff Layton ), 116165294c1fSJeff Layton TP_fast_assign( 116265294c1fSJeff Layton __entry->inode = inode; 116365294c1fSJeff Layton __entry->nlink = inode->i_nlink; 116465294c1fSJeff Layton __entry->mode = inode->i_mode; 116565294c1fSJeff Layton __entry->mask = mask; 116665294c1fSJeff Layton ), 11673a90e1dfSChuck Lever TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 116865294c1fSJeff Layton __entry->nlink, __entry->mode, __entry->mask) 116965294c1fSJeff Layton ); 117065294c1fSJeff Layton 1171c46203acSChuck Lever DECLARE_EVENT_CLASS(nfsd_file_gc_class, 1172c46203acSChuck Lever TP_PROTO( 1173c46203acSChuck Lever const struct nfsd_file *nf 1174c46203acSChuck Lever ), 1175c46203acSChuck Lever TP_ARGS(nf), 1176c46203acSChuck Lever TP_STRUCT__entry( 1177c46203acSChuck Lever __field(void *, nf_inode) 1178c46203acSChuck Lever __field(void *, nf_file) 1179c46203acSChuck Lever __field(int, nf_ref) 1180c46203acSChuck Lever __field(unsigned long, nf_flags) 1181c46203acSChuck Lever ), 1182c46203acSChuck Lever TP_fast_assign( 1183c46203acSChuck Lever __entry->nf_inode = nf->nf_inode; 1184c46203acSChuck Lever __entry->nf_file = nf->nf_file; 1185c46203acSChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 1186c46203acSChuck Lever __entry->nf_flags = nf->nf_flags; 1187c46203acSChuck Lever ), 1188c46203acSChuck Lever TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p", 1189c46203acSChuck Lever __entry->nf_inode, __entry->nf_ref, 1190c46203acSChuck Lever show_nf_flags(__entry->nf_flags), 1191c46203acSChuck Lever __entry->nf_file 1192c46203acSChuck Lever ) 1193c46203acSChuck Lever ); 1194c46203acSChuck Lever 1195c46203acSChuck Lever #define DEFINE_NFSD_FILE_GC_EVENT(name) \ 1196c46203acSChuck Lever DEFINE_EVENT(nfsd_file_gc_class, name, \ 1197c46203acSChuck Lever TP_PROTO( \ 1198c46203acSChuck Lever const struct nfsd_file *nf \ 1199c46203acSChuck Lever ), \ 1200c46203acSChuck Lever TP_ARGS(nf)) 1201c46203acSChuck Lever 1202c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 12034a0e73e6SChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed); 1204c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 12054a0e73e6SChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed); 1206c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1207c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1208c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1209c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_hashed); 1210c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1211c46203acSChuck Lever 121294660cc1SChuck Lever DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class, 121394660cc1SChuck Lever TP_PROTO( 121494660cc1SChuck Lever unsigned long removed, 121594660cc1SChuck Lever unsigned long remaining 121694660cc1SChuck Lever ), 121794660cc1SChuck Lever TP_ARGS(removed, remaining), 121894660cc1SChuck Lever TP_STRUCT__entry( 121994660cc1SChuck Lever __field(unsigned long, removed) 122094660cc1SChuck Lever __field(unsigned long, remaining) 122194660cc1SChuck Lever ), 122294660cc1SChuck Lever TP_fast_assign( 122394660cc1SChuck Lever __entry->removed = removed; 122494660cc1SChuck Lever __entry->remaining = remaining; 122594660cc1SChuck Lever ), 122694660cc1SChuck Lever TP_printk("%lu entries removed, %lu remaining", 122794660cc1SChuck Lever __entry->removed, __entry->remaining) 122894660cc1SChuck Lever ); 122994660cc1SChuck Lever 123094660cc1SChuck Lever #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \ 123194660cc1SChuck Lever DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 123294660cc1SChuck Lever TP_PROTO( \ 123394660cc1SChuck Lever unsigned long removed, \ 123494660cc1SChuck Lever unsigned long remaining \ 123594660cc1SChuck Lever ), \ 123694660cc1SChuck Lever TP_ARGS(removed, remaining)) 123794660cc1SChuck Lever 123894660cc1SChuck Lever DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 123994660cc1SChuck Lever DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 124094660cc1SChuck Lever 12410b175b18SChuck Lever #include "cache.h" 12420b175b18SChuck Lever 12430b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_DROPIT); 12440b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_REPLY); 12450b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_DOIT); 12460b175b18SChuck Lever 12470b175b18SChuck Lever #define show_drc_retval(x) \ 12480b175b18SChuck Lever __print_symbolic(x, \ 12490b175b18SChuck Lever { RC_DROPIT, "DROPIT" }, \ 12500b175b18SChuck Lever { RC_REPLY, "REPLY" }, \ 12510b175b18SChuck Lever { RC_DOIT, "DOIT" }) 12520b175b18SChuck Lever 12530b175b18SChuck Lever TRACE_EVENT(nfsd_drc_found, 12540b175b18SChuck Lever TP_PROTO( 12550b175b18SChuck Lever const struct nfsd_net *nn, 12560b175b18SChuck Lever const struct svc_rqst *rqstp, 12570b175b18SChuck Lever int result 12580b175b18SChuck Lever ), 12590b175b18SChuck Lever TP_ARGS(nn, rqstp, result), 12600b175b18SChuck Lever TP_STRUCT__entry( 12610b175b18SChuck Lever __field(unsigned long long, boot_time) 12620b175b18SChuck Lever __field(unsigned long, result) 12630b175b18SChuck Lever __field(u32, xid) 12640b175b18SChuck Lever ), 12650b175b18SChuck Lever TP_fast_assign( 12660b175b18SChuck Lever __entry->boot_time = nn->boot_time; 12670b175b18SChuck Lever __entry->result = result; 12680b175b18SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 12690b175b18SChuck Lever ), 12700b175b18SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x result=%s", 12710b175b18SChuck Lever __entry->boot_time, __entry->xid, 12720b175b18SChuck Lever show_drc_retval(__entry->result)) 12730b175b18SChuck Lever 12740b175b18SChuck Lever ); 12750b175b18SChuck Lever 12760b175b18SChuck Lever TRACE_EVENT(nfsd_drc_mismatch, 12770b175b18SChuck Lever TP_PROTO( 12780b175b18SChuck Lever const struct nfsd_net *nn, 12790b175b18SChuck Lever const struct svc_cacherep *key, 12800b175b18SChuck Lever const struct svc_cacherep *rp 12810b175b18SChuck Lever ), 12820b175b18SChuck Lever TP_ARGS(nn, key, rp), 12830b175b18SChuck Lever TP_STRUCT__entry( 12840b175b18SChuck Lever __field(unsigned long long, boot_time) 12850b175b18SChuck Lever __field(u32, xid) 12860b175b18SChuck Lever __field(u32, cached) 12870b175b18SChuck Lever __field(u32, ingress) 12880b175b18SChuck Lever ), 12890b175b18SChuck Lever TP_fast_assign( 12900b175b18SChuck Lever __entry->boot_time = nn->boot_time; 12910b175b18SChuck Lever __entry->xid = be32_to_cpu(key->c_key.k_xid); 12920b175b18SChuck Lever __entry->cached = (__force u32)key->c_key.k_csum; 12930b175b18SChuck Lever __entry->ingress = (__force u32)rp->c_key.k_csum; 12940b175b18SChuck Lever ), 12950b175b18SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 12960b175b18SChuck Lever __entry->boot_time, __entry->xid, __entry->cached, 12970b175b18SChuck Lever __entry->ingress) 12980b175b18SChuck Lever ); 12990b175b18SChuck Lever 13001eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_args, 13011eace0d1SChuck Lever TP_PROTO( 13021eace0d1SChuck Lever const struct nfs4_client *clp, 13031eace0d1SChuck Lever const struct nfs4_cb_conn *conn 13041eace0d1SChuck Lever ), 13051eace0d1SChuck Lever TP_ARGS(clp, conn), 13061eace0d1SChuck Lever TP_STRUCT__entry( 13071eace0d1SChuck Lever __field(u32, cl_boot) 13081eace0d1SChuck Lever __field(u32, cl_id) 13091eace0d1SChuck Lever __field(u32, prog) 13101eace0d1SChuck Lever __field(u32, ident) 13119db0e15fSChuck Lever __sockaddr(addr, conn->cb_addrlen) 13121eace0d1SChuck Lever ), 13131eace0d1SChuck Lever TP_fast_assign( 13141eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 13151eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 13161eace0d1SChuck Lever __entry->prog = conn->cb_prog; 13171eace0d1SChuck Lever __entry->ident = conn->cb_ident; 13189db0e15fSChuck Lever __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 13191eace0d1SChuck Lever ), 1320d6cbe98fSChuck Lever TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 13219db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1322d6cbe98fSChuck Lever __entry->prog, __entry->ident) 13231eace0d1SChuck Lever ); 13241eace0d1SChuck Lever 13251eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_nodelegs, 13261eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), 13271eace0d1SChuck Lever TP_ARGS(clp), 13281eace0d1SChuck Lever TP_STRUCT__entry( 13291eace0d1SChuck Lever __field(u32, cl_boot) 13301eace0d1SChuck Lever __field(u32, cl_id) 13311eace0d1SChuck Lever ), 13321eace0d1SChuck Lever TP_fast_assign( 13331eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 13341eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 13351eace0d1SChuck Lever ), 13361eace0d1SChuck Lever TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 13371eace0d1SChuck Lever ) 13381eace0d1SChuck Lever 13391eace0d1SChuck Lever #define show_cb_state(val) \ 13401eace0d1SChuck Lever __print_symbolic(val, \ 13411eace0d1SChuck Lever { NFSD4_CB_UP, "UP" }, \ 13421eace0d1SChuck Lever { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 13431eace0d1SChuck Lever { NFSD4_CB_DOWN, "DOWN" }, \ 13441eace0d1SChuck Lever { NFSD4_CB_FAULT, "FAULT"}) 13451eace0d1SChuck Lever 13461eace0d1SChuck Lever DECLARE_EVENT_CLASS(nfsd_cb_class, 13471eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), 13481eace0d1SChuck Lever TP_ARGS(clp), 13491eace0d1SChuck Lever TP_STRUCT__entry( 13501eace0d1SChuck Lever __field(unsigned long, state) 13511eace0d1SChuck Lever __field(u32, cl_boot) 13521eace0d1SChuck Lever __field(u32, cl_id) 13539db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 13541eace0d1SChuck Lever ), 13551eace0d1SChuck Lever TP_fast_assign( 13561eace0d1SChuck Lever __entry->state = clp->cl_cb_state; 13571eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 13581eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 13599db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 13609db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 13611eace0d1SChuck Lever ), 13621eace0d1SChuck Lever TP_printk("addr=%pISpc client %08x:%08x state=%s", 13639db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 13641eace0d1SChuck Lever show_cb_state(__entry->state)) 13651eace0d1SChuck Lever ); 13661eace0d1SChuck Lever 13671eace0d1SChuck Lever #define DEFINE_NFSD_CB_EVENT(name) \ 13681eace0d1SChuck Lever DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 13691eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), \ 13701eace0d1SChuck Lever TP_ARGS(clp)) 13711eace0d1SChuck Lever 13721eace0d1SChuck Lever DEFINE_NFSD_CB_EVENT(state); 13734ade892aSChuck Lever DEFINE_NFSD_CB_EVENT(probe); 1374806d65b6SChuck Lever DEFINE_NFSD_CB_EVENT(lost); 13751eace0d1SChuck Lever DEFINE_NFSD_CB_EVENT(shutdown); 13761eace0d1SChuck Lever 137787b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 137887b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 137987b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 138087b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 138187b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 138287b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 138387b2394dSChuck Lever 138487b2394dSChuck Lever #define show_nfsd_authflavor(val) \ 138587b2394dSChuck Lever __print_symbolic(val, \ 138687b2394dSChuck Lever { RPC_AUTH_NULL, "none" }, \ 138787b2394dSChuck Lever { RPC_AUTH_UNIX, "sys" }, \ 138887b2394dSChuck Lever { RPC_AUTH_GSS, "gss" }, \ 138987b2394dSChuck Lever { RPC_AUTH_GSS_KRB5, "krb5" }, \ 139087b2394dSChuck Lever { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 139187b2394dSChuck Lever { RPC_AUTH_GSS_KRB5P, "krb5p" }) 139287b2394dSChuck Lever 13933c92fba5SChuck Lever TRACE_EVENT(nfsd_cb_setup, 13943c92fba5SChuck Lever TP_PROTO(const struct nfs4_client *clp, 13953c92fba5SChuck Lever const char *netid, 13963c92fba5SChuck Lever rpc_authflavor_t authflavor 13973c92fba5SChuck Lever ), 13983c92fba5SChuck Lever TP_ARGS(clp, netid, authflavor), 13993c92fba5SChuck Lever TP_STRUCT__entry( 14003c92fba5SChuck Lever __field(u32, cl_boot) 14013c92fba5SChuck Lever __field(u32, cl_id) 14023c92fba5SChuck Lever __field(unsigned long, authflavor) 14039db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 14043c92fba5SChuck Lever __array(unsigned char, netid, 8) 14053c92fba5SChuck Lever ), 14063c92fba5SChuck Lever TP_fast_assign( 14073c92fba5SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 14083c92fba5SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 14093c92fba5SChuck Lever strlcpy(__entry->netid, netid, sizeof(__entry->netid)); 14103c92fba5SChuck Lever __entry->authflavor = authflavor; 14119db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 14129db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 14133c92fba5SChuck Lever ), 14143c92fba5SChuck Lever TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 14159db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 14163c92fba5SChuck Lever __entry->netid, show_nfsd_authflavor(__entry->authflavor)) 14173c92fba5SChuck Lever ); 14183c92fba5SChuck Lever 14191eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_setup_err, 14201eace0d1SChuck Lever TP_PROTO( 14211eace0d1SChuck Lever const struct nfs4_client *clp, 14221eace0d1SChuck Lever long error 14231eace0d1SChuck Lever ), 14241eace0d1SChuck Lever TP_ARGS(clp, error), 14251eace0d1SChuck Lever TP_STRUCT__entry( 14261eace0d1SChuck Lever __field(long, error) 14271eace0d1SChuck Lever __field(u32, cl_boot) 14281eace0d1SChuck Lever __field(u32, cl_id) 14299db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 14301eace0d1SChuck Lever ), 14311eace0d1SChuck Lever TP_fast_assign( 14321eace0d1SChuck Lever __entry->error = error; 14331eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 14341eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 14359db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 14369db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 14371eace0d1SChuck Lever ), 14381eace0d1SChuck Lever TP_printk("addr=%pISpc client %08x:%08x error=%ld", 14399db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 14409db0e15fSChuck Lever __entry->error) 14411eace0d1SChuck Lever ); 14421eace0d1SChuck Lever 14439db0e15fSChuck Lever TRACE_EVENT_CONDITION(nfsd_cb_recall, 144417d76ddfSChuck Lever TP_PROTO( 144517d76ddfSChuck Lever const struct nfs4_stid *stid 144617d76ddfSChuck Lever ), 144717d76ddfSChuck Lever TP_ARGS(stid), 14489db0e15fSChuck Lever TP_CONDITION(stid->sc_client), 144917d76ddfSChuck Lever TP_STRUCT__entry( 145017d76ddfSChuck Lever __field(u32, cl_boot) 145117d76ddfSChuck Lever __field(u32, cl_id) 145217d76ddfSChuck Lever __field(u32, si_id) 145317d76ddfSChuck Lever __field(u32, si_generation) 14549db0e15fSChuck Lever __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 145517d76ddfSChuck Lever ), 145617d76ddfSChuck Lever TP_fast_assign( 145717d76ddfSChuck Lever const stateid_t *stp = &stid->sc_stateid; 145817d76ddfSChuck Lever const struct nfs4_client *clp = stid->sc_client; 145917d76ddfSChuck Lever 146017d76ddfSChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 146117d76ddfSChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 146217d76ddfSChuck Lever __entry->si_id = stp->si_opaque.so_id; 146317d76ddfSChuck Lever __entry->si_generation = stp->si_generation; 14649db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 14659db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 146617d76ddfSChuck Lever ), 146717d76ddfSChuck Lever TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 14689db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 146917d76ddfSChuck Lever __entry->si_id, __entry->si_generation) 147017d76ddfSChuck Lever ); 147117d76ddfSChuck Lever 14722cde7f81SChuck Lever TRACE_EVENT(nfsd_cb_notify_lock, 14732cde7f81SChuck Lever TP_PROTO( 14742cde7f81SChuck Lever const struct nfs4_lockowner *lo, 14752cde7f81SChuck Lever const struct nfsd4_blocked_lock *nbl 14762cde7f81SChuck Lever ), 14772cde7f81SChuck Lever TP_ARGS(lo, nbl), 14782cde7f81SChuck Lever TP_STRUCT__entry( 14792cde7f81SChuck Lever __field(u32, cl_boot) 14802cde7f81SChuck Lever __field(u32, cl_id) 14812cde7f81SChuck Lever __field(u32, fh_hash) 14829db0e15fSChuck Lever __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 14832cde7f81SChuck Lever ), 14842cde7f81SChuck Lever TP_fast_assign( 14852cde7f81SChuck Lever const struct nfs4_client *clp = lo->lo_owner.so_client; 14862cde7f81SChuck Lever 14872cde7f81SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 14882cde7f81SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 14892cde7f81SChuck Lever __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 14909db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 14919db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 14922cde7f81SChuck Lever ), 14932cde7f81SChuck Lever TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 14949db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 14952cde7f81SChuck Lever __entry->fh_hash) 14962cde7f81SChuck Lever ); 14972cde7f81SChuck Lever 149887512386SChuck Lever TRACE_EVENT(nfsd_cb_offload, 149987512386SChuck Lever TP_PROTO( 150087512386SChuck Lever const struct nfs4_client *clp, 150187512386SChuck Lever const stateid_t *stp, 150287512386SChuck Lever const struct knfsd_fh *fh, 150387512386SChuck Lever u64 count, 150487512386SChuck Lever __be32 status 150587512386SChuck Lever ), 150687512386SChuck Lever TP_ARGS(clp, stp, fh, count, status), 150787512386SChuck Lever TP_STRUCT__entry( 150887512386SChuck Lever __field(u32, cl_boot) 150987512386SChuck Lever __field(u32, cl_id) 151087512386SChuck Lever __field(u32, si_id) 151187512386SChuck Lever __field(u32, si_generation) 151287512386SChuck Lever __field(u32, fh_hash) 151387512386SChuck Lever __field(int, status) 151487512386SChuck Lever __field(u64, count) 15159db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 151687512386SChuck Lever ), 151787512386SChuck Lever TP_fast_assign( 151887512386SChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 151987512386SChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 152087512386SChuck Lever __entry->si_id = stp->si_opaque.so_id; 152187512386SChuck Lever __entry->si_generation = stp->si_generation; 152287512386SChuck Lever __entry->fh_hash = knfsd_fh_hash(fh); 152387512386SChuck Lever __entry->status = be32_to_cpu(status); 152487512386SChuck Lever __entry->count = count; 15259db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 15269db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 152787512386SChuck Lever ), 152887512386SChuck Lever TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 15299db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 153087512386SChuck Lever __entry->si_id, __entry->si_generation, 153187512386SChuck Lever __entry->fh_hash, __entry->count, __entry->status) 153287512386SChuck Lever ); 153387512386SChuck Lever 15341035d654SChuck Lever DECLARE_EVENT_CLASS(nfsd_cb_done_class, 15351035d654SChuck Lever TP_PROTO( 15361035d654SChuck Lever const stateid_t *stp, 15371035d654SChuck Lever const struct rpc_task *task 15381035d654SChuck Lever ), 15391035d654SChuck Lever TP_ARGS(stp, task), 15401035d654SChuck Lever TP_STRUCT__entry( 15411035d654SChuck Lever __field(u32, cl_boot) 15421035d654SChuck Lever __field(u32, cl_id) 15431035d654SChuck Lever __field(u32, si_id) 15441035d654SChuck Lever __field(u32, si_generation) 15451035d654SChuck Lever __field(int, status) 15461035d654SChuck Lever ), 15471035d654SChuck Lever TP_fast_assign( 15481035d654SChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 15491035d654SChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 15501035d654SChuck Lever __entry->si_id = stp->si_opaque.so_id; 15511035d654SChuck Lever __entry->si_generation = stp->si_generation; 15521035d654SChuck Lever __entry->status = task->tk_status; 15531035d654SChuck Lever ), 15541035d654SChuck Lever TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 15551035d654SChuck Lever __entry->cl_boot, __entry->cl_id, __entry->si_id, 15561035d654SChuck Lever __entry->si_generation, __entry->status 15571035d654SChuck Lever ) 15581035d654SChuck Lever ); 15591035d654SChuck Lever 15601035d654SChuck Lever #define DEFINE_NFSD_CB_DONE_EVENT(name) \ 15611035d654SChuck Lever DEFINE_EVENT(nfsd_cb_done_class, name, \ 15621035d654SChuck Lever TP_PROTO( \ 15631035d654SChuck Lever const stateid_t *stp, \ 15641035d654SChuck Lever const struct rpc_task *task \ 15651035d654SChuck Lever ), \ 15661035d654SChuck Lever TP_ARGS(stp, task)) 15671035d654SChuck Lever 15681035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 15691035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 15701035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 15711035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 15721035d654SChuck Lever 157331ef83dcSChristoph Hellwig #endif /* _NFSD_TRACE_H */ 157431ef83dcSChristoph Hellwig 157531ef83dcSChristoph Hellwig #undef TRACE_INCLUDE_PATH 157631ef83dcSChristoph Hellwig #define TRACE_INCLUDE_PATH . 157731ef83dcSChristoph Hellwig #define TRACE_INCLUDE_FILE trace 157831ef83dcSChristoph Hellwig #include <trace/define_trace.h> 1579