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> 12cf749f3cSTrond Myklebust #include "export.h" 136e8b50d1SJeff Layton #include "nfsfh.h" 146e8b50d1SJeff Layton 150dfdad1cSChuck Lever #define NFSD_TRACE_PROC_ARG_FIELDS \ 160dfdad1cSChuck Lever __field(unsigned int, netns_ino) \ 170dfdad1cSChuck Lever __field(u32, xid) \ 180dfdad1cSChuck Lever __array(unsigned char, server, sizeof(struct sockaddr_in6)) \ 190dfdad1cSChuck Lever __array(unsigned char, client, sizeof(struct sockaddr_in6)) 200dfdad1cSChuck Lever 210dfdad1cSChuck Lever #define NFSD_TRACE_PROC_ARG_ASSIGNMENTS \ 220dfdad1cSChuck Lever do { \ 230dfdad1cSChuck Lever __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \ 240dfdad1cSChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); \ 250dfdad1cSChuck Lever memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \ 260dfdad1cSChuck Lever rqstp->rq_xprt->xpt_locallen); \ 270dfdad1cSChuck Lever memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \ 280dfdad1cSChuck Lever rqstp->rq_xprt->xpt_remotelen); \ 290dfdad1cSChuck Lever } while (0); 300dfdad1cSChuck Lever 3108281341SChuck Lever #define NFSD_TRACE_PROC_RES_FIELDS \ 3208281341SChuck Lever __field(unsigned int, netns_ino) \ 3308281341SChuck Lever __field(u32, xid) \ 3408281341SChuck Lever __field(unsigned long, status) \ 3508281341SChuck Lever __array(unsigned char, server, sizeof(struct sockaddr_in6)) \ 3608281341SChuck Lever __array(unsigned char, client, sizeof(struct sockaddr_in6)) 3708281341SChuck Lever 3808281341SChuck Lever #define NFSD_TRACE_PROC_RES_ASSIGNMENTS(error) \ 3908281341SChuck Lever do { \ 4008281341SChuck Lever __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \ 4108281341SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); \ 4208281341SChuck Lever __entry->status = be32_to_cpu(error); \ 4308281341SChuck Lever memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \ 4408281341SChuck Lever rqstp->rq_xprt->xpt_locallen); \ 4508281341SChuck Lever memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \ 4608281341SChuck Lever rqstp->rq_xprt->xpt_remotelen); \ 4708281341SChuck Lever } while (0); 4808281341SChuck Lever 490dfdad1cSChuck Lever TRACE_EVENT(nfsd_garbage_args_err, 500dfdad1cSChuck Lever TP_PROTO( 510dfdad1cSChuck Lever const struct svc_rqst *rqstp 520dfdad1cSChuck Lever ), 530dfdad1cSChuck Lever TP_ARGS(rqstp), 540dfdad1cSChuck Lever TP_STRUCT__entry( 550dfdad1cSChuck Lever NFSD_TRACE_PROC_ARG_FIELDS 560dfdad1cSChuck Lever 570dfdad1cSChuck Lever __field(u32, vers) 580dfdad1cSChuck Lever __field(u32, proc) 590dfdad1cSChuck Lever ), 600dfdad1cSChuck Lever TP_fast_assign( 610dfdad1cSChuck Lever NFSD_TRACE_PROC_ARG_ASSIGNMENTS 620dfdad1cSChuck Lever 630dfdad1cSChuck Lever __entry->vers = rqstp->rq_vers; 640dfdad1cSChuck Lever __entry->proc = rqstp->rq_proc; 650dfdad1cSChuck Lever ), 660dfdad1cSChuck Lever TP_printk("xid=0x%08x vers=%u proc=%u", 670dfdad1cSChuck Lever __entry->xid, __entry->vers, __entry->proc 680dfdad1cSChuck Lever ) 690dfdad1cSChuck Lever ); 700dfdad1cSChuck Lever 710dfdad1cSChuck Lever TRACE_EVENT(nfsd_cant_encode_err, 720dfdad1cSChuck Lever TP_PROTO( 730dfdad1cSChuck Lever const struct svc_rqst *rqstp 740dfdad1cSChuck Lever ), 750dfdad1cSChuck Lever TP_ARGS(rqstp), 760dfdad1cSChuck Lever TP_STRUCT__entry( 770dfdad1cSChuck Lever NFSD_TRACE_PROC_ARG_FIELDS 780dfdad1cSChuck Lever 790dfdad1cSChuck Lever __field(u32, vers) 800dfdad1cSChuck Lever __field(u32, proc) 810dfdad1cSChuck Lever ), 820dfdad1cSChuck Lever TP_fast_assign( 830dfdad1cSChuck Lever NFSD_TRACE_PROC_ARG_ASSIGNMENTS 840dfdad1cSChuck Lever 850dfdad1cSChuck Lever __entry->vers = rqstp->rq_vers; 860dfdad1cSChuck Lever __entry->proc = rqstp->rq_proc; 870dfdad1cSChuck Lever ), 880dfdad1cSChuck Lever TP_printk("xid=0x%08x vers=%u proc=%u", 890dfdad1cSChuck Lever __entry->xid, __entry->vers, __entry->proc 900dfdad1cSChuck Lever ) 910dfdad1cSChuck Lever ); 920dfdad1cSChuck Lever 93b76278aeSChuck Lever #define show_nfsd_may_flags(x) \ 94b76278aeSChuck Lever __print_flags(x, "|", \ 95b76278aeSChuck Lever { NFSD_MAY_EXEC, "EXEC" }, \ 96b76278aeSChuck Lever { NFSD_MAY_WRITE, "WRITE" }, \ 97b76278aeSChuck Lever { NFSD_MAY_READ, "READ" }, \ 98b76278aeSChuck Lever { NFSD_MAY_SATTR, "SATTR" }, \ 99b76278aeSChuck Lever { NFSD_MAY_TRUNC, "TRUNC" }, \ 100b76278aeSChuck Lever { NFSD_MAY_LOCK, "LOCK" }, \ 101b76278aeSChuck Lever { NFSD_MAY_OWNER_OVERRIDE, "OWNER_OVERRIDE" }, \ 102b76278aeSChuck Lever { NFSD_MAY_LOCAL_ACCESS, "LOCAL_ACCESS" }, \ 103b76278aeSChuck Lever { NFSD_MAY_BYPASS_GSS_ON_ROOT, "BYPASS_GSS_ON_ROOT" }, \ 104b76278aeSChuck Lever { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \ 105b76278aeSChuck Lever { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \ 106b76278aeSChuck Lever { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \ 107b76278aeSChuck Lever { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" }) 108b76278aeSChuck Lever 109fff4080bSChuck Lever TRACE_EVENT(nfsd_compound, 110fff4080bSChuck Lever TP_PROTO(const struct svc_rqst *rqst, 111fff4080bSChuck Lever u32 args_opcnt), 112fff4080bSChuck Lever TP_ARGS(rqst, args_opcnt), 113fff4080bSChuck Lever TP_STRUCT__entry( 114fff4080bSChuck Lever __field(u32, xid) 115fff4080bSChuck Lever __field(u32, args_opcnt) 116fff4080bSChuck Lever ), 117fff4080bSChuck Lever TP_fast_assign( 118fff4080bSChuck Lever __entry->xid = be32_to_cpu(rqst->rq_xid); 119fff4080bSChuck Lever __entry->args_opcnt = args_opcnt; 120fff4080bSChuck Lever ), 121fff4080bSChuck Lever TP_printk("xid=0x%08x opcnt=%u", 122fff4080bSChuck Lever __entry->xid, __entry->args_opcnt) 123fff4080bSChuck Lever ) 124fff4080bSChuck Lever 125fff4080bSChuck Lever TRACE_EVENT(nfsd_compound_status, 126fff4080bSChuck Lever TP_PROTO(u32 args_opcnt, 127fff4080bSChuck Lever u32 resp_opcnt, 128fff4080bSChuck Lever __be32 status, 129fff4080bSChuck Lever const char *name), 130fff4080bSChuck Lever TP_ARGS(args_opcnt, resp_opcnt, status, name), 131fff4080bSChuck Lever TP_STRUCT__entry( 132fff4080bSChuck Lever __field(u32, args_opcnt) 133fff4080bSChuck Lever __field(u32, resp_opcnt) 134fff4080bSChuck Lever __field(int, status) 135fff4080bSChuck Lever __string(name, name) 136fff4080bSChuck Lever ), 137fff4080bSChuck Lever TP_fast_assign( 138fff4080bSChuck Lever __entry->args_opcnt = args_opcnt; 139fff4080bSChuck Lever __entry->resp_opcnt = resp_opcnt; 140fff4080bSChuck Lever __entry->status = be32_to_cpu(status); 141fff4080bSChuck Lever __assign_str(name, name); 142fff4080bSChuck Lever ), 143fff4080bSChuck Lever TP_printk("op=%u/%u %s status=%d", 144fff4080bSChuck Lever __entry->resp_opcnt, __entry->args_opcnt, 145fff4080bSChuck Lever __get_str(name), __entry->status) 146fff4080bSChuck Lever ) 147fff4080bSChuck Lever 14808281341SChuck Lever TRACE_EVENT(nfsd_compound_decode_err, 14908281341SChuck Lever TP_PROTO( 15008281341SChuck Lever const struct svc_rqst *rqstp, 15108281341SChuck Lever u32 args_opcnt, 15208281341SChuck Lever u32 resp_opcnt, 15308281341SChuck Lever u32 opnum, 15408281341SChuck Lever __be32 status 15508281341SChuck Lever ), 15608281341SChuck Lever TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status), 15708281341SChuck Lever TP_STRUCT__entry( 15808281341SChuck Lever NFSD_TRACE_PROC_RES_FIELDS 15908281341SChuck Lever 16008281341SChuck Lever __field(u32, args_opcnt) 16108281341SChuck Lever __field(u32, resp_opcnt) 16208281341SChuck Lever __field(u32, opnum) 16308281341SChuck Lever ), 16408281341SChuck Lever TP_fast_assign( 16508281341SChuck Lever NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 16608281341SChuck Lever 16708281341SChuck Lever __entry->args_opcnt = args_opcnt; 16808281341SChuck Lever __entry->resp_opcnt = resp_opcnt; 16908281341SChuck Lever __entry->opnum = opnum; 17008281341SChuck Lever ), 17108281341SChuck Lever TP_printk("op=%u/%u opnum=%u status=%lu", 17208281341SChuck Lever __entry->resp_opcnt, __entry->args_opcnt, 17308281341SChuck Lever __entry->opnum, __entry->status) 17408281341SChuck Lever ); 17508281341SChuck Lever 17608281341SChuck Lever TRACE_EVENT(nfsd_compound_encode_err, 17708281341SChuck Lever TP_PROTO( 17808281341SChuck Lever const struct svc_rqst *rqstp, 17908281341SChuck Lever u32 opnum, 18008281341SChuck Lever __be32 status 18108281341SChuck Lever ), 18208281341SChuck Lever TP_ARGS(rqstp, opnum, status), 18308281341SChuck Lever TP_STRUCT__entry( 18408281341SChuck Lever NFSD_TRACE_PROC_RES_FIELDS 18508281341SChuck Lever 18608281341SChuck Lever __field(u32, opnum) 18708281341SChuck Lever ), 18808281341SChuck Lever TP_fast_assign( 18908281341SChuck Lever NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 19008281341SChuck Lever 19108281341SChuck Lever __entry->opnum = opnum; 19208281341SChuck Lever ), 19308281341SChuck Lever TP_printk("opnum=%u status=%lu", 19408281341SChuck Lever __entry->opnum, __entry->status) 19508281341SChuck Lever ); 19608281341SChuck Lever 19708281341SChuck Lever 198f01274a9STrond Myklebust DECLARE_EVENT_CLASS(nfsd_fh_err_class, 199f01274a9STrond Myklebust TP_PROTO(struct svc_rqst *rqstp, 200f01274a9STrond Myklebust struct svc_fh *fhp, 201f01274a9STrond Myklebust int status), 202f01274a9STrond Myklebust TP_ARGS(rqstp, fhp, status), 203f01274a9STrond Myklebust TP_STRUCT__entry( 204f01274a9STrond Myklebust __field(u32, xid) 205f01274a9STrond Myklebust __field(u32, fh_hash) 206f01274a9STrond Myklebust __field(int, status) 207f01274a9STrond Myklebust ), 208f01274a9STrond Myklebust TP_fast_assign( 209f01274a9STrond Myklebust __entry->xid = be32_to_cpu(rqstp->rq_xid); 210f01274a9STrond Myklebust __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 211f01274a9STrond Myklebust __entry->status = status; 212f01274a9STrond Myklebust ), 213f01274a9STrond Myklebust TP_printk("xid=0x%08x fh_hash=0x%08x status=%d", 214f01274a9STrond Myklebust __entry->xid, __entry->fh_hash, 215f01274a9STrond Myklebust __entry->status) 216f01274a9STrond Myklebust ) 217f01274a9STrond Myklebust 218f01274a9STrond Myklebust #define DEFINE_NFSD_FH_ERR_EVENT(name) \ 219f01274a9STrond Myklebust DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \ 220f01274a9STrond Myklebust TP_PROTO(struct svc_rqst *rqstp, \ 221f01274a9STrond Myklebust struct svc_fh *fhp, \ 222f01274a9STrond Myklebust int status), \ 223f01274a9STrond Myklebust TP_ARGS(rqstp, fhp, status)) 224f01274a9STrond Myklebust 225f01274a9STrond Myklebust DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport); 226f01274a9STrond Myklebust DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle); 227f01274a9STrond Myklebust 228cf749f3cSTrond Myklebust TRACE_EVENT(nfsd_exp_find_key, 229cf749f3cSTrond Myklebust TP_PROTO(const struct svc_expkey *key, 230cf749f3cSTrond Myklebust int status), 231cf749f3cSTrond Myklebust TP_ARGS(key, status), 232cf749f3cSTrond Myklebust TP_STRUCT__entry( 233cf749f3cSTrond Myklebust __field(int, fsidtype) 234cf749f3cSTrond Myklebust __array(u32, fsid, 6) 235cf749f3cSTrond Myklebust __string(auth_domain, key->ek_client->name) 236cf749f3cSTrond Myklebust __field(int, status) 237cf749f3cSTrond Myklebust ), 238cf749f3cSTrond Myklebust TP_fast_assign( 239cf749f3cSTrond Myklebust __entry->fsidtype = key->ek_fsidtype; 240cf749f3cSTrond Myklebust memcpy(__entry->fsid, key->ek_fsid, 4*6); 241cf749f3cSTrond Myklebust __assign_str(auth_domain, key->ek_client->name); 242cf749f3cSTrond Myklebust __entry->status = status; 243cf749f3cSTrond Myklebust ), 244cf749f3cSTrond Myklebust TP_printk("fsid=%x::%s domain=%s status=%d", 245cf749f3cSTrond Myklebust __entry->fsidtype, 246cf749f3cSTrond Myklebust __print_array(__entry->fsid, 6, 4), 247cf749f3cSTrond Myklebust __get_str(auth_domain), 248cf749f3cSTrond Myklebust __entry->status 249cf749f3cSTrond Myklebust ) 250cf749f3cSTrond Myklebust ); 251cf749f3cSTrond Myklebust 2526a30e47fSTrond Myklebust TRACE_EVENT(nfsd_expkey_update, 2536a30e47fSTrond Myklebust TP_PROTO(const struct svc_expkey *key, const char *exp_path), 2546a30e47fSTrond Myklebust TP_ARGS(key, exp_path), 2556a30e47fSTrond Myklebust TP_STRUCT__entry( 2566a30e47fSTrond Myklebust __field(int, fsidtype) 2576a30e47fSTrond Myklebust __array(u32, fsid, 6) 2586a30e47fSTrond Myklebust __string(auth_domain, key->ek_client->name) 2596a30e47fSTrond Myklebust __string(path, exp_path) 2606a30e47fSTrond Myklebust __field(bool, cache) 2616a30e47fSTrond Myklebust ), 2626a30e47fSTrond Myklebust TP_fast_assign( 2636a30e47fSTrond Myklebust __entry->fsidtype = key->ek_fsidtype; 2646a30e47fSTrond Myklebust memcpy(__entry->fsid, key->ek_fsid, 4*6); 2656a30e47fSTrond Myklebust __assign_str(auth_domain, key->ek_client->name); 2666a30e47fSTrond Myklebust __assign_str(path, exp_path); 2676a30e47fSTrond Myklebust __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 2686a30e47fSTrond Myklebust ), 2696a30e47fSTrond Myklebust TP_printk("fsid=%x::%s domain=%s path=%s cache=%s", 2706a30e47fSTrond Myklebust __entry->fsidtype, 2716a30e47fSTrond Myklebust __print_array(__entry->fsid, 6, 4), 2726a30e47fSTrond Myklebust __get_str(auth_domain), 2736a30e47fSTrond Myklebust __get_str(path), 2746a30e47fSTrond Myklebust __entry->cache ? "pos" : "neg" 2756a30e47fSTrond Myklebust ) 2766a30e47fSTrond Myklebust ); 2776a30e47fSTrond Myklebust 278cf749f3cSTrond Myklebust TRACE_EVENT(nfsd_exp_get_by_name, 279cf749f3cSTrond Myklebust TP_PROTO(const struct svc_export *key, 280cf749f3cSTrond Myklebust int status), 281cf749f3cSTrond Myklebust TP_ARGS(key, status), 282cf749f3cSTrond Myklebust TP_STRUCT__entry( 283cf749f3cSTrond Myklebust __string(path, key->ex_path.dentry->d_name.name) 284cf749f3cSTrond Myklebust __string(auth_domain, key->ex_client->name) 285cf749f3cSTrond Myklebust __field(int, status) 286cf749f3cSTrond Myklebust ), 287cf749f3cSTrond Myklebust TP_fast_assign( 288cf749f3cSTrond Myklebust __assign_str(path, key->ex_path.dentry->d_name.name); 289cf749f3cSTrond Myklebust __assign_str(auth_domain, key->ex_client->name); 290cf749f3cSTrond Myklebust __entry->status = status; 291cf749f3cSTrond Myklebust ), 292cf749f3cSTrond Myklebust TP_printk("path=%s domain=%s status=%d", 293cf749f3cSTrond Myklebust __get_str(path), 294cf749f3cSTrond Myklebust __get_str(auth_domain), 295cf749f3cSTrond Myklebust __entry->status 296cf749f3cSTrond Myklebust ) 297cf749f3cSTrond Myklebust ); 298cf749f3cSTrond Myklebust 2996a30e47fSTrond Myklebust TRACE_EVENT(nfsd_export_update, 3006a30e47fSTrond Myklebust TP_PROTO(const struct svc_export *key), 3016a30e47fSTrond Myklebust TP_ARGS(key), 3026a30e47fSTrond Myklebust TP_STRUCT__entry( 3036a30e47fSTrond Myklebust __string(path, key->ex_path.dentry->d_name.name) 3046a30e47fSTrond Myklebust __string(auth_domain, key->ex_client->name) 3056a30e47fSTrond Myklebust __field(bool, cache) 3066a30e47fSTrond Myklebust ), 3076a30e47fSTrond Myklebust TP_fast_assign( 3086a30e47fSTrond Myklebust __assign_str(path, key->ex_path.dentry->d_name.name); 3096a30e47fSTrond Myklebust __assign_str(auth_domain, key->ex_client->name); 3106a30e47fSTrond Myklebust __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 3116a30e47fSTrond Myklebust ), 3126a30e47fSTrond Myklebust TP_printk("path=%s domain=%s cache=%s", 3136a30e47fSTrond Myklebust __get_str(path), 3146a30e47fSTrond Myklebust __get_str(auth_domain), 3156a30e47fSTrond Myklebust __entry->cache ? "pos" : "neg" 3166a30e47fSTrond Myklebust ) 3176a30e47fSTrond Myklebust ); 3186a30e47fSTrond Myklebust 3196e8b50d1SJeff Layton DECLARE_EVENT_CLASS(nfsd_io_class, 3206e8b50d1SJeff Layton TP_PROTO(struct svc_rqst *rqstp, 3216e8b50d1SJeff Layton struct svc_fh *fhp, 3226e8b50d1SJeff Layton loff_t offset, 32379e0b4e2SChuck Lever unsigned long len), 3246e8b50d1SJeff Layton TP_ARGS(rqstp, fhp, offset, len), 3256e8b50d1SJeff Layton TP_STRUCT__entry( 326afa720a0SChuck Lever __field(u32, xid) 327afa720a0SChuck Lever __field(u32, fh_hash) 3286e8b50d1SJeff Layton __field(loff_t, offset) 32979e0b4e2SChuck Lever __field(unsigned long, len) 3306e8b50d1SJeff Layton ), 3316e8b50d1SJeff Layton TP_fast_assign( 332afa720a0SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 33379e0b4e2SChuck Lever __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 3346e8b50d1SJeff Layton __entry->offset = offset; 3356e8b50d1SJeff Layton __entry->len = len; 3366e8b50d1SJeff Layton ), 33779e0b4e2SChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld len=%lu", 338afa720a0SChuck Lever __entry->xid, __entry->fh_hash, 3396e8b50d1SJeff Layton __entry->offset, __entry->len) 3406e8b50d1SJeff Layton ) 3416e8b50d1SJeff Layton 3426e8b50d1SJeff Layton #define DEFINE_NFSD_IO_EVENT(name) \ 343f394b62bSChuck Lever DEFINE_EVENT(nfsd_io_class, nfsd_##name, \ 3446e8b50d1SJeff Layton TP_PROTO(struct svc_rqst *rqstp, \ 3456e8b50d1SJeff Layton struct svc_fh *fhp, \ 3466e8b50d1SJeff Layton loff_t offset, \ 34779e0b4e2SChuck Lever unsigned long len), \ 3486e8b50d1SJeff Layton TP_ARGS(rqstp, fhp, offset, len)) 3496e8b50d1SJeff Layton 3506e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_start); 35187c5942eSChuck Lever DEFINE_NFSD_IO_EVENT(read_splice); 35287c5942eSChuck Lever DEFINE_NFSD_IO_EVENT(read_vector); 3536e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_io_done); 3546e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(read_done); 3556e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_start); 3566e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_opened); 3576e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_io_done); 3586e8b50d1SJeff Layton DEFINE_NFSD_IO_EVENT(write_done); 35931ef83dcSChristoph Hellwig 360d890be15SChuck Lever DECLARE_EVENT_CLASS(nfsd_err_class, 361d890be15SChuck Lever TP_PROTO(struct svc_rqst *rqstp, 362d890be15SChuck Lever struct svc_fh *fhp, 363d890be15SChuck Lever loff_t offset, 364d890be15SChuck Lever int status), 365d890be15SChuck Lever TP_ARGS(rqstp, fhp, offset, status), 366d890be15SChuck Lever TP_STRUCT__entry( 367d890be15SChuck Lever __field(u32, xid) 368d890be15SChuck Lever __field(u32, fh_hash) 369d890be15SChuck Lever __field(loff_t, offset) 370d890be15SChuck Lever __field(int, status) 371d890be15SChuck Lever ), 372d890be15SChuck Lever TP_fast_assign( 373d890be15SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 374d890be15SChuck Lever __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 375d890be15SChuck Lever __entry->offset = offset; 376d890be15SChuck Lever __entry->status = status; 377d890be15SChuck Lever ), 378d890be15SChuck Lever TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d", 379d890be15SChuck Lever __entry->xid, __entry->fh_hash, 380d890be15SChuck Lever __entry->offset, __entry->status) 381d890be15SChuck Lever ) 382d890be15SChuck Lever 383d890be15SChuck Lever #define DEFINE_NFSD_ERR_EVENT(name) \ 384d890be15SChuck Lever DEFINE_EVENT(nfsd_err_class, nfsd_##name, \ 385d890be15SChuck Lever TP_PROTO(struct svc_rqst *rqstp, \ 386d890be15SChuck Lever struct svc_fh *fhp, \ 387d890be15SChuck Lever loff_t offset, \ 388d890be15SChuck Lever int len), \ 389d890be15SChuck Lever TP_ARGS(rqstp, fhp, offset, len)) 390d890be15SChuck Lever 39187c5942eSChuck Lever DEFINE_NFSD_ERR_EVENT(read_err); 392d890be15SChuck Lever DEFINE_NFSD_ERR_EVENT(write_err); 393d890be15SChuck Lever 3946019ce07SChuck Lever TRACE_EVENT(nfsd_dirent, 3956019ce07SChuck Lever TP_PROTO(struct svc_fh *fhp, 3966019ce07SChuck Lever u64 ino, 3976019ce07SChuck Lever const char *name, 3986019ce07SChuck Lever int namlen), 3996019ce07SChuck Lever TP_ARGS(fhp, ino, name, namlen), 4006019ce07SChuck Lever TP_STRUCT__entry( 4016019ce07SChuck Lever __field(u32, fh_hash) 4026019ce07SChuck Lever __field(u64, ino) 403*408c0de7SChuck Lever __string_len(name, name, namlen) 4046019ce07SChuck Lever ), 4056019ce07SChuck Lever TP_fast_assign( 4066019ce07SChuck Lever __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0; 4076019ce07SChuck Lever __entry->ino = ino; 408*408c0de7SChuck Lever __assign_str_len(name, name, namlen) 4096019ce07SChuck Lever ), 410*408c0de7SChuck Lever TP_printk("fh_hash=0x%08x ino=%llu name=%s", 411*408c0de7SChuck Lever __entry->fh_hash, __entry->ino, __get_str(name) 412*408c0de7SChuck Lever ) 4136019ce07SChuck Lever ) 4146019ce07SChuck Lever 415825213e5SJeff Layton #include "state.h" 41665294c1fSJeff Layton #include "filecache.h" 41765294c1fSJeff Layton #include "vfs.h" 418825213e5SJeff Layton 41931ef83dcSChristoph Hellwig DECLARE_EVENT_CLASS(nfsd_stateid_class, 42031ef83dcSChristoph Hellwig TP_PROTO(stateid_t *stp), 42131ef83dcSChristoph Hellwig TP_ARGS(stp), 42231ef83dcSChristoph Hellwig TP_STRUCT__entry( 42331ef83dcSChristoph Hellwig __field(u32, cl_boot) 42431ef83dcSChristoph Hellwig __field(u32, cl_id) 42531ef83dcSChristoph Hellwig __field(u32, si_id) 42631ef83dcSChristoph Hellwig __field(u32, si_generation) 42731ef83dcSChristoph Hellwig ), 42831ef83dcSChristoph Hellwig TP_fast_assign( 42931ef83dcSChristoph Hellwig __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 43031ef83dcSChristoph Hellwig __entry->cl_id = stp->si_opaque.so_clid.cl_id; 43131ef83dcSChristoph Hellwig __entry->si_id = stp->si_opaque.so_id; 43231ef83dcSChristoph Hellwig __entry->si_generation = stp->si_generation; 43331ef83dcSChristoph Hellwig ), 43431ef83dcSChristoph Hellwig TP_printk("client %08x:%08x stateid %08x:%08x", 43531ef83dcSChristoph Hellwig __entry->cl_boot, 43631ef83dcSChristoph Hellwig __entry->cl_id, 43731ef83dcSChristoph Hellwig __entry->si_id, 43831ef83dcSChristoph Hellwig __entry->si_generation) 43931ef83dcSChristoph Hellwig ) 44031ef83dcSChristoph Hellwig 44131ef83dcSChristoph Hellwig #define DEFINE_STATEID_EVENT(name) \ 442f394b62bSChuck Lever DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \ 44331ef83dcSChristoph Hellwig TP_PROTO(stateid_t *stp), \ 44431ef83dcSChristoph Hellwig TP_ARGS(stp)) 445dd5e3fbcSChuck Lever 44631ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_alloc); 44731ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_unhash); 44831ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layoutstate_free); 44931ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_get_lookup_fail); 45031ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_commit_lookup_fail); 45131ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_return_lookup_fail); 45231ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall); 45331ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_done); 45431ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_fail); 45531ef83dcSChristoph Hellwig DEFINE_STATEID_EVENT(layout_recall_release); 45631ef83dcSChristoph Hellwig 4573caf9175SHou Tao DEFINE_STATEID_EVENT(open); 4583caf9175SHou Tao DEFINE_STATEID_EVENT(deleg_read); 459dd5e3fbcSChuck Lever DEFINE_STATEID_EVENT(deleg_recall); 460dd5e3fbcSChuck Lever 461dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_stateseqid_class, 462dd5e3fbcSChuck Lever TP_PROTO(u32 seqid, const stateid_t *stp), 463dd5e3fbcSChuck Lever TP_ARGS(seqid, stp), 464dd5e3fbcSChuck Lever TP_STRUCT__entry( 465dd5e3fbcSChuck Lever __field(u32, seqid) 466dd5e3fbcSChuck Lever __field(u32, cl_boot) 467dd5e3fbcSChuck Lever __field(u32, cl_id) 468dd5e3fbcSChuck Lever __field(u32, si_id) 469dd5e3fbcSChuck Lever __field(u32, si_generation) 470dd5e3fbcSChuck Lever ), 471dd5e3fbcSChuck Lever TP_fast_assign( 472dd5e3fbcSChuck Lever __entry->seqid = seqid; 473dd5e3fbcSChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 474dd5e3fbcSChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 475dd5e3fbcSChuck Lever __entry->si_id = stp->si_opaque.so_id; 476dd5e3fbcSChuck Lever __entry->si_generation = stp->si_generation; 477dd5e3fbcSChuck Lever ), 478dd5e3fbcSChuck Lever TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x", 479dd5e3fbcSChuck Lever __entry->seqid, __entry->cl_boot, __entry->cl_id, 480dd5e3fbcSChuck Lever __entry->si_id, __entry->si_generation) 481dd5e3fbcSChuck Lever ) 482dd5e3fbcSChuck Lever 483dd5e3fbcSChuck Lever #define DEFINE_STATESEQID_EVENT(name) \ 484dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \ 485dd5e3fbcSChuck Lever TP_PROTO(u32 seqid, const stateid_t *stp), \ 486dd5e3fbcSChuck Lever TP_ARGS(seqid, stp)) 487dd5e3fbcSChuck Lever 488dd5e3fbcSChuck Lever DEFINE_STATESEQID_EVENT(preprocess); 489dd5e3fbcSChuck Lever DEFINE_STATESEQID_EVENT(open_confirm); 490dd5e3fbcSChuck Lever 491dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_clientid_class, 492dd5e3fbcSChuck Lever TP_PROTO(const clientid_t *clid), 493dd5e3fbcSChuck Lever TP_ARGS(clid), 494dd5e3fbcSChuck Lever TP_STRUCT__entry( 495dd5e3fbcSChuck Lever __field(u32, cl_boot) 496dd5e3fbcSChuck Lever __field(u32, cl_id) 497dd5e3fbcSChuck Lever ), 498dd5e3fbcSChuck Lever TP_fast_assign( 499dd5e3fbcSChuck Lever __entry->cl_boot = clid->cl_boot; 500dd5e3fbcSChuck Lever __entry->cl_id = clid->cl_id; 501dd5e3fbcSChuck Lever ), 502dd5e3fbcSChuck Lever TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 503dd5e3fbcSChuck Lever ) 504dd5e3fbcSChuck Lever 505dd5e3fbcSChuck Lever #define DEFINE_CLIENTID_EVENT(name) \ 506dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 507dd5e3fbcSChuck Lever TP_PROTO(const clientid_t *clid), \ 508dd5e3fbcSChuck Lever TP_ARGS(clid)) 509dd5e3fbcSChuck Lever 510237f91c8SChuck Lever DEFINE_CLIENTID_EVENT(expire_unconf); 511cee8aa07SChuck Lever DEFINE_CLIENTID_EVENT(reclaim_complete); 5127e3b32acSChuck Lever DEFINE_CLIENTID_EVENT(confirmed); 513c41a9b7aSChuck Lever DEFINE_CLIENTID_EVENT(destroyed); 5142958d2eeSChuck Lever DEFINE_CLIENTID_EVENT(admin_expired); 5152958d2eeSChuck Lever DEFINE_CLIENTID_EVENT(replaced); 516dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(purged); 517dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(renew); 518dd5e3fbcSChuck Lever DEFINE_CLIENTID_EVENT(stale); 519dd5e3fbcSChuck Lever 520dd5e3fbcSChuck Lever DECLARE_EVENT_CLASS(nfsd_net_class, 521dd5e3fbcSChuck Lever TP_PROTO(const struct nfsd_net *nn), 522dd5e3fbcSChuck Lever TP_ARGS(nn), 523dd5e3fbcSChuck Lever TP_STRUCT__entry( 524dd5e3fbcSChuck Lever __field(unsigned long long, boot_time) 525dd5e3fbcSChuck Lever ), 526dd5e3fbcSChuck Lever TP_fast_assign( 527dd5e3fbcSChuck Lever __entry->boot_time = nn->boot_time; 528dd5e3fbcSChuck Lever ), 529dd5e3fbcSChuck Lever TP_printk("boot_time=%16llx", __entry->boot_time) 530dd5e3fbcSChuck Lever ) 531dd5e3fbcSChuck Lever 532dd5e3fbcSChuck Lever #define DEFINE_NET_EVENT(name) \ 533dd5e3fbcSChuck Lever DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 534dd5e3fbcSChuck Lever TP_PROTO(const struct nfsd_net *nn), \ 535dd5e3fbcSChuck Lever TP_ARGS(nn)) 536dd5e3fbcSChuck Lever 537dd5e3fbcSChuck Lever DEFINE_NET_EVENT(grace_start); 538dd5e3fbcSChuck Lever DEFINE_NET_EVENT(grace_complete); 539dd5e3fbcSChuck Lever 54027787733SChuck Lever TRACE_EVENT(nfsd_clid_cred_mismatch, 54127787733SChuck Lever TP_PROTO( 54227787733SChuck Lever const struct nfs4_client *clp, 54327787733SChuck Lever const struct svc_rqst *rqstp 54427787733SChuck Lever ), 54527787733SChuck Lever TP_ARGS(clp, rqstp), 54627787733SChuck Lever TP_STRUCT__entry( 54727787733SChuck Lever __field(u32, cl_boot) 54827787733SChuck Lever __field(u32, cl_id) 54927787733SChuck Lever __field(unsigned long, cl_flavor) 55027787733SChuck Lever __field(unsigned long, new_flavor) 55127787733SChuck Lever __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 55227787733SChuck Lever ), 55327787733SChuck Lever TP_fast_assign( 55427787733SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 55527787733SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 55627787733SChuck Lever __entry->cl_flavor = clp->cl_cred.cr_flavor; 55727787733SChuck Lever __entry->new_flavor = rqstp->rq_cred.cr_flavor; 55827787733SChuck Lever memcpy(__entry->addr, &rqstp->rq_xprt->xpt_remote, 55927787733SChuck Lever sizeof(struct sockaddr_in6)); 56027787733SChuck Lever ), 56127787733SChuck Lever TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc", 56227787733SChuck Lever __entry->cl_boot, __entry->cl_id, 56327787733SChuck Lever show_nfsd_authflavor(__entry->cl_flavor), 56427787733SChuck Lever show_nfsd_authflavor(__entry->new_flavor), __entry->addr 56527787733SChuck Lever ) 56627787733SChuck Lever ) 56727787733SChuck Lever 568744ea54cSChuck Lever TRACE_EVENT(nfsd_clid_verf_mismatch, 569744ea54cSChuck Lever TP_PROTO( 570744ea54cSChuck Lever const struct nfs4_client *clp, 571744ea54cSChuck Lever const struct svc_rqst *rqstp, 572744ea54cSChuck Lever const nfs4_verifier *verf 573744ea54cSChuck Lever ), 574744ea54cSChuck Lever TP_ARGS(clp, rqstp, verf), 575744ea54cSChuck Lever TP_STRUCT__entry( 576744ea54cSChuck Lever __field(u32, cl_boot) 577744ea54cSChuck Lever __field(u32, cl_id) 578744ea54cSChuck Lever __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE) 579744ea54cSChuck Lever __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE) 580744ea54cSChuck Lever __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 581744ea54cSChuck Lever ), 582744ea54cSChuck Lever TP_fast_assign( 583744ea54cSChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 584744ea54cSChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 585744ea54cSChuck Lever memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier, 586744ea54cSChuck Lever NFS4_VERIFIER_SIZE); 587744ea54cSChuck Lever memcpy(__entry->new_verifier, (void *)verf, 588744ea54cSChuck Lever NFS4_VERIFIER_SIZE); 589744ea54cSChuck Lever memcpy(__entry->addr, &rqstp->rq_xprt->xpt_remote, 590744ea54cSChuck Lever sizeof(struct sockaddr_in6)); 591744ea54cSChuck Lever ), 592744ea54cSChuck Lever TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc", 593744ea54cSChuck Lever __entry->cl_boot, __entry->cl_id, 594744ea54cSChuck Lever __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE), 595744ea54cSChuck Lever __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE), 596744ea54cSChuck Lever __entry->addr 597744ea54cSChuck Lever ) 598744ea54cSChuck Lever ); 599744ea54cSChuck Lever 600237f91c8SChuck Lever DECLARE_EVENT_CLASS(nfsd_clid_class, 601237f91c8SChuck Lever TP_PROTO(const struct nfs4_client *clp), 602237f91c8SChuck Lever TP_ARGS(clp), 603237f91c8SChuck Lever TP_STRUCT__entry( 604237f91c8SChuck Lever __field(u32, cl_boot) 605237f91c8SChuck Lever __field(u32, cl_id) 606237f91c8SChuck Lever __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 607237f91c8SChuck Lever __field(unsigned long, flavor) 608237f91c8SChuck Lever __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 609237f91c8SChuck Lever __dynamic_array(char, name, clp->cl_name.len + 1) 610237f91c8SChuck Lever ), 611237f91c8SChuck Lever TP_fast_assign( 612237f91c8SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 613237f91c8SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 614237f91c8SChuck Lever memcpy(__entry->addr, &clp->cl_addr, 615237f91c8SChuck Lever sizeof(struct sockaddr_in6)); 616237f91c8SChuck Lever __entry->flavor = clp->cl_cred.cr_flavor; 617237f91c8SChuck Lever memcpy(__entry->verifier, (void *)&clp->cl_verifier, 618237f91c8SChuck Lever NFS4_VERIFIER_SIZE); 619237f91c8SChuck Lever memcpy(__get_str(name), clp->cl_name.data, clp->cl_name.len); 620237f91c8SChuck Lever __get_str(name)[clp->cl_name.len] = '\0'; 621237f91c8SChuck Lever ), 622237f91c8SChuck Lever TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x", 623237f91c8SChuck Lever __entry->addr, __get_str(name), 624237f91c8SChuck Lever __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE), 625237f91c8SChuck Lever show_nfsd_authflavor(__entry->flavor), 626237f91c8SChuck Lever __entry->cl_boot, __entry->cl_id) 627237f91c8SChuck Lever ); 628237f91c8SChuck Lever 629237f91c8SChuck Lever #define DEFINE_CLID_EVENT(name) \ 630237f91c8SChuck Lever DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 631237f91c8SChuck Lever TP_PROTO(const struct nfs4_client *clp), \ 632237f91c8SChuck Lever TP_ARGS(clp)) 633237f91c8SChuck Lever 634237f91c8SChuck Lever DEFINE_CLID_EVENT(fresh); 635e8f80c55SChuck Lever DEFINE_CLID_EVENT(confirmed_r); 636237f91c8SChuck Lever 637b76278aeSChuck Lever /* 638b76278aeSChuck Lever * from fs/nfsd/filecache.h 639b76278aeSChuck Lever */ 640c1928559STrond Myklebust TRACE_DEFINE_ENUM(NFSD_FILE_HASHED); 641c1928559STrond Myklebust TRACE_DEFINE_ENUM(NFSD_FILE_PENDING); 642c1928559STrond Myklebust TRACE_DEFINE_ENUM(NFSD_FILE_BREAK_READ); 643c1928559STrond Myklebust TRACE_DEFINE_ENUM(NFSD_FILE_BREAK_WRITE); 644c1928559STrond Myklebust TRACE_DEFINE_ENUM(NFSD_FILE_REFERENCED); 645c1928559STrond Myklebust 64665294c1fSJeff Layton #define show_nf_flags(val) \ 64765294c1fSJeff Layton __print_flags(val, "|", \ 64865294c1fSJeff Layton { 1 << NFSD_FILE_HASHED, "HASHED" }, \ 64965294c1fSJeff Layton { 1 << NFSD_FILE_PENDING, "PENDING" }, \ 65065294c1fSJeff Layton { 1 << NFSD_FILE_BREAK_READ, "BREAK_READ" }, \ 65165294c1fSJeff Layton { 1 << NFSD_FILE_BREAK_WRITE, "BREAK_WRITE" }, \ 65265294c1fSJeff Layton { 1 << NFSD_FILE_REFERENCED, "REFERENCED"}) 65365294c1fSJeff Layton 65465294c1fSJeff Layton DECLARE_EVENT_CLASS(nfsd_file_class, 65565294c1fSJeff Layton TP_PROTO(struct nfsd_file *nf), 65665294c1fSJeff Layton TP_ARGS(nf), 65765294c1fSJeff Layton TP_STRUCT__entry( 65865294c1fSJeff Layton __field(unsigned int, nf_hashval) 65965294c1fSJeff Layton __field(void *, nf_inode) 66065294c1fSJeff Layton __field(int, nf_ref) 66165294c1fSJeff Layton __field(unsigned long, nf_flags) 66265294c1fSJeff Layton __field(unsigned char, nf_may) 66365294c1fSJeff Layton __field(struct file *, nf_file) 66465294c1fSJeff Layton ), 66565294c1fSJeff Layton TP_fast_assign( 66665294c1fSJeff Layton __entry->nf_hashval = nf->nf_hashval; 66765294c1fSJeff Layton __entry->nf_inode = nf->nf_inode; 668689827cdSTrond Myklebust __entry->nf_ref = refcount_read(&nf->nf_ref); 66965294c1fSJeff Layton __entry->nf_flags = nf->nf_flags; 67065294c1fSJeff Layton __entry->nf_may = nf->nf_may; 67165294c1fSJeff Layton __entry->nf_file = nf->nf_file; 67265294c1fSJeff Layton ), 6733a90e1dfSChuck Lever TP_printk("hash=0x%x inode=%p ref=%d flags=%s may=%s file=%p", 67465294c1fSJeff Layton __entry->nf_hashval, 67565294c1fSJeff Layton __entry->nf_inode, 67665294c1fSJeff Layton __entry->nf_ref, 67765294c1fSJeff Layton show_nf_flags(__entry->nf_flags), 678b76278aeSChuck Lever show_nfsd_may_flags(__entry->nf_may), 67965294c1fSJeff Layton __entry->nf_file) 68065294c1fSJeff Layton ) 68165294c1fSJeff Layton 68265294c1fSJeff Layton #define DEFINE_NFSD_FILE_EVENT(name) \ 68365294c1fSJeff Layton DEFINE_EVENT(nfsd_file_class, name, \ 68465294c1fSJeff Layton TP_PROTO(struct nfsd_file *nf), \ 68565294c1fSJeff Layton TP_ARGS(nf)) 68665294c1fSJeff Layton 68765294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_alloc); 68865294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_put_final); 68965294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 69065294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 69165294c1fSJeff Layton DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_release_locked); 69265294c1fSJeff Layton 69365294c1fSJeff Layton TRACE_EVENT(nfsd_file_acquire, 69465294c1fSJeff Layton TP_PROTO(struct svc_rqst *rqstp, unsigned int hash, 69565294c1fSJeff Layton struct inode *inode, unsigned int may_flags, 69665294c1fSJeff Layton struct nfsd_file *nf, __be32 status), 69765294c1fSJeff Layton 69865294c1fSJeff Layton TP_ARGS(rqstp, hash, inode, may_flags, nf, status), 69965294c1fSJeff Layton 70065294c1fSJeff Layton TP_STRUCT__entry( 701a9ceb060STrond Myklebust __field(u32, xid) 70265294c1fSJeff Layton __field(unsigned int, hash) 70365294c1fSJeff Layton __field(void *, inode) 704b76278aeSChuck Lever __field(unsigned long, may_flags) 70565294c1fSJeff Layton __field(int, nf_ref) 70665294c1fSJeff Layton __field(unsigned long, nf_flags) 707b76278aeSChuck Lever __field(unsigned long, nf_may) 70865294c1fSJeff Layton __field(struct file *, nf_file) 709a9ceb060STrond Myklebust __field(u32, status) 71065294c1fSJeff Layton ), 71165294c1fSJeff Layton 71265294c1fSJeff Layton TP_fast_assign( 713a9ceb060STrond Myklebust __entry->xid = be32_to_cpu(rqstp->rq_xid); 71465294c1fSJeff Layton __entry->hash = hash; 71565294c1fSJeff Layton __entry->inode = inode; 71665294c1fSJeff Layton __entry->may_flags = may_flags; 717689827cdSTrond Myklebust __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 71865294c1fSJeff Layton __entry->nf_flags = nf ? nf->nf_flags : 0; 71965294c1fSJeff Layton __entry->nf_may = nf ? nf->nf_may : 0; 72065294c1fSJeff Layton __entry->nf_file = nf ? nf->nf_file : NULL; 721a9ceb060STrond Myklebust __entry->status = be32_to_cpu(status); 72265294c1fSJeff Layton ), 72365294c1fSJeff Layton 7243a90e1dfSChuck 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", 725a9ceb060STrond Myklebust __entry->xid, __entry->hash, __entry->inode, 726b76278aeSChuck Lever show_nfsd_may_flags(__entry->may_flags), 727b76278aeSChuck Lever __entry->nf_ref, show_nf_flags(__entry->nf_flags), 728b76278aeSChuck Lever show_nfsd_may_flags(__entry->nf_may), 729b76278aeSChuck Lever __entry->nf_file, __entry->status) 73065294c1fSJeff Layton ); 73165294c1fSJeff Layton 73265294c1fSJeff Layton DECLARE_EVENT_CLASS(nfsd_file_search_class, 73365294c1fSJeff Layton TP_PROTO(struct inode *inode, unsigned int hash, int found), 73465294c1fSJeff Layton TP_ARGS(inode, hash, found), 73565294c1fSJeff Layton TP_STRUCT__entry( 73665294c1fSJeff Layton __field(struct inode *, inode) 73765294c1fSJeff Layton __field(unsigned int, hash) 73865294c1fSJeff Layton __field(int, found) 73965294c1fSJeff Layton ), 74065294c1fSJeff Layton TP_fast_assign( 74165294c1fSJeff Layton __entry->inode = inode; 74265294c1fSJeff Layton __entry->hash = hash; 74365294c1fSJeff Layton __entry->found = found; 74465294c1fSJeff Layton ), 7453a90e1dfSChuck Lever TP_printk("hash=0x%x inode=%p found=%d", __entry->hash, 74665294c1fSJeff Layton __entry->inode, __entry->found) 74765294c1fSJeff Layton ); 74865294c1fSJeff Layton 74965294c1fSJeff Layton #define DEFINE_NFSD_FILE_SEARCH_EVENT(name) \ 75065294c1fSJeff Layton DEFINE_EVENT(nfsd_file_search_class, name, \ 75165294c1fSJeff Layton TP_PROTO(struct inode *inode, unsigned int hash, int found), \ 75265294c1fSJeff Layton TP_ARGS(inode, hash, found)) 75365294c1fSJeff Layton 75465294c1fSJeff Layton DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode_sync); 75565294c1fSJeff Layton DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode); 75665294c1fSJeff Layton DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_is_cached); 75765294c1fSJeff Layton 75865294c1fSJeff Layton TRACE_EVENT(nfsd_file_fsnotify_handle_event, 75965294c1fSJeff Layton TP_PROTO(struct inode *inode, u32 mask), 76065294c1fSJeff Layton TP_ARGS(inode, mask), 76165294c1fSJeff Layton TP_STRUCT__entry( 76265294c1fSJeff Layton __field(struct inode *, inode) 76365294c1fSJeff Layton __field(unsigned int, nlink) 76465294c1fSJeff Layton __field(umode_t, mode) 76565294c1fSJeff Layton __field(u32, mask) 76665294c1fSJeff Layton ), 76765294c1fSJeff Layton TP_fast_assign( 76865294c1fSJeff Layton __entry->inode = inode; 76965294c1fSJeff Layton __entry->nlink = inode->i_nlink; 77065294c1fSJeff Layton __entry->mode = inode->i_mode; 77165294c1fSJeff Layton __entry->mask = mask; 77265294c1fSJeff Layton ), 7733a90e1dfSChuck Lever TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 77465294c1fSJeff Layton __entry->nlink, __entry->mode, __entry->mask) 77565294c1fSJeff Layton ); 77665294c1fSJeff Layton 7770b175b18SChuck Lever #include "cache.h" 7780b175b18SChuck Lever 7790b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_DROPIT); 7800b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_REPLY); 7810b175b18SChuck Lever TRACE_DEFINE_ENUM(RC_DOIT); 7820b175b18SChuck Lever 7830b175b18SChuck Lever #define show_drc_retval(x) \ 7840b175b18SChuck Lever __print_symbolic(x, \ 7850b175b18SChuck Lever { RC_DROPIT, "DROPIT" }, \ 7860b175b18SChuck Lever { RC_REPLY, "REPLY" }, \ 7870b175b18SChuck Lever { RC_DOIT, "DOIT" }) 7880b175b18SChuck Lever 7890b175b18SChuck Lever TRACE_EVENT(nfsd_drc_found, 7900b175b18SChuck Lever TP_PROTO( 7910b175b18SChuck Lever const struct nfsd_net *nn, 7920b175b18SChuck Lever const struct svc_rqst *rqstp, 7930b175b18SChuck Lever int result 7940b175b18SChuck Lever ), 7950b175b18SChuck Lever TP_ARGS(nn, rqstp, result), 7960b175b18SChuck Lever TP_STRUCT__entry( 7970b175b18SChuck Lever __field(unsigned long long, boot_time) 7980b175b18SChuck Lever __field(unsigned long, result) 7990b175b18SChuck Lever __field(u32, xid) 8000b175b18SChuck Lever ), 8010b175b18SChuck Lever TP_fast_assign( 8020b175b18SChuck Lever __entry->boot_time = nn->boot_time; 8030b175b18SChuck Lever __entry->result = result; 8040b175b18SChuck Lever __entry->xid = be32_to_cpu(rqstp->rq_xid); 8050b175b18SChuck Lever ), 8060b175b18SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x result=%s", 8070b175b18SChuck Lever __entry->boot_time, __entry->xid, 8080b175b18SChuck Lever show_drc_retval(__entry->result)) 8090b175b18SChuck Lever 8100b175b18SChuck Lever ); 8110b175b18SChuck Lever 8120b175b18SChuck Lever TRACE_EVENT(nfsd_drc_mismatch, 8130b175b18SChuck Lever TP_PROTO( 8140b175b18SChuck Lever const struct nfsd_net *nn, 8150b175b18SChuck Lever const struct svc_cacherep *key, 8160b175b18SChuck Lever const struct svc_cacherep *rp 8170b175b18SChuck Lever ), 8180b175b18SChuck Lever TP_ARGS(nn, key, rp), 8190b175b18SChuck Lever TP_STRUCT__entry( 8200b175b18SChuck Lever __field(unsigned long long, boot_time) 8210b175b18SChuck Lever __field(u32, xid) 8220b175b18SChuck Lever __field(u32, cached) 8230b175b18SChuck Lever __field(u32, ingress) 8240b175b18SChuck Lever ), 8250b175b18SChuck Lever TP_fast_assign( 8260b175b18SChuck Lever __entry->boot_time = nn->boot_time; 8270b175b18SChuck Lever __entry->xid = be32_to_cpu(key->c_key.k_xid); 8280b175b18SChuck Lever __entry->cached = (__force u32)key->c_key.k_csum; 8290b175b18SChuck Lever __entry->ingress = (__force u32)rp->c_key.k_csum; 8300b175b18SChuck Lever ), 8310b175b18SChuck Lever TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 8320b175b18SChuck Lever __entry->boot_time, __entry->xid, __entry->cached, 8330b175b18SChuck Lever __entry->ingress) 8340b175b18SChuck Lever ); 8350b175b18SChuck Lever 8361eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_args, 8371eace0d1SChuck Lever TP_PROTO( 8381eace0d1SChuck Lever const struct nfs4_client *clp, 8391eace0d1SChuck Lever const struct nfs4_cb_conn *conn 8401eace0d1SChuck Lever ), 8411eace0d1SChuck Lever TP_ARGS(clp, conn), 8421eace0d1SChuck Lever TP_STRUCT__entry( 8431eace0d1SChuck Lever __field(u32, cl_boot) 8441eace0d1SChuck Lever __field(u32, cl_id) 8451eace0d1SChuck Lever __field(u32, prog) 8461eace0d1SChuck Lever __field(u32, ident) 8471eace0d1SChuck Lever __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 8481eace0d1SChuck Lever ), 8491eace0d1SChuck Lever TP_fast_assign( 8501eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 8511eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 8521eace0d1SChuck Lever __entry->prog = conn->cb_prog; 8531eace0d1SChuck Lever __entry->ident = conn->cb_ident; 8541eace0d1SChuck Lever memcpy(__entry->addr, &conn->cb_addr, 8551eace0d1SChuck Lever sizeof(struct sockaddr_in6)); 8561eace0d1SChuck Lever ), 857d6cbe98fSChuck Lever TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 858d6cbe98fSChuck Lever __entry->addr, __entry->cl_boot, __entry->cl_id, 859d6cbe98fSChuck Lever __entry->prog, __entry->ident) 8601eace0d1SChuck Lever ); 8611eace0d1SChuck Lever 8621eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_nodelegs, 8631eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), 8641eace0d1SChuck Lever TP_ARGS(clp), 8651eace0d1SChuck Lever TP_STRUCT__entry( 8661eace0d1SChuck Lever __field(u32, cl_boot) 8671eace0d1SChuck Lever __field(u32, cl_id) 8681eace0d1SChuck Lever ), 8691eace0d1SChuck Lever TP_fast_assign( 8701eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 8711eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 8721eace0d1SChuck Lever ), 8731eace0d1SChuck Lever TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 8741eace0d1SChuck Lever ) 8751eace0d1SChuck Lever 8761eace0d1SChuck Lever #define show_cb_state(val) \ 8771eace0d1SChuck Lever __print_symbolic(val, \ 8781eace0d1SChuck Lever { NFSD4_CB_UP, "UP" }, \ 8791eace0d1SChuck Lever { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 8801eace0d1SChuck Lever { NFSD4_CB_DOWN, "DOWN" }, \ 8811eace0d1SChuck Lever { NFSD4_CB_FAULT, "FAULT"}) 8821eace0d1SChuck Lever 8831eace0d1SChuck Lever DECLARE_EVENT_CLASS(nfsd_cb_class, 8841eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), 8851eace0d1SChuck Lever TP_ARGS(clp), 8861eace0d1SChuck Lever TP_STRUCT__entry( 8871eace0d1SChuck Lever __field(unsigned long, state) 8881eace0d1SChuck Lever __field(u32, cl_boot) 8891eace0d1SChuck Lever __field(u32, cl_id) 8901eace0d1SChuck Lever __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 8911eace0d1SChuck Lever ), 8921eace0d1SChuck Lever TP_fast_assign( 8931eace0d1SChuck Lever __entry->state = clp->cl_cb_state; 8941eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 8951eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 8961eace0d1SChuck Lever memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr, 8971eace0d1SChuck Lever sizeof(struct sockaddr_in6)); 8981eace0d1SChuck Lever ), 8991eace0d1SChuck Lever TP_printk("addr=%pISpc client %08x:%08x state=%s", 9001eace0d1SChuck Lever __entry->addr, __entry->cl_boot, __entry->cl_id, 9011eace0d1SChuck Lever show_cb_state(__entry->state)) 9021eace0d1SChuck Lever ); 9031eace0d1SChuck Lever 9041eace0d1SChuck Lever #define DEFINE_NFSD_CB_EVENT(name) \ 9051eace0d1SChuck Lever DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 9061eace0d1SChuck Lever TP_PROTO(const struct nfs4_client *clp), \ 9071eace0d1SChuck Lever TP_ARGS(clp)) 9081eace0d1SChuck Lever 9091eace0d1SChuck Lever DEFINE_NFSD_CB_EVENT(state); 9104ade892aSChuck Lever DEFINE_NFSD_CB_EVENT(probe); 911806d65b6SChuck Lever DEFINE_NFSD_CB_EVENT(lost); 9121eace0d1SChuck Lever DEFINE_NFSD_CB_EVENT(shutdown); 9131eace0d1SChuck Lever 91487b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 91587b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 91687b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 91787b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 91887b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 91987b2394dSChuck Lever TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 92087b2394dSChuck Lever 92187b2394dSChuck Lever #define show_nfsd_authflavor(val) \ 92287b2394dSChuck Lever __print_symbolic(val, \ 92387b2394dSChuck Lever { RPC_AUTH_NULL, "none" }, \ 92487b2394dSChuck Lever { RPC_AUTH_UNIX, "sys" }, \ 92587b2394dSChuck Lever { RPC_AUTH_GSS, "gss" }, \ 92687b2394dSChuck Lever { RPC_AUTH_GSS_KRB5, "krb5" }, \ 92787b2394dSChuck Lever { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 92887b2394dSChuck Lever { RPC_AUTH_GSS_KRB5P, "krb5p" }) 92987b2394dSChuck Lever 9303c92fba5SChuck Lever TRACE_EVENT(nfsd_cb_setup, 9313c92fba5SChuck Lever TP_PROTO(const struct nfs4_client *clp, 9323c92fba5SChuck Lever const char *netid, 9333c92fba5SChuck Lever rpc_authflavor_t authflavor 9343c92fba5SChuck Lever ), 9353c92fba5SChuck Lever TP_ARGS(clp, netid, authflavor), 9363c92fba5SChuck Lever TP_STRUCT__entry( 9373c92fba5SChuck Lever __field(u32, cl_boot) 9383c92fba5SChuck Lever __field(u32, cl_id) 9393c92fba5SChuck Lever __field(unsigned long, authflavor) 9403c92fba5SChuck Lever __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 9413c92fba5SChuck Lever __array(unsigned char, netid, 8) 9423c92fba5SChuck Lever ), 9433c92fba5SChuck Lever TP_fast_assign( 9443c92fba5SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 9453c92fba5SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 9463c92fba5SChuck Lever strlcpy(__entry->netid, netid, sizeof(__entry->netid)); 9473c92fba5SChuck Lever __entry->authflavor = authflavor; 9483c92fba5SChuck Lever memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr, 9493c92fba5SChuck Lever sizeof(struct sockaddr_in6)); 9503c92fba5SChuck Lever ), 9513c92fba5SChuck Lever TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 9523c92fba5SChuck Lever __entry->addr, __entry->cl_boot, __entry->cl_id, 9533c92fba5SChuck Lever __entry->netid, show_nfsd_authflavor(__entry->authflavor)) 9543c92fba5SChuck Lever ); 9553c92fba5SChuck Lever 9561eace0d1SChuck Lever TRACE_EVENT(nfsd_cb_setup_err, 9571eace0d1SChuck Lever TP_PROTO( 9581eace0d1SChuck Lever const struct nfs4_client *clp, 9591eace0d1SChuck Lever long error 9601eace0d1SChuck Lever ), 9611eace0d1SChuck Lever TP_ARGS(clp, error), 9621eace0d1SChuck Lever TP_STRUCT__entry( 9631eace0d1SChuck Lever __field(long, error) 9641eace0d1SChuck Lever __field(u32, cl_boot) 9651eace0d1SChuck Lever __field(u32, cl_id) 9661eace0d1SChuck Lever __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 9671eace0d1SChuck Lever ), 9681eace0d1SChuck Lever TP_fast_assign( 9691eace0d1SChuck Lever __entry->error = error; 9701eace0d1SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 9711eace0d1SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 9721eace0d1SChuck Lever memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr, 9731eace0d1SChuck Lever sizeof(struct sockaddr_in6)); 9741eace0d1SChuck Lever ), 9751eace0d1SChuck Lever TP_printk("addr=%pISpc client %08x:%08x error=%ld", 9761eace0d1SChuck Lever __entry->addr, __entry->cl_boot, __entry->cl_id, __entry->error) 9771eace0d1SChuck Lever ); 9781eace0d1SChuck Lever 97917d76ddfSChuck Lever TRACE_EVENT(nfsd_cb_recall, 98017d76ddfSChuck Lever TP_PROTO( 98117d76ddfSChuck Lever const struct nfs4_stid *stid 98217d76ddfSChuck Lever ), 98317d76ddfSChuck Lever TP_ARGS(stid), 98417d76ddfSChuck Lever TP_STRUCT__entry( 98517d76ddfSChuck Lever __field(u32, cl_boot) 98617d76ddfSChuck Lever __field(u32, cl_id) 98717d76ddfSChuck Lever __field(u32, si_id) 98817d76ddfSChuck Lever __field(u32, si_generation) 98917d76ddfSChuck Lever __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 99017d76ddfSChuck Lever ), 99117d76ddfSChuck Lever TP_fast_assign( 99217d76ddfSChuck Lever const stateid_t *stp = &stid->sc_stateid; 99317d76ddfSChuck Lever const struct nfs4_client *clp = stid->sc_client; 99417d76ddfSChuck Lever 99517d76ddfSChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 99617d76ddfSChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 99717d76ddfSChuck Lever __entry->si_id = stp->si_opaque.so_id; 99817d76ddfSChuck Lever __entry->si_generation = stp->si_generation; 99917d76ddfSChuck Lever if (clp) 100017d76ddfSChuck Lever memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr, 100117d76ddfSChuck Lever sizeof(struct sockaddr_in6)); 100217d76ddfSChuck Lever else 100317d76ddfSChuck Lever memset(__entry->addr, 0, sizeof(struct sockaddr_in6)); 100417d76ddfSChuck Lever ), 100517d76ddfSChuck Lever TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 100617d76ddfSChuck Lever __entry->addr, __entry->cl_boot, __entry->cl_id, 100717d76ddfSChuck Lever __entry->si_id, __entry->si_generation) 100817d76ddfSChuck Lever ); 100917d76ddfSChuck Lever 10102cde7f81SChuck Lever TRACE_EVENT(nfsd_cb_notify_lock, 10112cde7f81SChuck Lever TP_PROTO( 10122cde7f81SChuck Lever const struct nfs4_lockowner *lo, 10132cde7f81SChuck Lever const struct nfsd4_blocked_lock *nbl 10142cde7f81SChuck Lever ), 10152cde7f81SChuck Lever TP_ARGS(lo, nbl), 10162cde7f81SChuck Lever TP_STRUCT__entry( 10172cde7f81SChuck Lever __field(u32, cl_boot) 10182cde7f81SChuck Lever __field(u32, cl_id) 10192cde7f81SChuck Lever __field(u32, fh_hash) 10202cde7f81SChuck Lever __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 10212cde7f81SChuck Lever ), 10222cde7f81SChuck Lever TP_fast_assign( 10232cde7f81SChuck Lever const struct nfs4_client *clp = lo->lo_owner.so_client; 10242cde7f81SChuck Lever 10252cde7f81SChuck Lever __entry->cl_boot = clp->cl_clientid.cl_boot; 10262cde7f81SChuck Lever __entry->cl_id = clp->cl_clientid.cl_id; 10272cde7f81SChuck Lever __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 10282cde7f81SChuck Lever memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr, 10292cde7f81SChuck Lever sizeof(struct sockaddr_in6)); 10302cde7f81SChuck Lever ), 10312cde7f81SChuck Lever TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 10322cde7f81SChuck Lever __entry->addr, __entry->cl_boot, __entry->cl_id, 10332cde7f81SChuck Lever __entry->fh_hash) 10342cde7f81SChuck Lever ); 10352cde7f81SChuck Lever 103687512386SChuck Lever TRACE_EVENT(nfsd_cb_offload, 103787512386SChuck Lever TP_PROTO( 103887512386SChuck Lever const struct nfs4_client *clp, 103987512386SChuck Lever const stateid_t *stp, 104087512386SChuck Lever const struct knfsd_fh *fh, 104187512386SChuck Lever u64 count, 104287512386SChuck Lever __be32 status 104387512386SChuck Lever ), 104487512386SChuck Lever TP_ARGS(clp, stp, fh, count, status), 104587512386SChuck Lever TP_STRUCT__entry( 104687512386SChuck Lever __field(u32, cl_boot) 104787512386SChuck Lever __field(u32, cl_id) 104887512386SChuck Lever __field(u32, si_id) 104987512386SChuck Lever __field(u32, si_generation) 105087512386SChuck Lever __field(u32, fh_hash) 105187512386SChuck Lever __field(int, status) 105287512386SChuck Lever __field(u64, count) 105387512386SChuck Lever __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 105487512386SChuck Lever ), 105587512386SChuck Lever TP_fast_assign( 105687512386SChuck Lever __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 105787512386SChuck Lever __entry->cl_id = stp->si_opaque.so_clid.cl_id; 105887512386SChuck Lever __entry->si_id = stp->si_opaque.so_id; 105987512386SChuck Lever __entry->si_generation = stp->si_generation; 106087512386SChuck Lever __entry->fh_hash = knfsd_fh_hash(fh); 106187512386SChuck Lever __entry->status = be32_to_cpu(status); 106287512386SChuck Lever __entry->count = count; 106387512386SChuck Lever memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr, 106487512386SChuck Lever sizeof(struct sockaddr_in6)); 106587512386SChuck Lever ), 106687512386SChuck Lever TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 106787512386SChuck Lever __entry->addr, __entry->cl_boot, __entry->cl_id, 106887512386SChuck Lever __entry->si_id, __entry->si_generation, 106987512386SChuck Lever __entry->fh_hash, __entry->count, __entry->status) 107087512386SChuck Lever ); 107187512386SChuck Lever 107231ef83dcSChristoph Hellwig #endif /* _NFSD_TRACE_H */ 107331ef83dcSChristoph Hellwig 107431ef83dcSChristoph Hellwig #undef TRACE_INCLUDE_PATH 107531ef83dcSChristoph Hellwig #define TRACE_INCLUDE_PATH . 107631ef83dcSChristoph Hellwig #define TRACE_INCLUDE_FILE trace 107731ef83dcSChristoph Hellwig #include <trace/define_trace.h> 1078