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); 257948755efSChuck Lever __entry->inode = d_inode(fhp->fh_dentry); 258948755efSChuck Lever __entry->type = type; 259948755efSChuck Lever __entry->access = access; 260948755efSChuck Lever __entry->error = be32_to_cpu(error); 261948755efSChuck Lever ), 262948755efSChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s error=%d", 263948755efSChuck Lever __entry->xid, __entry->fh_hash, 264948755efSChuck Lever show_fs_file_type(__entry->type), 265948755efSChuck Lever show_nfsd_may_flags(__entry->access), 266948755efSChuck Lever __entry->error 267948755efSChuck Lever ) 268948755efSChuck Lever ); 269948755efSChuck Lever 270f01274a9STrond Myklebust DECLARE_EVENT_CLASS(nfsd_fh_err_class, 271f01274a9STrond Myklebust TP_PROTO(struct svc_rqst *rqstp, 272f01274a9STrond Myklebust struct svc_fh *fhp, 273f01274a9STrond Myklebust int status), 274f01274a9STrond Myklebust TP_ARGS(rqstp, fhp, status), 275f01274a9STrond Myklebust TP_STRUCT__entry( 276f01274a9STrond Myklebust __field(u32, xid) 277f01274a9STrond Myklebust __field(u32, fh_hash) 278f01274a9STrond Myklebust __field(int, status) 279f01274a9STrond Myklebust ), 280f01274a9STrond Myklebust TP_fast_assign( 281f01274a9STrond Myklebust __entry->xid = be32_to_cpu(rqstp->rq_xid); 282f01274a9STrond Myklebust __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 283f01274a9STrond Myklebust __entry->status = status; 284f01274a9STrond Myklebust ), 285f01274a9STrond Myklebust TP_printk("xid=0x%08x fh_hash=0x%08x status=%d", 286f01274a9STrond Myklebust __entry->xid, __entry->fh_hash, 287f01274a9STrond Myklebust __entry->status) 288f01274a9STrond Myklebust ) 289f01274a9STrond Myklebust 290f01274a9STrond Myklebust #define DEFINE_NFSD_FH_ERR_EVENT(name) \ 291f01274a9STrond Myklebust DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \ 292f01274a9STrond Myklebust TP_PROTO(struct svc_rqst *rqstp, \ 293f01274a9STrond Myklebust struct svc_fh *fhp, \ 294f01274a9STrond Myklebust int status), \ 295f01274a9STrond Myklebust TP_ARGS(rqstp, fhp, status)) 296f01274a9STrond Myklebust 297f01274a9STrond Myklebust DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport); 298f01274a9STrond Myklebust DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle); 299f01274a9STrond Myklebust 300cf749f3cSTrond Myklebust TRACE_EVENT(nfsd_exp_find_key, 301cf749f3cSTrond Myklebust TP_PROTO(const struct svc_expkey *key, 302cf749f3cSTrond Myklebust int status), 303cf749f3cSTrond Myklebust TP_ARGS(key, status), 304cf749f3cSTrond Myklebust TP_STRUCT__entry( 305cf749f3cSTrond Myklebust __field(int, fsidtype) 306cf749f3cSTrond Myklebust __array(u32, fsid, 6) 307cf749f3cSTrond Myklebust __string(auth_domain, key->ek_client->name) 308cf749f3cSTrond Myklebust __field(int, status) 309cf749f3cSTrond Myklebust ), 310cf749f3cSTrond Myklebust TP_fast_assign( 311cf749f3cSTrond Myklebust __entry->fsidtype = key->ek_fsidtype; 312cf749f3cSTrond Myklebust memcpy(__entry->fsid, key->ek_fsid, 4*6); 313cf749f3cSTrond Myklebust __assign_str(auth_domain, key->ek_client->name); 314cf749f3cSTrond Myklebust __entry->status = status; 315cf749f3cSTrond Myklebust ), 316cf749f3cSTrond Myklebust TP_printk("fsid=%x::%s domain=%s status=%d", 317cf749f3cSTrond Myklebust __entry->fsidtype, 318cf749f3cSTrond Myklebust __print_array(__entry->fsid, 6, 4), 319cf749f3cSTrond Myklebust __get_str(auth_domain), 320cf749f3cSTrond Myklebust __entry->status 321cf749f3cSTrond Myklebust ) 322cf749f3cSTrond Myklebust ); 323cf749f3cSTrond Myklebust 3246a30e47fSTrond Myklebust TRACE_EVENT(nfsd_expkey_update, 3256a30e47fSTrond Myklebust TP_PROTO(const struct svc_expkey *key, const char *exp_path), 3266a30e47fSTrond Myklebust TP_ARGS(key, exp_path), 3276a30e47fSTrond Myklebust TP_STRUCT__entry( 3286a30e47fSTrond Myklebust __field(int, fsidtype) 3296a30e47fSTrond Myklebust __array(u32, fsid, 6) 3306a30e47fSTrond Myklebust __string(auth_domain, key->ek_client->name) 3316a30e47fSTrond Myklebust __string(path, exp_path) 3326a30e47fSTrond Myklebust __field(bool, cache) 3336a30e47fSTrond Myklebust ), 3346a30e47fSTrond Myklebust TP_fast_assign( 3356a30e47fSTrond Myklebust __entry->fsidtype = key->ek_fsidtype; 3366a30e47fSTrond Myklebust memcpy(__entry->fsid, key->ek_fsid, 4*6); 3376a30e47fSTrond Myklebust __assign_str(auth_domain, key->ek_client->name); 3386a30e47fSTrond Myklebust __assign_str(path, exp_path); 3396a30e47fSTrond Myklebust __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 3406a30e47fSTrond Myklebust ), 3416a30e47fSTrond Myklebust TP_printk("fsid=%x::%s domain=%s path=%s cache=%s", 3426a30e47fSTrond Myklebust __entry->fsidtype, 3436a30e47fSTrond Myklebust __print_array(__entry->fsid, 6, 4), 3446a30e47fSTrond Myklebust __get_str(auth_domain), 3456a30e47fSTrond Myklebust __get_str(path), 3466a30e47fSTrond Myklebust __entry->cache ? "pos" : "neg" 3476a30e47fSTrond Myklebust ) 3486a30e47fSTrond Myklebust ); 3496a30e47fSTrond Myklebust 350cf749f3cSTrond Myklebust TRACE_EVENT(nfsd_exp_get_by_name, 351cf749f3cSTrond Myklebust TP_PROTO(const struct svc_export *key, 352cf749f3cSTrond Myklebust int status), 353cf749f3cSTrond Myklebust TP_ARGS(key, status), 354cf749f3cSTrond Myklebust TP_STRUCT__entry( 355cf749f3cSTrond Myklebust __string(path, key->ex_path.dentry->d_name.name) 356cf749f3cSTrond Myklebust __string(auth_domain, key->ex_client->name) 357cf749f3cSTrond Myklebust __field(int, status) 358cf749f3cSTrond Myklebust ), 359cf749f3cSTrond Myklebust TP_fast_assign( 360cf749f3cSTrond Myklebust __assign_str(path, key->ex_path.dentry->d_name.name); 361cf749f3cSTrond Myklebust __assign_str(auth_domain, key->ex_client->name); 362cf749f3cSTrond Myklebust __entry->status = status; 363cf749f3cSTrond Myklebust ), 364cf749f3cSTrond Myklebust TP_printk("path=%s domain=%s status=%d", 365cf749f3cSTrond Myklebust __get_str(path), 366cf749f3cSTrond Myklebust __get_str(auth_domain), 367cf749f3cSTrond Myklebust __entry->status 368cf749f3cSTrond Myklebust ) 369cf749f3cSTrond Myklebust ); 370cf749f3cSTrond Myklebust 3716a30e47fSTrond Myklebust TRACE_EVENT(nfsd_export_update, 3726a30e47fSTrond Myklebust TP_PROTO(const struct svc_export *key), 3736a30e47fSTrond Myklebust TP_ARGS(key), 3746a30e47fSTrond Myklebust TP_STRUCT__entry( 3756a30e47fSTrond Myklebust __string(path, key->ex_path.dentry->d_name.name) 3766a30e47fSTrond Myklebust __string(auth_domain, key->ex_client->name) 3776a30e47fSTrond Myklebust __field(bool, cache) 3786a30e47fSTrond Myklebust ), 3796a30e47fSTrond Myklebust TP_fast_assign( 3806a30e47fSTrond Myklebust __assign_str(path, key->ex_path.dentry->d_name.name); 3816a30e47fSTrond Myklebust __assign_str(auth_domain, key->ex_client->name); 3826a30e47fSTrond Myklebust __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 3836a30e47fSTrond Myklebust ), 3846a30e47fSTrond Myklebust TP_printk("path=%s domain=%s cache=%s", 3856a30e47fSTrond Myklebust __get_str(path), 3866a30e47fSTrond Myklebust __get_str(auth_domain), 3876a30e47fSTrond Myklebust __entry->cache ? "pos" : "neg" 3886a30e47fSTrond Myklebust ) 3896a30e47fSTrond Myklebust ); 3906a30e47fSTrond Myklebust 3916e8b50d1SJeff Layton DECLARE_EVENT_CLASS(nfsd_io_class, 3926e8b50d1SJeff Layton TP_PROTO(struct svc_rqst *rqstp, 3936e8b50d1SJeff Layton struct svc_fh *fhp, 3946a4d333dSChuck Lever u64 offset, 3956a4d333dSChuck Lever u32 len), 3966e8b50d1SJeff Layton TP_ARGS(rqstp, fhp, offset, len), 3976e8b50d1SJeff Layton TP_STRUCT__entry( 398afa720a0SChuck Lever __field(u32, xid) 399afa720a0SChuck Lever __field(u32, fh_hash) 4006a4d333dSChuck Lever __field(u64, offset) 4016a4d333dSChuck Lever __field(u32, len) 4026e8b50d1SJeff Layton ), 4036e8b50d1SJeff Layton TP_fast_assign( 404afa720a0SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 40579e0b4e2SChuck Lever __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 4066e8b50d1SJeff Layton __entry->offset = offset; 4076e8b50d1SJeff Layton __entry->len = len; 4086e8b50d1SJeff Layton ), 4096a4d333dSChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u", 410afa720a0SChuck Lever __entry->xid, __entry->fh_hash, 4116e8b50d1SJeff Layton __entry->offset, __entry->len) 4126e8b50d1SJeff Layton ) 4136e8b50d1SJeff Layton 4146e8b50d1SJeff Layton #define DEFINE_NFSD_IO_EVENT(name) \ 415f394b62bSChuck Lever DEFINE_EVENT(nfsd_io_class, nfsd_##name, \ 4166e8b50d1SJeff Layton TP_PROTO(struct svc_rqst *rqstp, \ 4176e8b50d1SJeff Layton struct svc_fh *fhp, \ 4186a4d333dSChuck Lever u64 offset, \ 4196a4d333dSChuck Lever u32 len), \ 4206e8b50d1SJeff Layton TP_ARGS(rqstp, fhp, offset, len)) 4216e8b50d1SJeff Layton 4226e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_start); 42387c5942eSChuck Lever DEFINE_NFSD_IO_EVENT(read_splice); 42487c5942eSChuck Lever DEFINE_NFSD_IO_EVENT(read_vector); 4256e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_io_done); 4266e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_done); 4276e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_start); 4286e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_opened); 4296e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_io_done); 4306e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_done); 43131ef83dcSChristoph Hellwig 432d890be15SChuck Lever DECLARE_EVENT_CLASS(nfsd_err_class, 433d890be15SChuck Lever TP_PROTO(struct svc_rqst *rqstp, 434d890be15SChuck Lever struct svc_fh *fhp, 435d890be15SChuck Lever loff_t offset, 436d890be15SChuck Lever int status), 437d890be15SChuck Lever TP_ARGS(rqstp, fhp, offset, status), 438d890be15SChuck Lever TP_STRUCT__entry( 439d890be15SChuck Lever __field(u32, xid) 440d890be15SChuck Lever __field(u32, fh_hash) 441d890be15SChuck Lever __field(loff_t, offset) 442d890be15SChuck Lever __field(int, status) 443d890be15SChuck Lever ), 444d890be15SChuck Lever TP_fast_assign( 445d890be15SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 446d890be15SChuck Lever __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 447d890be15SChuck Lever __entry->offset = offset; 448d890be15SChuck Lever __entry->status = status; 449d890be15SChuck Lever ), 450d890be15SChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d", 451d890be15SChuck Lever __entry->xid, __entry->fh_hash, 452d890be15SChuck Lever __entry->offset, __entry->status) 453d890be15SChuck Lever ) 454d890be15SChuck Lever 455d890be15SChuck Lever #define DEFINE_NFSD_ERR_EVENT(name) \ 456d890be15SChuck Lever DEFINE_EVENT(nfsd_err_class, nfsd_##name, \ 457d890be15SChuck Lever TP_PROTO(struct svc_rqst *rqstp, \ 458d890be15SChuck Lever struct svc_fh *fhp, \ 459d890be15SChuck Lever loff_t offset, \ 460d890be15SChuck Lever int len), \ 461d890be15SChuck Lever TP_ARGS(rqstp, fhp, offset, len)) 462d890be15SChuck Lever 46387c5942eSChuck Lever DEFINE_NFSD_ERR_EVENT(read_err); 464d890be15SChuck Lever DEFINE_NFSD_ERR_EVENT(write_err); 465d890be15SChuck Lever 4666019ce07SChuck Lever TRACE_EVENT(nfsd_dirent, 4676019ce07SChuck Lever TP_PROTO(struct svc_fh *fhp, 4686019ce07SChuck Lever u64 ino, 4696019ce07SChuck Lever const char *name, 4706019ce07SChuck Lever int namlen), 4716019ce07SChuck Lever TP_ARGS(fhp, ino, name, namlen), 4726019ce07SChuck Lever TP_STRUCT__entry( 4736019ce07SChuck Lever __field(u32, fh_hash) 4746019ce07SChuck Lever __field(u64, ino) 475408c0de7SChuck Lever __string_len(name, name, namlen) 4766019ce07SChuck Lever ), 4776019ce07SChuck Lever TP_fast_assign( 4786019ce07SChuck Lever __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0; 4796019ce07SChuck Lever __entry->ino = ino; 480408c0de7SChuck Lever __assign_str_len(name, name, namlen) 4816019ce07SChuck Lever ), 482408c0de7SChuck Lever TP_printk("fh_hash=0x%08x ino=%llu name=%s", 483408c0de7SChuck Lever __entry->fh_hash, __entry->ino, __get_str(name) 484408c0de7SChuck Lever ) 4856019ce07SChuck Lever ) 4866019ce07SChuck Lever 487a2f4c3faSTrond Myklebust DECLARE_EVENT_CLASS(nfsd_copy_err_class, 488a2f4c3faSTrond Myklebust TP_PROTO(struct svc_rqst *rqstp, 489a2f4c3faSTrond Myklebust struct svc_fh *src_fhp, 490a2f4c3faSTrond Myklebust loff_t src_offset, 491a2f4c3faSTrond Myklebust struct svc_fh *dst_fhp, 492a2f4c3faSTrond Myklebust loff_t dst_offset, 493a2f4c3faSTrond Myklebust u64 count, 494a2f4c3faSTrond Myklebust int status), 495a2f4c3faSTrond Myklebust TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status), 496a2f4c3faSTrond Myklebust TP_STRUCT__entry( 497a2f4c3faSTrond Myklebust __field(u32, xid) 498a2f4c3faSTrond Myklebust __field(u32, src_fh_hash) 499a2f4c3faSTrond Myklebust __field(loff_t, src_offset) 500a2f4c3faSTrond Myklebust __field(u32, dst_fh_hash) 501a2f4c3faSTrond Myklebust __field(loff_t, dst_offset) 502a2f4c3faSTrond Myklebust __field(u64, count) 503a2f4c3faSTrond Myklebust __field(int, status) 504a2f4c3faSTrond Myklebust ), 505a2f4c3faSTrond Myklebust TP_fast_assign( 506a2f4c3faSTrond Myklebust __entry->xid = be32_to_cpu(rqstp->rq_xid); 507a2f4c3faSTrond Myklebust __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle); 508a2f4c3faSTrond Myklebust __entry->src_offset = src_offset; 509a2f4c3faSTrond Myklebust __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle); 510a2f4c3faSTrond Myklebust __entry->dst_offset = dst_offset; 511a2f4c3faSTrond Myklebust __entry->count = count; 512a2f4c3faSTrond Myklebust __entry->status = status; 513a2f4c3faSTrond Myklebust ), 514a2f4c3faSTrond Myklebust TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld " 515a2f4c3faSTrond Myklebust "dst_fh_hash=0x%08x dst_offset=%lld " 516a2f4c3faSTrond Myklebust "count=%llu status=%d", 517a2f4c3faSTrond Myklebust __entry->xid, __entry->src_fh_hash, __entry->src_offset, 518a2f4c3faSTrond Myklebust __entry->dst_fh_hash, __entry->dst_offset, 519a2f4c3faSTrond Myklebust (unsigned long long)__entry->count, 520a2f4c3faSTrond Myklebust __entry->status) 521a2f4c3faSTrond Myklebust ) 522a2f4c3faSTrond Myklebust 523a2f4c3faSTrond Myklebust #define DEFINE_NFSD_COPY_ERR_EVENT(name) \ 524a2f4c3faSTrond Myklebust DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \ 525a2f4c3faSTrond Myklebust TP_PROTO(struct svc_rqst *rqstp, \ 526a2f4c3faSTrond Myklebust struct svc_fh *src_fhp, \ 527a2f4c3faSTrond Myklebust loff_t src_offset, \ 528a2f4c3faSTrond Myklebust struct svc_fh *dst_fhp, \ 529a2f4c3faSTrond Myklebust loff_t dst_offset, \ 530a2f4c3faSTrond Myklebust u64 count, \ 531a2f4c3faSTrond Myklebust int status), \ 532a2f4c3faSTrond Myklebust TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \ 533a2f4c3faSTrond Myklebust count, status)) 534a2f4c3faSTrond Myklebust 535a2f4c3faSTrond Myklebust DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err); 536a2f4c3faSTrond Myklebust 537825213e5SJeff Layton #include "state.h" 53865294c1fSJeff Layton #include "filecache.h" 53965294c1fSJeff Layton #include "vfs.h" 540825213e5SJeff Layton 541*c035362eSChuck Lever TRACE_EVENT(nfsd_delegret_wakeup, 542*c035362eSChuck Lever TP_PROTO( 543*c035362eSChuck Lever const struct svc_rqst *rqstp, 544*c035362eSChuck Lever const struct inode *inode, 545*c035362eSChuck Lever long timeo 546*c035362eSChuck Lever ), 547*c035362eSChuck Lever TP_ARGS(rqstp, inode, timeo), 548*c035362eSChuck Lever TP_STRUCT__entry( 549*c035362eSChuck Lever __field(u32, xid) 550*c035362eSChuck Lever __field(const void *, inode) 551*c035362eSChuck Lever __field(long, timeo) 552*c035362eSChuck Lever ), 553*c035362eSChuck Lever TP_fast_assign( 554*c035362eSChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 555*c035362eSChuck Lever __entry->inode = inode; 556*c035362eSChuck Lever __entry->timeo = timeo; 557*c035362eSChuck Lever ), 558*c035362eSChuck Lever TP_printk("xid=0x%08x inode=%p%s", 559*c035362eSChuck Lever __entry->xid, __entry->inode, 560*c035362eSChuck Lever __entry->timeo == 0 ? " (timed out)" : "" 561*c035362eSChuck Lever ) 562*c035362eSChuck Lever ); 563*c035362eSChuck Lever 56431ef83dcSChristoph Hellwig DECLARE_EVENT_CLASS(nfsd_stateid_class, 56531ef83dcSChristoph Hellwig TP_PROTO(stateid_t *stp), 56631ef83dcSChristoph Hellwig TP_ARGS(stp), 56731ef83dcSChristoph Hellwig TP_STRUCT__entry( 56831ef83dcSChristoph Hellwig __field(u32, cl_boot) 56931ef83dcSChristoph Hellwig __field(u32, cl_id) 57031ef83dcSChristoph Hellwig __field(u32, si_id) 57131ef83dcSChristoph Hellwig __field(u32, si_generation) 57231ef83dcSChristoph Hellwig ), 57331ef83dcSChristoph Hellwig TP_fast_assign( 57431ef83dcSChristoph Hellwig __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 57531ef83dcSChristoph Hellwig __entry->cl_id = stp->si_opaque.so_clid.cl_id; 57631ef83dcSChristoph Hellwig __entry->si_id = stp->si_opaque.so_id; 57731ef83dcSChristoph Hellwig __entry->si_generation = stp->si_generation; 57831ef83dcSChristoph Hellwig ), 57931ef83dcSChristoph Hellwig TP_printk("client %08x:%08x stateid %08x:%08x", 58031ef83dcSChristoph Hellwig __entry->cl_boot, 58131ef83dcSChristoph Hellwig __entry->cl_id, 58231ef83dcSChristoph Hellwig __entry->si_id, 58331ef83dcSChristoph Hellwig __entry->si_generation) 58431ef83dcSChristoph Hellwig ) 58531ef83dcSChristoph Hellwig 58631ef83dcSChristoph Hellwig #define DEFINE_STATEID_EVENT(name) \ 587f394b62bSChuck Lever DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \ 58831ef83dcSChristoph Hellwig TP_PROTO(stateid_t *stp), \ 58931ef83dcSChristoph Hellwig TP_ARGS(stp)) 590dd5e3fbcSChuck Lever 59131ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_alloc); 59231ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_unhash); 59331ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_free); 59431ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_get_lookup_fail); 59531ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_commit_lookup_fail); 59631ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_return_lookup_fail); 59731ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall); 59831ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_done); 59931ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_fail); 60031ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_release); 60131ef83dcSChristoph Hellwig 6023caf9175SHou Tao DEFINE_STATEID_EVENT(open); 6033caf9175SHou Tao DEFINE_STATEID_EVENT(deleg_read); 604dd5e3fbcSChuck Lever DEFINE_STATEID_EVENT(deleg_recall); 605dd5e3fbcSChuck Lever 606dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_stateseqid_class, 607dd5e3fbcSChuck Lever TP_PROTO(u32 seqid, const stateid_t *stp), 608dd5e3fbcSChuck Lever TP_ARGS(seqid, stp), 609dd5e3fbcSChuck Lever TP_STRUCT__entry( 610dd5e3fbcSChuck Lever __field(u32, seqid) 611dd5e3fbcSChuck Lever __field(u32, cl_boot) 612dd5e3fbcSChuck Lever __field(u32, cl_id) 613dd5e3fbcSChuck Lever __field(u32, si_id) 614dd5e3fbcSChuck Lever __field(u32, si_generation) 615dd5e3fbcSChuck Lever ), 616dd5e3fbcSChuck Lever TP_fast_assign( 617dd5e3fbcSChuck Lever __entry->seqid = seqid; 618dd5e3fbcSChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 619dd5e3fbcSChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 620dd5e3fbcSChuck Lever __entry->si_id = stp->si_opaque.so_id; 621dd5e3fbcSChuck Lever __entry->si_generation = stp->si_generation; 622dd5e3fbcSChuck Lever ), 623dd5e3fbcSChuck Lever TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x", 624dd5e3fbcSChuck Lever __entry->seqid, __entry->cl_boot, __entry->cl_id, 625dd5e3fbcSChuck Lever __entry->si_id, __entry->si_generation) 626dd5e3fbcSChuck Lever ) 627dd5e3fbcSChuck Lever 628dd5e3fbcSChuck Lever #define DEFINE_STATESEQID_EVENT(name) \ 629dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \ 630dd5e3fbcSChuck Lever TP_PROTO(u32 seqid, const stateid_t *stp), \ 631dd5e3fbcSChuck Lever TP_ARGS(seqid, stp)) 632dd5e3fbcSChuck Lever 633dd5e3fbcSChuck Lever DEFINE_STATESEQID_EVENT(preprocess); 634dd5e3fbcSChuck Lever DEFINE_STATESEQID_EVENT(open_confirm); 635dd5e3fbcSChuck Lever 636dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_clientid_class, 637dd5e3fbcSChuck Lever TP_PROTO(const clientid_t *clid), 638dd5e3fbcSChuck Lever TP_ARGS(clid), 639dd5e3fbcSChuck Lever TP_STRUCT__entry( 640dd5e3fbcSChuck Lever __field(u32, cl_boot) 641dd5e3fbcSChuck Lever __field(u32, cl_id) 642dd5e3fbcSChuck Lever ), 643dd5e3fbcSChuck Lever TP_fast_assign( 644dd5e3fbcSChuck Lever __entry->cl_boot = clid->cl_boot; 645dd5e3fbcSChuck Lever __entry->cl_id = clid->cl_id; 646dd5e3fbcSChuck Lever ), 647dd5e3fbcSChuck Lever TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 648dd5e3fbcSChuck Lever ) 649dd5e3fbcSChuck Lever 650dd5e3fbcSChuck Lever #define DEFINE_CLIENTID_EVENT(name) \ 651dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 652dd5e3fbcSChuck Lever TP_PROTO(const clientid_t *clid), \ 653dd5e3fbcSChuck Lever TP_ARGS(clid)) 654dd5e3fbcSChuck Lever 655237f91c8SChuck Lever DEFINE_CLIENTID_EVENT(expire_unconf); 656cee8aa07SChuck Lever DEFINE_CLIENTID_EVENT(reclaim_complete); 6577e3b32acSChuck Lever DEFINE_CLIENTID_EVENT(confirmed); 658c41a9b7aSChuck Lever DEFINE_CLIENTID_EVENT(destroyed); 6592958d2eeSChuck Lever DEFINE_CLIENTID_EVENT(admin_expired); 6602958d2eeSChuck Lever DEFINE_CLIENTID_EVENT(replaced); 661dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(purged); 662dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(renew); 663dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(stale); 664dd5e3fbcSChuck Lever 665dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_net_class, 666dd5e3fbcSChuck Lever TP_PROTO(const struct nfsd_net *nn), 667dd5e3fbcSChuck Lever TP_ARGS(nn), 668dd5e3fbcSChuck Lever TP_STRUCT__entry( 669dd5e3fbcSChuck Lever __field(unsigned long long, boot_time) 670dd5e3fbcSChuck Lever ), 671dd5e3fbcSChuck Lever TP_fast_assign( 672dd5e3fbcSChuck Lever __entry->boot_time = nn->boot_time; 673dd5e3fbcSChuck Lever ), 674dd5e3fbcSChuck Lever TP_printk("boot_time=%16llx", __entry->boot_time) 675dd5e3fbcSChuck Lever ) 676dd5e3fbcSChuck Lever 677dd5e3fbcSChuck Lever #define DEFINE_NET_EVENT(name) \ 678dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 679dd5e3fbcSChuck Lever TP_PROTO(const struct nfsd_net *nn), \ 680dd5e3fbcSChuck Lever TP_ARGS(nn)) 681dd5e3fbcSChuck Lever 682dd5e3fbcSChuck Lever DEFINE_NET_EVENT(grace_start); 683dd5e3fbcSChuck Lever DEFINE_NET_EVENT(grace_complete); 684dd5e3fbcSChuck Lever 68575acacb6SChuck Lever TRACE_EVENT(nfsd_writeverf_reset, 68675acacb6SChuck Lever TP_PROTO( 68775acacb6SChuck Lever const struct nfsd_net *nn, 68875acacb6SChuck Lever const struct svc_rqst *rqstp, 68975acacb6SChuck Lever int error 69075acacb6SChuck Lever ), 69175acacb6SChuck Lever TP_ARGS(nn, rqstp, error), 69275acacb6SChuck Lever TP_STRUCT__entry( 69375acacb6SChuck Lever __field(unsigned long long, boot_time) 69475acacb6SChuck Lever __field(u32, xid) 69575acacb6SChuck Lever __field(int, error) 69675acacb6SChuck Lever __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 69775acacb6SChuck Lever ), 69875acacb6SChuck Lever TP_fast_assign( 69975acacb6SChuck Lever __entry->boot_time = nn->boot_time; 70075acacb6SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 70175acacb6SChuck Lever __entry->error = error; 70275acacb6SChuck Lever 70375acacb6SChuck Lever /* avoid seqlock inside TP_fast_assign */ 70475acacb6SChuck Lever memcpy(__entry->verifier, nn->writeverf, 70575acacb6SChuck Lever NFS4_VERIFIER_SIZE); 70675acacb6SChuck Lever ), 70775acacb6SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s", 70875acacb6SChuck Lever __entry->boot_time, __entry->xid, __entry->error, 70975acacb6SChuck Lever __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 71075acacb6SChuck Lever ) 71175acacb6SChuck Lever ); 71275acacb6SChuck Lever 71327787733SChuck Lever TRACE_EVENT(nfsd_clid_cred_mismatch, 71427787733SChuck Lever TP_PROTO( 71527787733SChuck Lever const struct nfs4_client *clp, 71627787733SChuck Lever const struct svc_rqst *rqstp 71727787733SChuck Lever ), 71827787733SChuck Lever TP_ARGS(clp, rqstp), 71927787733SChuck Lever TP_STRUCT__entry( 72027787733SChuck Lever __field(u32, cl_boot) 72127787733SChuck Lever __field(u32, cl_id) 72227787733SChuck Lever __field(unsigned long, cl_flavor) 72327787733SChuck Lever __field(unsigned long, new_flavor) 7249db0e15fSChuck Lever __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 72527787733SChuck Lever ), 72627787733SChuck Lever TP_fast_assign( 72727787733SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 72827787733SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 72927787733SChuck Lever __entry->cl_flavor = clp->cl_cred.cr_flavor; 73027787733SChuck Lever __entry->new_flavor = rqstp->rq_cred.cr_flavor; 7319db0e15fSChuck Lever __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 7329db0e15fSChuck Lever rqstp->rq_xprt->xpt_remotelen); 73327787733SChuck Lever ), 73427787733SChuck Lever TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc", 73527787733SChuck Lever __entry->cl_boot, __entry->cl_id, 73627787733SChuck Lever show_nfsd_authflavor(__entry->cl_flavor), 7379db0e15fSChuck Lever show_nfsd_authflavor(__entry->new_flavor), 7389db0e15fSChuck Lever __get_sockaddr(addr) 73927787733SChuck Lever ) 74027787733SChuck Lever ) 74127787733SChuck Lever 742744ea54cSChuck Lever TRACE_EVENT(nfsd_clid_verf_mismatch, 743744ea54cSChuck Lever TP_PROTO( 744744ea54cSChuck Lever const struct nfs4_client *clp, 745744ea54cSChuck Lever const struct svc_rqst *rqstp, 746744ea54cSChuck Lever const nfs4_verifier *verf 747744ea54cSChuck Lever ), 748744ea54cSChuck Lever TP_ARGS(clp, rqstp, verf), 749744ea54cSChuck Lever TP_STRUCT__entry( 750744ea54cSChuck Lever __field(u32, cl_boot) 751744ea54cSChuck Lever __field(u32, cl_id) 752744ea54cSChuck Lever __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE) 753744ea54cSChuck Lever __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE) 7549db0e15fSChuck Lever __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 755744ea54cSChuck Lever ), 756744ea54cSChuck Lever TP_fast_assign( 757744ea54cSChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 758744ea54cSChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 759744ea54cSChuck Lever memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier, 760744ea54cSChuck Lever NFS4_VERIFIER_SIZE); 761744ea54cSChuck Lever memcpy(__entry->new_verifier, (void *)verf, 762744ea54cSChuck Lever NFS4_VERIFIER_SIZE); 7639db0e15fSChuck Lever __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 7649db0e15fSChuck Lever rqstp->rq_xprt->xpt_remotelen); 765744ea54cSChuck Lever ), 766744ea54cSChuck Lever TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc", 767744ea54cSChuck Lever __entry->cl_boot, __entry->cl_id, 768744ea54cSChuck Lever __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE), 769744ea54cSChuck Lever __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE), 7709db0e15fSChuck Lever __get_sockaddr(addr) 771744ea54cSChuck Lever ) 772744ea54cSChuck Lever ); 773744ea54cSChuck Lever 774237f91c8SChuck Lever DECLARE_EVENT_CLASS(nfsd_clid_class, 775237f91c8SChuck Lever TP_PROTO(const struct nfs4_client *clp), 776237f91c8SChuck Lever TP_ARGS(clp), 777237f91c8SChuck Lever TP_STRUCT__entry( 778237f91c8SChuck Lever __field(u32, cl_boot) 779237f91c8SChuck Lever __field(u32, cl_id) 780237f91c8SChuck Lever __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 781237f91c8SChuck Lever __field(unsigned long, flavor) 782237f91c8SChuck Lever __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 783d27b74a8SChuck Lever __string_len(name, name, clp->cl_name.len) 784237f91c8SChuck Lever ), 785237f91c8SChuck Lever TP_fast_assign( 786237f91c8SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 787237f91c8SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 788237f91c8SChuck Lever memcpy(__entry->addr, &clp->cl_addr, 789237f91c8SChuck Lever sizeof(struct sockaddr_in6)); 790237f91c8SChuck Lever __entry->flavor = clp->cl_cred.cr_flavor; 791237f91c8SChuck Lever memcpy(__entry->verifier, (void *)&clp->cl_verifier, 792237f91c8SChuck Lever NFS4_VERIFIER_SIZE); 793d27b74a8SChuck Lever __assign_str_len(name, clp->cl_name.data, clp->cl_name.len); 794237f91c8SChuck Lever ), 795237f91c8SChuck Lever TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x", 796237f91c8SChuck Lever __entry->addr, __get_str(name), 797237f91c8SChuck Lever __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE), 798237f91c8SChuck Lever show_nfsd_authflavor(__entry->flavor), 799237f91c8SChuck Lever __entry->cl_boot, __entry->cl_id) 800237f91c8SChuck Lever ); 801237f91c8SChuck Lever 802237f91c8SChuck Lever #define DEFINE_CLID_EVENT(name) \ 803237f91c8SChuck Lever DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 804237f91c8SChuck Lever TP_PROTO(const struct nfs4_client *clp), \ 805237f91c8SChuck Lever TP_ARGS(clp)) 806237f91c8SChuck Lever 807237f91c8SChuck Lever DEFINE_CLID_EVENT(fresh); 808e8f80c55SChuck Lever DEFINE_CLID_EVENT(confirmed_r); 809237f91c8SChuck Lever 810b76278aeSChuck Lever /* 811b76278aeSChuck Lever * from fs/nfsd/filecache.h 812b76278aeSChuck Lever */ 81365294c1fSJeff Layton #define show_nf_flags(val) \ 81465294c1fSJeff Layton __print_flags(val, "|", \ 81565294c1fSJeff Layton { 1 << NFSD_FILE_HASHED, "HASHED" }, \ 81665294c1fSJeff Layton { 1 << NFSD_FILE_PENDING, "PENDING" }, \ 81765294c1fSJeff Layton { 1 << NFSD_FILE_REFERENCED, "REFERENCED"}) 81865294c1fSJeff Layton 81965294c1fSJeff Layton DECLARE_EVENT_CLASS(nfsd_file_class, 82065294c1fSJeff Layton TP_PROTO(struct nfsd_file *nf), 82165294c1fSJeff Layton TP_ARGS(nf), 82265294c1fSJeff Layton TP_STRUCT__entry( 82365294c1fSJeff Layton __field(void *, nf_inode) 82465294c1fSJeff Layton __field(int, nf_ref) 82565294c1fSJeff Layton __field(unsigned long, nf_flags) 82665294c1fSJeff Layton __field(unsigned char, nf_may) 82765294c1fSJeff Layton __field(struct file *, nf_file) 82865294c1fSJeff Layton ), 82965294c1fSJeff Layton TP_fast_assign( 83065294c1fSJeff Layton __entry->nf_inode = nf->nf_inode; 831689827cdSTrond Myklebust __entry->nf_ref = refcount_read(&nf->nf_ref); 83265294c1fSJeff Layton __entry->nf_flags = nf->nf_flags; 83365294c1fSJeff Layton __entry->nf_may = nf->nf_may; 83465294c1fSJeff Layton __entry->nf_file = nf->nf_file; 83565294c1fSJeff Layton ), 83654f7df70SChuck Lever TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p", 83765294c1fSJeff Layton __entry->nf_inode, 83865294c1fSJeff Layton __entry->nf_ref, 83965294c1fSJeff Layton show_nf_flags(__entry->nf_flags), 840b76278aeSChuck Lever show_nfsd_may_flags(__entry->nf_may), 84165294c1fSJeff Layton __entry->nf_file) 84265294c1fSJeff Layton ) 84365294c1fSJeff Layton 84465294c1fSJeff Layton #define DEFINE_NFSD_FILE_EVENT(name) \ 84565294c1fSJeff Layton DEFINE_EVENT(nfsd_file_class, name, \ 84665294c1fSJeff Layton TP_PROTO(struct nfsd_file *nf), \ 84765294c1fSJeff Layton TP_ARGS(nf)) 84865294c1fSJeff Layton 84965294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_put_final); 85065294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 85165294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 852ce502f81SChuck Lever DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_dispose); 85365294c1fSJeff Layton 854b40a2839SChuck Lever TRACE_EVENT(nfsd_file_alloc, 855b40a2839SChuck Lever TP_PROTO( 856b40a2839SChuck Lever const struct nfsd_file *nf 857b40a2839SChuck Lever ), 858b40a2839SChuck Lever TP_ARGS(nf), 859b40a2839SChuck Lever TP_STRUCT__entry( 860b40a2839SChuck Lever __field(const void *, nf_inode) 861b40a2839SChuck Lever __field(unsigned long, nf_flags) 862b40a2839SChuck Lever __field(unsigned long, nf_may) 863b40a2839SChuck Lever __field(unsigned int, nf_ref) 864b40a2839SChuck Lever ), 865b40a2839SChuck Lever TP_fast_assign( 866b40a2839SChuck Lever __entry->nf_inode = nf->nf_inode; 867b40a2839SChuck Lever __entry->nf_flags = nf->nf_flags; 868b40a2839SChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 869b40a2839SChuck Lever __entry->nf_may = nf->nf_may; 870b40a2839SChuck Lever ), 871b40a2839SChuck Lever TP_printk("inode=%p ref=%u flags=%s may=%s", 872b40a2839SChuck Lever __entry->nf_inode, __entry->nf_ref, 873b40a2839SChuck Lever show_nf_flags(__entry->nf_flags), 874b40a2839SChuck Lever show_nfsd_may_flags(__entry->nf_may) 875b40a2839SChuck Lever ) 876b40a2839SChuck Lever ); 877b40a2839SChuck Lever 87865294c1fSJeff Layton TRACE_EVENT(nfsd_file_acquire, 87954f7df70SChuck Lever TP_PROTO( 880be023006SChuck Lever const struct svc_rqst *rqstp, 881be023006SChuck Lever const struct inode *inode, 88254f7df70SChuck Lever unsigned int may_flags, 883be023006SChuck Lever const struct nfsd_file *nf, 88454f7df70SChuck Lever __be32 status 88554f7df70SChuck Lever ), 88665294c1fSJeff Layton 88754f7df70SChuck Lever TP_ARGS(rqstp, inode, may_flags, nf, status), 88865294c1fSJeff Layton 88965294c1fSJeff Layton TP_STRUCT__entry( 890a9ceb060STrond Myklebust __field(u32, xid) 891be023006SChuck Lever __field(const void *, inode) 892b76278aeSChuck Lever __field(unsigned long, may_flags) 893be023006SChuck Lever __field(unsigned int, nf_ref) 89465294c1fSJeff Layton __field(unsigned long, nf_flags) 895b76278aeSChuck Lever __field(unsigned long, nf_may) 896be023006SChuck Lever __field(const void *, nf_file) 897a9ceb060STrond Myklebust __field(u32, status) 89865294c1fSJeff Layton ), 89965294c1fSJeff Layton 90065294c1fSJeff Layton TP_fast_assign( 901a9ceb060STrond Myklebust __entry->xid = be32_to_cpu(rqstp->rq_xid); 90265294c1fSJeff Layton __entry->inode = inode; 90365294c1fSJeff Layton __entry->may_flags = may_flags; 904689827cdSTrond Myklebust __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 90565294c1fSJeff Layton __entry->nf_flags = nf ? nf->nf_flags : 0; 90665294c1fSJeff Layton __entry->nf_may = nf ? nf->nf_may : 0; 90765294c1fSJeff Layton __entry->nf_file = nf ? nf->nf_file : NULL; 908a9ceb060STrond Myklebust __entry->status = be32_to_cpu(status); 90965294c1fSJeff Layton ), 91065294c1fSJeff Layton 911be023006SChuck Lever TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u", 91254f7df70SChuck Lever __entry->xid, __entry->inode, 913b76278aeSChuck Lever show_nfsd_may_flags(__entry->may_flags), 914b76278aeSChuck Lever __entry->nf_ref, show_nf_flags(__entry->nf_flags), 915b76278aeSChuck Lever show_nfsd_may_flags(__entry->nf_may), 916be023006SChuck Lever __entry->nf_file, __entry->status 917be023006SChuck Lever ) 918be023006SChuck Lever ); 919be023006SChuck Lever 920be023006SChuck Lever TRACE_EVENT(nfsd_file_create, 921be023006SChuck Lever TP_PROTO( 922be023006SChuck Lever const struct svc_rqst *rqstp, 923be023006SChuck Lever unsigned int may_flags, 924be023006SChuck Lever const struct nfsd_file *nf 925be023006SChuck Lever ), 926be023006SChuck Lever 927be023006SChuck Lever TP_ARGS(rqstp, may_flags, nf), 928be023006SChuck Lever 929be023006SChuck Lever TP_STRUCT__entry( 930be023006SChuck Lever __field(const void *, nf_inode) 931be023006SChuck Lever __field(const void *, nf_file) 932be023006SChuck Lever __field(unsigned long, may_flags) 933be023006SChuck Lever __field(unsigned long, nf_flags) 934be023006SChuck Lever __field(unsigned long, nf_may) 935be023006SChuck Lever __field(unsigned int, nf_ref) 936be023006SChuck Lever __field(u32, xid) 937be023006SChuck Lever ), 938be023006SChuck Lever 939be023006SChuck Lever TP_fast_assign( 940be023006SChuck Lever __entry->nf_inode = nf->nf_inode; 941be023006SChuck Lever __entry->nf_file = nf->nf_file; 942be023006SChuck Lever __entry->may_flags = may_flags; 943be023006SChuck Lever __entry->nf_flags = nf->nf_flags; 944be023006SChuck Lever __entry->nf_may = nf->nf_may; 945be023006SChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 946be023006SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 947be023006SChuck Lever ), 948be023006SChuck Lever 949be023006SChuck Lever TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 950be023006SChuck Lever __entry->xid, __entry->nf_inode, 951be023006SChuck Lever show_nfsd_may_flags(__entry->may_flags), 952be023006SChuck Lever __entry->nf_ref, show_nf_flags(__entry->nf_flags), 953be023006SChuck Lever show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 954be023006SChuck Lever ) 95565294c1fSJeff Layton ); 95665294c1fSJeff Layton 957ce502f81SChuck Lever TRACE_EVENT(nfsd_file_insert_err, 958ce502f81SChuck Lever TP_PROTO( 959ce502f81SChuck Lever const struct svc_rqst *rqstp, 960ce502f81SChuck Lever const struct inode *inode, 961ce502f81SChuck Lever unsigned int may_flags, 962ce502f81SChuck Lever long error 963ce502f81SChuck Lever ), 964ce502f81SChuck Lever TP_ARGS(rqstp, inode, may_flags, error), 965ce502f81SChuck Lever TP_STRUCT__entry( 966ce502f81SChuck Lever __field(u32, xid) 967ce502f81SChuck Lever __field(const void *, inode) 968ce502f81SChuck Lever __field(unsigned long, may_flags) 969ce502f81SChuck Lever __field(long, error) 970ce502f81SChuck Lever ), 971ce502f81SChuck Lever TP_fast_assign( 972ce502f81SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 973ce502f81SChuck Lever __entry->inode = inode; 974ce502f81SChuck Lever __entry->may_flags = may_flags; 975ce502f81SChuck Lever __entry->error = error; 976ce502f81SChuck Lever ), 977ce502f81SChuck Lever TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld", 978ce502f81SChuck Lever __entry->xid, __entry->inode, 979ce502f81SChuck Lever show_nfsd_may_flags(__entry->may_flags), 980ce502f81SChuck Lever __entry->error 981ce502f81SChuck Lever ) 982ce502f81SChuck Lever ); 983ce502f81SChuck Lever 984ce502f81SChuck Lever TRACE_EVENT(nfsd_file_cons_err, 985ce502f81SChuck Lever TP_PROTO( 986ce502f81SChuck Lever const struct svc_rqst *rqstp, 987ce502f81SChuck Lever const struct inode *inode, 988ce502f81SChuck Lever unsigned int may_flags, 989ce502f81SChuck Lever const struct nfsd_file *nf 990ce502f81SChuck Lever ), 991ce502f81SChuck Lever TP_ARGS(rqstp, inode, may_flags, nf), 992ce502f81SChuck Lever TP_STRUCT__entry( 993ce502f81SChuck Lever __field(u32, xid) 994ce502f81SChuck Lever __field(const void *, inode) 995ce502f81SChuck Lever __field(unsigned long, may_flags) 996ce502f81SChuck Lever __field(unsigned int, nf_ref) 997ce502f81SChuck Lever __field(unsigned long, nf_flags) 998ce502f81SChuck Lever __field(unsigned long, nf_may) 999ce502f81SChuck Lever __field(const void *, nf_file) 1000ce502f81SChuck Lever ), 1001ce502f81SChuck Lever TP_fast_assign( 1002ce502f81SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 1003ce502f81SChuck Lever __entry->inode = inode; 1004ce502f81SChuck Lever __entry->may_flags = may_flags; 1005ce502f81SChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 1006ce502f81SChuck Lever __entry->nf_flags = nf->nf_flags; 1007ce502f81SChuck Lever __entry->nf_may = nf->nf_may; 1008ce502f81SChuck Lever __entry->nf_file = nf->nf_file; 1009ce502f81SChuck Lever ), 1010ce502f81SChuck Lever TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1011ce502f81SChuck Lever __entry->xid, __entry->inode, 1012ce502f81SChuck Lever show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref, 1013ce502f81SChuck Lever show_nf_flags(__entry->nf_flags), 1014ce502f81SChuck Lever show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1015ce502f81SChuck Lever ) 1016ce502f81SChuck Lever ); 1017ce502f81SChuck Lever 10180122e882SChuck Lever TRACE_EVENT(nfsd_file_open, 10190122e882SChuck Lever TP_PROTO(struct nfsd_file *nf, __be32 status), 10200122e882SChuck Lever TP_ARGS(nf, status), 10210122e882SChuck Lever TP_STRUCT__entry( 10220122e882SChuck Lever __field(void *, nf_inode) /* cannot be dereferenced */ 10230122e882SChuck Lever __field(int, nf_ref) 10240122e882SChuck Lever __field(unsigned long, nf_flags) 10250122e882SChuck Lever __field(unsigned long, nf_may) 10260122e882SChuck Lever __field(void *, nf_file) /* cannot be dereferenced */ 10270122e882SChuck Lever ), 10280122e882SChuck Lever TP_fast_assign( 10290122e882SChuck Lever __entry->nf_inode = nf->nf_inode; 10300122e882SChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 10310122e882SChuck Lever __entry->nf_flags = nf->nf_flags; 10320122e882SChuck Lever __entry->nf_may = nf->nf_may; 10330122e882SChuck Lever __entry->nf_file = nf->nf_file; 10340122e882SChuck Lever ), 103554f7df70SChuck Lever TP_printk("inode=%p ref=%d flags=%s may=%s file=%p", 10360122e882SChuck Lever __entry->nf_inode, 10370122e882SChuck Lever __entry->nf_ref, 10380122e882SChuck Lever show_nf_flags(__entry->nf_flags), 10390122e882SChuck Lever show_nfsd_may_flags(__entry->nf_may), 10400122e882SChuck Lever __entry->nf_file) 10410122e882SChuck Lever ) 10420122e882SChuck Lever 104365294c1fSJeff Layton DECLARE_EVENT_CLASS(nfsd_file_search_class, 104454f7df70SChuck Lever TP_PROTO( 1045a8455110SChuck Lever const struct inode *inode, 1046a8455110SChuck Lever unsigned int count 1047a8455110SChuck Lever ), 1048a8455110SChuck Lever TP_ARGS(inode, count), 1049a8455110SChuck Lever TP_STRUCT__entry( 1050a8455110SChuck Lever __field(const struct inode *, inode) 1051a8455110SChuck Lever __field(unsigned int, count) 1052a8455110SChuck Lever ), 1053a8455110SChuck Lever TP_fast_assign( 1054a8455110SChuck Lever __entry->inode = inode; 1055a8455110SChuck Lever __entry->count = count; 1056a8455110SChuck Lever ), 1057a8455110SChuck Lever TP_printk("inode=%p count=%u", 1058a8455110SChuck Lever __entry->inode, __entry->count) 1059a8455110SChuck Lever ); 1060a8455110SChuck Lever 1061a8455110SChuck Lever #define DEFINE_NFSD_FILE_SEARCH_EVENT(name) \ 1062a8455110SChuck Lever DEFINE_EVENT(nfsd_file_search_class, name, \ 1063a8455110SChuck Lever TP_PROTO( \ 1064a8455110SChuck Lever const struct inode *inode, \ 1065a8455110SChuck Lever unsigned int count \ 1066a8455110SChuck Lever ), \ 1067a8455110SChuck Lever TP_ARGS(inode, count)) 1068a8455110SChuck Lever 1069a8455110SChuck Lever DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode_sync); 1070a8455110SChuck Lever DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode); 1071a8455110SChuck Lever 1072a8455110SChuck Lever TRACE_EVENT(nfsd_file_is_cached, 1073a8455110SChuck Lever TP_PROTO( 1074a8455110SChuck Lever const struct inode *inode, 107554f7df70SChuck Lever int found 107654f7df70SChuck Lever ), 107754f7df70SChuck Lever TP_ARGS(inode, found), 107865294c1fSJeff Layton TP_STRUCT__entry( 1079a8455110SChuck Lever __field(const struct inode *, inode) 108065294c1fSJeff Layton __field(int, found) 108165294c1fSJeff Layton ), 108265294c1fSJeff Layton TP_fast_assign( 108365294c1fSJeff Layton __entry->inode = inode; 108465294c1fSJeff Layton __entry->found = found; 108565294c1fSJeff Layton ), 1086a8455110SChuck Lever TP_printk("inode=%p is %scached", 1087a8455110SChuck Lever __entry->inode, 1088a8455110SChuck Lever __entry->found ? "" : "not " 1089a8455110SChuck Lever ) 109065294c1fSJeff Layton ); 109165294c1fSJeff Layton 109265294c1fSJeff Layton TRACE_EVENT(nfsd_file_fsnotify_handle_event, 109365294c1fSJeff Layton TP_PROTO(struct inode *inode, u32 mask), 109465294c1fSJeff Layton TP_ARGS(inode, mask), 109565294c1fSJeff Layton TP_STRUCT__entry( 109665294c1fSJeff Layton __field(struct inode *, inode) 109765294c1fSJeff Layton __field(unsigned int, nlink) 109865294c1fSJeff Layton __field(umode_t, mode) 109965294c1fSJeff Layton __field(u32, mask) 110065294c1fSJeff Layton ), 110165294c1fSJeff Layton TP_fast_assign( 110265294c1fSJeff Layton __entry->inode = inode; 110365294c1fSJeff Layton __entry->nlink = inode->i_nlink; 110465294c1fSJeff Layton __entry->mode = inode->i_mode; 110565294c1fSJeff Layton __entry->mask = mask; 110665294c1fSJeff Layton ), 11073a90e1dfSChuck Lever TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 110865294c1fSJeff Layton __entry->nlink, __entry->mode, __entry->mask) 110965294c1fSJeff Layton ); 111065294c1fSJeff Layton 1111c46203acSChuck Lever DECLARE_EVENT_CLASS(nfsd_file_gc_class, 1112c46203acSChuck Lever TP_PROTO( 1113c46203acSChuck Lever const struct nfsd_file *nf 1114c46203acSChuck Lever ), 1115c46203acSChuck Lever TP_ARGS(nf), 1116c46203acSChuck Lever TP_STRUCT__entry( 1117c46203acSChuck Lever __field(void *, nf_inode) 1118c46203acSChuck Lever __field(void *, nf_file) 1119c46203acSChuck Lever __field(int, nf_ref) 1120c46203acSChuck Lever __field(unsigned long, nf_flags) 1121c46203acSChuck Lever ), 1122c46203acSChuck Lever TP_fast_assign( 1123c46203acSChuck Lever __entry->nf_inode = nf->nf_inode; 1124c46203acSChuck Lever __entry->nf_file = nf->nf_file; 1125c46203acSChuck Lever __entry->nf_ref = refcount_read(&nf->nf_ref); 1126c46203acSChuck Lever __entry->nf_flags = nf->nf_flags; 1127c46203acSChuck Lever ), 1128c46203acSChuck Lever TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p", 1129c46203acSChuck Lever __entry->nf_inode, __entry->nf_ref, 1130c46203acSChuck Lever show_nf_flags(__entry->nf_flags), 1131c46203acSChuck Lever __entry->nf_file 1132c46203acSChuck Lever ) 1133c46203acSChuck Lever ); 1134c46203acSChuck Lever 1135c46203acSChuck Lever #define DEFINE_NFSD_FILE_GC_EVENT(name) \ 1136c46203acSChuck Lever DEFINE_EVENT(nfsd_file_gc_class, name, \ 1137c46203acSChuck Lever TP_PROTO( \ 1138c46203acSChuck Lever const struct nfsd_file *nf \ 1139c46203acSChuck Lever ), \ 1140c46203acSChuck Lever TP_ARGS(nf)) 1141c46203acSChuck Lever 1142c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 11434a0e73e6SChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed); 1144c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 11454a0e73e6SChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed); 1146c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1147c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1148c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1149c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_hashed); 1150c46203acSChuck Lever DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1151c46203acSChuck Lever 115294660cc1SChuck Lever DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class, 115394660cc1SChuck Lever TP_PROTO( 115494660cc1SChuck Lever unsigned long removed, 115594660cc1SChuck Lever unsigned long remaining 115694660cc1SChuck Lever ), 115794660cc1SChuck Lever TP_ARGS(removed, remaining), 115894660cc1SChuck Lever TP_STRUCT__entry( 115994660cc1SChuck Lever __field(unsigned long, removed) 116094660cc1SChuck Lever __field(unsigned long, remaining) 116194660cc1SChuck Lever ), 116294660cc1SChuck Lever TP_fast_assign( 116394660cc1SChuck Lever __entry->removed = removed; 116494660cc1SChuck Lever __entry->remaining = remaining; 116594660cc1SChuck Lever ), 116694660cc1SChuck Lever TP_printk("%lu entries removed, %lu remaining", 116794660cc1SChuck Lever __entry->removed, __entry->remaining) 116894660cc1SChuck Lever ); 116994660cc1SChuck Lever 117094660cc1SChuck Lever #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \ 117194660cc1SChuck Lever DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 117294660cc1SChuck Lever TP_PROTO( \ 117394660cc1SChuck Lever unsigned long removed, \ 117494660cc1SChuck Lever unsigned long remaining \ 117594660cc1SChuck Lever ), \ 117694660cc1SChuck Lever TP_ARGS(removed, remaining)) 117794660cc1SChuck Lever 117894660cc1SChuck Lever DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 117994660cc1SChuck Lever DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 118094660cc1SChuck Lever 11810b175b18SChuck Lever #include "cache.h" 11820b175b18SChuck Lever 11830b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_DROPIT); 11840b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_REPLY); 11850b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_DOIT); 11860b175b18SChuck Lever 11870b175b18SChuck Lever #define show_drc_retval(x) \ 11880b175b18SChuck Lever __print_symbolic(x, \ 11890b175b18SChuck Lever { RC_DROPIT, "DROPIT" }, \ 11900b175b18SChuck Lever { RC_REPLY, "REPLY" }, \ 11910b175b18SChuck Lever { RC_DOIT, "DOIT" }) 11920b175b18SChuck Lever 11930b175b18SChuck Lever TRACE_EVENT(nfsd_drc_found, 11940b175b18SChuck Lever TP_PROTO( 11950b175b18SChuck Lever const struct nfsd_net *nn, 11960b175b18SChuck Lever const struct svc_rqst *rqstp, 11970b175b18SChuck Lever int result 11980b175b18SChuck Lever ), 11990b175b18SChuck Lever TP_ARGS(nn, rqstp, result), 12000b175b18SChuck Lever TP_STRUCT__entry( 12010b175b18SChuck Lever __field(unsigned long long, boot_time) 12020b175b18SChuck Lever __field(unsigned long, result) 12030b175b18SChuck Lever __field(u32, xid) 12040b175b18SChuck Lever ), 12050b175b18SChuck Lever TP_fast_assign( 12060b175b18SChuck Lever __entry->boot_time = nn->boot_time; 12070b175b18SChuck Lever __entry->result = result; 12080b175b18SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 12090b175b18SChuck Lever ), 12100b175b18SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x result=%s", 12110b175b18SChuck Lever __entry->boot_time, __entry->xid, 12120b175b18SChuck Lever show_drc_retval(__entry->result)) 12130b175b18SChuck Lever 12140b175b18SChuck Lever ); 12150b175b18SChuck Lever 12160b175b18SChuck Lever TRACE_EVENT(nfsd_drc_mismatch, 12170b175b18SChuck Lever TP_PROTO( 12180b175b18SChuck Lever const struct nfsd_net *nn, 12190b175b18SChuck Lever const struct svc_cacherep *key, 12200b175b18SChuck Lever const struct svc_cacherep *rp 12210b175b18SChuck Lever ), 12220b175b18SChuck Lever TP_ARGS(nn, key, rp), 12230b175b18SChuck Lever TP_STRUCT__entry( 12240b175b18SChuck Lever __field(unsigned long long, boot_time) 12250b175b18SChuck Lever __field(u32, xid) 12260b175b18SChuck Lever __field(u32, cached) 12270b175b18SChuck Lever __field(u32, ingress) 12280b175b18SChuck Lever ), 12290b175b18SChuck Lever TP_fast_assign( 12300b175b18SChuck Lever __entry->boot_time = nn->boot_time; 12310b175b18SChuck Lever __entry->xid = be32_to_cpu(key->c_key.k_xid); 12320b175b18SChuck Lever __entry->cached = (__force u32)key->c_key.k_csum; 12330b175b18SChuck Lever __entry->ingress = (__force u32)rp->c_key.k_csum; 12340b175b18SChuck Lever ), 12350b175b18SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 12360b175b18SChuck Lever __entry->boot_time, __entry->xid, __entry->cached, 12370b175b18SChuck Lever __entry->ingress) 12380b175b18SChuck Lever ); 12390b175b18SChuck Lever 12401eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_args, 12411eace0d1SChuck Lever TP_PROTO( 12421eace0d1SChuck Lever const struct nfs4_client *clp, 12431eace0d1SChuck Lever const struct nfs4_cb_conn *conn 12441eace0d1SChuck Lever ), 12451eace0d1SChuck Lever TP_ARGS(clp, conn), 12461eace0d1SChuck Lever TP_STRUCT__entry( 12471eace0d1SChuck Lever __field(u32, cl_boot) 12481eace0d1SChuck Lever __field(u32, cl_id) 12491eace0d1SChuck Lever __field(u32, prog) 12501eace0d1SChuck Lever __field(u32, ident) 12519db0e15fSChuck Lever __sockaddr(addr, conn->cb_addrlen) 12521eace0d1SChuck Lever ), 12531eace0d1SChuck Lever TP_fast_assign( 12541eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 12551eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 12561eace0d1SChuck Lever __entry->prog = conn->cb_prog; 12571eace0d1SChuck Lever __entry->ident = conn->cb_ident; 12589db0e15fSChuck Lever __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 12591eace0d1SChuck Lever ), 1260d6cbe98fSChuck Lever TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 12619db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1262d6cbe98fSChuck Lever __entry->prog, __entry->ident) 12631eace0d1SChuck Lever ); 12641eace0d1SChuck Lever 12651eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_nodelegs, 12661eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), 12671eace0d1SChuck Lever TP_ARGS(clp), 12681eace0d1SChuck Lever TP_STRUCT__entry( 12691eace0d1SChuck Lever __field(u32, cl_boot) 12701eace0d1SChuck Lever __field(u32, cl_id) 12711eace0d1SChuck Lever ), 12721eace0d1SChuck Lever TP_fast_assign( 12731eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 12741eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 12751eace0d1SChuck Lever ), 12761eace0d1SChuck Lever TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 12771eace0d1SChuck Lever ) 12781eace0d1SChuck Lever 12791eace0d1SChuck Lever #define show_cb_state(val) \ 12801eace0d1SChuck Lever __print_symbolic(val, \ 12811eace0d1SChuck Lever { NFSD4_CB_UP, "UP" }, \ 12821eace0d1SChuck Lever { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 12831eace0d1SChuck Lever { NFSD4_CB_DOWN, "DOWN" }, \ 12841eace0d1SChuck Lever { NFSD4_CB_FAULT, "FAULT"}) 12851eace0d1SChuck Lever 12861eace0d1SChuck Lever DECLARE_EVENT_CLASS(nfsd_cb_class, 12871eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), 12881eace0d1SChuck Lever TP_ARGS(clp), 12891eace0d1SChuck Lever TP_STRUCT__entry( 12901eace0d1SChuck Lever __field(unsigned long, state) 12911eace0d1SChuck Lever __field(u32, cl_boot) 12921eace0d1SChuck Lever __field(u32, cl_id) 12939db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 12941eace0d1SChuck Lever ), 12951eace0d1SChuck Lever TP_fast_assign( 12961eace0d1SChuck Lever __entry->state = clp->cl_cb_state; 12971eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 12981eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 12999db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 13009db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 13011eace0d1SChuck Lever ), 13021eace0d1SChuck Lever TP_printk("addr=%pISpc client %08x:%08x state=%s", 13039db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 13041eace0d1SChuck Lever show_cb_state(__entry->state)) 13051eace0d1SChuck Lever ); 13061eace0d1SChuck Lever 13071eace0d1SChuck Lever #define DEFINE_NFSD_CB_EVENT(name) \ 13081eace0d1SChuck Lever DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 13091eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), \ 13101eace0d1SChuck Lever TP_ARGS(clp)) 13111eace0d1SChuck Lever 13121eace0d1SChuck Lever DEFINE_NFSD_CB_EVENT(state); 13134ade892aSChuck Lever DEFINE_NFSD_CB_EVENT(probe); 1314806d65b6SChuck Lever DEFINE_NFSD_CB_EVENT(lost); 13151eace0d1SChuck Lever DEFINE_NFSD_CB_EVENT(shutdown); 13161eace0d1SChuck Lever 131787b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 131887b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 131987b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 132087b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 132187b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 132287b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 132387b2394dSChuck Lever 132487b2394dSChuck Lever #define show_nfsd_authflavor(val) \ 132587b2394dSChuck Lever __print_symbolic(val, \ 132687b2394dSChuck Lever { RPC_AUTH_NULL, "none" }, \ 132787b2394dSChuck Lever { RPC_AUTH_UNIX, "sys" }, \ 132887b2394dSChuck Lever { RPC_AUTH_GSS, "gss" }, \ 132987b2394dSChuck Lever { RPC_AUTH_GSS_KRB5, "krb5" }, \ 133087b2394dSChuck Lever { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 133187b2394dSChuck Lever { RPC_AUTH_GSS_KRB5P, "krb5p" }) 133287b2394dSChuck Lever 13333c92fba5SChuck Lever TRACE_EVENT(nfsd_cb_setup, 13343c92fba5SChuck Lever TP_PROTO(const struct nfs4_client *clp, 13353c92fba5SChuck Lever const char *netid, 13363c92fba5SChuck Lever rpc_authflavor_t authflavor 13373c92fba5SChuck Lever ), 13383c92fba5SChuck Lever TP_ARGS(clp, netid, authflavor), 13393c92fba5SChuck Lever TP_STRUCT__entry( 13403c92fba5SChuck Lever __field(u32, cl_boot) 13413c92fba5SChuck Lever __field(u32, cl_id) 13423c92fba5SChuck Lever __field(unsigned long, authflavor) 13439db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 13443c92fba5SChuck Lever __array(unsigned char, netid, 8) 13453c92fba5SChuck Lever ), 13463c92fba5SChuck Lever TP_fast_assign( 13473c92fba5SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 13483c92fba5SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 13493c92fba5SChuck Lever strlcpy(__entry->netid, netid, sizeof(__entry->netid)); 13503c92fba5SChuck Lever __entry->authflavor = authflavor; 13519db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 13529db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 13533c92fba5SChuck Lever ), 13543c92fba5SChuck Lever TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 13559db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 13563c92fba5SChuck Lever __entry->netid, show_nfsd_authflavor(__entry->authflavor)) 13573c92fba5SChuck Lever ); 13583c92fba5SChuck Lever 13591eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_setup_err, 13601eace0d1SChuck Lever TP_PROTO( 13611eace0d1SChuck Lever const struct nfs4_client *clp, 13621eace0d1SChuck Lever long error 13631eace0d1SChuck Lever ), 13641eace0d1SChuck Lever TP_ARGS(clp, error), 13651eace0d1SChuck Lever TP_STRUCT__entry( 13661eace0d1SChuck Lever __field(long, error) 13671eace0d1SChuck Lever __field(u32, cl_boot) 13681eace0d1SChuck Lever __field(u32, cl_id) 13699db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 13701eace0d1SChuck Lever ), 13711eace0d1SChuck Lever TP_fast_assign( 13721eace0d1SChuck Lever __entry->error = error; 13731eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 13741eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 13759db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 13769db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 13771eace0d1SChuck Lever ), 13781eace0d1SChuck Lever TP_printk("addr=%pISpc client %08x:%08x error=%ld", 13799db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 13809db0e15fSChuck Lever __entry->error) 13811eace0d1SChuck Lever ); 13821eace0d1SChuck Lever 13839db0e15fSChuck Lever TRACE_EVENT_CONDITION(nfsd_cb_recall, 138417d76ddfSChuck Lever TP_PROTO( 138517d76ddfSChuck Lever const struct nfs4_stid *stid 138617d76ddfSChuck Lever ), 138717d76ddfSChuck Lever TP_ARGS(stid), 13889db0e15fSChuck Lever TP_CONDITION(stid->sc_client), 138917d76ddfSChuck Lever TP_STRUCT__entry( 139017d76ddfSChuck Lever __field(u32, cl_boot) 139117d76ddfSChuck Lever __field(u32, cl_id) 139217d76ddfSChuck Lever __field(u32, si_id) 139317d76ddfSChuck Lever __field(u32, si_generation) 13949db0e15fSChuck Lever __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 139517d76ddfSChuck Lever ), 139617d76ddfSChuck Lever TP_fast_assign( 139717d76ddfSChuck Lever const stateid_t *stp = &stid->sc_stateid; 139817d76ddfSChuck Lever const struct nfs4_client *clp = stid->sc_client; 139917d76ddfSChuck Lever 140017d76ddfSChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 140117d76ddfSChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 140217d76ddfSChuck Lever __entry->si_id = stp->si_opaque.so_id; 140317d76ddfSChuck Lever __entry->si_generation = stp->si_generation; 14049db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 14059db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 140617d76ddfSChuck Lever ), 140717d76ddfSChuck Lever TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 14089db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 140917d76ddfSChuck Lever __entry->si_id, __entry->si_generation) 141017d76ddfSChuck Lever ); 141117d76ddfSChuck Lever 14122cde7f81SChuck Lever TRACE_EVENT(nfsd_cb_notify_lock, 14132cde7f81SChuck Lever TP_PROTO( 14142cde7f81SChuck Lever const struct nfs4_lockowner *lo, 14152cde7f81SChuck Lever const struct nfsd4_blocked_lock *nbl 14162cde7f81SChuck Lever ), 14172cde7f81SChuck Lever TP_ARGS(lo, nbl), 14182cde7f81SChuck Lever TP_STRUCT__entry( 14192cde7f81SChuck Lever __field(u32, cl_boot) 14202cde7f81SChuck Lever __field(u32, cl_id) 14212cde7f81SChuck Lever __field(u32, fh_hash) 14229db0e15fSChuck Lever __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 14232cde7f81SChuck Lever ), 14242cde7f81SChuck Lever TP_fast_assign( 14252cde7f81SChuck Lever const struct nfs4_client *clp = lo->lo_owner.so_client; 14262cde7f81SChuck Lever 14272cde7f81SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 14282cde7f81SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 14292cde7f81SChuck Lever __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 14309db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 14319db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 14322cde7f81SChuck Lever ), 14332cde7f81SChuck Lever TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 14349db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 14352cde7f81SChuck Lever __entry->fh_hash) 14362cde7f81SChuck Lever ); 14372cde7f81SChuck Lever 143887512386SChuck Lever TRACE_EVENT(nfsd_cb_offload, 143987512386SChuck Lever TP_PROTO( 144087512386SChuck Lever const struct nfs4_client *clp, 144187512386SChuck Lever const stateid_t *stp, 144287512386SChuck Lever const struct knfsd_fh *fh, 144387512386SChuck Lever u64 count, 144487512386SChuck Lever __be32 status 144587512386SChuck Lever ), 144687512386SChuck Lever TP_ARGS(clp, stp, fh, count, status), 144787512386SChuck Lever TP_STRUCT__entry( 144887512386SChuck Lever __field(u32, cl_boot) 144987512386SChuck Lever __field(u32, cl_id) 145087512386SChuck Lever __field(u32, si_id) 145187512386SChuck Lever __field(u32, si_generation) 145287512386SChuck Lever __field(u32, fh_hash) 145387512386SChuck Lever __field(int, status) 145487512386SChuck Lever __field(u64, count) 14559db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 145687512386SChuck Lever ), 145787512386SChuck Lever TP_fast_assign( 145887512386SChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 145987512386SChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 146087512386SChuck Lever __entry->si_id = stp->si_opaque.so_id; 146187512386SChuck Lever __entry->si_generation = stp->si_generation; 146287512386SChuck Lever __entry->fh_hash = knfsd_fh_hash(fh); 146387512386SChuck Lever __entry->status = be32_to_cpu(status); 146487512386SChuck Lever __entry->count = count; 14659db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 14669db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 146787512386SChuck Lever ), 146887512386SChuck Lever TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 14699db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 147087512386SChuck Lever __entry->si_id, __entry->si_generation, 147187512386SChuck Lever __entry->fh_hash, __entry->count, __entry->status) 147287512386SChuck Lever ); 147387512386SChuck Lever 14741035d654SChuck Lever DECLARE_EVENT_CLASS(nfsd_cb_done_class, 14751035d654SChuck Lever TP_PROTO( 14761035d654SChuck Lever const stateid_t *stp, 14771035d654SChuck Lever const struct rpc_task *task 14781035d654SChuck Lever ), 14791035d654SChuck Lever TP_ARGS(stp, task), 14801035d654SChuck Lever TP_STRUCT__entry( 14811035d654SChuck Lever __field(u32, cl_boot) 14821035d654SChuck Lever __field(u32, cl_id) 14831035d654SChuck Lever __field(u32, si_id) 14841035d654SChuck Lever __field(u32, si_generation) 14851035d654SChuck Lever __field(int, status) 14861035d654SChuck Lever ), 14871035d654SChuck Lever TP_fast_assign( 14881035d654SChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 14891035d654SChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 14901035d654SChuck Lever __entry->si_id = stp->si_opaque.so_id; 14911035d654SChuck Lever __entry->si_generation = stp->si_generation; 14921035d654SChuck Lever __entry->status = task->tk_status; 14931035d654SChuck Lever ), 14941035d654SChuck Lever TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 14951035d654SChuck Lever __entry->cl_boot, __entry->cl_id, __entry->si_id, 14961035d654SChuck Lever __entry->si_generation, __entry->status 14971035d654SChuck Lever ) 14981035d654SChuck Lever ); 14991035d654SChuck Lever 15001035d654SChuck Lever #define DEFINE_NFSD_CB_DONE_EVENT(name) \ 15011035d654SChuck Lever DEFINE_EVENT(nfsd_cb_done_class, name, \ 15021035d654SChuck Lever TP_PROTO( \ 15031035d654SChuck Lever const stateid_t *stp, \ 15041035d654SChuck Lever const struct rpc_task *task \ 15051035d654SChuck Lever ), \ 15061035d654SChuck Lever TP_ARGS(stp, task)) 15071035d654SChuck Lever 15081035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 15091035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 15101035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 15111035d654SChuck Lever DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 15121035d654SChuck Lever 151331ef83dcSChristoph Hellwig #endif /* _NFSD_TRACE_H */ 151431ef83dcSChristoph Hellwig 151531ef83dcSChristoph Hellwig #undef TRACE_INCLUDE_PATH 151631ef83dcSChristoph Hellwig #define TRACE_INCLUDE_PATH . 151731ef83dcSChristoph Hellwig #define TRACE_INCLUDE_FILE trace 151831ef83dcSChristoph Hellwig #include <trace/define_trace.h> 1519