Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 /*
0003  * Copyright (c) 2014 Christoph Hellwig.
0004  */
0005 #undef TRACE_SYSTEM
0006 #define TRACE_SYSTEM nfsd
0007 
0008 #if !defined(_NFSD_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
0009 #define _NFSD_TRACE_H
0010 
0011 #include <linux/tracepoint.h>
0012 
0013 #include "export.h"
0014 #include "nfsfh.h"
0015 
0016 #define NFSD_TRACE_PROC_RES_FIELDS \
0017         __field(unsigned int, netns_ino) \
0018         __field(u32, xid) \
0019         __field(unsigned long, status) \
0020         __array(unsigned char, server, sizeof(struct sockaddr_in6)) \
0021         __array(unsigned char, client, sizeof(struct sockaddr_in6))
0022 
0023 #define NFSD_TRACE_PROC_RES_ASSIGNMENTS(error) \
0024         do { \
0025             __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \
0026             __entry->xid = be32_to_cpu(rqstp->rq_xid); \
0027             __entry->status = be32_to_cpu(error); \
0028             memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \
0029                    rqstp->rq_xprt->xpt_locallen); \
0030             memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \
0031                    rqstp->rq_xprt->xpt_remotelen); \
0032         } while (0);
0033 
0034 DECLARE_EVENT_CLASS(nfsd_xdr_err_class,
0035     TP_PROTO(
0036         const struct svc_rqst *rqstp
0037     ),
0038     TP_ARGS(rqstp),
0039     TP_STRUCT__entry(
0040         __field(unsigned int, netns_ino)
0041         __field(u32, xid)
0042         __field(u32, vers)
0043         __field(u32, proc)
0044         __sockaddr(server, rqstp->rq_xprt->xpt_locallen)
0045         __sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
0046     ),
0047     TP_fast_assign(
0048         const struct svc_xprt *xprt = rqstp->rq_xprt;
0049 
0050         __entry->netns_ino = xprt->xpt_net->ns.inum;
0051         __entry->xid = be32_to_cpu(rqstp->rq_xid);
0052         __entry->vers = rqstp->rq_vers;
0053         __entry->proc = rqstp->rq_proc;
0054         __assign_sockaddr(server, &xprt->xpt_local, xprt->xpt_locallen);
0055         __assign_sockaddr(client, &xprt->xpt_remote, xprt->xpt_remotelen);
0056     ),
0057     TP_printk("xid=0x%08x vers=%u proc=%u",
0058         __entry->xid, __entry->vers, __entry->proc
0059     )
0060 );
0061 
0062 #define DEFINE_NFSD_XDR_ERR_EVENT(name) \
0063 DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \
0064     TP_PROTO(const struct svc_rqst *rqstp), \
0065     TP_ARGS(rqstp))
0066 
0067 DEFINE_NFSD_XDR_ERR_EVENT(garbage_args);
0068 DEFINE_NFSD_XDR_ERR_EVENT(cant_encode);
0069 
0070 #define show_nfsd_may_flags(x)                      \
0071     __print_flags(x, "|",                       \
0072         { NFSD_MAY_EXEC,        "EXEC" },       \
0073         { NFSD_MAY_WRITE,       "WRITE" },      \
0074         { NFSD_MAY_READ,        "READ" },       \
0075         { NFSD_MAY_SATTR,       "SATTR" },      \
0076         { NFSD_MAY_TRUNC,       "TRUNC" },      \
0077         { NFSD_MAY_LOCK,        "LOCK" },       \
0078         { NFSD_MAY_OWNER_OVERRIDE,  "OWNER_OVERRIDE" }, \
0079         { NFSD_MAY_LOCAL_ACCESS,    "LOCAL_ACCESS" },   \
0080         { NFSD_MAY_BYPASS_GSS_ON_ROOT,  "BYPASS_GSS_ON_ROOT" }, \
0081         { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" },    \
0082         { NFSD_MAY_BYPASS_GSS,      "BYPASS_GSS" },     \
0083         { NFSD_MAY_READ_IF_EXEC,    "READ_IF_EXEC" },   \
0084         { NFSD_MAY_64BIT_COOKIE,    "64BIT_COOKIE" })
0085 
0086 TRACE_EVENT(nfsd_compound,
0087     TP_PROTO(const struct svc_rqst *rqst,
0088          u32 args_opcnt),
0089     TP_ARGS(rqst, args_opcnt),
0090     TP_STRUCT__entry(
0091         __field(u32, xid)
0092         __field(u32, args_opcnt)
0093     ),
0094     TP_fast_assign(
0095         __entry->xid = be32_to_cpu(rqst->rq_xid);
0096         __entry->args_opcnt = args_opcnt;
0097     ),
0098     TP_printk("xid=0x%08x opcnt=%u",
0099         __entry->xid, __entry->args_opcnt)
0100 )
0101 
0102 TRACE_EVENT(nfsd_compound_status,
0103     TP_PROTO(u32 args_opcnt,
0104          u32 resp_opcnt,
0105          __be32 status,
0106          const char *name),
0107     TP_ARGS(args_opcnt, resp_opcnt, status, name),
0108     TP_STRUCT__entry(
0109         __field(u32, args_opcnt)
0110         __field(u32, resp_opcnt)
0111         __field(int, status)
0112         __string(name, name)
0113     ),
0114     TP_fast_assign(
0115         __entry->args_opcnt = args_opcnt;
0116         __entry->resp_opcnt = resp_opcnt;
0117         __entry->status = be32_to_cpu(status);
0118         __assign_str(name, name);
0119     ),
0120     TP_printk("op=%u/%u %s status=%d",
0121         __entry->resp_opcnt, __entry->args_opcnt,
0122         __get_str(name), __entry->status)
0123 )
0124 
0125 TRACE_EVENT(nfsd_compound_decode_err,
0126     TP_PROTO(
0127         const struct svc_rqst *rqstp,
0128         u32 args_opcnt,
0129         u32 resp_opcnt,
0130         u32 opnum,
0131         __be32 status
0132     ),
0133     TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status),
0134     TP_STRUCT__entry(
0135         NFSD_TRACE_PROC_RES_FIELDS
0136 
0137         __field(u32, args_opcnt)
0138         __field(u32, resp_opcnt)
0139         __field(u32, opnum)
0140     ),
0141     TP_fast_assign(
0142         NFSD_TRACE_PROC_RES_ASSIGNMENTS(status)
0143 
0144         __entry->args_opcnt = args_opcnt;
0145         __entry->resp_opcnt = resp_opcnt;
0146         __entry->opnum = opnum;
0147     ),
0148     TP_printk("op=%u/%u opnum=%u status=%lu",
0149         __entry->resp_opcnt, __entry->args_opcnt,
0150         __entry->opnum, __entry->status)
0151 );
0152 
0153 TRACE_EVENT(nfsd_compound_encode_err,
0154     TP_PROTO(
0155         const struct svc_rqst *rqstp,
0156         u32 opnum,
0157         __be32 status
0158     ),
0159     TP_ARGS(rqstp, opnum, status),
0160     TP_STRUCT__entry(
0161         NFSD_TRACE_PROC_RES_FIELDS
0162 
0163         __field(u32, opnum)
0164     ),
0165     TP_fast_assign(
0166         NFSD_TRACE_PROC_RES_ASSIGNMENTS(status)
0167 
0168         __entry->opnum = opnum;
0169     ),
0170     TP_printk("opnum=%u status=%lu",
0171         __entry->opnum, __entry->status)
0172 );
0173 
0174 #define show_fs_file_type(x) \
0175     __print_symbolic(x, \
0176         { S_IFLNK,      "LNK" }, \
0177         { S_IFREG,      "REG" }, \
0178         { S_IFDIR,      "DIR" }, \
0179         { S_IFCHR,      "CHR" }, \
0180         { S_IFBLK,      "BLK" }, \
0181         { S_IFIFO,      "FIFO" }, \
0182         { S_IFSOCK,     "SOCK" })
0183 
0184 TRACE_EVENT(nfsd_fh_verify,
0185     TP_PROTO(
0186         const struct svc_rqst *rqstp,
0187         const struct svc_fh *fhp,
0188         umode_t type,
0189         int access
0190     ),
0191     TP_ARGS(rqstp, fhp, type, access),
0192     TP_STRUCT__entry(
0193         __field(unsigned int, netns_ino)
0194         __sockaddr(server, rqstp->rq_xprt->xpt_remotelen)
0195         __sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
0196         __field(u32, xid)
0197         __field(u32, fh_hash)
0198         __field(void *, inode)
0199         __field(unsigned long, type)
0200         __field(unsigned long, access)
0201     ),
0202     TP_fast_assign(
0203         __entry->netns_ino = SVC_NET(rqstp)->ns.inum;
0204         __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local,
0205                rqstp->rq_xprt->xpt_locallen);
0206         __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote,
0207                   rqstp->rq_xprt->xpt_remotelen);
0208         __entry->xid = be32_to_cpu(rqstp->rq_xid);
0209         __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
0210         __entry->inode = d_inode(fhp->fh_dentry);
0211         __entry->type = type;
0212         __entry->access = access;
0213     ),
0214     TP_printk("xid=0x%08x fh_hash=0x%08x inode=%p type=%s access=%s",
0215         __entry->xid, __entry->fh_hash, __entry->inode,
0216         show_fs_file_type(__entry->type),
0217         show_nfsd_may_flags(__entry->access)
0218     )
0219 );
0220 
0221 DECLARE_EVENT_CLASS(nfsd_fh_err_class,
0222     TP_PROTO(struct svc_rqst *rqstp,
0223          struct svc_fh  *fhp,
0224          int        status),
0225     TP_ARGS(rqstp, fhp, status),
0226     TP_STRUCT__entry(
0227         __field(u32, xid)
0228         __field(u32, fh_hash)
0229         __field(int, status)
0230     ),
0231     TP_fast_assign(
0232         __entry->xid = be32_to_cpu(rqstp->rq_xid);
0233         __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
0234         __entry->status = status;
0235     ),
0236     TP_printk("xid=0x%08x fh_hash=0x%08x status=%d",
0237           __entry->xid, __entry->fh_hash,
0238           __entry->status)
0239 )
0240 
0241 #define DEFINE_NFSD_FH_ERR_EVENT(name)      \
0242 DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name,    \
0243     TP_PROTO(struct svc_rqst *rqstp,    \
0244          struct svc_fh  *fhp,       \
0245          int        status),    \
0246     TP_ARGS(rqstp, fhp, status))
0247 
0248 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport);
0249 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle);
0250 
0251 TRACE_EVENT(nfsd_exp_find_key,
0252     TP_PROTO(const struct svc_expkey *key,
0253          int status),
0254     TP_ARGS(key, status),
0255     TP_STRUCT__entry(
0256         __field(int, fsidtype)
0257         __array(u32, fsid, 6)
0258         __string(auth_domain, key->ek_client->name)
0259         __field(int, status)
0260     ),
0261     TP_fast_assign(
0262         __entry->fsidtype = key->ek_fsidtype;
0263         memcpy(__entry->fsid, key->ek_fsid, 4*6);
0264         __assign_str(auth_domain, key->ek_client->name);
0265         __entry->status = status;
0266     ),
0267     TP_printk("fsid=%x::%s domain=%s status=%d",
0268         __entry->fsidtype,
0269         __print_array(__entry->fsid, 6, 4),
0270         __get_str(auth_domain),
0271         __entry->status
0272     )
0273 );
0274 
0275 TRACE_EVENT(nfsd_expkey_update,
0276     TP_PROTO(const struct svc_expkey *key, const char *exp_path),
0277     TP_ARGS(key, exp_path),
0278     TP_STRUCT__entry(
0279         __field(int, fsidtype)
0280         __array(u32, fsid, 6)
0281         __string(auth_domain, key->ek_client->name)
0282         __string(path, exp_path)
0283         __field(bool, cache)
0284     ),
0285     TP_fast_assign(
0286         __entry->fsidtype = key->ek_fsidtype;
0287         memcpy(__entry->fsid, key->ek_fsid, 4*6);
0288         __assign_str(auth_domain, key->ek_client->name);
0289         __assign_str(path, exp_path);
0290         __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags);
0291     ),
0292     TP_printk("fsid=%x::%s domain=%s path=%s cache=%s",
0293         __entry->fsidtype,
0294         __print_array(__entry->fsid, 6, 4),
0295         __get_str(auth_domain),
0296         __get_str(path),
0297         __entry->cache ? "pos" : "neg"
0298     )
0299 );
0300 
0301 TRACE_EVENT(nfsd_exp_get_by_name,
0302     TP_PROTO(const struct svc_export *key,
0303          int status),
0304     TP_ARGS(key, status),
0305     TP_STRUCT__entry(
0306         __string(path, key->ex_path.dentry->d_name.name)
0307         __string(auth_domain, key->ex_client->name)
0308         __field(int, status)
0309     ),
0310     TP_fast_assign(
0311         __assign_str(path, key->ex_path.dentry->d_name.name);
0312         __assign_str(auth_domain, key->ex_client->name);
0313         __entry->status = status;
0314     ),
0315     TP_printk("path=%s domain=%s status=%d",
0316         __get_str(path),
0317         __get_str(auth_domain),
0318         __entry->status
0319     )
0320 );
0321 
0322 TRACE_EVENT(nfsd_export_update,
0323     TP_PROTO(const struct svc_export *key),
0324     TP_ARGS(key),
0325     TP_STRUCT__entry(
0326         __string(path, key->ex_path.dentry->d_name.name)
0327         __string(auth_domain, key->ex_client->name)
0328         __field(bool, cache)
0329     ),
0330     TP_fast_assign(
0331         __assign_str(path, key->ex_path.dentry->d_name.name);
0332         __assign_str(auth_domain, key->ex_client->name);
0333         __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags);
0334     ),
0335     TP_printk("path=%s domain=%s cache=%s",
0336         __get_str(path),
0337         __get_str(auth_domain),
0338         __entry->cache ? "pos" : "neg"
0339     )
0340 );
0341 
0342 DECLARE_EVENT_CLASS(nfsd_io_class,
0343     TP_PROTO(struct svc_rqst *rqstp,
0344          struct svc_fh  *fhp,
0345          u64        offset,
0346          u32        len),
0347     TP_ARGS(rqstp, fhp, offset, len),
0348     TP_STRUCT__entry(
0349         __field(u32, xid)
0350         __field(u32, fh_hash)
0351         __field(u64, offset)
0352         __field(u32, len)
0353     ),
0354     TP_fast_assign(
0355         __entry->xid = be32_to_cpu(rqstp->rq_xid);
0356         __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
0357         __entry->offset = offset;
0358         __entry->len = len;
0359     ),
0360     TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u",
0361           __entry->xid, __entry->fh_hash,
0362           __entry->offset, __entry->len)
0363 )
0364 
0365 #define DEFINE_NFSD_IO_EVENT(name)      \
0366 DEFINE_EVENT(nfsd_io_class, nfsd_##name,    \
0367     TP_PROTO(struct svc_rqst *rqstp,    \
0368          struct svc_fh  *fhp,       \
0369          u64        offset,     \
0370          u32        len),       \
0371     TP_ARGS(rqstp, fhp, offset, len))
0372 
0373 DEFINE_NFSD_IO_EVENT(read_start);
0374 DEFINE_NFSD_IO_EVENT(read_splice);
0375 DEFINE_NFSD_IO_EVENT(read_vector);
0376 DEFINE_NFSD_IO_EVENT(read_io_done);
0377 DEFINE_NFSD_IO_EVENT(read_done);
0378 DEFINE_NFSD_IO_EVENT(write_start);
0379 DEFINE_NFSD_IO_EVENT(write_opened);
0380 DEFINE_NFSD_IO_EVENT(write_io_done);
0381 DEFINE_NFSD_IO_EVENT(write_done);
0382 
0383 DECLARE_EVENT_CLASS(nfsd_err_class,
0384     TP_PROTO(struct svc_rqst *rqstp,
0385          struct svc_fh  *fhp,
0386          loff_t     offset,
0387          int        status),
0388     TP_ARGS(rqstp, fhp, offset, status),
0389     TP_STRUCT__entry(
0390         __field(u32, xid)
0391         __field(u32, fh_hash)
0392         __field(loff_t, offset)
0393         __field(int, status)
0394     ),
0395     TP_fast_assign(
0396         __entry->xid = be32_to_cpu(rqstp->rq_xid);
0397         __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
0398         __entry->offset = offset;
0399         __entry->status = status;
0400     ),
0401     TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d",
0402           __entry->xid, __entry->fh_hash,
0403           __entry->offset, __entry->status)
0404 )
0405 
0406 #define DEFINE_NFSD_ERR_EVENT(name)     \
0407 DEFINE_EVENT(nfsd_err_class, nfsd_##name,   \
0408     TP_PROTO(struct svc_rqst *rqstp,    \
0409          struct svc_fh  *fhp,       \
0410          loff_t     offset,     \
0411          int        len),       \
0412     TP_ARGS(rqstp, fhp, offset, len))
0413 
0414 DEFINE_NFSD_ERR_EVENT(read_err);
0415 DEFINE_NFSD_ERR_EVENT(write_err);
0416 
0417 TRACE_EVENT(nfsd_dirent,
0418     TP_PROTO(struct svc_fh *fhp,
0419          u64 ino,
0420          const char *name,
0421          int namlen),
0422     TP_ARGS(fhp, ino, name, namlen),
0423     TP_STRUCT__entry(
0424         __field(u32, fh_hash)
0425         __field(u64, ino)
0426         __string_len(name, name, namlen)
0427     ),
0428     TP_fast_assign(
0429         __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0;
0430         __entry->ino = ino;
0431         __assign_str_len(name, name, namlen)
0432     ),
0433     TP_printk("fh_hash=0x%08x ino=%llu name=%s",
0434         __entry->fh_hash, __entry->ino, __get_str(name)
0435     )
0436 )
0437 
0438 DECLARE_EVENT_CLASS(nfsd_copy_err_class,
0439     TP_PROTO(struct svc_rqst *rqstp,
0440          struct svc_fh  *src_fhp,
0441          loff_t     src_offset,
0442          struct svc_fh  *dst_fhp,
0443          loff_t     dst_offset,
0444          u64        count,
0445          int        status),
0446     TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status),
0447     TP_STRUCT__entry(
0448         __field(u32, xid)
0449         __field(u32, src_fh_hash)
0450         __field(loff_t, src_offset)
0451         __field(u32, dst_fh_hash)
0452         __field(loff_t, dst_offset)
0453         __field(u64, count)
0454         __field(int, status)
0455     ),
0456     TP_fast_assign(
0457         __entry->xid = be32_to_cpu(rqstp->rq_xid);
0458         __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle);
0459         __entry->src_offset = src_offset;
0460         __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle);
0461         __entry->dst_offset = dst_offset;
0462         __entry->count = count;
0463         __entry->status = status;
0464     ),
0465     TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld "
0466             "dst_fh_hash=0x%08x dst_offset=%lld "
0467             "count=%llu status=%d",
0468           __entry->xid, __entry->src_fh_hash, __entry->src_offset,
0469           __entry->dst_fh_hash, __entry->dst_offset,
0470           (unsigned long long)__entry->count,
0471           __entry->status)
0472 )
0473 
0474 #define DEFINE_NFSD_COPY_ERR_EVENT(name)        \
0475 DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name,      \
0476     TP_PROTO(struct svc_rqst    *rqstp,     \
0477          struct svc_fh      *src_fhp,   \
0478          loff_t         src_offset, \
0479          struct svc_fh      *dst_fhp,   \
0480          loff_t         dst_offset, \
0481          u64            count,      \
0482          int            status),    \
0483     TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \
0484         count, status))
0485 
0486 DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err);
0487 
0488 #include "state.h"
0489 #include "filecache.h"
0490 #include "vfs.h"
0491 
0492 DECLARE_EVENT_CLASS(nfsd_stateid_class,
0493     TP_PROTO(stateid_t *stp),
0494     TP_ARGS(stp),
0495     TP_STRUCT__entry(
0496         __field(u32, cl_boot)
0497         __field(u32, cl_id)
0498         __field(u32, si_id)
0499         __field(u32, si_generation)
0500     ),
0501     TP_fast_assign(
0502         __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
0503         __entry->cl_id = stp->si_opaque.so_clid.cl_id;
0504         __entry->si_id = stp->si_opaque.so_id;
0505         __entry->si_generation = stp->si_generation;
0506     ),
0507     TP_printk("client %08x:%08x stateid %08x:%08x",
0508         __entry->cl_boot,
0509         __entry->cl_id,
0510         __entry->si_id,
0511         __entry->si_generation)
0512 )
0513 
0514 #define DEFINE_STATEID_EVENT(name) \
0515 DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \
0516     TP_PROTO(stateid_t *stp), \
0517     TP_ARGS(stp))
0518 
0519 DEFINE_STATEID_EVENT(layoutstate_alloc);
0520 DEFINE_STATEID_EVENT(layoutstate_unhash);
0521 DEFINE_STATEID_EVENT(layoutstate_free);
0522 DEFINE_STATEID_EVENT(layout_get_lookup_fail);
0523 DEFINE_STATEID_EVENT(layout_commit_lookup_fail);
0524 DEFINE_STATEID_EVENT(layout_return_lookup_fail);
0525 DEFINE_STATEID_EVENT(layout_recall);
0526 DEFINE_STATEID_EVENT(layout_recall_done);
0527 DEFINE_STATEID_EVENT(layout_recall_fail);
0528 DEFINE_STATEID_EVENT(layout_recall_release);
0529 
0530 DEFINE_STATEID_EVENT(open);
0531 DEFINE_STATEID_EVENT(deleg_read);
0532 DEFINE_STATEID_EVENT(deleg_recall);
0533 
0534 DECLARE_EVENT_CLASS(nfsd_stateseqid_class,
0535     TP_PROTO(u32 seqid, const stateid_t *stp),
0536     TP_ARGS(seqid, stp),
0537     TP_STRUCT__entry(
0538         __field(u32, seqid)
0539         __field(u32, cl_boot)
0540         __field(u32, cl_id)
0541         __field(u32, si_id)
0542         __field(u32, si_generation)
0543     ),
0544     TP_fast_assign(
0545         __entry->seqid = seqid;
0546         __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
0547         __entry->cl_id = stp->si_opaque.so_clid.cl_id;
0548         __entry->si_id = stp->si_opaque.so_id;
0549         __entry->si_generation = stp->si_generation;
0550     ),
0551     TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x",
0552         __entry->seqid, __entry->cl_boot, __entry->cl_id,
0553         __entry->si_id, __entry->si_generation)
0554 )
0555 
0556 #define DEFINE_STATESEQID_EVENT(name) \
0557 DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \
0558     TP_PROTO(u32 seqid, const stateid_t *stp), \
0559     TP_ARGS(seqid, stp))
0560 
0561 DEFINE_STATESEQID_EVENT(preprocess);
0562 DEFINE_STATESEQID_EVENT(open_confirm);
0563 
0564 DECLARE_EVENT_CLASS(nfsd_clientid_class,
0565     TP_PROTO(const clientid_t *clid),
0566     TP_ARGS(clid),
0567     TP_STRUCT__entry(
0568         __field(u32, cl_boot)
0569         __field(u32, cl_id)
0570     ),
0571     TP_fast_assign(
0572         __entry->cl_boot = clid->cl_boot;
0573         __entry->cl_id = clid->cl_id;
0574     ),
0575     TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
0576 )
0577 
0578 #define DEFINE_CLIENTID_EVENT(name) \
0579 DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \
0580     TP_PROTO(const clientid_t *clid), \
0581     TP_ARGS(clid))
0582 
0583 DEFINE_CLIENTID_EVENT(expire_unconf);
0584 DEFINE_CLIENTID_EVENT(reclaim_complete);
0585 DEFINE_CLIENTID_EVENT(confirmed);
0586 DEFINE_CLIENTID_EVENT(destroyed);
0587 DEFINE_CLIENTID_EVENT(admin_expired);
0588 DEFINE_CLIENTID_EVENT(replaced);
0589 DEFINE_CLIENTID_EVENT(purged);
0590 DEFINE_CLIENTID_EVENT(renew);
0591 DEFINE_CLIENTID_EVENT(stale);
0592 
0593 DECLARE_EVENT_CLASS(nfsd_net_class,
0594     TP_PROTO(const struct nfsd_net *nn),
0595     TP_ARGS(nn),
0596     TP_STRUCT__entry(
0597         __field(unsigned long long, boot_time)
0598     ),
0599     TP_fast_assign(
0600         __entry->boot_time = nn->boot_time;
0601     ),
0602     TP_printk("boot_time=%16llx", __entry->boot_time)
0603 )
0604 
0605 #define DEFINE_NET_EVENT(name) \
0606 DEFINE_EVENT(nfsd_net_class, nfsd_##name, \
0607     TP_PROTO(const struct nfsd_net *nn), \
0608     TP_ARGS(nn))
0609 
0610 DEFINE_NET_EVENT(grace_start);
0611 DEFINE_NET_EVENT(grace_complete);
0612 
0613 TRACE_EVENT(nfsd_writeverf_reset,
0614     TP_PROTO(
0615         const struct nfsd_net *nn,
0616         const struct svc_rqst *rqstp,
0617         int error
0618     ),
0619     TP_ARGS(nn, rqstp, error),
0620     TP_STRUCT__entry(
0621         __field(unsigned long long, boot_time)
0622         __field(u32, xid)
0623         __field(int, error)
0624         __array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
0625     ),
0626     TP_fast_assign(
0627         __entry->boot_time = nn->boot_time;
0628         __entry->xid = be32_to_cpu(rqstp->rq_xid);
0629         __entry->error = error;
0630 
0631         /* avoid seqlock inside TP_fast_assign */
0632         memcpy(__entry->verifier, nn->writeverf,
0633                NFS4_VERIFIER_SIZE);
0634     ),
0635     TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s",
0636         __entry->boot_time, __entry->xid, __entry->error,
0637         __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE)
0638     )
0639 );
0640 
0641 TRACE_EVENT(nfsd_clid_cred_mismatch,
0642     TP_PROTO(
0643         const struct nfs4_client *clp,
0644         const struct svc_rqst *rqstp
0645     ),
0646     TP_ARGS(clp, rqstp),
0647     TP_STRUCT__entry(
0648         __field(u32, cl_boot)
0649         __field(u32, cl_id)
0650         __field(unsigned long, cl_flavor)
0651         __field(unsigned long, new_flavor)
0652         __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
0653     ),
0654     TP_fast_assign(
0655         __entry->cl_boot = clp->cl_clientid.cl_boot;
0656         __entry->cl_id = clp->cl_clientid.cl_id;
0657         __entry->cl_flavor = clp->cl_cred.cr_flavor;
0658         __entry->new_flavor = rqstp->rq_cred.cr_flavor;
0659         __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
0660                   rqstp->rq_xprt->xpt_remotelen);
0661     ),
0662     TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc",
0663         __entry->cl_boot, __entry->cl_id,
0664         show_nfsd_authflavor(__entry->cl_flavor),
0665         show_nfsd_authflavor(__entry->new_flavor),
0666         __get_sockaddr(addr)
0667     )
0668 )
0669 
0670 TRACE_EVENT(nfsd_clid_verf_mismatch,
0671     TP_PROTO(
0672         const struct nfs4_client *clp,
0673         const struct svc_rqst *rqstp,
0674         const nfs4_verifier *verf
0675     ),
0676     TP_ARGS(clp, rqstp, verf),
0677     TP_STRUCT__entry(
0678         __field(u32, cl_boot)
0679         __field(u32, cl_id)
0680         __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE)
0681         __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE)
0682         __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
0683     ),
0684     TP_fast_assign(
0685         __entry->cl_boot = clp->cl_clientid.cl_boot;
0686         __entry->cl_id = clp->cl_clientid.cl_id;
0687         memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier,
0688                NFS4_VERIFIER_SIZE);
0689         memcpy(__entry->new_verifier, (void *)verf,
0690                NFS4_VERIFIER_SIZE);
0691         __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
0692                   rqstp->rq_xprt->xpt_remotelen);
0693     ),
0694     TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc",
0695         __entry->cl_boot, __entry->cl_id,
0696         __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE),
0697         __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE),
0698         __get_sockaddr(addr)
0699     )
0700 );
0701 
0702 DECLARE_EVENT_CLASS(nfsd_clid_class,
0703     TP_PROTO(const struct nfs4_client *clp),
0704     TP_ARGS(clp),
0705     TP_STRUCT__entry(
0706         __field(u32, cl_boot)
0707         __field(u32, cl_id)
0708         __array(unsigned char, addr, sizeof(struct sockaddr_in6))
0709         __field(unsigned long, flavor)
0710         __array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
0711         __string_len(name, name, clp->cl_name.len)
0712     ),
0713     TP_fast_assign(
0714         __entry->cl_boot = clp->cl_clientid.cl_boot;
0715         __entry->cl_id = clp->cl_clientid.cl_id;
0716         memcpy(__entry->addr, &clp->cl_addr,
0717             sizeof(struct sockaddr_in6));
0718         __entry->flavor = clp->cl_cred.cr_flavor;
0719         memcpy(__entry->verifier, (void *)&clp->cl_verifier,
0720                NFS4_VERIFIER_SIZE);
0721         __assign_str_len(name, clp->cl_name.data, clp->cl_name.len);
0722     ),
0723     TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x",
0724         __entry->addr, __get_str(name),
0725         __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE),
0726         show_nfsd_authflavor(__entry->flavor),
0727         __entry->cl_boot, __entry->cl_id)
0728 );
0729 
0730 #define DEFINE_CLID_EVENT(name) \
0731 DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \
0732     TP_PROTO(const struct nfs4_client *clp), \
0733     TP_ARGS(clp))
0734 
0735 DEFINE_CLID_EVENT(fresh);
0736 DEFINE_CLID_EVENT(confirmed_r);
0737 
0738 /*
0739  * from fs/nfsd/filecache.h
0740  */
0741 #define show_nf_flags(val)                      \
0742     __print_flags(val, "|",                     \
0743         { 1 << NFSD_FILE_HASHED,    "HASHED" },     \
0744         { 1 << NFSD_FILE_PENDING,   "PENDING" },        \
0745         { 1 << NFSD_FILE_REFERENCED,    "REFERENCED"})
0746 
0747 DECLARE_EVENT_CLASS(nfsd_file_class,
0748     TP_PROTO(struct nfsd_file *nf),
0749     TP_ARGS(nf),
0750     TP_STRUCT__entry(
0751         __field(void *, nf_inode)
0752         __field(int, nf_ref)
0753         __field(unsigned long, nf_flags)
0754         __field(unsigned char, nf_may)
0755         __field(struct file *, nf_file)
0756     ),
0757     TP_fast_assign(
0758         __entry->nf_inode = nf->nf_inode;
0759         __entry->nf_ref = refcount_read(&nf->nf_ref);
0760         __entry->nf_flags = nf->nf_flags;
0761         __entry->nf_may = nf->nf_may;
0762         __entry->nf_file = nf->nf_file;
0763     ),
0764     TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p",
0765         __entry->nf_inode,
0766         __entry->nf_ref,
0767         show_nf_flags(__entry->nf_flags),
0768         show_nfsd_may_flags(__entry->nf_may),
0769         __entry->nf_file)
0770 )
0771 
0772 #define DEFINE_NFSD_FILE_EVENT(name) \
0773 DEFINE_EVENT(nfsd_file_class, name, \
0774     TP_PROTO(struct nfsd_file *nf), \
0775     TP_ARGS(nf))
0776 
0777 DEFINE_NFSD_FILE_EVENT(nfsd_file_put_final);
0778 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash);
0779 DEFINE_NFSD_FILE_EVENT(nfsd_file_put);
0780 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_dispose);
0781 
0782 TRACE_EVENT(nfsd_file_alloc,
0783     TP_PROTO(
0784         const struct nfsd_file *nf
0785     ),
0786     TP_ARGS(nf),
0787     TP_STRUCT__entry(
0788         __field(const void *, nf_inode)
0789         __field(unsigned long, nf_flags)
0790         __field(unsigned long, nf_may)
0791         __field(unsigned int, nf_ref)
0792     ),
0793     TP_fast_assign(
0794         __entry->nf_inode = nf->nf_inode;
0795         __entry->nf_flags = nf->nf_flags;
0796         __entry->nf_ref = refcount_read(&nf->nf_ref);
0797         __entry->nf_may = nf->nf_may;
0798     ),
0799     TP_printk("inode=%p ref=%u flags=%s may=%s",
0800         __entry->nf_inode, __entry->nf_ref,
0801         show_nf_flags(__entry->nf_flags),
0802         show_nfsd_may_flags(__entry->nf_may)
0803     )
0804 );
0805 
0806 TRACE_EVENT(nfsd_file_acquire,
0807     TP_PROTO(
0808         const struct svc_rqst *rqstp,
0809         const struct inode *inode,
0810         unsigned int may_flags,
0811         const struct nfsd_file *nf,
0812         __be32 status
0813     ),
0814 
0815     TP_ARGS(rqstp, inode, may_flags, nf, status),
0816 
0817     TP_STRUCT__entry(
0818         __field(u32, xid)
0819         __field(const void *, inode)
0820         __field(unsigned long, may_flags)
0821         __field(unsigned int, nf_ref)
0822         __field(unsigned long, nf_flags)
0823         __field(unsigned long, nf_may)
0824         __field(const void *, nf_file)
0825         __field(u32, status)
0826     ),
0827 
0828     TP_fast_assign(
0829         __entry->xid = be32_to_cpu(rqstp->rq_xid);
0830         __entry->inode = inode;
0831         __entry->may_flags = may_flags;
0832         __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0;
0833         __entry->nf_flags = nf ? nf->nf_flags : 0;
0834         __entry->nf_may = nf ? nf->nf_may : 0;
0835         __entry->nf_file = nf ? nf->nf_file : NULL;
0836         __entry->status = be32_to_cpu(status);
0837     ),
0838 
0839     TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u",
0840             __entry->xid, __entry->inode,
0841             show_nfsd_may_flags(__entry->may_flags),
0842             __entry->nf_ref, show_nf_flags(__entry->nf_flags),
0843             show_nfsd_may_flags(__entry->nf_may),
0844             __entry->nf_file, __entry->status
0845     )
0846 );
0847 
0848 TRACE_EVENT(nfsd_file_create,
0849     TP_PROTO(
0850         const struct svc_rqst *rqstp,
0851         unsigned int may_flags,
0852         const struct nfsd_file *nf
0853     ),
0854 
0855     TP_ARGS(rqstp, may_flags, nf),
0856 
0857     TP_STRUCT__entry(
0858         __field(const void *, nf_inode)
0859         __field(const void *, nf_file)
0860         __field(unsigned long, may_flags)
0861         __field(unsigned long, nf_flags)
0862         __field(unsigned long, nf_may)
0863         __field(unsigned int, nf_ref)
0864         __field(u32, xid)
0865     ),
0866 
0867     TP_fast_assign(
0868         __entry->nf_inode = nf->nf_inode;
0869         __entry->nf_file = nf->nf_file;
0870         __entry->may_flags = may_flags;
0871         __entry->nf_flags = nf->nf_flags;
0872         __entry->nf_may = nf->nf_may;
0873         __entry->nf_ref = refcount_read(&nf->nf_ref);
0874         __entry->xid = be32_to_cpu(rqstp->rq_xid);
0875     ),
0876 
0877     TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p",
0878         __entry->xid, __entry->nf_inode,
0879         show_nfsd_may_flags(__entry->may_flags),
0880         __entry->nf_ref, show_nf_flags(__entry->nf_flags),
0881         show_nfsd_may_flags(__entry->nf_may), __entry->nf_file
0882     )
0883 );
0884 
0885 TRACE_EVENT(nfsd_file_insert_err,
0886     TP_PROTO(
0887         const struct svc_rqst *rqstp,
0888         const struct inode *inode,
0889         unsigned int may_flags,
0890         long error
0891     ),
0892     TP_ARGS(rqstp, inode, may_flags, error),
0893     TP_STRUCT__entry(
0894         __field(u32, xid)
0895         __field(const void *, inode)
0896         __field(unsigned long, may_flags)
0897         __field(long, error)
0898     ),
0899     TP_fast_assign(
0900         __entry->xid = be32_to_cpu(rqstp->rq_xid);
0901         __entry->inode = inode;
0902         __entry->may_flags = may_flags;
0903         __entry->error = error;
0904     ),
0905     TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld",
0906         __entry->xid, __entry->inode,
0907         show_nfsd_may_flags(__entry->may_flags),
0908         __entry->error
0909     )
0910 );
0911 
0912 TRACE_EVENT(nfsd_file_cons_err,
0913     TP_PROTO(
0914         const struct svc_rqst *rqstp,
0915         const struct inode *inode,
0916         unsigned int may_flags,
0917         const struct nfsd_file *nf
0918     ),
0919     TP_ARGS(rqstp, inode, may_flags, nf),
0920     TP_STRUCT__entry(
0921         __field(u32, xid)
0922         __field(const void *, inode)
0923         __field(unsigned long, may_flags)
0924         __field(unsigned int, nf_ref)
0925         __field(unsigned long, nf_flags)
0926         __field(unsigned long, nf_may)
0927         __field(const void *, nf_file)
0928     ),
0929     TP_fast_assign(
0930         __entry->xid = be32_to_cpu(rqstp->rq_xid);
0931         __entry->inode = inode;
0932         __entry->may_flags = may_flags;
0933         __entry->nf_ref = refcount_read(&nf->nf_ref);
0934         __entry->nf_flags = nf->nf_flags;
0935         __entry->nf_may = nf->nf_may;
0936         __entry->nf_file = nf->nf_file;
0937     ),
0938     TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p",
0939         __entry->xid, __entry->inode,
0940         show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref,
0941         show_nf_flags(__entry->nf_flags),
0942         show_nfsd_may_flags(__entry->nf_may), __entry->nf_file
0943     )
0944 );
0945 
0946 TRACE_EVENT(nfsd_file_open,
0947     TP_PROTO(struct nfsd_file *nf, __be32 status),
0948     TP_ARGS(nf, status),
0949     TP_STRUCT__entry(
0950         __field(void *, nf_inode)   /* cannot be dereferenced */
0951         __field(int, nf_ref)
0952         __field(unsigned long, nf_flags)
0953         __field(unsigned long, nf_may)
0954         __field(void *, nf_file)    /* cannot be dereferenced */
0955     ),
0956     TP_fast_assign(
0957         __entry->nf_inode = nf->nf_inode;
0958         __entry->nf_ref = refcount_read(&nf->nf_ref);
0959         __entry->nf_flags = nf->nf_flags;
0960         __entry->nf_may = nf->nf_may;
0961         __entry->nf_file = nf->nf_file;
0962     ),
0963     TP_printk("inode=%p ref=%d flags=%s may=%s file=%p",
0964         __entry->nf_inode,
0965         __entry->nf_ref,
0966         show_nf_flags(__entry->nf_flags),
0967         show_nfsd_may_flags(__entry->nf_may),
0968         __entry->nf_file)
0969 )
0970 
0971 DECLARE_EVENT_CLASS(nfsd_file_search_class,
0972     TP_PROTO(
0973         const struct inode *inode,
0974         unsigned int count
0975     ),
0976     TP_ARGS(inode, count),
0977     TP_STRUCT__entry(
0978         __field(const struct inode *, inode)
0979         __field(unsigned int, count)
0980     ),
0981     TP_fast_assign(
0982         __entry->inode = inode;
0983         __entry->count = count;
0984     ),
0985     TP_printk("inode=%p count=%u",
0986         __entry->inode, __entry->count)
0987 );
0988 
0989 #define DEFINE_NFSD_FILE_SEARCH_EVENT(name)             \
0990 DEFINE_EVENT(nfsd_file_search_class, name,              \
0991     TP_PROTO(                           \
0992         const struct inode *inode,              \
0993         unsigned int count                  \
0994     ),                              \
0995     TP_ARGS(inode, count))
0996 
0997 DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode_sync);
0998 DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode);
0999 
1000 TRACE_EVENT(nfsd_file_is_cached,
1001     TP_PROTO(
1002         const struct inode *inode,
1003         int found
1004     ),
1005     TP_ARGS(inode, found),
1006     TP_STRUCT__entry(
1007         __field(const struct inode *, inode)
1008         __field(int, found)
1009     ),
1010     TP_fast_assign(
1011         __entry->inode = inode;
1012         __entry->found = found;
1013     ),
1014     TP_printk("inode=%p is %scached",
1015         __entry->inode,
1016         __entry->found ? "" : "not "
1017     )
1018 );
1019 
1020 TRACE_EVENT(nfsd_file_fsnotify_handle_event,
1021     TP_PROTO(struct inode *inode, u32 mask),
1022     TP_ARGS(inode, mask),
1023     TP_STRUCT__entry(
1024         __field(struct inode *, inode)
1025         __field(unsigned int, nlink)
1026         __field(umode_t, mode)
1027         __field(u32, mask)
1028     ),
1029     TP_fast_assign(
1030         __entry->inode = inode;
1031         __entry->nlink = inode->i_nlink;
1032         __entry->mode = inode->i_mode;
1033         __entry->mask = mask;
1034     ),
1035     TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode,
1036             __entry->nlink, __entry->mode, __entry->mask)
1037 );
1038 
1039 DECLARE_EVENT_CLASS(nfsd_file_gc_class,
1040     TP_PROTO(
1041         const struct nfsd_file *nf
1042     ),
1043     TP_ARGS(nf),
1044     TP_STRUCT__entry(
1045         __field(void *, nf_inode)
1046         __field(void *, nf_file)
1047         __field(int, nf_ref)
1048         __field(unsigned long, nf_flags)
1049     ),
1050     TP_fast_assign(
1051         __entry->nf_inode = nf->nf_inode;
1052         __entry->nf_file = nf->nf_file;
1053         __entry->nf_ref = refcount_read(&nf->nf_ref);
1054         __entry->nf_flags = nf->nf_flags;
1055     ),
1056     TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p",
1057         __entry->nf_inode, __entry->nf_ref,
1058         show_nf_flags(__entry->nf_flags),
1059         __entry->nf_file
1060     )
1061 );
1062 
1063 #define DEFINE_NFSD_FILE_GC_EVENT(name)                 \
1064 DEFINE_EVENT(nfsd_file_gc_class, name,                  \
1065     TP_PROTO(                           \
1066         const struct nfsd_file *nf              \
1067     ),                              \
1068     TP_ARGS(nf))
1069 
1070 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add);
1071 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed);
1072 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del);
1073 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed);
1074 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use);
1075 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback);
1076 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced);
1077 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_hashed);
1078 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed);
1079 
1080 DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class,
1081     TP_PROTO(
1082         unsigned long removed,
1083         unsigned long remaining
1084     ),
1085     TP_ARGS(removed, remaining),
1086     TP_STRUCT__entry(
1087         __field(unsigned long, removed)
1088         __field(unsigned long, remaining)
1089     ),
1090     TP_fast_assign(
1091         __entry->removed = removed;
1092         __entry->remaining = remaining;
1093     ),
1094     TP_printk("%lu entries removed, %lu remaining",
1095         __entry->removed, __entry->remaining)
1096 );
1097 
1098 #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name)                \
1099 DEFINE_EVENT(nfsd_file_lruwalk_class, name,             \
1100     TP_PROTO(                           \
1101         unsigned long removed,                  \
1102         unsigned long remaining                 \
1103     ),                              \
1104     TP_ARGS(removed, remaining))
1105 
1106 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed);
1107 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed);
1108 
1109 #include "cache.h"
1110 
1111 TRACE_DEFINE_ENUM(RC_DROPIT);
1112 TRACE_DEFINE_ENUM(RC_REPLY);
1113 TRACE_DEFINE_ENUM(RC_DOIT);
1114 
1115 #define show_drc_retval(x)                      \
1116     __print_symbolic(x,                     \
1117         { RC_DROPIT, "DROPIT" },                \
1118         { RC_REPLY, "REPLY" },                  \
1119         { RC_DOIT, "DOIT" })
1120 
1121 TRACE_EVENT(nfsd_drc_found,
1122     TP_PROTO(
1123         const struct nfsd_net *nn,
1124         const struct svc_rqst *rqstp,
1125         int result
1126     ),
1127     TP_ARGS(nn, rqstp, result),
1128     TP_STRUCT__entry(
1129         __field(unsigned long long, boot_time)
1130         __field(unsigned long, result)
1131         __field(u32, xid)
1132     ),
1133     TP_fast_assign(
1134         __entry->boot_time = nn->boot_time;
1135         __entry->result = result;
1136         __entry->xid = be32_to_cpu(rqstp->rq_xid);
1137     ),
1138     TP_printk("boot_time=%16llx xid=0x%08x result=%s",
1139         __entry->boot_time, __entry->xid,
1140         show_drc_retval(__entry->result))
1141 
1142 );
1143 
1144 TRACE_EVENT(nfsd_drc_mismatch,
1145     TP_PROTO(
1146         const struct nfsd_net *nn,
1147         const struct svc_cacherep *key,
1148         const struct svc_cacherep *rp
1149     ),
1150     TP_ARGS(nn, key, rp),
1151     TP_STRUCT__entry(
1152         __field(unsigned long long, boot_time)
1153         __field(u32, xid)
1154         __field(u32, cached)
1155         __field(u32, ingress)
1156     ),
1157     TP_fast_assign(
1158         __entry->boot_time = nn->boot_time;
1159         __entry->xid = be32_to_cpu(key->c_key.k_xid);
1160         __entry->cached = (__force u32)key->c_key.k_csum;
1161         __entry->ingress = (__force u32)rp->c_key.k_csum;
1162     ),
1163     TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x",
1164         __entry->boot_time, __entry->xid, __entry->cached,
1165         __entry->ingress)
1166 );
1167 
1168 TRACE_EVENT(nfsd_cb_args,
1169     TP_PROTO(
1170         const struct nfs4_client *clp,
1171         const struct nfs4_cb_conn *conn
1172     ),
1173     TP_ARGS(clp, conn),
1174     TP_STRUCT__entry(
1175         __field(u32, cl_boot)
1176         __field(u32, cl_id)
1177         __field(u32, prog)
1178         __field(u32, ident)
1179         __sockaddr(addr, conn->cb_addrlen)
1180     ),
1181     TP_fast_assign(
1182         __entry->cl_boot = clp->cl_clientid.cl_boot;
1183         __entry->cl_id = clp->cl_clientid.cl_id;
1184         __entry->prog = conn->cb_prog;
1185         __entry->ident = conn->cb_ident;
1186         __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen);
1187     ),
1188     TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u",
1189         __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1190         __entry->prog, __entry->ident)
1191 );
1192 
1193 TRACE_EVENT(nfsd_cb_nodelegs,
1194     TP_PROTO(const struct nfs4_client *clp),
1195     TP_ARGS(clp),
1196     TP_STRUCT__entry(
1197         __field(u32, cl_boot)
1198         __field(u32, cl_id)
1199     ),
1200     TP_fast_assign(
1201         __entry->cl_boot = clp->cl_clientid.cl_boot;
1202         __entry->cl_id = clp->cl_clientid.cl_id;
1203     ),
1204     TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
1205 )
1206 
1207 #define show_cb_state(val)                      \
1208     __print_symbolic(val,                       \
1209         { NFSD4_CB_UP,      "UP" },             \
1210         { NFSD4_CB_UNKNOWN, "UNKNOWN" },            \
1211         { NFSD4_CB_DOWN,    "DOWN" },           \
1212         { NFSD4_CB_FAULT,   "FAULT"})
1213 
1214 DECLARE_EVENT_CLASS(nfsd_cb_class,
1215     TP_PROTO(const struct nfs4_client *clp),
1216     TP_ARGS(clp),
1217     TP_STRUCT__entry(
1218         __field(unsigned long, state)
1219         __field(u32, cl_boot)
1220         __field(u32, cl_id)
1221         __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1222     ),
1223     TP_fast_assign(
1224         __entry->state = clp->cl_cb_state;
1225         __entry->cl_boot = clp->cl_clientid.cl_boot;
1226         __entry->cl_id = clp->cl_clientid.cl_id;
1227         __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1228                   clp->cl_cb_conn.cb_addrlen)
1229     ),
1230     TP_printk("addr=%pISpc client %08x:%08x state=%s",
1231         __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1232         show_cb_state(__entry->state))
1233 );
1234 
1235 #define DEFINE_NFSD_CB_EVENT(name)          \
1236 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name,     \
1237     TP_PROTO(const struct nfs4_client *clp),    \
1238     TP_ARGS(clp))
1239 
1240 DEFINE_NFSD_CB_EVENT(state);
1241 DEFINE_NFSD_CB_EVENT(probe);
1242 DEFINE_NFSD_CB_EVENT(lost);
1243 DEFINE_NFSD_CB_EVENT(shutdown);
1244 
1245 TRACE_DEFINE_ENUM(RPC_AUTH_NULL);
1246 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX);
1247 TRACE_DEFINE_ENUM(RPC_AUTH_GSS);
1248 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5);
1249 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I);
1250 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P);
1251 
1252 #define show_nfsd_authflavor(val)                   \
1253     __print_symbolic(val,                       \
1254         { RPC_AUTH_NULL,        "none" },       \
1255         { RPC_AUTH_UNIX,        "sys" },        \
1256         { RPC_AUTH_GSS,         "gss" },        \
1257         { RPC_AUTH_GSS_KRB5,        "krb5" },       \
1258         { RPC_AUTH_GSS_KRB5I,       "krb5i" },      \
1259         { RPC_AUTH_GSS_KRB5P,       "krb5p" })
1260 
1261 TRACE_EVENT(nfsd_cb_setup,
1262     TP_PROTO(const struct nfs4_client *clp,
1263          const char *netid,
1264          rpc_authflavor_t authflavor
1265     ),
1266     TP_ARGS(clp, netid, authflavor),
1267     TP_STRUCT__entry(
1268         __field(u32, cl_boot)
1269         __field(u32, cl_id)
1270         __field(unsigned long, authflavor)
1271         __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1272         __array(unsigned char, netid, 8)
1273     ),
1274     TP_fast_assign(
1275         __entry->cl_boot = clp->cl_clientid.cl_boot;
1276         __entry->cl_id = clp->cl_clientid.cl_id;
1277         strlcpy(__entry->netid, netid, sizeof(__entry->netid));
1278         __entry->authflavor = authflavor;
1279         __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1280                   clp->cl_cb_conn.cb_addrlen)
1281     ),
1282     TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s",
1283         __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1284         __entry->netid, show_nfsd_authflavor(__entry->authflavor))
1285 );
1286 
1287 TRACE_EVENT(nfsd_cb_setup_err,
1288     TP_PROTO(
1289         const struct nfs4_client *clp,
1290         long error
1291     ),
1292     TP_ARGS(clp, error),
1293     TP_STRUCT__entry(
1294         __field(long, error)
1295         __field(u32, cl_boot)
1296         __field(u32, cl_id)
1297         __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1298     ),
1299     TP_fast_assign(
1300         __entry->error = error;
1301         __entry->cl_boot = clp->cl_clientid.cl_boot;
1302         __entry->cl_id = clp->cl_clientid.cl_id;
1303         __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1304                   clp->cl_cb_conn.cb_addrlen)
1305     ),
1306     TP_printk("addr=%pISpc client %08x:%08x error=%ld",
1307         __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1308         __entry->error)
1309 );
1310 
1311 TRACE_EVENT_CONDITION(nfsd_cb_recall,
1312     TP_PROTO(
1313         const struct nfs4_stid *stid
1314     ),
1315     TP_ARGS(stid),
1316     TP_CONDITION(stid->sc_client),
1317     TP_STRUCT__entry(
1318         __field(u32, cl_boot)
1319         __field(u32, cl_id)
1320         __field(u32, si_id)
1321         __field(u32, si_generation)
1322         __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen)
1323     ),
1324     TP_fast_assign(
1325         const stateid_t *stp = &stid->sc_stateid;
1326         const struct nfs4_client *clp = stid->sc_client;
1327 
1328         __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1329         __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1330         __entry->si_id = stp->si_opaque.so_id;
1331         __entry->si_generation = stp->si_generation;
1332         __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1333                   clp->cl_cb_conn.cb_addrlen)
1334     ),
1335     TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x",
1336         __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1337         __entry->si_id, __entry->si_generation)
1338 );
1339 
1340 TRACE_EVENT(nfsd_cb_notify_lock,
1341     TP_PROTO(
1342         const struct nfs4_lockowner *lo,
1343         const struct nfsd4_blocked_lock *nbl
1344     ),
1345     TP_ARGS(lo, nbl),
1346     TP_STRUCT__entry(
1347         __field(u32, cl_boot)
1348         __field(u32, cl_id)
1349         __field(u32, fh_hash)
1350         __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen)
1351     ),
1352     TP_fast_assign(
1353         const struct nfs4_client *clp = lo->lo_owner.so_client;
1354 
1355         __entry->cl_boot = clp->cl_clientid.cl_boot;
1356         __entry->cl_id = clp->cl_clientid.cl_id;
1357         __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh);
1358         __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1359                   clp->cl_cb_conn.cb_addrlen)
1360     ),
1361     TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x",
1362         __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1363         __entry->fh_hash)
1364 );
1365 
1366 TRACE_EVENT(nfsd_cb_offload,
1367     TP_PROTO(
1368         const struct nfs4_client *clp,
1369         const stateid_t *stp,
1370         const struct knfsd_fh *fh,
1371         u64 count,
1372         __be32 status
1373     ),
1374     TP_ARGS(clp, stp, fh, count, status),
1375     TP_STRUCT__entry(
1376         __field(u32, cl_boot)
1377         __field(u32, cl_id)
1378         __field(u32, si_id)
1379         __field(u32, si_generation)
1380         __field(u32, fh_hash)
1381         __field(int, status)
1382         __field(u64, count)
1383         __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1384     ),
1385     TP_fast_assign(
1386         __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1387         __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1388         __entry->si_id = stp->si_opaque.so_id;
1389         __entry->si_generation = stp->si_generation;
1390         __entry->fh_hash = knfsd_fh_hash(fh);
1391         __entry->status = be32_to_cpu(status);
1392         __entry->count = count;
1393         __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1394                   clp->cl_cb_conn.cb_addrlen)
1395     ),
1396     TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d",
1397         __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1398         __entry->si_id, __entry->si_generation,
1399         __entry->fh_hash, __entry->count, __entry->status)
1400 );
1401 
1402 #endif /* _NFSD_TRACE_H */
1403 
1404 #undef TRACE_INCLUDE_PATH
1405 #define TRACE_INCLUDE_PATH .
1406 #define TRACE_INCLUDE_FILE trace
1407 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!