include/trace/events/cachefiles.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /* CacheFiles tracepoints
   3  *
   4  * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7 #undef TRACE_SYSTEM
   8 #define TRACE_SYSTEM cachefiles
   9
  10 #if !defined(_TRACE_CACHEFILES_H) || defined(TRACE_HEADER_MULTI_READ)
  11 #define _TRACE_CACHEFILES_H
  12
  13 #include <linux/tracepoint.h>
  14
  15 /*
  16  * Define enums for tracing information.
  17  */
  18 #ifndef __CACHEFILES_DECLARE_TRACE_ENUMS_ONCE_ONLY
  19 #define __CACHEFILES_DECLARE_TRACE_ENUMS_ONCE_ONLY
  20
  21 enum cachefiles_obj_ref_trace {
  22         cachefiles_obj_get_ioreq,
  23         cachefiles_obj_new,
  24         cachefiles_obj_put_alloc_fail,
  25         cachefiles_obj_put_detach,
  26         cachefiles_obj_put_ioreq,
  27         cachefiles_obj_see_clean_commit,
  28         cachefiles_obj_see_clean_delete,
  29         cachefiles_obj_see_clean_drop_tmp,
  30         cachefiles_obj_see_lookup_cookie,
  31         cachefiles_obj_see_lookup_failed,
  32         cachefiles_obj_see_withdraw_cookie,
  33         cachefiles_obj_see_withdrawal,
  34 };
  35
  36 enum fscache_why_object_killed {
  37         FSCACHE_OBJECT_IS_STALE,
  38         FSCACHE_OBJECT_IS_WEIRD,
  39         FSCACHE_OBJECT_INVALIDATED,
  40         FSCACHE_OBJECT_NO_SPACE,
  41         FSCACHE_OBJECT_WAS_RETIRED,
  42         FSCACHE_OBJECT_WAS_CULLED,
  43         FSCACHE_VOLUME_IS_WEIRD,
  44 };
  45
  46 enum cachefiles_coherency_trace {
  47         cachefiles_coherency_check_aux,
  48         cachefiles_coherency_check_content,
  49         cachefiles_coherency_check_dirty,
  50         cachefiles_coherency_check_len,
  51         cachefiles_coherency_check_objsize,
  52         cachefiles_coherency_check_ok,
  53         cachefiles_coherency_check_type,
  54         cachefiles_coherency_check_xattr,
  55         cachefiles_coherency_set_fail,
  56         cachefiles_coherency_set_ok,
  57         cachefiles_coherency_vol_check_cmp,
  58         cachefiles_coherency_vol_check_ok,
  59         cachefiles_coherency_vol_check_resv,
  60         cachefiles_coherency_vol_check_xattr,
  61         cachefiles_coherency_vol_set_fail,
  62         cachefiles_coherency_vol_set_ok,
  63 };
  64
  65 enum cachefiles_trunc_trace {
  66         cachefiles_trunc_dio_adjust,
  67         cachefiles_trunc_expand_tmpfile,
  68         cachefiles_trunc_shrink,
  69 };
  70
  71 enum cachefiles_prepare_read_trace {
  72         cachefiles_trace_read_after_eof,
  73         cachefiles_trace_read_found_hole,
  74         cachefiles_trace_read_found_part,
  75         cachefiles_trace_read_have_data,
  76         cachefiles_trace_read_no_data,
  77         cachefiles_trace_read_no_file,
  78         cachefiles_trace_read_seek_error,
  79         cachefiles_trace_read_seek_nxio,
  80 };
  81
  82 enum cachefiles_error_trace {
  83         cachefiles_trace_fallocate_error,
  84         cachefiles_trace_getxattr_error,
  85         cachefiles_trace_link_error,
  86         cachefiles_trace_lookup_error,
  87         cachefiles_trace_mkdir_error,
  88         cachefiles_trace_notify_change_error,
  89         cachefiles_trace_open_error,
  90         cachefiles_trace_read_error,
  91         cachefiles_trace_remxattr_error,
  92         cachefiles_trace_rename_error,
  93         cachefiles_trace_seek_error,
  94         cachefiles_trace_setxattr_error,
  95         cachefiles_trace_statfs_error,
  96         cachefiles_trace_tmpfile_error,
  97         cachefiles_trace_trunc_error,
  98         cachefiles_trace_unlink_error,
  99         cachefiles_trace_write_error,
 100 };
 101
 102 #endif
 103
 104 /*
 105  * Define enum -> string mappings for display.
 106  */
 107 #define cachefiles_obj_kill_traces                              \
 108         EM(FSCACHE_OBJECT_IS_STALE,     "stale")                \
 109         EM(FSCACHE_OBJECT_IS_WEIRD,     "weird")                \
 110         EM(FSCACHE_OBJECT_INVALIDATED,  "inval")                \
 111         EM(FSCACHE_OBJECT_NO_SPACE,     "no_space")             \
 112         EM(FSCACHE_OBJECT_WAS_RETIRED,  "was_retired")          \
 113         EM(FSCACHE_OBJECT_WAS_CULLED,   "was_culled")           \
 114         E_(FSCACHE_VOLUME_IS_WEIRD,     "volume_weird")
 115
 116 #define cachefiles_obj_ref_traces                                       \
 117         EM(cachefiles_obj_get_ioreq,            "GET ioreq")            \
 118         EM(cachefiles_obj_new,                  "NEW obj")              \
 119         EM(cachefiles_obj_put_alloc_fail,       "PUT alloc_fail")       \
 120         EM(cachefiles_obj_put_detach,           "PUT detach")           \
 121         EM(cachefiles_obj_put_ioreq,            "PUT ioreq")            \
 122         EM(cachefiles_obj_see_clean_commit,     "SEE clean_commit")     \
 123         EM(cachefiles_obj_see_clean_delete,     "SEE clean_delete")     \
 124         EM(cachefiles_obj_see_clean_drop_tmp,   "SEE clean_drop_tmp")   \
 125         EM(cachefiles_obj_see_lookup_cookie,    "SEE lookup_cookie")    \
 126         EM(cachefiles_obj_see_lookup_failed,    "SEE lookup_failed")    \
 127         EM(cachefiles_obj_see_withdraw_cookie,  "SEE withdraw_cookie")  \
 128         E_(cachefiles_obj_see_withdrawal,       "SEE withdrawal")
 129
 130 #define cachefiles_coherency_traces                                     \
 131         EM(cachefiles_coherency_check_aux,      "BAD aux ")             \
 132         EM(cachefiles_coherency_check_content,  "BAD cont")             \
 133         EM(cachefiles_coherency_check_dirty,    "BAD dirt")             \
 134         EM(cachefiles_coherency_check_len,      "BAD len ")             \
 135         EM(cachefiles_coherency_check_objsize,  "BAD osiz")             \
 136         EM(cachefiles_coherency_check_ok,       "OK      ")             \
 137         EM(cachefiles_coherency_check_type,     "BAD type")             \
 138         EM(cachefiles_coherency_check_xattr,    "BAD xatt")             \
 139         EM(cachefiles_coherency_set_fail,       "SET fail")             \
 140         EM(cachefiles_coherency_set_ok,         "SET ok  ")             \
 141         EM(cachefiles_coherency_vol_check_cmp,  "VOL BAD cmp ")         \
 142         EM(cachefiles_coherency_vol_check_ok,   "VOL OK      ")         \
 143         EM(cachefiles_coherency_vol_check_resv, "VOL BAD resv") \
 144         EM(cachefiles_coherency_vol_check_xattr,"VOL BAD xatt")         \
 145         EM(cachefiles_coherency_vol_set_fail,   "VOL SET fail")         \
 146         E_(cachefiles_coherency_vol_set_ok,     "VOL SET ok  ")
 147
 148 #define cachefiles_trunc_traces                                         \
 149         EM(cachefiles_trunc_dio_adjust,         "DIOADJ")               \
 150         EM(cachefiles_trunc_expand_tmpfile,     "EXPTMP")               \
 151         E_(cachefiles_trunc_shrink,             "SHRINK")
 152
 153 #define cachefiles_prepare_read_traces                                  \
 154         EM(cachefiles_trace_read_after_eof,     "after-eof ")           \
 155         EM(cachefiles_trace_read_found_hole,    "found-hole")           \
 156         EM(cachefiles_trace_read_found_part,    "found-part")           \
 157         EM(cachefiles_trace_read_have_data,     "have-data ")           \
 158         EM(cachefiles_trace_read_no_data,       "no-data   ")           \
 159         EM(cachefiles_trace_read_no_file,       "no-file   ")           \
 160         EM(cachefiles_trace_read_seek_error,    "seek-error")           \
 161         E_(cachefiles_trace_read_seek_nxio,     "seek-enxio")
 162
 163 #define cachefiles_error_traces                                         \
 164         EM(cachefiles_trace_fallocate_error,    "fallocate")            \
 165         EM(cachefiles_trace_getxattr_error,     "getxattr")             \
 166         EM(cachefiles_trace_link_error,         "link")                 \
 167         EM(cachefiles_trace_lookup_error,       "lookup")               \
 168         EM(cachefiles_trace_mkdir_error,        "mkdir")                \
 169         EM(cachefiles_trace_notify_change_error, "notify_change")       \
 170         EM(cachefiles_trace_open_error,         "open")                 \
 171         EM(cachefiles_trace_read_error,         "read")                 \
 172         EM(cachefiles_trace_remxattr_error,     "remxattr")             \
 173         EM(cachefiles_trace_rename_error,       "rename")               \
 174         EM(cachefiles_trace_seek_error,         "seek")                 \
 175         EM(cachefiles_trace_setxattr_error,     "setxattr")             \
 176         EM(cachefiles_trace_statfs_error,       "statfs")               \
 177         EM(cachefiles_trace_tmpfile_error,      "tmpfile")              \
 178         EM(cachefiles_trace_trunc_error,        "trunc")                \
 179         EM(cachefiles_trace_unlink_error,       "unlink")               \
 180         E_(cachefiles_trace_write_error,        "write")
 181
 182
 183 /*
 184  * Export enum symbols via userspace.
 185  */
 186 #undef EM
 187 #undef E_
 188 #define EM(a, b) TRACE_DEFINE_ENUM(a);
 189 #define E_(a, b) TRACE_DEFINE_ENUM(a);
 190
 191 cachefiles_obj_kill_traces;
 192 cachefiles_obj_ref_traces;
 193 cachefiles_coherency_traces;
 194 cachefiles_trunc_traces;
 195 cachefiles_prepare_read_traces;
 196 cachefiles_error_traces;
 197
 198 /*
 199  * Now redefine the EM() and E_() macros to map the enums to the strings that
 200  * will be printed in the output.
 201  */
 202 #undef EM
 203 #undef E_
 204 #define EM(a, b)        { a, b },
 205 #define E_(a, b)        { a, b }
 206
 207
 208 TRACE_EVENT(cachefiles_ref,
 209             TP_PROTO(unsigned int object_debug_id,
 210                      unsigned int cookie_debug_id,
 211                      int usage,
 212                      enum cachefiles_obj_ref_trace why),
 213
 214             TP_ARGS(object_debug_id, cookie_debug_id, usage, why),
 215
 216             /* Note that obj may be NULL */
 217             TP_STRUCT__entry(
 218                     __field(unsigned int,                       obj             )
 219                     __field(unsigned int,                       cookie          )
 220                     __field(enum cachefiles_obj_ref_trace,      why             )
 221                     __field(int,                                usage           )
 222                              ),
 223
 224             TP_fast_assign(
 225                     __entry->obj        = object_debug_id;
 226                     __entry->cookie     = cookie_debug_id;
 227                     __entry->usage      = usage;
 228                     __entry->why        = why;
 229                            ),
 230
 231             TP_printk("c=%08x o=%08x u=%d %s",
 232                       __entry->cookie, __entry->obj, __entry->usage,
 233                       __print_symbolic(__entry->why, cachefiles_obj_ref_traces))
 234             );
 235
 236 TRACE_EVENT(cachefiles_lookup,
 237             TP_PROTO(struct cachefiles_object *obj,
 238                      struct dentry *dir,
 239                      struct dentry *de),
 240
 241             TP_ARGS(obj, dir, de),
 242
 243             TP_STRUCT__entry(
 244                     __field(unsigned int,               obj     )
 245                     __field(short,                      error   )
 246                     __field(unsigned long,              dino    )
 247                     __field(unsigned long,              ino     )
 248                              ),
 249
 250             TP_fast_assign(
 251                     __entry->obj        = obj ? obj->debug_id : 0;
 252                     __entry->dino       = d_backing_inode(dir)->i_ino;
 253                     __entry->ino        = (!IS_ERR(de) && d_backing_inode(de) ?
 254                                            d_backing_inode(de)->i_ino : 0);
 255                     __entry->error      = IS_ERR(de) ? PTR_ERR(de) : 0;
 256                            ),
 257
 258             TP_printk("o=%08x dB=%lx B=%lx e=%d",
 259                       __entry->obj, __entry->dino, __entry->ino, __entry->error)
 260             );
 261
 262 TRACE_EVENT(cachefiles_mkdir,
 263             TP_PROTO(struct dentry *dir, struct dentry *subdir),
 264
 265             TP_ARGS(dir, subdir),
 266
 267             TP_STRUCT__entry(
 268                     __field(unsigned int,                       dir     )
 269                     __field(unsigned int,                       subdir  )
 270                              ),
 271
 272             TP_fast_assign(
 273                     __entry->dir        = d_backing_inode(dir)->i_ino;
 274                     __entry->subdir     = d_backing_inode(subdir)->i_ino;
 275                            ),
 276
 277             TP_printk("dB=%x sB=%x",
 278                       __entry->dir,
 279                       __entry->subdir)
 280             );
 281
 282 TRACE_EVENT(cachefiles_tmpfile,
 283             TP_PROTO(struct cachefiles_object *obj, struct inode *backer),
 284
 285             TP_ARGS(obj, backer),
 286
 287             TP_STRUCT__entry(
 288                     __field(unsigned int,                       obj     )
 289                     __field(unsigned int,                       backer  )
 290                              ),
 291
 292             TP_fast_assign(
 293                     __entry->obj        = obj->debug_id;
 294                     __entry->backer     = backer->i_ino;
 295                            ),
 296
 297             TP_printk("o=%08x B=%x",
 298                       __entry->obj,
 299                       __entry->backer)
 300             );
 301
 302 TRACE_EVENT(cachefiles_link,
 303             TP_PROTO(struct cachefiles_object *obj, struct inode *backer),
 304
 305             TP_ARGS(obj, backer),
 306
 307             TP_STRUCT__entry(
 308                     __field(unsigned int,                       obj     )
 309                     __field(unsigned int,                       backer  )
 310                              ),
 311
 312             TP_fast_assign(
 313                     __entry->obj        = obj->debug_id;
 314                     __entry->backer     = backer->i_ino;
 315                            ),
 316
 317             TP_printk("o=%08x B=%x",
 318                       __entry->obj,
 319                       __entry->backer)
 320             );
 321
 322 TRACE_EVENT(cachefiles_unlink,
 323             TP_PROTO(struct cachefiles_object *obj,
 324                      ino_t ino,
 325                      enum fscache_why_object_killed why),
 326
 327             TP_ARGS(obj, ino, why),
 328
 329             /* Note that obj may be NULL */
 330             TP_STRUCT__entry(
 331                     __field(unsigned int,               obj             )
 332                     __field(unsigned int,               ino             )
 333                     __field(enum fscache_why_object_killed, why         )
 334                              ),
 335
 336             TP_fast_assign(
 337                     __entry->obj        = obj ? obj->debug_id : UINT_MAX;
 338                     __entry->ino        = ino;
 339                     __entry->why        = why;
 340                            ),
 341
 342             TP_printk("o=%08x B=%x w=%s",
 343                       __entry->obj, __entry->ino,
 344                       __print_symbolic(__entry->why, cachefiles_obj_kill_traces))
 345             );
 346
 347 TRACE_EVENT(cachefiles_rename,
 348             TP_PROTO(struct cachefiles_object *obj,
 349                      ino_t ino,
 350                      enum fscache_why_object_killed why),
 351
 352             TP_ARGS(obj, ino, why),
 353
 354             /* Note that obj may be NULL */
 355             TP_STRUCT__entry(
 356                     __field(unsigned int,               obj             )
 357                     __field(unsigned int,               ino             )
 358                     __field(enum fscache_why_object_killed, why         )
 359                              ),
 360
 361             TP_fast_assign(
 362                     __entry->obj        = obj ? obj->debug_id : UINT_MAX;
 363                     __entry->ino        = ino;
 364                     __entry->why        = why;
 365                            ),
 366
 367             TP_printk("o=%08x B=%x w=%s",
 368                       __entry->obj, __entry->ino,
 369                       __print_symbolic(__entry->why, cachefiles_obj_kill_traces))
 370             );
 371
 372 TRACE_EVENT(cachefiles_coherency,
 373             TP_PROTO(struct cachefiles_object *obj,
 374                      ino_t ino,
 375                      enum cachefiles_content content,
 376                      enum cachefiles_coherency_trace why),
 377
 378             TP_ARGS(obj, ino, content, why),
 379
 380             /* Note that obj may be NULL */
 381             TP_STRUCT__entry(
 382                     __field(unsigned int,                       obj     )
 383                     __field(enum cachefiles_coherency_trace,    why     )
 384                     __field(enum cachefiles_content,            content )
 385                     __field(u64,                                ino     )
 386                              ),
 387
 388             TP_fast_assign(
 389                     __entry->obj        = obj->debug_id;
 390                     __entry->why        = why;
 391                     __entry->content    = content;
 392                     __entry->ino        = ino;
 393                            ),
 394
 395             TP_printk("o=%08x %s B=%llx c=%u",
 396                       __entry->obj,
 397                       __print_symbolic(__entry->why, cachefiles_coherency_traces),
 398                       __entry->ino,
 399                       __entry->content)
 400             );
 401
 402 TRACE_EVENT(cachefiles_vol_coherency,
 403             TP_PROTO(struct cachefiles_volume *volume,
 404                      ino_t ino,
 405                      enum cachefiles_coherency_trace why),
 406
 407             TP_ARGS(volume, ino, why),
 408
 409             /* Note that obj may be NULL */
 410             TP_STRUCT__entry(
 411                     __field(unsigned int,                       vol     )
 412                     __field(enum cachefiles_coherency_trace,    why     )
 413                     __field(u64,                                ino     )
 414                              ),
 415
 416             TP_fast_assign(
 417                     __entry->vol        = volume->vcookie->debug_id;
 418                     __entry->why        = why;
 419                     __entry->ino        = ino;
 420                            ),
 421
 422             TP_printk("V=%08x %s B=%llx",
 423                       __entry->vol,
 424                       __print_symbolic(__entry->why, cachefiles_coherency_traces),
 425                       __entry->ino)
 426             );
 427
 428 TRACE_EVENT(cachefiles_prep_read,
 429             TP_PROTO(struct netfs_read_subrequest *sreq,
 430                      enum netfs_read_source source,
 431                      enum cachefiles_prepare_read_trace why,
 432                      ino_t cache_inode),
 433
 434             TP_ARGS(sreq, source, why, cache_inode),
 435
 436             TP_STRUCT__entry(
 437                     __field(unsigned int,               rreq            )
 438                     __field(unsigned short,             index           )
 439                     __field(unsigned short,             flags           )
 440                     __field(enum netfs_read_source,     source          )
 441                     __field(enum cachefiles_prepare_read_trace, why     )
 442                     __field(size_t,                     len             )
 443                     __field(loff_t,                     start           )
 444                     __field(unsigned int,               netfs_inode     )
 445                     __field(unsigned int,               cache_inode     )
 446                              ),
 447
 448             TP_fast_assign(
 449                     __entry->rreq       = sreq->rreq->debug_id;
 450                     __entry->index      = sreq->debug_index;
 451                     __entry->flags      = sreq->flags;
 452                     __entry->source     = source;
 453                     __entry->why        = why;
 454                     __entry->len        = sreq->len;
 455                     __entry->start      = sreq->start;
 456                     __entry->netfs_inode = sreq->rreq->inode->i_ino;
 457                     __entry->cache_inode = cache_inode;
 458                            ),
 459
 460             TP_printk("R=%08x[%u] %s %s f=%02x s=%llx %zx ni=%x B=%x",
 461                       __entry->rreq, __entry->index,
 462                       __print_symbolic(__entry->source, netfs_sreq_sources),
 463                       __print_symbolic(__entry->why, cachefiles_prepare_read_traces),
 464                       __entry->flags,
 465                       __entry->start, __entry->len,
 466                       __entry->netfs_inode, __entry->cache_inode)
 467             );
 468
 469 TRACE_EVENT(cachefiles_read,
 470             TP_PROTO(struct cachefiles_object *obj,
 471                      struct inode *backer,
 472                      loff_t start,
 473                      size_t len),
 474
 475             TP_ARGS(obj, backer, start, len),
 476
 477             TP_STRUCT__entry(
 478                     __field(unsigned int,                       obj     )
 479                     __field(unsigned int,                       backer  )
 480                     __field(size_t,                             len     )
 481                     __field(loff_t,                             start   )
 482                              ),
 483
 484             TP_fast_assign(
 485                     __entry->obj        = obj->debug_id;
 486                     __entry->backer     = backer->i_ino;
 487                     __entry->start      = start;
 488                     __entry->len        = len;
 489                            ),
 490
 491             TP_printk("o=%08x B=%x s=%llx l=%zx",
 492                       __entry->obj,
 493                       __entry->backer,
 494                       __entry->start,
 495                       __entry->len)
 496             );
 497
 498 TRACE_EVENT(cachefiles_write,
 499             TP_PROTO(struct cachefiles_object *obj,
 500                      struct inode *backer,
 501                      loff_t start,
 502                      size_t len),
 503
 504             TP_ARGS(obj, backer, start, len),
 505
 506             TP_STRUCT__entry(
 507                     __field(unsigned int,                       obj     )
 508                     __field(unsigned int,                       backer  )
 509                     __field(size_t,                             len     )
 510                     __field(loff_t,                             start   )
 511                              ),
 512
 513             TP_fast_assign(
 514                     __entry->obj        = obj->debug_id;
 515                     __entry->backer     = backer->i_ino;
 516                     __entry->start      = start;
 517                     __entry->len        = len;
 518                            ),
 519
 520             TP_printk("o=%08x B=%x s=%llx l=%zx",
 521                       __entry->obj,
 522                       __entry->backer,
 523                       __entry->start,
 524                       __entry->len)
 525             );
 526
 527 TRACE_EVENT(cachefiles_trunc,
 528             TP_PROTO(struct cachefiles_object *obj, struct inode *backer,
 529                      loff_t from, loff_t to, enum cachefiles_trunc_trace why),
 530
 531             TP_ARGS(obj, backer, from, to, why),
 532
 533             TP_STRUCT__entry(
 534                     __field(unsigned int,                       obj     )
 535                     __field(unsigned int,                       backer  )
 536                     __field(enum cachefiles_trunc_trace,        why     )
 537                     __field(loff_t,                             from    )
 538                     __field(loff_t,                             to      )
 539                              ),
 540
 541             TP_fast_assign(
 542                     __entry->obj        = obj->debug_id;
 543                     __entry->backer     = backer->i_ino;
 544                     __entry->from       = from;
 545                     __entry->to         = to;
 546                     __entry->why        = why;
 547                            ),
 548
 549             TP_printk("o=%08x B=%x %s l=%llx->%llx",
 550                       __entry->obj,
 551                       __entry->backer,
 552                       __print_symbolic(__entry->why, cachefiles_trunc_traces),
 553                       __entry->from,
 554                       __entry->to)
 555             );
 556
 557 TRACE_EVENT(cachefiles_mark_active,
 558             TP_PROTO(struct cachefiles_object *obj,
 559                      struct inode *inode),
 560
 561             TP_ARGS(obj, inode),
 562
 563             /* Note that obj may be NULL */
 564             TP_STRUCT__entry(
 565                     __field(unsigned int,               obj             )
 566                     __field(ino_t,                      inode           )
 567                              ),
 568
 569             TP_fast_assign(
 570                     __entry->obj        = obj ? obj->debug_id : 0;
 571                     __entry->inode      = inode->i_ino;
 572                            ),
 573
 574             TP_printk("o=%08x B=%lx",
 575                       __entry->obj, __entry->inode)
 576             );
 577
 578 TRACE_EVENT(cachefiles_mark_failed,
 579             TP_PROTO(struct cachefiles_object *obj,
 580                      struct inode *inode),
 581
 582             TP_ARGS(obj, inode),
 583
 584             /* Note that obj may be NULL */
 585             TP_STRUCT__entry(
 586                     __field(unsigned int,               obj             )
 587                     __field(ino_t,                      inode           )
 588                              ),
 589
 590             TP_fast_assign(
 591                     __entry->obj        = obj ? obj->debug_id : 0;
 592                     __entry->inode      = inode->i_ino;
 593                            ),
 594
 595             TP_printk("o=%08x B=%lx",
 596                       __entry->obj, __entry->inode)
 597             );
 598
 599 TRACE_EVENT(cachefiles_mark_inactive,
 600             TP_PROTO(struct cachefiles_object *obj,
 601                      struct inode *inode),
 602
 603             TP_ARGS(obj, inode),
 604
 605             /* Note that obj may be NULL */
 606             TP_STRUCT__entry(
 607                     __field(unsigned int,               obj             )
 608                     __field(ino_t,                      inode           )
 609                              ),
 610
 611             TP_fast_assign(
 612                     __entry->obj        = obj ? obj->debug_id : 0;
 613                     __entry->inode      = inode->i_ino;
 614                            ),
 615
 616             TP_printk("o=%08x B=%lx",
 617                       __entry->obj, __entry->inode)
 618             );
 619
 620 TRACE_EVENT(cachefiles_vfs_error,
 621             TP_PROTO(struct cachefiles_object *obj, struct inode *backer,
 622                      int error, enum cachefiles_error_trace where),
 623
 624             TP_ARGS(obj, backer, error, where),
 625
 626             TP_STRUCT__entry(
 627                     __field(unsigned int,                       obj     )
 628                     __field(unsigned int,                       backer  )
 629                     __field(enum cachefiles_error_trace,        where   )
 630                     __field(short,                              error   )
 631                              ),
 632
 633             TP_fast_assign(
 634                     __entry->obj        = obj ? obj->debug_id : 0;
 635                     __entry->backer     = backer->i_ino;
 636                     __entry->error      = error;
 637                     __entry->where      = where;
 638                            ),
 639
 640             TP_printk("o=%08x B=%x %s e=%d",
 641                       __entry->obj,
 642                       __entry->backer,
 643                       __print_symbolic(__entry->where, cachefiles_error_traces),
 644                       __entry->error)
 645             );
 646
 647 TRACE_EVENT(cachefiles_io_error,
 648             TP_PROTO(struct cachefiles_object *obj, struct inode *backer,
 649                      int error, enum cachefiles_error_trace where),
 650
 651             TP_ARGS(obj, backer, error, where),
 652
 653             TP_STRUCT__entry(
 654                     __field(unsigned int,                       obj     )
 655                     __field(unsigned int,                       backer  )
 656                     __field(enum cachefiles_error_trace,        where   )
 657                     __field(short,                              error   )
 658                              ),
 659
 660             TP_fast_assign(
 661                     __entry->obj        = obj ? obj->debug_id : 0;
 662                     __entry->backer     = backer->i_ino;
 663                     __entry->error      = error;
 664                     __entry->where      = where;
 665                            ),
 666
 667             TP_printk("o=%08x B=%x %s e=%d",
 668                       __entry->obj,
 669                       __entry->backer,
 670                       __print_symbolic(__entry->where, cachefiles_error_traces),
 671                       __entry->error)
 672             );
 673
 674 #endif /* _TRACE_CACHEFILES_H */
 675
 676 /* This part must be outside protection */
 677 #include <trace/define_trace.h>