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 160dfdad1cSChuck Lever #define NFSD_TRACE_PROC_ARG_FIELDS \ 170dfdad1cSChuck Lever __field(unsigned int, netns_ino) \ 180dfdad1cSChuck Lever __field(u32, xid) \ 190dfdad1cSChuck Lever __array(unsigned char, server, sizeof(struct sockaddr_in6)) \ 200dfdad1cSChuck Lever __array(unsigned char, client, sizeof(struct sockaddr_in6)) 210dfdad1cSChuck Lever 220dfdad1cSChuck Lever #define NFSD_TRACE_PROC_ARG_ASSIGNMENTS \ 230dfdad1cSChuck Lever do { \ 240dfdad1cSChuck Lever __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \ 250dfdad1cSChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); \ 260dfdad1cSChuck Lever memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \ 270dfdad1cSChuck Lever rqstp->rq_xprt->xpt_locallen); \ 280dfdad1cSChuck Lever memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \ 290dfdad1cSChuck Lever rqstp->rq_xprt->xpt_remotelen); \ 300dfdad1cSChuck Lever } while (0); 310dfdad1cSChuck Lever 3208281341SChuck Lever #define NFSD_TRACE_PROC_RES_FIELDS \ 3308281341SChuck Lever __field(unsigned int, netns_ino) \ 3408281341SChuck Lever __field(u32, xid) \ 3508281341SChuck Lever __field(unsigned long, status) \ 3608281341SChuck Lever __array(unsigned char, server, sizeof(struct sockaddr_in6)) \ 3708281341SChuck Lever __array(unsigned char, client, sizeof(struct sockaddr_in6)) 3808281341SChuck Lever 3908281341SChuck Lever #define NFSD_TRACE_PROC_RES_ASSIGNMENTS(error) \ 4008281341SChuck Lever do { \ 4108281341SChuck Lever __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \ 4208281341SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); \ 4308281341SChuck Lever __entry->status = be32_to_cpu(error); \ 4408281341SChuck Lever memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \ 4508281341SChuck Lever rqstp->rq_xprt->xpt_locallen); \ 4608281341SChuck Lever memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \ 4708281341SChuck Lever rqstp->rq_xprt->xpt_remotelen); \ 4808281341SChuck Lever } while (0); 4908281341SChuck Lever 5070e94d75SChuck Lever DECLARE_EVENT_CLASS(nfsd_xdr_err_class, 510dfdad1cSChuck Lever TP_PROTO( 520dfdad1cSChuck Lever const struct svc_rqst *rqstp 530dfdad1cSChuck Lever ), 540dfdad1cSChuck Lever TP_ARGS(rqstp), 550dfdad1cSChuck Lever TP_STRUCT__entry( 560dfdad1cSChuck Lever NFSD_TRACE_PROC_ARG_FIELDS 570dfdad1cSChuck Lever 580dfdad1cSChuck Lever __field(u32, vers) 590dfdad1cSChuck Lever __field(u32, proc) 600dfdad1cSChuck Lever ), 610dfdad1cSChuck Lever TP_fast_assign( 620dfdad1cSChuck Lever NFSD_TRACE_PROC_ARG_ASSIGNMENTS 630dfdad1cSChuck Lever 640dfdad1cSChuck Lever __entry->vers = rqstp->rq_vers; 650dfdad1cSChuck Lever __entry->proc = rqstp->rq_proc; 660dfdad1cSChuck Lever ), 670dfdad1cSChuck Lever TP_printk("xid=0x%08x vers=%u proc=%u", 680dfdad1cSChuck Lever __entry->xid, __entry->vers, __entry->proc 690dfdad1cSChuck Lever ) 700dfdad1cSChuck Lever ); 710dfdad1cSChuck Lever 7270e94d75SChuck Lever #define DEFINE_NFSD_XDR_ERR_EVENT(name) \ 7370e94d75SChuck Lever DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \ 7470e94d75SChuck Lever TP_PROTO(const struct svc_rqst *rqstp), \ 7570e94d75SChuck Lever TP_ARGS(rqstp)) 760dfdad1cSChuck Lever 7770e94d75SChuck Lever DEFINE_NFSD_XDR_ERR_EVENT(garbage_args); 7870e94d75SChuck Lever DEFINE_NFSD_XDR_ERR_EVENT(cant_encode); 790dfdad1cSChuck Lever 80b76278aeSChuck Lever #define show_nfsd_may_flags(x) \ 81b76278aeSChuck Lever __print_flags(x, "|", \ 82b76278aeSChuck Lever { NFSD_MAY_EXEC, "EXEC" }, \ 83b76278aeSChuck Lever { NFSD_MAY_WRITE, "WRITE" }, \ 84b76278aeSChuck Lever { NFSD_MAY_READ, "READ" }, \ 85b76278aeSChuck Lever { NFSD_MAY_SATTR, "SATTR" }, \ 86b76278aeSChuck Lever { NFSD_MAY_TRUNC, "TRUNC" }, \ 87b76278aeSChuck Lever { NFSD_MAY_LOCK, "LOCK" }, \ 88b76278aeSChuck Lever { NFSD_MAY_OWNER_OVERRIDE, "OWNER_OVERRIDE" }, \ 89b76278aeSChuck Lever { NFSD_MAY_LOCAL_ACCESS, "LOCAL_ACCESS" }, \ 90b76278aeSChuck Lever { NFSD_MAY_BYPASS_GSS_ON_ROOT, "BYPASS_GSS_ON_ROOT" }, \ 91b76278aeSChuck Lever { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \ 92b76278aeSChuck Lever { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \ 93b76278aeSChuck Lever { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \ 94b76278aeSChuck Lever { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" }) 95b76278aeSChuck Lever 96fff4080bSChuck Lever TRACE_EVENT(nfsd_compound, 97fff4080bSChuck Lever TP_PROTO(const struct svc_rqst *rqst, 98fff4080bSChuck Lever u32 args_opcnt), 99fff4080bSChuck Lever TP_ARGS(rqst, args_opcnt), 100fff4080bSChuck Lever TP_STRUCT__entry( 101fff4080bSChuck Lever __field(u32, xid) 102fff4080bSChuck Lever __field(u32, args_opcnt) 103fff4080bSChuck Lever ), 104fff4080bSChuck Lever TP_fast_assign( 105fff4080bSChuck Lever __entry->xid = be32_to_cpu(rqst->rq_xid); 106fff4080bSChuck Lever __entry->args_opcnt = args_opcnt; 107fff4080bSChuck Lever ), 108fff4080bSChuck Lever TP_printk("xid=0x%08x opcnt=%u", 109fff4080bSChuck Lever __entry->xid, __entry->args_opcnt) 110fff4080bSChuck Lever ) 111fff4080bSChuck Lever 112fff4080bSChuck Lever TRACE_EVENT(nfsd_compound_status, 113fff4080bSChuck Lever TP_PROTO(u32 args_opcnt, 114fff4080bSChuck Lever u32 resp_opcnt, 115fff4080bSChuck Lever __be32 status, 116fff4080bSChuck Lever const char *name), 117fff4080bSChuck Lever TP_ARGS(args_opcnt, resp_opcnt, status, name), 118fff4080bSChuck Lever TP_STRUCT__entry( 119fff4080bSChuck Lever __field(u32, args_opcnt) 120fff4080bSChuck Lever __field(u32, resp_opcnt) 121fff4080bSChuck Lever __field(int, status) 122fff4080bSChuck Lever __string(name, name) 123fff4080bSChuck Lever ), 124fff4080bSChuck Lever TP_fast_assign( 125fff4080bSChuck Lever __entry->args_opcnt = args_opcnt; 126fff4080bSChuck Lever __entry->resp_opcnt = resp_opcnt; 127fff4080bSChuck Lever __entry->status = be32_to_cpu(status); 128fff4080bSChuck Lever __assign_str(name, name); 129fff4080bSChuck Lever ), 130fff4080bSChuck Lever TP_printk("op=%u/%u %s status=%d", 131fff4080bSChuck Lever __entry->resp_opcnt, __entry->args_opcnt, 132fff4080bSChuck Lever __get_str(name), __entry->status) 133fff4080bSChuck Lever ) 134fff4080bSChuck Lever 13508281341SChuck Lever TRACE_EVENT(nfsd_compound_decode_err, 13608281341SChuck Lever TP_PROTO( 13708281341SChuck Lever const struct svc_rqst *rqstp, 13808281341SChuck Lever u32 args_opcnt, 13908281341SChuck Lever u32 resp_opcnt, 14008281341SChuck Lever u32 opnum, 14108281341SChuck Lever __be32 status 14208281341SChuck Lever ), 14308281341SChuck Lever TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status), 14408281341SChuck Lever TP_STRUCT__entry( 14508281341SChuck Lever NFSD_TRACE_PROC_RES_FIELDS 14608281341SChuck Lever 14708281341SChuck Lever __field(u32, args_opcnt) 14808281341SChuck Lever __field(u32, resp_opcnt) 14908281341SChuck Lever __field(u32, opnum) 15008281341SChuck Lever ), 15108281341SChuck Lever TP_fast_assign( 15208281341SChuck Lever NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 15308281341SChuck Lever 15408281341SChuck Lever __entry->args_opcnt = args_opcnt; 15508281341SChuck Lever __entry->resp_opcnt = resp_opcnt; 15608281341SChuck Lever __entry->opnum = opnum; 15708281341SChuck Lever ), 15808281341SChuck Lever TP_printk("op=%u/%u opnum=%u status=%lu", 15908281341SChuck Lever __entry->resp_opcnt, __entry->args_opcnt, 16008281341SChuck Lever __entry->opnum, __entry->status) 16108281341SChuck Lever ); 16208281341SChuck Lever 16308281341SChuck Lever TRACE_EVENT(nfsd_compound_encode_err, 16408281341SChuck Lever TP_PROTO( 16508281341SChuck Lever const struct svc_rqst *rqstp, 16608281341SChuck Lever u32 opnum, 16708281341SChuck Lever __be32 status 16808281341SChuck Lever ), 16908281341SChuck Lever TP_ARGS(rqstp, opnum, status), 17008281341SChuck Lever TP_STRUCT__entry( 17108281341SChuck Lever NFSD_TRACE_PROC_RES_FIELDS 17208281341SChuck Lever 17308281341SChuck Lever __field(u32, opnum) 17408281341SChuck Lever ), 17508281341SChuck Lever TP_fast_assign( 17608281341SChuck Lever NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 17708281341SChuck Lever 17808281341SChuck Lever __entry->opnum = opnum; 17908281341SChuck Lever ), 18008281341SChuck Lever TP_printk("opnum=%u status=%lu", 18108281341SChuck Lever __entry->opnum, __entry->status) 18208281341SChuck Lever ); 18308281341SChuck Lever 18408281341SChuck Lever 185f01274a9STrond Myklebust DECLARE_EVENT_CLASS(nfsd_fh_err_class, 186f01274a9STrond Myklebust TP_PROTO(struct svc_rqst *rqstp, 187f01274a9STrond Myklebust struct svc_fh *fhp, 188f01274a9STrond Myklebust int status), 189f01274a9STrond Myklebust TP_ARGS(rqstp, fhp, status), 190f01274a9STrond Myklebust TP_STRUCT__entry( 191f01274a9STrond Myklebust __field(u32, xid) 192f01274a9STrond Myklebust __field(u32, fh_hash) 193f01274a9STrond Myklebust __field(int, status) 194f01274a9STrond Myklebust ), 195f01274a9STrond Myklebust TP_fast_assign( 196f01274a9STrond Myklebust __entry->xid = be32_to_cpu(rqstp->rq_xid); 197f01274a9STrond Myklebust __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 198f01274a9STrond Myklebust __entry->status = status; 199f01274a9STrond Myklebust ), 200f01274a9STrond Myklebust TP_printk("xid=0x%08x fh_hash=0x%08x status=%d", 201f01274a9STrond Myklebust __entry->xid, __entry->fh_hash, 202f01274a9STrond Myklebust __entry->status) 203f01274a9STrond Myklebust ) 204f01274a9STrond Myklebust 205f01274a9STrond Myklebust #define DEFINE_NFSD_FH_ERR_EVENT(name) \ 206f01274a9STrond Myklebust DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \ 207f01274a9STrond Myklebust TP_PROTO(struct svc_rqst *rqstp, \ 208f01274a9STrond Myklebust struct svc_fh *fhp, \ 209f01274a9STrond Myklebust int status), \ 210f01274a9STrond Myklebust TP_ARGS(rqstp, fhp, status)) 211f01274a9STrond Myklebust 212f01274a9STrond Myklebust DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport); 213f01274a9STrond Myklebust DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle); 214f01274a9STrond Myklebust 215cf749f3cSTrond Myklebust TRACE_EVENT(nfsd_exp_find_key, 216cf749f3cSTrond Myklebust TP_PROTO(const struct svc_expkey *key, 217cf749f3cSTrond Myklebust int status), 218cf749f3cSTrond Myklebust TP_ARGS(key, status), 219cf749f3cSTrond Myklebust TP_STRUCT__entry( 220cf749f3cSTrond Myklebust __field(int, fsidtype) 221cf749f3cSTrond Myklebust __array(u32, fsid, 6) 222cf749f3cSTrond Myklebust __string(auth_domain, key->ek_client->name) 223cf749f3cSTrond Myklebust __field(int, status) 224cf749f3cSTrond Myklebust ), 225cf749f3cSTrond Myklebust TP_fast_assign( 226cf749f3cSTrond Myklebust __entry->fsidtype = key->ek_fsidtype; 227cf749f3cSTrond Myklebust memcpy(__entry->fsid, key->ek_fsid, 4*6); 228cf749f3cSTrond Myklebust __assign_str(auth_domain, key->ek_client->name); 229cf749f3cSTrond Myklebust __entry->status = status; 230cf749f3cSTrond Myklebust ), 231cf749f3cSTrond Myklebust TP_printk("fsid=%x::%s domain=%s status=%d", 232cf749f3cSTrond Myklebust __entry->fsidtype, 233cf749f3cSTrond Myklebust __print_array(__entry->fsid, 6, 4), 234cf749f3cSTrond Myklebust __get_str(auth_domain), 235cf749f3cSTrond Myklebust __entry->status 236cf749f3cSTrond Myklebust ) 237cf749f3cSTrond Myklebust ); 238cf749f3cSTrond Myklebust 2396a30e47fSTrond Myklebust TRACE_EVENT(nfsd_expkey_update, 2406a30e47fSTrond Myklebust TP_PROTO(const struct svc_expkey *key, const char *exp_path), 2416a30e47fSTrond Myklebust TP_ARGS(key, exp_path), 2426a30e47fSTrond Myklebust TP_STRUCT__entry( 2436a30e47fSTrond Myklebust __field(int, fsidtype) 2446a30e47fSTrond Myklebust __array(u32, fsid, 6) 2456a30e47fSTrond Myklebust __string(auth_domain, key->ek_client->name) 2466a30e47fSTrond Myklebust __string(path, exp_path) 2476a30e47fSTrond Myklebust __field(bool, cache) 2486a30e47fSTrond Myklebust ), 2496a30e47fSTrond Myklebust TP_fast_assign( 2506a30e47fSTrond Myklebust __entry->fsidtype = key->ek_fsidtype; 2516a30e47fSTrond Myklebust memcpy(__entry->fsid, key->ek_fsid, 4*6); 2526a30e47fSTrond Myklebust __assign_str(auth_domain, key->ek_client->name); 2536a30e47fSTrond Myklebust __assign_str(path, exp_path); 2546a30e47fSTrond Myklebust __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 2556a30e47fSTrond Myklebust ), 2566a30e47fSTrond Myklebust TP_printk("fsid=%x::%s domain=%s path=%s cache=%s", 2576a30e47fSTrond Myklebust __entry->fsidtype, 2586a30e47fSTrond Myklebust __print_array(__entry->fsid, 6, 4), 2596a30e47fSTrond Myklebust __get_str(auth_domain), 2606a30e47fSTrond Myklebust __get_str(path), 2616a30e47fSTrond Myklebust __entry->cache ? "pos" : "neg" 2626a30e47fSTrond Myklebust ) 2636a30e47fSTrond Myklebust ); 2646a30e47fSTrond Myklebust 265cf749f3cSTrond Myklebust TRACE_EVENT(nfsd_exp_get_by_name, 266cf749f3cSTrond Myklebust TP_PROTO(const struct svc_export *key, 267cf749f3cSTrond Myklebust int status), 268cf749f3cSTrond Myklebust TP_ARGS(key, status), 269cf749f3cSTrond Myklebust TP_STRUCT__entry( 270cf749f3cSTrond Myklebust __string(path, key->ex_path.dentry->d_name.name) 271cf749f3cSTrond Myklebust __string(auth_domain, key->ex_client->name) 272cf749f3cSTrond Myklebust __field(int, status) 273cf749f3cSTrond Myklebust ), 274cf749f3cSTrond Myklebust TP_fast_assign( 275cf749f3cSTrond Myklebust __assign_str(path, key->ex_path.dentry->d_name.name); 276cf749f3cSTrond Myklebust __assign_str(auth_domain, key->ex_client->name); 277cf749f3cSTrond Myklebust __entry->status = status; 278cf749f3cSTrond Myklebust ), 279cf749f3cSTrond Myklebust TP_printk("path=%s domain=%s status=%d", 280cf749f3cSTrond Myklebust __get_str(path), 281cf749f3cSTrond Myklebust __get_str(auth_domain), 282cf749f3cSTrond Myklebust __entry->status 283cf749f3cSTrond Myklebust ) 284cf749f3cSTrond Myklebust ); 285cf749f3cSTrond Myklebust 2866a30e47fSTrond Myklebust TRACE_EVENT(nfsd_export_update, 2876a30e47fSTrond Myklebust TP_PROTO(const struct svc_export *key), 2886a30e47fSTrond Myklebust TP_ARGS(key), 2896a30e47fSTrond Myklebust TP_STRUCT__entry( 2906a30e47fSTrond Myklebust __string(path, key->ex_path.dentry->d_name.name) 2916a30e47fSTrond Myklebust __string(auth_domain, key->ex_client->name) 2926a30e47fSTrond Myklebust __field(bool, cache) 2936a30e47fSTrond Myklebust ), 2946a30e47fSTrond Myklebust TP_fast_assign( 2956a30e47fSTrond Myklebust __assign_str(path, key->ex_path.dentry->d_name.name); 2966a30e47fSTrond Myklebust __assign_str(auth_domain, key->ex_client->name); 2976a30e47fSTrond Myklebust __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 2986a30e47fSTrond Myklebust ), 2996a30e47fSTrond Myklebust TP_printk("path=%s domain=%s cache=%s", 3006a30e47fSTrond Myklebust __get_str(path), 3016a30e47fSTrond Myklebust __get_str(auth_domain), 3026a30e47fSTrond Myklebust __entry->cache ? "pos" : "neg" 3036a30e47fSTrond Myklebust ) 3046a30e47fSTrond Myklebust ); 3056a30e47fSTrond Myklebust 3066e8b50d1SJeff Layton DECLARE_EVENT_CLASS(nfsd_io_class, 3076e8b50d1SJeff Layton TP_PROTO(struct svc_rqst *rqstp, 3086e8b50d1SJeff Layton struct svc_fh *fhp, 3096a4d333dSChuck Lever u64 offset, 3106a4d333dSChuck Lever u32 len), 3116e8b50d1SJeff Layton TP_ARGS(rqstp, fhp, offset, len), 3126e8b50d1SJeff Layton TP_STRUCT__entry( 313afa720a0SChuck Lever __field(u32, xid) 314afa720a0SChuck Lever __field(u32, fh_hash) 3156a4d333dSChuck Lever __field(u64, offset) 3166a4d333dSChuck Lever __field(u32, len) 3176e8b50d1SJeff Layton ), 3186e8b50d1SJeff Layton TP_fast_assign( 319afa720a0SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 32079e0b4e2SChuck Lever __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 3216e8b50d1SJeff Layton __entry->offset = offset; 3226e8b50d1SJeff Layton __entry->len = len; 3236e8b50d1SJeff Layton ), 3246a4d333dSChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u", 325afa720a0SChuck Lever __entry->xid, __entry->fh_hash, 3266e8b50d1SJeff Layton __entry->offset, __entry->len) 3276e8b50d1SJeff Layton ) 3286e8b50d1SJeff Layton 3296e8b50d1SJeff Layton #define DEFINE_NFSD_IO_EVENT(name) \ 330f394b62bSChuck Lever DEFINE_EVENT(nfsd_io_class, nfsd_##name, \ 3316e8b50d1SJeff Layton TP_PROTO(struct svc_rqst *rqstp, \ 3326e8b50d1SJeff Layton struct svc_fh *fhp, \ 3336a4d333dSChuck Lever u64 offset, \ 3346a4d333dSChuck Lever u32 len), \ 3356e8b50d1SJeff Layton TP_ARGS(rqstp, fhp, offset, len)) 3366e8b50d1SJeff Layton 3376e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_start); 33887c5942eSChuck Lever DEFINE_NFSD_IO_EVENT(read_splice); 33987c5942eSChuck Lever DEFINE_NFSD_IO_EVENT(read_vector); 3406e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_io_done); 3416e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_done); 3426e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_start); 3436e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_opened); 3446e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_io_done); 3456e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_done); 34631ef83dcSChristoph Hellwig 347d890be15SChuck Lever DECLARE_EVENT_CLASS(nfsd_err_class, 348d890be15SChuck Lever TP_PROTO(struct svc_rqst *rqstp, 349d890be15SChuck Lever struct svc_fh *fhp, 350d890be15SChuck Lever loff_t offset, 351d890be15SChuck Lever int status), 352d890be15SChuck Lever TP_ARGS(rqstp, fhp, offset, status), 353d890be15SChuck Lever TP_STRUCT__entry( 354d890be15SChuck Lever __field(u32, xid) 355d890be15SChuck Lever __field(u32, fh_hash) 356d890be15SChuck Lever __field(loff_t, offset) 357d890be15SChuck Lever __field(int, status) 358d890be15SChuck Lever ), 359d890be15SChuck Lever TP_fast_assign( 360d890be15SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 361d890be15SChuck Lever __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 362d890be15SChuck Lever __entry->offset = offset; 363d890be15SChuck Lever __entry->status = status; 364d890be15SChuck Lever ), 365d890be15SChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d", 366d890be15SChuck Lever __entry->xid, __entry->fh_hash, 367d890be15SChuck Lever __entry->offset, __entry->status) 368d890be15SChuck Lever ) 369d890be15SChuck Lever 370d890be15SChuck Lever #define DEFINE_NFSD_ERR_EVENT(name) \ 371d890be15SChuck Lever DEFINE_EVENT(nfsd_err_class, nfsd_##name, \ 372d890be15SChuck Lever TP_PROTO(struct svc_rqst *rqstp, \ 373d890be15SChuck Lever struct svc_fh *fhp, \ 374d890be15SChuck Lever loff_t offset, \ 375d890be15SChuck Lever int len), \ 376d890be15SChuck Lever TP_ARGS(rqstp, fhp, offset, len)) 377d890be15SChuck Lever 37887c5942eSChuck Lever DEFINE_NFSD_ERR_EVENT(read_err); 379d890be15SChuck Lever DEFINE_NFSD_ERR_EVENT(write_err); 380d890be15SChuck Lever 3816019ce07SChuck Lever TRACE_EVENT(nfsd_dirent, 3826019ce07SChuck Lever TP_PROTO(struct svc_fh *fhp, 3836019ce07SChuck Lever u64 ino, 3846019ce07SChuck Lever const char *name, 3856019ce07SChuck Lever int namlen), 3866019ce07SChuck Lever TP_ARGS(fhp, ino, name, namlen), 3876019ce07SChuck Lever TP_STRUCT__entry( 3886019ce07SChuck Lever __field(u32, fh_hash) 3896019ce07SChuck Lever __field(u64, ino) 390408c0de7SChuck Lever __string_len(name, name, namlen) 3916019ce07SChuck Lever ), 3926019ce07SChuck Lever TP_fast_assign( 3936019ce07SChuck Lever __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0; 3946019ce07SChuck Lever __entry->ino = ino; 395408c0de7SChuck Lever __assign_str_len(name, name, namlen) 3966019ce07SChuck Lever ), 397408c0de7SChuck Lever TP_printk("fh_hash=0x%08x ino=%llu name=%s", 398408c0de7SChuck Lever __entry->fh_hash, __entry->ino, __get_str(name) 399408c0de7SChuck Lever ) 4006019ce07SChuck Lever ) 4016019ce07SChuck Lever 402a2f4c3faSTrond Myklebust DECLARE_EVENT_CLASS(nfsd_copy_err_class, 403a2f4c3faSTrond Myklebust TP_PROTO(struct svc_rqst *rqstp, 404a2f4c3faSTrond Myklebust struct svc_fh *src_fhp, 405a2f4c3faSTrond Myklebust loff_t src_offset, 406a2f4c3faSTrond Myklebust struct svc_fh *dst_fhp, 407a2f4c3faSTrond Myklebust loff_t dst_offset, 408a2f4c3faSTrond Myklebust u64 count, 409a2f4c3faSTrond Myklebust int status), 410a2f4c3faSTrond Myklebust TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status), 411a2f4c3faSTrond Myklebust TP_STRUCT__entry( 412a2f4c3faSTrond Myklebust __field(u32, xid) 413a2f4c3faSTrond Myklebust __field(u32, src_fh_hash) 414a2f4c3faSTrond Myklebust __field(loff_t, src_offset) 415a2f4c3faSTrond Myklebust __field(u32, dst_fh_hash) 416a2f4c3faSTrond Myklebust __field(loff_t, dst_offset) 417a2f4c3faSTrond Myklebust __field(u64, count) 418a2f4c3faSTrond Myklebust __field(int, status) 419a2f4c3faSTrond Myklebust ), 420a2f4c3faSTrond Myklebust TP_fast_assign( 421a2f4c3faSTrond Myklebust __entry->xid = be32_to_cpu(rqstp->rq_xid); 422a2f4c3faSTrond Myklebust __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle); 423a2f4c3faSTrond Myklebust __entry->src_offset = src_offset; 424a2f4c3faSTrond Myklebust __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle); 425a2f4c3faSTrond Myklebust __entry->dst_offset = dst_offset; 426a2f4c3faSTrond Myklebust __entry->count = count; 427a2f4c3faSTrond Myklebust __entry->status = status; 428a2f4c3faSTrond Myklebust ), 429a2f4c3faSTrond Myklebust TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld " 430a2f4c3faSTrond Myklebust "dst_fh_hash=0x%08x dst_offset=%lld " 431a2f4c3faSTrond Myklebust "count=%llu status=%d", 432a2f4c3faSTrond Myklebust __entry->xid, __entry->src_fh_hash, __entry->src_offset, 433a2f4c3faSTrond Myklebust __entry->dst_fh_hash, __entry->dst_offset, 434a2f4c3faSTrond Myklebust (unsigned long long)__entry->count, 435a2f4c3faSTrond Myklebust __entry->status) 436a2f4c3faSTrond Myklebust ) 437a2f4c3faSTrond Myklebust 438a2f4c3faSTrond Myklebust #define DEFINE_NFSD_COPY_ERR_EVENT(name) \ 439a2f4c3faSTrond Myklebust DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \ 440a2f4c3faSTrond Myklebust TP_PROTO(struct svc_rqst *rqstp, \ 441a2f4c3faSTrond Myklebust struct svc_fh *src_fhp, \ 442a2f4c3faSTrond Myklebust loff_t src_offset, \ 443a2f4c3faSTrond Myklebust struct svc_fh *dst_fhp, \ 444a2f4c3faSTrond Myklebust loff_t dst_offset, \ 445a2f4c3faSTrond Myklebust u64 count, \ 446a2f4c3faSTrond Myklebust int status), \ 447a2f4c3faSTrond Myklebust TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \ 448a2f4c3faSTrond Myklebust count, status)) 449a2f4c3faSTrond Myklebust 450a2f4c3faSTrond Myklebust DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err); 451a2f4c3faSTrond Myklebust 452825213e5SJeff Layton #include "state.h" 45365294c1fSJeff Layton #include "filecache.h" 45465294c1fSJeff Layton #include "vfs.h" 455825213e5SJeff Layton 45631ef83dcSChristoph Hellwig DECLARE_EVENT_CLASS(nfsd_stateid_class, 45731ef83dcSChristoph Hellwig TP_PROTO(stateid_t *stp), 45831ef83dcSChristoph Hellwig TP_ARGS(stp), 45931ef83dcSChristoph Hellwig TP_STRUCT__entry( 46031ef83dcSChristoph Hellwig __field(u32, cl_boot) 46131ef83dcSChristoph Hellwig __field(u32, cl_id) 46231ef83dcSChristoph Hellwig __field(u32, si_id) 46331ef83dcSChristoph Hellwig __field(u32, si_generation) 46431ef83dcSChristoph Hellwig ), 46531ef83dcSChristoph Hellwig TP_fast_assign( 46631ef83dcSChristoph Hellwig __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 46731ef83dcSChristoph Hellwig __entry->cl_id = stp->si_opaque.so_clid.cl_id; 46831ef83dcSChristoph Hellwig __entry->si_id = stp->si_opaque.so_id; 46931ef83dcSChristoph Hellwig __entry->si_generation = stp->si_generation; 47031ef83dcSChristoph Hellwig ), 47131ef83dcSChristoph Hellwig TP_printk("client %08x:%08x stateid %08x:%08x", 47231ef83dcSChristoph Hellwig __entry->cl_boot, 47331ef83dcSChristoph Hellwig __entry->cl_id, 47431ef83dcSChristoph Hellwig __entry->si_id, 47531ef83dcSChristoph Hellwig __entry->si_generation) 47631ef83dcSChristoph Hellwig ) 47731ef83dcSChristoph Hellwig 47831ef83dcSChristoph Hellwig #define DEFINE_STATEID_EVENT(name) \ 479f394b62bSChuck Lever DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \ 48031ef83dcSChristoph Hellwig TP_PROTO(stateid_t *stp), \ 48131ef83dcSChristoph Hellwig TP_ARGS(stp)) 482dd5e3fbcSChuck Lever 48331ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_alloc); 48431ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_unhash); 48531ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_free); 48631ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_get_lookup_fail); 48731ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_commit_lookup_fail); 48831ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_return_lookup_fail); 48931ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall); 49031ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_done); 49131ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_fail); 49231ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_release); 49331ef83dcSChristoph Hellwig 4943caf9175SHou Tao DEFINE_STATEID_EVENT(open); 4953caf9175SHou Tao DEFINE_STATEID_EVENT(deleg_read); 496dd5e3fbcSChuck Lever DEFINE_STATEID_EVENT(deleg_recall); 497dd5e3fbcSChuck Lever 498dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_stateseqid_class, 499dd5e3fbcSChuck Lever TP_PROTO(u32 seqid, const stateid_t *stp), 500dd5e3fbcSChuck Lever TP_ARGS(seqid, stp), 501dd5e3fbcSChuck Lever TP_STRUCT__entry( 502dd5e3fbcSChuck Lever __field(u32, seqid) 503dd5e3fbcSChuck Lever __field(u32, cl_boot) 504dd5e3fbcSChuck Lever __field(u32, cl_id) 505dd5e3fbcSChuck Lever __field(u32, si_id) 506dd5e3fbcSChuck Lever __field(u32, si_generation) 507dd5e3fbcSChuck Lever ), 508dd5e3fbcSChuck Lever TP_fast_assign( 509dd5e3fbcSChuck Lever __entry->seqid = seqid; 510dd5e3fbcSChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 511dd5e3fbcSChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 512dd5e3fbcSChuck Lever __entry->si_id = stp->si_opaque.so_id; 513dd5e3fbcSChuck Lever __entry->si_generation = stp->si_generation; 514dd5e3fbcSChuck Lever ), 515dd5e3fbcSChuck Lever TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x", 516dd5e3fbcSChuck Lever __entry->seqid, __entry->cl_boot, __entry->cl_id, 517dd5e3fbcSChuck Lever __entry->si_id, __entry->si_generation) 518dd5e3fbcSChuck Lever ) 519dd5e3fbcSChuck Lever 520dd5e3fbcSChuck Lever #define DEFINE_STATESEQID_EVENT(name) \ 521dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \ 522dd5e3fbcSChuck Lever TP_PROTO(u32 seqid, const stateid_t *stp), \ 523dd5e3fbcSChuck Lever TP_ARGS(seqid, stp)) 524dd5e3fbcSChuck Lever 525dd5e3fbcSChuck Lever DEFINE_STATESEQID_EVENT(preprocess); 526dd5e3fbcSChuck Lever DEFINE_STATESEQID_EVENT(open_confirm); 527dd5e3fbcSChuck Lever 528dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_clientid_class, 529dd5e3fbcSChuck Lever TP_PROTO(const clientid_t *clid), 530dd5e3fbcSChuck Lever TP_ARGS(clid), 531dd5e3fbcSChuck Lever TP_STRUCT__entry( 532dd5e3fbcSChuck Lever __field(u32, cl_boot) 533dd5e3fbcSChuck Lever __field(u32, cl_id) 534dd5e3fbcSChuck Lever ), 535dd5e3fbcSChuck Lever TP_fast_assign( 536dd5e3fbcSChuck Lever __entry->cl_boot = clid->cl_boot; 537dd5e3fbcSChuck Lever __entry->cl_id = clid->cl_id; 538dd5e3fbcSChuck Lever ), 539dd5e3fbcSChuck Lever TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 540dd5e3fbcSChuck Lever ) 541dd5e3fbcSChuck Lever 542dd5e3fbcSChuck Lever #define DEFINE_CLIENTID_EVENT(name) \ 543dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 544dd5e3fbcSChuck Lever TP_PROTO(const clientid_t *clid), \ 545dd5e3fbcSChuck Lever TP_ARGS(clid)) 546dd5e3fbcSChuck Lever 547237f91c8SChuck Lever DEFINE_CLIENTID_EVENT(expire_unconf); 548cee8aa07SChuck Lever DEFINE_CLIENTID_EVENT(reclaim_complete); 5497e3b32acSChuck Lever DEFINE_CLIENTID_EVENT(confirmed); 550c41a9b7aSChuck Lever DEFINE_CLIENTID_EVENT(destroyed); 5512958d2eeSChuck Lever DEFINE_CLIENTID_EVENT(admin_expired); 5522958d2eeSChuck Lever DEFINE_CLIENTID_EVENT(replaced); 553dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(purged); 554dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(renew); 555dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(stale); 556dd5e3fbcSChuck Lever 557dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_net_class, 558dd5e3fbcSChuck Lever TP_PROTO(const struct nfsd_net *nn), 559dd5e3fbcSChuck Lever TP_ARGS(nn), 560dd5e3fbcSChuck Lever TP_STRUCT__entry( 561dd5e3fbcSChuck Lever __field(unsigned long long, boot_time) 562dd5e3fbcSChuck Lever ), 563dd5e3fbcSChuck Lever TP_fast_assign( 564dd5e3fbcSChuck Lever __entry->boot_time = nn->boot_time; 565dd5e3fbcSChuck Lever ), 566dd5e3fbcSChuck Lever TP_printk("boot_time=%16llx", __entry->boot_time) 567dd5e3fbcSChuck Lever ) 568dd5e3fbcSChuck Lever 569dd5e3fbcSChuck Lever #define DEFINE_NET_EVENT(name) \ 570dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 571dd5e3fbcSChuck Lever TP_PROTO(const struct nfsd_net *nn), \ 572dd5e3fbcSChuck Lever TP_ARGS(nn)) 573dd5e3fbcSChuck Lever 574dd5e3fbcSChuck Lever DEFINE_NET_EVENT(grace_start); 575dd5e3fbcSChuck Lever DEFINE_NET_EVENT(grace_complete); 576dd5e3fbcSChuck Lever 57775acacb6SChuck Lever TRACE_EVENT(nfsd_writeverf_reset, 57875acacb6SChuck Lever TP_PROTO( 57975acacb6SChuck Lever const struct nfsd_net *nn, 58075acacb6SChuck Lever const struct svc_rqst *rqstp, 58175acacb6SChuck Lever int error 58275acacb6SChuck Lever ), 58375acacb6SChuck Lever TP_ARGS(nn, rqstp, error), 58475acacb6SChuck Lever TP_STRUCT__entry( 58575acacb6SChuck Lever __field(unsigned long long, boot_time) 58675acacb6SChuck Lever __field(u32, xid) 58775acacb6SChuck Lever __field(int, error) 58875acacb6SChuck Lever __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 58975acacb6SChuck Lever ), 59075acacb6SChuck Lever TP_fast_assign( 59175acacb6SChuck Lever __entry->boot_time = nn->boot_time; 59275acacb6SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 59375acacb6SChuck Lever __entry->error = error; 59475acacb6SChuck Lever 59575acacb6SChuck Lever /* avoid seqlock inside TP_fast_assign */ 59675acacb6SChuck Lever memcpy(__entry->verifier, nn->writeverf, 59775acacb6SChuck Lever NFS4_VERIFIER_SIZE); 59875acacb6SChuck Lever ), 59975acacb6SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s", 60075acacb6SChuck Lever __entry->boot_time, __entry->xid, __entry->error, 60175acacb6SChuck Lever __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 60275acacb6SChuck Lever ) 60375acacb6SChuck Lever ); 60475acacb6SChuck Lever 60527787733SChuck Lever TRACE_EVENT(nfsd_clid_cred_mismatch, 60627787733SChuck Lever TP_PROTO( 60727787733SChuck Lever const struct nfs4_client *clp, 60827787733SChuck Lever const struct svc_rqst *rqstp 60927787733SChuck Lever ), 61027787733SChuck Lever TP_ARGS(clp, rqstp), 61127787733SChuck Lever TP_STRUCT__entry( 61227787733SChuck Lever __field(u32, cl_boot) 61327787733SChuck Lever __field(u32, cl_id) 61427787733SChuck Lever __field(unsigned long, cl_flavor) 61527787733SChuck Lever __field(unsigned long, new_flavor) 616*9db0e15fSChuck Lever __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 61727787733SChuck Lever ), 61827787733SChuck Lever TP_fast_assign( 61927787733SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 62027787733SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 62127787733SChuck Lever __entry->cl_flavor = clp->cl_cred.cr_flavor; 62227787733SChuck Lever __entry->new_flavor = rqstp->rq_cred.cr_flavor; 623*9db0e15fSChuck Lever __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 624*9db0e15fSChuck Lever rqstp->rq_xprt->xpt_remotelen); 62527787733SChuck Lever ), 62627787733SChuck Lever TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc", 62727787733SChuck Lever __entry->cl_boot, __entry->cl_id, 62827787733SChuck Lever show_nfsd_authflavor(__entry->cl_flavor), 629*9db0e15fSChuck Lever show_nfsd_authflavor(__entry->new_flavor), 630*9db0e15fSChuck Lever __get_sockaddr(addr) 63127787733SChuck Lever ) 63227787733SChuck Lever ) 63327787733SChuck Lever 634744ea54cSChuck Lever TRACE_EVENT(nfsd_clid_verf_mismatch, 635744ea54cSChuck Lever TP_PROTO( 636744ea54cSChuck Lever const struct nfs4_client *clp, 637744ea54cSChuck Lever const struct svc_rqst *rqstp, 638744ea54cSChuck Lever const nfs4_verifier *verf 639744ea54cSChuck Lever ), 640744ea54cSChuck Lever TP_ARGS(clp, rqstp, verf), 641744ea54cSChuck Lever TP_STRUCT__entry( 642744ea54cSChuck Lever __field(u32, cl_boot) 643744ea54cSChuck Lever __field(u32, cl_id) 644744ea54cSChuck Lever __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE) 645744ea54cSChuck Lever __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE) 646*9db0e15fSChuck Lever __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 647744ea54cSChuck Lever ), 648744ea54cSChuck Lever TP_fast_assign( 649744ea54cSChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 650744ea54cSChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 651744ea54cSChuck Lever memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier, 652744ea54cSChuck Lever NFS4_VERIFIER_SIZE); 653744ea54cSChuck Lever memcpy(__entry->new_verifier, (void *)verf, 654744ea54cSChuck Lever NFS4_VERIFIER_SIZE); 655*9db0e15fSChuck Lever __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 656*9db0e15fSChuck Lever rqstp->rq_xprt->xpt_remotelen); 657744ea54cSChuck Lever ), 658744ea54cSChuck Lever TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc", 659744ea54cSChuck Lever __entry->cl_boot, __entry->cl_id, 660744ea54cSChuck Lever __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE), 661744ea54cSChuck Lever __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE), 662*9db0e15fSChuck Lever __get_sockaddr(addr) 663744ea54cSChuck Lever ) 664744ea54cSChuck Lever ); 665744ea54cSChuck Lever 666237f91c8SChuck Lever DECLARE_EVENT_CLASS(nfsd_clid_class, 667237f91c8SChuck Lever TP_PROTO(const struct nfs4_client *clp), 668237f91c8SChuck Lever TP_ARGS(clp), 669237f91c8SChuck Lever TP_STRUCT__entry( 670237f91c8SChuck Lever __field(u32, cl_boot) 671237f91c8SChuck Lever __field(u32, cl_id) 672237f91c8SChuck Lever __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 673237f91c8SChuck Lever __field(unsigned long, flavor) 674237f91c8SChuck Lever __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 675d27b74a8SChuck Lever __string_len(name, name, clp->cl_name.len) 676237f91c8SChuck Lever ), 677237f91c8SChuck Lever TP_fast_assign( 678237f91c8SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 679237f91c8SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 680237f91c8SChuck Lever memcpy(__entry->addr, &clp->cl_addr, 681237f91c8SChuck Lever sizeof(struct sockaddr_in6)); 682237f91c8SChuck Lever __entry->flavor = clp->cl_cred.cr_flavor; 683237f91c8SChuck Lever memcpy(__entry->verifier, (void *)&clp->cl_verifier, 684237f91c8SChuck Lever NFS4_VERIFIER_SIZE); 685d27b74a8SChuck Lever __assign_str_len(name, clp->cl_name.data, clp->cl_name.len); 686237f91c8SChuck Lever ), 687237f91c8SChuck Lever TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x", 688237f91c8SChuck Lever __entry->addr, __get_str(name), 689237f91c8SChuck Lever __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE), 690237f91c8SChuck Lever show_nfsd_authflavor(__entry->flavor), 691237f91c8SChuck Lever __entry->cl_boot, __entry->cl_id) 692237f91c8SChuck Lever ); 693237f91c8SChuck Lever 694237f91c8SChuck Lever #define DEFINE_CLID_EVENT(name) \ 695237f91c8SChuck Lever DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 696237f91c8SChuck Lever TP_PROTO(const struct nfs4_client *clp), \ 697237f91c8SChuck Lever TP_ARGS(clp)) 698237f91c8SChuck Lever 699237f91c8SChuck Lever DEFINE_CLID_EVENT(fresh); 700e8f80c55SChuck Lever DEFINE_CLID_EVENT(confirmed_r); 701237f91c8SChuck Lever 702b76278aeSChuck Lever /* 703b76278aeSChuck Lever * from fs/nfsd/filecache.h 704b76278aeSChuck Lever */ 705c1928559STrond Myklebust TRACE_DEFINE_ENUM(NFSD_FILE_HASHED); 706c1928559STrond Myklebust TRACE_DEFINE_ENUM(NFSD_FILE_PENDING); 707c1928559STrond Myklebust TRACE_DEFINE_ENUM(NFSD_FILE_BREAK_READ); 708c1928559STrond Myklebust TRACE_DEFINE_ENUM(NFSD_FILE_BREAK_WRITE); 709c1928559STrond Myklebust TRACE_DEFINE_ENUM(NFSD_FILE_REFERENCED); 710c1928559STrond Myklebust 71165294c1fSJeff Layton #define show_nf_flags(val) \ 71265294c1fSJeff Layton __print_flags(val, "|", \ 71365294c1fSJeff Layton { 1 << NFSD_FILE_HASHED, "HASHED" }, \ 71465294c1fSJeff Layton { 1 << NFSD_FILE_PENDING, "PENDING" }, \ 71565294c1fSJeff Layton { 1 << NFSD_FILE_BREAK_READ, "BREAK_READ" }, \ 71665294c1fSJeff Layton { 1 << NFSD_FILE_BREAK_WRITE, "BREAK_WRITE" }, \ 71765294c1fSJeff Layton { 1 << NFSD_FILE_REFERENCED, "REFERENCED"}) 71865294c1fSJeff Layton 71965294c1fSJeff Layton DECLARE_EVENT_CLASS(nfsd_file_class, 72065294c1fSJeff Layton TP_PROTO(struct nfsd_file *nf), 72165294c1fSJeff Layton TP_ARGS(nf), 72265294c1fSJeff Layton TP_STRUCT__entry( 72365294c1fSJeff Layton __field(unsigned int, nf_hashval) 72465294c1fSJeff Layton __field(void *, nf_inode) 72565294c1fSJeff Layton __field(int, nf_ref) 72665294c1fSJeff Layton __field(unsigned long, nf_flags) 72765294c1fSJeff Layton __field(unsigned char, nf_may) 72865294c1fSJeff Layton __field(struct file *, nf_file) 72965294c1fSJeff Layton ), 73065294c1fSJeff Layton TP_fast_assign( 73165294c1fSJeff Layton __entry->nf_hashval = nf->nf_hashval; 73265294c1fSJeff Layton __entry->nf_inode = nf->nf_inode; 733689827cdSTrond Myklebust __entry->nf_ref = refcount_read(&nf->nf_ref); 73465294c1fSJeff Layton __entry->nf_flags = nf->nf_flags; 73565294c1fSJeff Layton __entry->nf_may = nf->nf_may; 73665294c1fSJeff Layton __entry->nf_file = nf->nf_file; 73765294c1fSJeff Layton ), 7383a90e1dfSChuck Lever TP_printk("hash=0x%x inode=%p ref=%d flags=%s may=%s file=%p", 73965294c1fSJeff Layton __entry->nf_hashval, 74065294c1fSJeff Layton __entry->nf_inode, 74165294c1fSJeff Layton __entry->nf_ref, 74265294c1fSJeff Layton show_nf_flags(__entry->nf_flags), 743b76278aeSChuck Lever show_nfsd_may_flags(__entry->nf_may), 74465294c1fSJeff Layton __entry->nf_file) 74565294c1fSJeff Layton ) 74665294c1fSJeff Layton 74765294c1fSJeff Layton #define DEFINE_NFSD_FILE_EVENT(name) \ 74865294c1fSJeff Layton DEFINE_EVENT(nfsd_file_class, name, \ 74965294c1fSJeff Layton TP_PROTO(struct nfsd_file *nf), \ 75065294c1fSJeff Layton TP_ARGS(nf)) 75165294c1fSJeff Layton 75265294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_alloc); 75365294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_put_final); 75465294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 75565294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 75665294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_release_locked); 75765294c1fSJeff Layton 75865294c1fSJeff Layton TRACE_EVENT(nfsd_file_acquire, 75965294c1fSJeff Layton TP_PROTO(struct svc_rqst *rqstp, unsigned int hash, 76065294c1fSJeff Layton struct inode *inode, unsigned int may_flags, 76165294c1fSJeff Layton struct nfsd_file *nf, __be32 status), 76265294c1fSJeff Layton 76365294c1fSJeff Layton TP_ARGS(rqstp, hash, inode, may_flags, nf, status), 76465294c1fSJeff Layton 76565294c1fSJeff Layton TP_STRUCT__entry( 766a9ceb060STrond Myklebust __field(u32, xid) 76765294c1fSJeff Layton __field(unsigned int, hash) 76865294c1fSJeff Layton __field(void *, inode) 769b76278aeSChuck Lever __field(unsigned long, may_flags) 77065294c1fSJeff Layton __field(int, nf_ref) 77165294c1fSJeff Layton __field(unsigned long, nf_flags) 772b76278aeSChuck Lever __field(unsigned long, nf_may) 77365294c1fSJeff Layton __field(struct file *, nf_file) 774a9ceb060STrond Myklebust __field(u32, status) 77565294c1fSJeff Layton ), 77665294c1fSJeff Layton 77765294c1fSJeff Layton TP_fast_assign( 778a9ceb060STrond Myklebust __entry->xid = be32_to_cpu(rqstp->rq_xid); 77965294c1fSJeff Layton __entry->hash = hash; 78065294c1fSJeff Layton __entry->inode = inode; 78165294c1fSJeff Layton __entry->may_flags = may_flags; 782689827cdSTrond Myklebust __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 78365294c1fSJeff Layton __entry->nf_flags = nf ? nf->nf_flags : 0; 78465294c1fSJeff Layton __entry->nf_may = nf ? nf->nf_may : 0; 78565294c1fSJeff Layton __entry->nf_file = nf ? nf->nf_file : NULL; 786a9ceb060STrond Myklebust __entry->status = be32_to_cpu(status); 78765294c1fSJeff Layton ), 78865294c1fSJeff Layton 7893a90e1dfSChuck Lever TP_printk("xid=0x%x hash=0x%x inode=%p may_flags=%s ref=%d nf_flags=%s nf_may=%s nf_file=%p status=%u", 790a9ceb060STrond Myklebust __entry->xid, __entry->hash, __entry->inode, 791b76278aeSChuck Lever show_nfsd_may_flags(__entry->may_flags), 792b76278aeSChuck Lever __entry->nf_ref, show_nf_flags(__entry->nf_flags), 793b76278aeSChuck Lever show_nfsd_may_flags(__entry->nf_may), 794b76278aeSChuck Lever __entry->nf_file, __entry->status) 79565294c1fSJeff Layton ); 79665294c1fSJeff Layton 79765294c1fSJeff Layton DECLARE_EVENT_CLASS(nfsd_file_search_class, 79865294c1fSJeff Layton TP_PROTO(struct inode *inode, unsigned int hash, int found), 79965294c1fSJeff Layton TP_ARGS(inode, hash, found), 80065294c1fSJeff Layton TP_STRUCT__entry( 80165294c1fSJeff Layton __field(struct inode *, inode) 80265294c1fSJeff Layton __field(unsigned int, hash) 80365294c1fSJeff Layton __field(int, found) 80465294c1fSJeff Layton ), 80565294c1fSJeff Layton TP_fast_assign( 80665294c1fSJeff Layton __entry->inode = inode; 80765294c1fSJeff Layton __entry->hash = hash; 80865294c1fSJeff Layton __entry->found = found; 80965294c1fSJeff Layton ), 8103a90e1dfSChuck Lever TP_printk("hash=0x%x inode=%p found=%d", __entry->hash, 81165294c1fSJeff Layton __entry->inode, __entry->found) 81265294c1fSJeff Layton ); 81365294c1fSJeff Layton 81465294c1fSJeff Layton #define DEFINE_NFSD_FILE_SEARCH_EVENT(name) \ 81565294c1fSJeff Layton DEFINE_EVENT(nfsd_file_search_class, name, \ 81665294c1fSJeff Layton TP_PROTO(struct inode *inode, unsigned int hash, int found), \ 81765294c1fSJeff Layton TP_ARGS(inode, hash, found)) 81865294c1fSJeff Layton 81965294c1fSJeff Layton DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode_sync); 82065294c1fSJeff Layton DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode); 82165294c1fSJeff Layton DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_is_cached); 82265294c1fSJeff Layton 82365294c1fSJeff Layton TRACE_EVENT(nfsd_file_fsnotify_handle_event, 82465294c1fSJeff Layton TP_PROTO(struct inode *inode, u32 mask), 82565294c1fSJeff Layton TP_ARGS(inode, mask), 82665294c1fSJeff Layton TP_STRUCT__entry( 82765294c1fSJeff Layton __field(struct inode *, inode) 82865294c1fSJeff Layton __field(unsigned int, nlink) 82965294c1fSJeff Layton __field(umode_t, mode) 83065294c1fSJeff Layton __field(u32, mask) 83165294c1fSJeff Layton ), 83265294c1fSJeff Layton TP_fast_assign( 83365294c1fSJeff Layton __entry->inode = inode; 83465294c1fSJeff Layton __entry->nlink = inode->i_nlink; 83565294c1fSJeff Layton __entry->mode = inode->i_mode; 83665294c1fSJeff Layton __entry->mask = mask; 83765294c1fSJeff Layton ), 8383a90e1dfSChuck Lever TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 83965294c1fSJeff Layton __entry->nlink, __entry->mode, __entry->mask) 84065294c1fSJeff Layton ); 84165294c1fSJeff Layton 8420b175b18SChuck Lever #include "cache.h" 8430b175b18SChuck Lever 8440b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_DROPIT); 8450b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_REPLY); 8460b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_DOIT); 8470b175b18SChuck Lever 8480b175b18SChuck Lever #define show_drc_retval(x) \ 8490b175b18SChuck Lever __print_symbolic(x, \ 8500b175b18SChuck Lever { RC_DROPIT, "DROPIT" }, \ 8510b175b18SChuck Lever { RC_REPLY, "REPLY" }, \ 8520b175b18SChuck Lever { RC_DOIT, "DOIT" }) 8530b175b18SChuck Lever 8540b175b18SChuck Lever TRACE_EVENT(nfsd_drc_found, 8550b175b18SChuck Lever TP_PROTO( 8560b175b18SChuck Lever const struct nfsd_net *nn, 8570b175b18SChuck Lever const struct svc_rqst *rqstp, 8580b175b18SChuck Lever int result 8590b175b18SChuck Lever ), 8600b175b18SChuck Lever TP_ARGS(nn, rqstp, result), 8610b175b18SChuck Lever TP_STRUCT__entry( 8620b175b18SChuck Lever __field(unsigned long long, boot_time) 8630b175b18SChuck Lever __field(unsigned long, result) 8640b175b18SChuck Lever __field(u32, xid) 8650b175b18SChuck Lever ), 8660b175b18SChuck Lever TP_fast_assign( 8670b175b18SChuck Lever __entry->boot_time = nn->boot_time; 8680b175b18SChuck Lever __entry->result = result; 8690b175b18SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 8700b175b18SChuck Lever ), 8710b175b18SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x result=%s", 8720b175b18SChuck Lever __entry->boot_time, __entry->xid, 8730b175b18SChuck Lever show_drc_retval(__entry->result)) 8740b175b18SChuck Lever 8750b175b18SChuck Lever ); 8760b175b18SChuck Lever 8770b175b18SChuck Lever TRACE_EVENT(nfsd_drc_mismatch, 8780b175b18SChuck Lever TP_PROTO( 8790b175b18SChuck Lever const struct nfsd_net *nn, 8800b175b18SChuck Lever const struct svc_cacherep *key, 8810b175b18SChuck Lever const struct svc_cacherep *rp 8820b175b18SChuck Lever ), 8830b175b18SChuck Lever TP_ARGS(nn, key, rp), 8840b175b18SChuck Lever TP_STRUCT__entry( 8850b175b18SChuck Lever __field(unsigned long long, boot_time) 8860b175b18SChuck Lever __field(u32, xid) 8870b175b18SChuck Lever __field(u32, cached) 8880b175b18SChuck Lever __field(u32, ingress) 8890b175b18SChuck Lever ), 8900b175b18SChuck Lever TP_fast_assign( 8910b175b18SChuck Lever __entry->boot_time = nn->boot_time; 8920b175b18SChuck Lever __entry->xid = be32_to_cpu(key->c_key.k_xid); 8930b175b18SChuck Lever __entry->cached = (__force u32)key->c_key.k_csum; 8940b175b18SChuck Lever __entry->ingress = (__force u32)rp->c_key.k_csum; 8950b175b18SChuck Lever ), 8960b175b18SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 8970b175b18SChuck Lever __entry->boot_time, __entry->xid, __entry->cached, 8980b175b18SChuck Lever __entry->ingress) 8990b175b18SChuck Lever ); 9000b175b18SChuck Lever 9011eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_args, 9021eace0d1SChuck Lever TP_PROTO( 9031eace0d1SChuck Lever const struct nfs4_client *clp, 9041eace0d1SChuck Lever const struct nfs4_cb_conn *conn 9051eace0d1SChuck Lever ), 9061eace0d1SChuck Lever TP_ARGS(clp, conn), 9071eace0d1SChuck Lever TP_STRUCT__entry( 9081eace0d1SChuck Lever __field(u32, cl_boot) 9091eace0d1SChuck Lever __field(u32, cl_id) 9101eace0d1SChuck Lever __field(u32, prog) 9111eace0d1SChuck Lever __field(u32, ident) 912*9db0e15fSChuck Lever __sockaddr(addr, conn->cb_addrlen) 9131eace0d1SChuck Lever ), 9141eace0d1SChuck Lever TP_fast_assign( 9151eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 9161eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 9171eace0d1SChuck Lever __entry->prog = conn->cb_prog; 9181eace0d1SChuck Lever __entry->ident = conn->cb_ident; 919*9db0e15fSChuck Lever __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 9201eace0d1SChuck Lever ), 921d6cbe98fSChuck Lever TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 922*9db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 923d6cbe98fSChuck Lever __entry->prog, __entry->ident) 9241eace0d1SChuck Lever ); 9251eace0d1SChuck Lever 9261eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_nodelegs, 9271eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), 9281eace0d1SChuck Lever TP_ARGS(clp), 9291eace0d1SChuck Lever TP_STRUCT__entry( 9301eace0d1SChuck Lever __field(u32, cl_boot) 9311eace0d1SChuck Lever __field(u32, cl_id) 9321eace0d1SChuck Lever ), 9331eace0d1SChuck Lever TP_fast_assign( 9341eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 9351eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 9361eace0d1SChuck Lever ), 9371eace0d1SChuck Lever TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 9381eace0d1SChuck Lever ) 9391eace0d1SChuck Lever 9401eace0d1SChuck Lever #define show_cb_state(val) \ 9411eace0d1SChuck Lever __print_symbolic(val, \ 9421eace0d1SChuck Lever { NFSD4_CB_UP, "UP" }, \ 9431eace0d1SChuck Lever { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 9441eace0d1SChuck Lever { NFSD4_CB_DOWN, "DOWN" }, \ 9451eace0d1SChuck Lever { NFSD4_CB_FAULT, "FAULT"}) 9461eace0d1SChuck Lever 9471eace0d1SChuck Lever DECLARE_EVENT_CLASS(nfsd_cb_class, 9481eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), 9491eace0d1SChuck Lever TP_ARGS(clp), 9501eace0d1SChuck Lever TP_STRUCT__entry( 9511eace0d1SChuck Lever __field(unsigned long, state) 9521eace0d1SChuck Lever __field(u32, cl_boot) 9531eace0d1SChuck Lever __field(u32, cl_id) 954*9db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 9551eace0d1SChuck Lever ), 9561eace0d1SChuck Lever TP_fast_assign( 9571eace0d1SChuck Lever __entry->state = clp->cl_cb_state; 9581eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 9591eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 960*9db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 961*9db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 9621eace0d1SChuck Lever ), 9631eace0d1SChuck Lever TP_printk("addr=%pISpc client %08x:%08x state=%s", 964*9db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 9651eace0d1SChuck Lever show_cb_state(__entry->state)) 9661eace0d1SChuck Lever ); 9671eace0d1SChuck Lever 9681eace0d1SChuck Lever #define DEFINE_NFSD_CB_EVENT(name) \ 9691eace0d1SChuck Lever DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 9701eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), \ 9711eace0d1SChuck Lever TP_ARGS(clp)) 9721eace0d1SChuck Lever 9731eace0d1SChuck Lever DEFINE_NFSD_CB_EVENT(state); 9744ade892aSChuck Lever DEFINE_NFSD_CB_EVENT(probe); 975806d65b6SChuck Lever DEFINE_NFSD_CB_EVENT(lost); 9761eace0d1SChuck Lever DEFINE_NFSD_CB_EVENT(shutdown); 9771eace0d1SChuck Lever 97887b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 97987b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 98087b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 98187b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 98287b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 98387b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 98487b2394dSChuck Lever 98587b2394dSChuck Lever #define show_nfsd_authflavor(val) \ 98687b2394dSChuck Lever __print_symbolic(val, \ 98787b2394dSChuck Lever { RPC_AUTH_NULL, "none" }, \ 98887b2394dSChuck Lever { RPC_AUTH_UNIX, "sys" }, \ 98987b2394dSChuck Lever { RPC_AUTH_GSS, "gss" }, \ 99087b2394dSChuck Lever { RPC_AUTH_GSS_KRB5, "krb5" }, \ 99187b2394dSChuck Lever { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 99287b2394dSChuck Lever { RPC_AUTH_GSS_KRB5P, "krb5p" }) 99387b2394dSChuck Lever 9943c92fba5SChuck Lever TRACE_EVENT(nfsd_cb_setup, 9953c92fba5SChuck Lever TP_PROTO(const struct nfs4_client *clp, 9963c92fba5SChuck Lever const char *netid, 9973c92fba5SChuck Lever rpc_authflavor_t authflavor 9983c92fba5SChuck Lever ), 9993c92fba5SChuck Lever TP_ARGS(clp, netid, authflavor), 10003c92fba5SChuck Lever TP_STRUCT__entry( 10013c92fba5SChuck Lever __field(u32, cl_boot) 10023c92fba5SChuck Lever __field(u32, cl_id) 10033c92fba5SChuck Lever __field(unsigned long, authflavor) 1004*9db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 10053c92fba5SChuck Lever __array(unsigned char, netid, 8) 10063c92fba5SChuck Lever ), 10073c92fba5SChuck Lever TP_fast_assign( 10083c92fba5SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 10093c92fba5SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 10103c92fba5SChuck Lever strlcpy(__entry->netid, netid, sizeof(__entry->netid)); 10113c92fba5SChuck Lever __entry->authflavor = authflavor; 1012*9db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1013*9db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 10143c92fba5SChuck Lever ), 10153c92fba5SChuck Lever TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 1016*9db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 10173c92fba5SChuck Lever __entry->netid, show_nfsd_authflavor(__entry->authflavor)) 10183c92fba5SChuck Lever ); 10193c92fba5SChuck Lever 10201eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_setup_err, 10211eace0d1SChuck Lever TP_PROTO( 10221eace0d1SChuck Lever const struct nfs4_client *clp, 10231eace0d1SChuck Lever long error 10241eace0d1SChuck Lever ), 10251eace0d1SChuck Lever TP_ARGS(clp, error), 10261eace0d1SChuck Lever TP_STRUCT__entry( 10271eace0d1SChuck Lever __field(long, error) 10281eace0d1SChuck Lever __field(u32, cl_boot) 10291eace0d1SChuck Lever __field(u32, cl_id) 1030*9db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 10311eace0d1SChuck Lever ), 10321eace0d1SChuck Lever TP_fast_assign( 10331eace0d1SChuck Lever __entry->error = error; 10341eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 10351eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 1036*9db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1037*9db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 10381eace0d1SChuck Lever ), 10391eace0d1SChuck Lever TP_printk("addr=%pISpc client %08x:%08x error=%ld", 1040*9db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1041*9db0e15fSChuck Lever __entry->error) 10421eace0d1SChuck Lever ); 10431eace0d1SChuck Lever 1044*9db0e15fSChuck Lever TRACE_EVENT_CONDITION(nfsd_cb_recall, 104517d76ddfSChuck Lever TP_PROTO( 104617d76ddfSChuck Lever const struct nfs4_stid *stid 104717d76ddfSChuck Lever ), 104817d76ddfSChuck Lever TP_ARGS(stid), 1049*9db0e15fSChuck Lever TP_CONDITION(stid->sc_client), 105017d76ddfSChuck Lever TP_STRUCT__entry( 105117d76ddfSChuck Lever __field(u32, cl_boot) 105217d76ddfSChuck Lever __field(u32, cl_id) 105317d76ddfSChuck Lever __field(u32, si_id) 105417d76ddfSChuck Lever __field(u32, si_generation) 1055*9db0e15fSChuck Lever __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 105617d76ddfSChuck Lever ), 105717d76ddfSChuck Lever TP_fast_assign( 105817d76ddfSChuck Lever const stateid_t *stp = &stid->sc_stateid; 105917d76ddfSChuck Lever const struct nfs4_client *clp = stid->sc_client; 106017d76ddfSChuck Lever 106117d76ddfSChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 106217d76ddfSChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 106317d76ddfSChuck Lever __entry->si_id = stp->si_opaque.so_id; 106417d76ddfSChuck Lever __entry->si_generation = stp->si_generation; 1065*9db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1066*9db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 106717d76ddfSChuck Lever ), 106817d76ddfSChuck Lever TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 1069*9db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 107017d76ddfSChuck Lever __entry->si_id, __entry->si_generation) 107117d76ddfSChuck Lever ); 107217d76ddfSChuck Lever 10732cde7f81SChuck Lever TRACE_EVENT(nfsd_cb_notify_lock, 10742cde7f81SChuck Lever TP_PROTO( 10752cde7f81SChuck Lever const struct nfs4_lockowner *lo, 10762cde7f81SChuck Lever const struct nfsd4_blocked_lock *nbl 10772cde7f81SChuck Lever ), 10782cde7f81SChuck Lever TP_ARGS(lo, nbl), 10792cde7f81SChuck Lever TP_STRUCT__entry( 10802cde7f81SChuck Lever __field(u32, cl_boot) 10812cde7f81SChuck Lever __field(u32, cl_id) 10822cde7f81SChuck Lever __field(u32, fh_hash) 1083*9db0e15fSChuck Lever __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 10842cde7f81SChuck Lever ), 10852cde7f81SChuck Lever TP_fast_assign( 10862cde7f81SChuck Lever const struct nfs4_client *clp = lo->lo_owner.so_client; 10872cde7f81SChuck Lever 10882cde7f81SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 10892cde7f81SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 10902cde7f81SChuck Lever __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 1091*9db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1092*9db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 10932cde7f81SChuck Lever ), 10942cde7f81SChuck Lever TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 1095*9db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 10962cde7f81SChuck Lever __entry->fh_hash) 10972cde7f81SChuck Lever ); 10982cde7f81SChuck Lever 109987512386SChuck Lever TRACE_EVENT(nfsd_cb_offload, 110087512386SChuck Lever TP_PROTO( 110187512386SChuck Lever const struct nfs4_client *clp, 110287512386SChuck Lever const stateid_t *stp, 110387512386SChuck Lever const struct knfsd_fh *fh, 110487512386SChuck Lever u64 count, 110587512386SChuck Lever __be32 status 110687512386SChuck Lever ), 110787512386SChuck Lever TP_ARGS(clp, stp, fh, count, status), 110887512386SChuck Lever TP_STRUCT__entry( 110987512386SChuck Lever __field(u32, cl_boot) 111087512386SChuck Lever __field(u32, cl_id) 111187512386SChuck Lever __field(u32, si_id) 111287512386SChuck Lever __field(u32, si_generation) 111387512386SChuck Lever __field(u32, fh_hash) 111487512386SChuck Lever __field(int, status) 111587512386SChuck Lever __field(u64, count) 1116*9db0e15fSChuck Lever __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 111787512386SChuck Lever ), 111887512386SChuck Lever TP_fast_assign( 111987512386SChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 112087512386SChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 112187512386SChuck Lever __entry->si_id = stp->si_opaque.so_id; 112287512386SChuck Lever __entry->si_generation = stp->si_generation; 112387512386SChuck Lever __entry->fh_hash = knfsd_fh_hash(fh); 112487512386SChuck Lever __entry->status = be32_to_cpu(status); 112587512386SChuck Lever __entry->count = count; 1126*9db0e15fSChuck Lever __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1127*9db0e15fSChuck Lever clp->cl_cb_conn.cb_addrlen) 112887512386SChuck Lever ), 112987512386SChuck Lever TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 1130*9db0e15fSChuck Lever __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 113187512386SChuck Lever __entry->si_id, __entry->si_generation, 113287512386SChuck Lever __entry->fh_hash, __entry->count, __entry->status) 113387512386SChuck Lever ); 113487512386SChuck Lever 113531ef83dcSChristoph Hellwig #endif /* _NFSD_TRACE_H */ 113631ef83dcSChristoph Hellwig 113731ef83dcSChristoph Hellwig #undef TRACE_INCLUDE_PATH 113831ef83dcSChristoph Hellwig #define TRACE_INCLUDE_PATH . 113931ef83dcSChristoph Hellwig #define TRACE_INCLUDE_FILE trace 114031ef83dcSChristoph Hellwig #include <trace/define_trace.h> 1141