fs/nfsd/trace.h

   1 /*
   2  * Copyright (c) 2014 Christoph Hellwig.
   3  */
   4 #undef TRACE_SYSTEM
   5 #define TRACE_SYSTEM nfsd
   6
   7 #if !defined(_NFSD_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
   8 #define _NFSD_TRACE_H
   9
  10 #include <linux/tracepoint.h>
  11
  12 #include "state.h"
  13 #include "filecache.h"
  14 #include "vfs.h"
  15
  16 DECLARE_EVENT_CLASS(nfsd_stateid_class,
  17         TP_PROTO(stateid_t *stp),
  18         TP_ARGS(stp),
  19         TP_STRUCT__entry(
  20                 __field(u32, cl_boot)
  21                 __field(u32, cl_id)
  22                 __field(u32, si_id)
  23                 __field(u32, si_generation)
  24         ),
  25         TP_fast_assign(
  26                 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
  27                 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
  28                 __entry->si_id = stp->si_opaque.so_id;
  29                 __entry->si_generation = stp->si_generation;
  30         ),
  31         TP_printk("client %08x:%08x stateid %08x:%08x",
  32                 __entry->cl_boot,
  33                 __entry->cl_id,
  34                 __entry->si_id,
  35                 __entry->si_generation)
  36 )
  37
  38 #define DEFINE_STATEID_EVENT(name) \
  39 DEFINE_EVENT(nfsd_stateid_class, name, \
  40         TP_PROTO(stateid_t *stp), \
  41         TP_ARGS(stp))
  42 DEFINE_STATEID_EVENT(layoutstate_alloc);
  43 DEFINE_STATEID_EVENT(layoutstate_unhash);
  44 DEFINE_STATEID_EVENT(layoutstate_free);
  45 DEFINE_STATEID_EVENT(layout_get_lookup_fail);
  46 DEFINE_STATEID_EVENT(layout_commit_lookup_fail);
  47 DEFINE_STATEID_EVENT(layout_return_lookup_fail);
  48 DEFINE_STATEID_EVENT(layout_recall);
  49 DEFINE_STATEID_EVENT(layout_recall_done);
  50 DEFINE_STATEID_EVENT(layout_recall_fail);
  51 DEFINE_STATEID_EVENT(layout_recall_release);
  52
  53 #define show_nf_flags(val)                                              \
  54         __print_flags(val, "|",                                         \
  55                 { 1 << NFSD_FILE_HASHED,        "HASHED" },             \
  56                 { 1 << NFSD_FILE_PENDING,       "PENDING" },            \
  57                 { 1 << NFSD_FILE_BREAK_READ,    "BREAK_READ" },         \
  58                 { 1 << NFSD_FILE_BREAK_WRITE,   "BREAK_WRITE" })
  59
  60 /* FIXME: This should probably be fleshed out in the future. */
  61 #define show_nf_may(val)                                                \
  62         __print_flags(val, "|",                                         \
  63                 { NFSD_MAY_READ,                "READ" },               \
  64                 { NFSD_MAY_WRITE,               "WRITE" },              \
  65                 { NFSD_MAY_NOT_BREAK_LEASE,     "NOT_BREAK_LEASE" })
  66
  67 DECLARE_EVENT_CLASS(nfsd_file_class,
  68         TP_PROTO(struct nfsd_file *nf),
  69         TP_ARGS(nf),
  70         TP_STRUCT__entry(
  71                 __field(unsigned int, nf_hashval)
  72                 __field(void *, nf_inode)
  73                 __field(int, nf_ref)
  74                 __field(unsigned long, nf_flags)
  75                 __field(unsigned char, nf_may)
  76                 __field(struct file *, nf_file)
  77         ),
  78         TP_fast_assign(
  79                 __entry->nf_hashval = nf->nf_hashval;
  80                 __entry->nf_inode = nf->nf_inode;
  81                 __entry->nf_ref = atomic_read(&nf->nf_ref);
  82                 __entry->nf_flags = nf->nf_flags;
  83                 __entry->nf_may = nf->nf_may;
  84                 __entry->nf_file = nf->nf_file;
  85         ),
  86         TP_printk("hash=0x%x inode=0x%p ref=%d flags=%s may=%s file=%p",
  87                 __entry->nf_hashval,
  88                 __entry->nf_inode,
  89                 __entry->nf_ref,
  90                 show_nf_flags(__entry->nf_flags),
  91                 show_nf_may(__entry->nf_may),
  92                 __entry->nf_file)
  93 )
  94
  95 #define DEFINE_NFSD_FILE_EVENT(name) \
  96 DEFINE_EVENT(nfsd_file_class, name, \
  97         TP_PROTO(struct nfsd_file *nf), \
  98         TP_ARGS(nf))
  99
 100 DEFINE_NFSD_FILE_EVENT(nfsd_file_alloc);
 101 DEFINE_NFSD_FILE_EVENT(nfsd_file_put_final);
 102 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash);
 103 DEFINE_NFSD_FILE_EVENT(nfsd_file_put);
 104 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_release_locked);
 105
 106 TRACE_EVENT(nfsd_file_acquire,
 107         TP_PROTO(unsigned int hash, struct inode *inode,
 108                  unsigned int may_flags, struct nfsd_file *nf,
 109                  __be32 status),
 110
 111         TP_ARGS(hash, inode, may_flags, nf, status),
 112
 113         TP_STRUCT__entry(
 114                 __field(unsigned int, hash)
 115                 __field(void *, inode)
 116                 __field(unsigned int, may_flags)
 117                 __field(int, nf_ref)
 118                 __field(unsigned long, nf_flags)
 119                 __field(unsigned char, nf_may)
 120                 __field(struct file *, nf_file)
 121                 __field(__be32, status)
 122         ),
 123
 124         TP_fast_assign(
 125                 __entry->hash = hash;
 126                 __entry->inode = inode;
 127                 __entry->may_flags = may_flags;
 128                 __entry->nf_ref = nf ? atomic_read(&nf->nf_ref) : 0;
 129                 __entry->nf_flags = nf ? nf->nf_flags : 0;
 130                 __entry->nf_may = nf ? nf->nf_may : 0;
 131                 __entry->nf_file = nf ? nf->nf_file : NULL;
 132                 __entry->status = status;
 133         ),
 134
 135         TP_printk("hash=0x%x inode=0x%p may_flags=%s ref=%d nf_flags=%s nf_may=%s nf_file=0x%p status=%u",
 136                         __entry->hash, __entry->inode,
 137                         show_nf_may(__entry->may_flags), __entry->nf_ref,
 138                         show_nf_flags(__entry->nf_flags),
 139                         show_nf_may(__entry->nf_may), __entry->nf_file,
 140                         be32_to_cpu(__entry->status))
 141 );
 142
 143 DECLARE_EVENT_CLASS(nfsd_file_search_class,
 144         TP_PROTO(struct inode *inode, unsigned int hash, int found),
 145         TP_ARGS(inode, hash, found),
 146         TP_STRUCT__entry(
 147                 __field(struct inode *, inode)
 148                 __field(unsigned int, hash)
 149                 __field(int, found)
 150         ),
 151         TP_fast_assign(
 152                 __entry->inode = inode;
 153                 __entry->hash = hash;
 154                 __entry->found = found;
 155         ),
 156         TP_printk("hash=0x%x inode=0x%p found=%d", __entry->hash,
 157                         __entry->inode, __entry->found)
 158 );
 159
 160 #define DEFINE_NFSD_FILE_SEARCH_EVENT(name)                             \
 161 DEFINE_EVENT(nfsd_file_search_class, name,                              \
 162         TP_PROTO(struct inode *inode, unsigned int hash, int found),    \
 163         TP_ARGS(inode, hash, found))
 164
 165 DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode_sync);
 166 DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode);
 167
 168 TRACE_EVENT(nfsd_file_fsnotify_handle_event,
 169         TP_PROTO(struct inode *inode, u32 mask),
 170         TP_ARGS(inode, mask),
 171         TP_STRUCT__entry(
 172                 __field(struct inode *, inode)
 173                 __field(unsigned int, nlink)
 174                 __field(umode_t, mode)
 175                 __field(u32, mask)
 176         ),
 177         TP_fast_assign(
 178                 __entry->inode = inode;
 179                 __entry->nlink = inode->i_nlink;
 180                 __entry->mode = inode->i_mode;
 181                 __entry->mask = mask;
 182         ),
 183         TP_printk("inode=0x%p nlink=%u mode=0%ho mask=0x%x", __entry->inode,
 184                         __entry->nlink, __entry->mode, __entry->mask)
 185 );
 186 #endif /* _NFSD_TRACE_H */
 187
 188 #undef TRACE_INCLUDE_PATH
 189 #define TRACE_INCLUDE_PATH .
 190 #define TRACE_INCLUDE_FILE trace
 191 #include <trace/define_trace.h>