Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0-or-later */
0002 /* Network filesystem support module tracepoints
0003  *
0004  * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
0005  * Written by David Howells (dhowells@redhat.com)
0006  */
0007 #undef TRACE_SYSTEM
0008 #define TRACE_SYSTEM netfs
0009 
0010 #if !defined(_TRACE_NETFS_H) || defined(TRACE_HEADER_MULTI_READ)
0011 #define _TRACE_NETFS_H
0012 
0013 #include <linux/tracepoint.h>
0014 
0015 /*
0016  * Define enums for tracing information.
0017  */
0018 #define netfs_read_traces                   \
0019     EM(netfs_read_trace_expanded,       "EXPANDED ")    \
0020     EM(netfs_read_trace_readahead,      "READAHEAD")    \
0021     EM(netfs_read_trace_readpage,       "READPAGE ")    \
0022     E_(netfs_read_trace_write_begin,    "WRITEBEGN")
0023 
0024 #define netfs_rreq_origins                  \
0025     EM(NETFS_READAHEAD,         "RA")       \
0026     EM(NETFS_READPAGE,          "RP")       \
0027     E_(NETFS_READ_FOR_WRITE,        "RW")
0028 
0029 #define netfs_rreq_traces                   \
0030     EM(netfs_rreq_trace_assess,     "ASSESS ")  \
0031     EM(netfs_rreq_trace_copy,       "COPY   ")  \
0032     EM(netfs_rreq_trace_done,       "DONE   ")  \
0033     EM(netfs_rreq_trace_free,       "FREE   ")  \
0034     EM(netfs_rreq_trace_resubmit,       "RESUBMT")  \
0035     EM(netfs_rreq_trace_unlock,     "UNLOCK ")  \
0036     E_(netfs_rreq_trace_unmark,     "UNMARK ")
0037 
0038 #define netfs_sreq_sources                  \
0039     EM(NETFS_FILL_WITH_ZEROES,      "ZERO")     \
0040     EM(NETFS_DOWNLOAD_FROM_SERVER,      "DOWN")     \
0041     EM(NETFS_READ_FROM_CACHE,       "READ")     \
0042     E_(NETFS_INVALID_READ,          "INVL")     \
0043 
0044 #define netfs_sreq_traces                   \
0045     EM(netfs_sreq_trace_download_instead,   "RDOWN")    \
0046     EM(netfs_sreq_trace_free,       "FREE ")    \
0047     EM(netfs_sreq_trace_prepare,        "PREP ")    \
0048     EM(netfs_sreq_trace_resubmit_short, "SHORT")    \
0049     EM(netfs_sreq_trace_submit,     "SUBMT")    \
0050     EM(netfs_sreq_trace_terminated,     "TERM ")    \
0051     EM(netfs_sreq_trace_write,      "WRITE")    \
0052     EM(netfs_sreq_trace_write_skip,     "SKIP ")    \
0053     E_(netfs_sreq_trace_write_term,     "WTERM")
0054 
0055 #define netfs_failures                          \
0056     EM(netfs_fail_check_write_begin,    "check-write-begin")    \
0057     EM(netfs_fail_copy_to_cache,        "copy-to-cache")    \
0058     EM(netfs_fail_read,         "read")         \
0059     EM(netfs_fail_short_read,       "short-read")       \
0060     E_(netfs_fail_prepare_write,        "prep-write")
0061 
0062 #define netfs_rreq_ref_traces                   \
0063     EM(netfs_rreq_trace_get_hold,       "GET HOLD   ")  \
0064     EM(netfs_rreq_trace_get_subreq,     "GET SUBREQ ")  \
0065     EM(netfs_rreq_trace_put_complete,   "PUT COMPLT ")  \
0066     EM(netfs_rreq_trace_put_discard,    "PUT DISCARD")  \
0067     EM(netfs_rreq_trace_put_failed,     "PUT FAILED ")  \
0068     EM(netfs_rreq_trace_put_hold,       "PUT HOLD   ")  \
0069     EM(netfs_rreq_trace_put_subreq,     "PUT SUBREQ ")  \
0070     EM(netfs_rreq_trace_put_zero_len,   "PUT ZEROLEN")  \
0071     E_(netfs_rreq_trace_new,        "NEW        ")
0072 
0073 #define netfs_sreq_ref_traces                   \
0074     EM(netfs_sreq_trace_get_copy_to_cache,  "GET COPY2C ")  \
0075     EM(netfs_sreq_trace_get_resubmit,   "GET RESUBMIT") \
0076     EM(netfs_sreq_trace_get_short_read, "GET SHORTRD")  \
0077     EM(netfs_sreq_trace_new,        "NEW        ")  \
0078     EM(netfs_sreq_trace_put_clear,      "PUT CLEAR  ")  \
0079     EM(netfs_sreq_trace_put_failed,     "PUT FAILED ")  \
0080     EM(netfs_sreq_trace_put_merged,     "PUT MERGED ")  \
0081     EM(netfs_sreq_trace_put_no_copy,    "PUT NO COPY")  \
0082     E_(netfs_sreq_trace_put_terminated, "PUT TERM   ")
0083 
0084 #ifndef __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
0085 #define __NETFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
0086 
0087 #undef EM
0088 #undef E_
0089 #define EM(a, b) a,
0090 #define E_(a, b) a
0091 
0092 enum netfs_read_trace { netfs_read_traces } __mode(byte);
0093 enum netfs_rreq_trace { netfs_rreq_traces } __mode(byte);
0094 enum netfs_sreq_trace { netfs_sreq_traces } __mode(byte);
0095 enum netfs_failure { netfs_failures } __mode(byte);
0096 enum netfs_rreq_ref_trace { netfs_rreq_ref_traces } __mode(byte);
0097 enum netfs_sreq_ref_trace { netfs_sreq_ref_traces } __mode(byte);
0098 
0099 #endif
0100 
0101 /*
0102  * Export enum symbols via userspace.
0103  */
0104 #undef EM
0105 #undef E_
0106 #define EM(a, b) TRACE_DEFINE_ENUM(a);
0107 #define E_(a, b) TRACE_DEFINE_ENUM(a);
0108 
0109 netfs_read_traces;
0110 netfs_rreq_origins;
0111 netfs_rreq_traces;
0112 netfs_sreq_sources;
0113 netfs_sreq_traces;
0114 netfs_failures;
0115 netfs_rreq_ref_traces;
0116 netfs_sreq_ref_traces;
0117 
0118 /*
0119  * Now redefine the EM() and E_() macros to map the enums to the strings that
0120  * will be printed in the output.
0121  */
0122 #undef EM
0123 #undef E_
0124 #define EM(a, b)    { a, b },
0125 #define E_(a, b)    { a, b }
0126 
0127 TRACE_EVENT(netfs_read,
0128         TP_PROTO(struct netfs_io_request *rreq,
0129              loff_t start, size_t len,
0130              enum netfs_read_trace what),
0131 
0132         TP_ARGS(rreq, start, len, what),
0133 
0134         TP_STRUCT__entry(
0135             __field(unsigned int,       rreq        )
0136             __field(unsigned int,       cookie      )
0137             __field(loff_t,         start       )
0138             __field(size_t,         len     )
0139             __field(enum netfs_read_trace,  what        )
0140             __field(unsigned int,       netfs_inode )
0141                  ),
0142 
0143         TP_fast_assign(
0144             __entry->rreq   = rreq->debug_id;
0145             __entry->cookie = rreq->cache_resources.debug_id;
0146             __entry->start  = start;
0147             __entry->len    = len;
0148             __entry->what   = what;
0149             __entry->netfs_inode = rreq->inode->i_ino;
0150                ),
0151 
0152         TP_printk("R=%08x %s c=%08x ni=%x s=%llx %zx",
0153               __entry->rreq,
0154               __print_symbolic(__entry->what, netfs_read_traces),
0155               __entry->cookie,
0156               __entry->netfs_inode,
0157               __entry->start, __entry->len)
0158         );
0159 
0160 TRACE_EVENT(netfs_rreq,
0161         TP_PROTO(struct netfs_io_request *rreq,
0162              enum netfs_rreq_trace what),
0163 
0164         TP_ARGS(rreq, what),
0165 
0166         TP_STRUCT__entry(
0167             __field(unsigned int,       rreq        )
0168             __field(unsigned int,       flags       )
0169             __field(enum netfs_io_origin,   origin      )
0170             __field(enum netfs_rreq_trace,  what        )
0171                  ),
0172 
0173         TP_fast_assign(
0174             __entry->rreq   = rreq->debug_id;
0175             __entry->flags  = rreq->flags;
0176             __entry->origin = rreq->origin;
0177             __entry->what   = what;
0178                ),
0179 
0180         TP_printk("R=%08x %s %s f=%02x",
0181               __entry->rreq,
0182               __print_symbolic(__entry->origin, netfs_rreq_origins),
0183               __print_symbolic(__entry->what, netfs_rreq_traces),
0184               __entry->flags)
0185         );
0186 
0187 TRACE_EVENT(netfs_sreq,
0188         TP_PROTO(struct netfs_io_subrequest *sreq,
0189              enum netfs_sreq_trace what),
0190 
0191         TP_ARGS(sreq, what),
0192 
0193         TP_STRUCT__entry(
0194             __field(unsigned int,       rreq        )
0195             __field(unsigned short,     index       )
0196             __field(short,          error       )
0197             __field(unsigned short,     flags       )
0198             __field(enum netfs_io_source,   source      )
0199             __field(enum netfs_sreq_trace,  what        )
0200             __field(size_t,         len     )
0201             __field(size_t,         transferred )
0202             __field(loff_t,         start       )
0203                  ),
0204 
0205         TP_fast_assign(
0206             __entry->rreq   = sreq->rreq->debug_id;
0207             __entry->index  = sreq->debug_index;
0208             __entry->error  = sreq->error;
0209             __entry->flags  = sreq->flags;
0210             __entry->source = sreq->source;
0211             __entry->what   = what;
0212             __entry->len    = sreq->len;
0213             __entry->transferred = sreq->transferred;
0214             __entry->start  = sreq->start;
0215                ),
0216 
0217         TP_printk("R=%08x[%u] %s %s f=%02x s=%llx %zx/%zx e=%d",
0218               __entry->rreq, __entry->index,
0219               __print_symbolic(__entry->source, netfs_sreq_sources),
0220               __print_symbolic(__entry->what, netfs_sreq_traces),
0221               __entry->flags,
0222               __entry->start, __entry->transferred, __entry->len,
0223               __entry->error)
0224         );
0225 
0226 TRACE_EVENT(netfs_failure,
0227         TP_PROTO(struct netfs_io_request *rreq,
0228              struct netfs_io_subrequest *sreq,
0229              int error, enum netfs_failure what),
0230 
0231         TP_ARGS(rreq, sreq, error, what),
0232 
0233         TP_STRUCT__entry(
0234             __field(unsigned int,       rreq        )
0235             __field(short,          index       )
0236             __field(short,          error       )
0237             __field(unsigned short,     flags       )
0238             __field(enum netfs_io_source,   source      )
0239             __field(enum netfs_failure,     what        )
0240             __field(size_t,         len     )
0241             __field(size_t,         transferred )
0242             __field(loff_t,         start       )
0243                  ),
0244 
0245         TP_fast_assign(
0246             __entry->rreq   = rreq->debug_id;
0247             __entry->index  = sreq ? sreq->debug_index : -1;
0248             __entry->error  = error;
0249             __entry->flags  = sreq ? sreq->flags : 0;
0250             __entry->source = sreq ? sreq->source : NETFS_INVALID_READ;
0251             __entry->what   = what;
0252             __entry->len    = sreq ? sreq->len : rreq->len;
0253             __entry->transferred = sreq ? sreq->transferred : 0;
0254             __entry->start  = sreq ? sreq->start : 0;
0255                ),
0256 
0257         TP_printk("R=%08x[%d] %s f=%02x s=%llx %zx/%zx %s e=%d",
0258               __entry->rreq, __entry->index,
0259               __print_symbolic(__entry->source, netfs_sreq_sources),
0260               __entry->flags,
0261               __entry->start, __entry->transferred, __entry->len,
0262               __print_symbolic(__entry->what, netfs_failures),
0263               __entry->error)
0264         );
0265 
0266 TRACE_EVENT(netfs_rreq_ref,
0267         TP_PROTO(unsigned int rreq_debug_id, int ref,
0268              enum netfs_rreq_ref_trace what),
0269 
0270         TP_ARGS(rreq_debug_id, ref, what),
0271 
0272         TP_STRUCT__entry(
0273             __field(unsigned int,       rreq        )
0274             __field(int,            ref     )
0275             __field(enum netfs_rreq_ref_trace,  what        )
0276                  ),
0277 
0278         TP_fast_assign(
0279             __entry->rreq   = rreq_debug_id;
0280             __entry->ref    = ref;
0281             __entry->what   = what;
0282                ),
0283 
0284         TP_printk("R=%08x %s r=%u",
0285               __entry->rreq,
0286               __print_symbolic(__entry->what, netfs_rreq_ref_traces),
0287               __entry->ref)
0288         );
0289 
0290 TRACE_EVENT(netfs_sreq_ref,
0291         TP_PROTO(unsigned int rreq_debug_id, unsigned int subreq_debug_index,
0292              int ref, enum netfs_sreq_ref_trace what),
0293 
0294         TP_ARGS(rreq_debug_id, subreq_debug_index, ref, what),
0295 
0296         TP_STRUCT__entry(
0297             __field(unsigned int,       rreq        )
0298             __field(unsigned int,       subreq      )
0299             __field(int,            ref     )
0300             __field(enum netfs_sreq_ref_trace,  what        )
0301                  ),
0302 
0303         TP_fast_assign(
0304             __entry->rreq   = rreq_debug_id;
0305             __entry->subreq = subreq_debug_index;
0306             __entry->ref    = ref;
0307             __entry->what   = what;
0308                ),
0309 
0310         TP_printk("R=%08x[%x] %s r=%u",
0311               __entry->rreq,
0312               __entry->subreq,
0313               __print_symbolic(__entry->what, netfs_sreq_ref_traces),
0314               __entry->ref)
0315         );
0316 
0317 #undef EM
0318 #undef E_
0319 #endif /* _TRACE_NETFS_H */
0320 
0321 /* This part must be outside protection */
0322 #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!