include/trace/events/cachefiles.h

   1 /* CacheFiles tracepoints
   2  *
   3  * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public Licence
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the Licence, or (at your option) any later version.
  10  */
  11 #undef TRACE_SYSTEM
  12 #define TRACE_SYSTEM cachefiles
  13
  14 #if !defined(_TRACE_CACHEFILES_H) || defined(TRACE_HEADER_MULTI_READ)
  15 #define _TRACE_CACHEFILES_H
  16
  17 #include <linux/tracepoint.h>
  18
  19 /*
  20  * Define enums for tracing information.
  21  */
  22 #ifndef __CACHEFILES_DECLARE_TRACE_ENUMS_ONCE_ONLY
  23 #define __CACHEFILES_DECLARE_TRACE_ENUMS_ONCE_ONLY
  24
  25 enum cachefiles_obj_ref_trace {
  26         cachefiles_obj_put_wait_retry = fscache_obj_ref__nr_traces,
  27         cachefiles_obj_put_wait_timeo,
  28         cachefiles_obj_ref__nr_traces
  29 };
  30
  31 #endif
  32
  33 /*
  34  * Define enum -> string mappings for display.
  35  */
  36 #define cachefiles_obj_kill_traces                              \
  37         EM(FSCACHE_OBJECT_IS_STALE,     "stale")                \
  38         EM(FSCACHE_OBJECT_NO_SPACE,     "no_space")             \
  39         EM(FSCACHE_OBJECT_WAS_RETIRED,  "was_retired")          \
  40         E_(FSCACHE_OBJECT_WAS_CULLED,   "was_culled")
  41
  42 #define cachefiles_obj_ref_traces                                       \
  43         EM(fscache_obj_get_add_to_deps,         "GET add_to_deps")      \
  44         EM(fscache_obj_get_queue,               "GET queue")            \
  45         EM(fscache_obj_put_alloc_fail,          "PUT alloc_fail")       \
  46         EM(fscache_obj_put_attach_fail,         "PUT attach_fail")      \
  47         EM(fscache_obj_put_drop_obj,            "PUT drop_obj")         \
  48         EM(fscache_obj_put_enq_dep,             "PUT enq_dep")          \
  49         EM(fscache_obj_put_queue,               "PUT queue")            \
  50         EM(fscache_obj_put_work,                "PUT work")             \
  51         EM(cachefiles_obj_put_wait_retry,       "PUT wait_retry")       \
  52         E_(cachefiles_obj_put_wait_timeo,       "PUT wait_timeo")
  53
  54 /*
  55  * Export enum symbols via userspace.
  56  */
  57 #undef EM
  58 #undef E_
  59 #define EM(a, b) TRACE_DEFINE_ENUM(a);
  60 #define E_(a, b) TRACE_DEFINE_ENUM(a);
  61
  62 cachefiles_obj_kill_traces;
  63 cachefiles_obj_ref_traces;
  64
  65 /*
  66  * Now redefine the EM() and E_() macros to map the enums to the strings that
  67  * will be printed in the output.
  68  */
  69 #undef EM
  70 #undef E_
  71 #define EM(a, b)        { a, b },
  72 #define E_(a, b)        { a, b }
  73
  74
  75 TRACE_EVENT(cachefiles_ref,
  76             TP_PROTO(struct cachefiles_object *obj,
  77                      struct fscache_cookie *cookie,
  78                      enum cachefiles_obj_ref_trace why,
  79                      int usage),
  80
  81             TP_ARGS(obj, cookie, why, usage),
  82
  83             /* Note that obj may be NULL */
  84             TP_STRUCT__entry(
  85                     __field(struct cachefiles_object *,         obj             )
  86                     __field(struct fscache_cookie *,            cookie          )
  87                     __field(enum cachefiles_obj_ref_trace,      why             )
  88                     __field(int,                                usage           )
  89                              ),
  90
  91             TP_fast_assign(
  92                     __entry->obj        = obj;
  93                     __entry->cookie     = cookie;
  94                     __entry->usage      = usage;
  95                     __entry->why        = why;
  96                            ),
  97
  98             TP_printk("c=%p o=%p u=%d %s",
  99                       __entry->cookie, __entry->obj, __entry->usage,
 100                       __print_symbolic(__entry->why, cachefiles_obj_ref_traces))
 101             );
 102
 103 TRACE_EVENT(cachefiles_lookup,
 104             TP_PROTO(struct cachefiles_object *obj,
 105                      struct dentry *de,
 106                      struct inode *inode),
 107
 108             TP_ARGS(obj, de, inode),
 109
 110             TP_STRUCT__entry(
 111                     __field(struct cachefiles_object *, obj     )
 112                     __field(struct dentry *,            de      )
 113                     __field(struct inode *,             inode   )
 114                              ),
 115
 116             TP_fast_assign(
 117                     __entry->obj        = obj;
 118                     __entry->de         = de;
 119                     __entry->inode      = inode;
 120                            ),
 121
 122             TP_printk("o=%p d=%p i=%p",
 123                       __entry->obj, __entry->de, __entry->inode)
 124             );
 125
 126 TRACE_EVENT(cachefiles_mkdir,
 127             TP_PROTO(struct cachefiles_object *obj,
 128                      struct dentry *de, int ret),
 129
 130             TP_ARGS(obj, de, ret),
 131
 132             TP_STRUCT__entry(
 133                     __field(struct cachefiles_object *, obj     )
 134                     __field(struct dentry *,            de      )
 135                     __field(int,                        ret     )
 136                              ),
 137
 138             TP_fast_assign(
 139                     __entry->obj        = obj;
 140                     __entry->de         = de;
 141                     __entry->ret        = ret;
 142                            ),
 143
 144             TP_printk("o=%p d=%p r=%u",
 145                       __entry->obj, __entry->de, __entry->ret)
 146             );
 147
 148 TRACE_EVENT(cachefiles_create,
 149             TP_PROTO(struct cachefiles_object *obj,
 150                      struct dentry *de, int ret),
 151
 152             TP_ARGS(obj, de, ret),
 153
 154             TP_STRUCT__entry(
 155                     __field(struct cachefiles_object *, obj     )
 156                     __field(struct dentry *,            de      )
 157                     __field(int,                        ret     )
 158                              ),
 159
 160             TP_fast_assign(
 161                     __entry->obj        = obj;
 162                     __entry->de         = de;
 163                     __entry->ret        = ret;
 164                            ),
 165
 166             TP_printk("o=%p d=%p r=%u",
 167                       __entry->obj, __entry->de, __entry->ret)
 168             );
 169
 170 TRACE_EVENT(cachefiles_unlink,
 171             TP_PROTO(struct cachefiles_object *obj,
 172                      struct dentry *de,
 173                      enum fscache_why_object_killed why),
 174
 175             TP_ARGS(obj, de, why),
 176
 177             /* Note that obj may be NULL */
 178             TP_STRUCT__entry(
 179                     __field(struct cachefiles_object *, obj             )
 180                     __field(struct dentry *,            de              )
 181                     __field(enum fscache_why_object_killed, why         )
 182                              ),
 183
 184             TP_fast_assign(
 185                     __entry->obj        = obj;
 186                     __entry->de         = de;
 187                     __entry->why        = why;
 188                            ),
 189
 190             TP_printk("o=%p d=%p w=%s",
 191                       __entry->obj, __entry->de,
 192                       __print_symbolic(__entry->why, cachefiles_obj_kill_traces))
 193             );
 194
 195 TRACE_EVENT(cachefiles_rename,
 196             TP_PROTO(struct cachefiles_object *obj,
 197                      struct dentry *de,
 198                      struct dentry *to,
 199                      enum fscache_why_object_killed why),
 200
 201             TP_ARGS(obj, de, to, why),
 202
 203             /* Note that obj may be NULL */
 204             TP_STRUCT__entry(
 205                     __field(struct cachefiles_object *, obj             )
 206                     __field(struct dentry *,            de              )
 207                     __field(struct dentry *,            to              )
 208                     __field(enum fscache_why_object_killed, why         )
 209                              ),
 210
 211             TP_fast_assign(
 212                     __entry->obj        = obj;
 213                     __entry->de         = de;
 214                     __entry->to         = to;
 215                     __entry->why        = why;
 216                            ),
 217
 218             TP_printk("o=%p d=%p t=%p w=%s",
 219                       __entry->obj, __entry->de, __entry->to,
 220                       __print_symbolic(__entry->why, cachefiles_obj_kill_traces))
 221             );
 222
 223 TRACE_EVENT(cachefiles_mark_active,
 224             TP_PROTO(struct cachefiles_object *obj,
 225                      struct dentry *de),
 226
 227             TP_ARGS(obj, de),
 228
 229             /* Note that obj may be NULL */
 230             TP_STRUCT__entry(
 231                     __field(struct cachefiles_object *, obj             )
 232                     __field(struct dentry *,            de              )
 233                              ),
 234
 235             TP_fast_assign(
 236                     __entry->obj        = obj;
 237                     __entry->de         = de;
 238                            ),
 239
 240             TP_printk("o=%p d=%p",
 241                       __entry->obj, __entry->de)
 242             );
 243
 244 TRACE_EVENT(cachefiles_wait_active,
 245             TP_PROTO(struct cachefiles_object *obj,
 246                      struct dentry *de,
 247                      struct cachefiles_object *xobj),
 248
 249             TP_ARGS(obj, de, xobj),
 250
 251             /* Note that obj may be NULL */
 252             TP_STRUCT__entry(
 253                     __field(struct cachefiles_object *, obj             )
 254                     __field(struct dentry *,            de              )
 255                     __field(struct cachefiles_object *, xobj            )
 256                     __field(u16,                        flags           )
 257                     __field(u16,                        fsc_flags       )
 258                              ),
 259
 260             TP_fast_assign(
 261                     __entry->obj        = obj;
 262                     __entry->de         = de;
 263                     __entry->xobj       = xobj;
 264                     __entry->flags      = xobj->flags;
 265                     __entry->fsc_flags  = xobj->fscache.flags;
 266                            ),
 267
 268             TP_printk("o=%p d=%p wo=%p wf=%x wff=%x",
 269                       __entry->obj, __entry->de, __entry->xobj,
 270                       __entry->flags, __entry->fsc_flags)
 271             );
 272
 273 TRACE_EVENT(cachefiles_mark_inactive,
 274             TP_PROTO(struct cachefiles_object *obj,
 275                      struct dentry *de,
 276                      struct inode *inode),
 277
 278             TP_ARGS(obj, de, inode),
 279
 280             /* Note that obj may be NULL */
 281             TP_STRUCT__entry(
 282                     __field(struct cachefiles_object *, obj             )
 283                     __field(struct dentry *,            de              )
 284                     __field(struct inode *,             inode           )
 285                              ),
 286
 287             TP_fast_assign(
 288                     __entry->obj        = obj;
 289                     __entry->de         = de;
 290                     __entry->inode      = inode;
 291                            ),
 292
 293             TP_printk("o=%p d=%p i=%p",
 294                       __entry->obj, __entry->de, __entry->inode)
 295             );
 296
 297 TRACE_EVENT(cachefiles_mark_buried,
 298             TP_PROTO(struct cachefiles_object *obj,
 299                      struct dentry *de,
 300                      enum fscache_why_object_killed why),
 301
 302             TP_ARGS(obj, de, why),
 303
 304             /* Note that obj may be NULL */
 305             TP_STRUCT__entry(
 306                     __field(struct cachefiles_object *, obj             )
 307                     __field(struct dentry *,            de              )
 308                     __field(enum fscache_why_object_killed, why         )
 309                              ),
 310
 311             TP_fast_assign(
 312                     __entry->obj        = obj;
 313                     __entry->de         = de;
 314                     __entry->why        = why;
 315                            ),
 316
 317             TP_printk("o=%p d=%p w=%s",
 318                       __entry->obj, __entry->de,
 319                       __print_symbolic(__entry->why, cachefiles_obj_kill_traces))
 320             );
 321
 322 #endif /* _TRACE_CACHEFILES_H */
 323
 324 /* This part must be outside protection */
 325 #include <trace/define_trace.h>