include/trace/events/fscache.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /* FS-Cache tracepoints
   3  *
   4  * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7 #undef TRACE_SYSTEM
   8 #define TRACE_SYSTEM fscache
   9
  10 #if !defined(_TRACE_FSCACHE_H) || defined(TRACE_HEADER_MULTI_READ)
  11 #define _TRACE_FSCACHE_H
  12
  13 #include <linux/fscache.h>
  14 #include <linux/tracepoint.h>
  15
  16 /*
  17  * Define enums for tracing information.
  18  */
  19 #ifndef __FSCACHE_DECLARE_TRACE_ENUMS_ONCE_ONLY
  20 #define __FSCACHE_DECLARE_TRACE_ENUMS_ONCE_ONLY
  21
  22 enum fscache_cookie_trace {
  23         fscache_cookie_collision,
  24         fscache_cookie_discard,
  25         fscache_cookie_get_acquire_parent,
  26         fscache_cookie_get_attach_object,
  27         fscache_cookie_get_reacquire,
  28         fscache_cookie_get_register_netfs,
  29         fscache_cookie_put_acquire_nobufs,
  30         fscache_cookie_put_dup_netfs,
  31         fscache_cookie_put_relinquish,
  32         fscache_cookie_put_object,
  33         fscache_cookie_put_parent,
  34 };
  35
  36 enum fscache_page_trace {
  37         fscache_page_cached,
  38         fscache_page_inval,
  39         fscache_page_maybe_release,
  40         fscache_page_radix_clear_store,
  41         fscache_page_radix_delete,
  42         fscache_page_radix_insert,
  43         fscache_page_radix_pend2store,
  44         fscache_page_radix_set_pend,
  45         fscache_page_uncache,
  46         fscache_page_write,
  47         fscache_page_write_end,
  48         fscache_page_write_end_pend,
  49         fscache_page_write_end_noc,
  50         fscache_page_write_wait,
  51         fscache_page_trace__nr
  52 };
  53
  54 enum fscache_op_trace {
  55         fscache_op_cancel,
  56         fscache_op_cancel_all,
  57         fscache_op_cancelled,
  58         fscache_op_completed,
  59         fscache_op_enqueue_async,
  60         fscache_op_enqueue_mythread,
  61         fscache_op_gc,
  62         fscache_op_init,
  63         fscache_op_put,
  64         fscache_op_run,
  65         fscache_op_signal,
  66         fscache_op_submit,
  67         fscache_op_submit_ex,
  68         fscache_op_work,
  69         fscache_op_trace__nr
  70 };
  71
  72 enum fscache_page_op_trace {
  73         fscache_page_op_alloc_one,
  74         fscache_page_op_attr_changed,
  75         fscache_page_op_check_consistency,
  76         fscache_page_op_invalidate,
  77         fscache_page_op_retr_multi,
  78         fscache_page_op_retr_one,
  79         fscache_page_op_write_one,
  80         fscache_page_op_trace__nr
  81 };
  82
  83 #endif
  84
  85 /*
  86  * Declare tracing information enums and their string mappings for display.
  87  */
  88 #define fscache_cookie_traces                                           \
  89         EM(fscache_cookie_collision,            "*COLLISION*")          \
  90         EM(fscache_cookie_discard,              "DISCARD")              \
  91         EM(fscache_cookie_get_acquire_parent,   "GET prn")              \
  92         EM(fscache_cookie_get_attach_object,    "GET obj")              \
  93         EM(fscache_cookie_get_reacquire,        "GET raq")              \
  94         EM(fscache_cookie_get_register_netfs,   "GET net")              \
  95         EM(fscache_cookie_put_acquire_nobufs,   "PUT nbf")              \
  96         EM(fscache_cookie_put_dup_netfs,        "PUT dnt")              \
  97         EM(fscache_cookie_put_relinquish,       "PUT rlq")              \
  98         EM(fscache_cookie_put_object,           "PUT obj")              \
  99         E_(fscache_cookie_put_parent,           "PUT prn")
 100
 101 #define fscache_page_traces                                             \
 102         EM(fscache_page_cached,                 "Cached ")              \
 103         EM(fscache_page_inval,                  "InvalPg")              \
 104         EM(fscache_page_maybe_release,          "MayRels")              \
 105         EM(fscache_page_uncache,                "Uncache")              \
 106         EM(fscache_page_radix_clear_store,      "RxCStr ")              \
 107         EM(fscache_page_radix_delete,           "RxDel  ")              \
 108         EM(fscache_page_radix_insert,           "RxIns  ")              \
 109         EM(fscache_page_radix_pend2store,       "RxP2S  ")              \
 110         EM(fscache_page_radix_set_pend,         "RxSPend ")             \
 111         EM(fscache_page_write,                  "WritePg")              \
 112         EM(fscache_page_write_end,              "EndPgWr")              \
 113         EM(fscache_page_write_end_pend,         "EndPgWP")              \
 114         EM(fscache_page_write_end_noc,          "EndPgNC")              \
 115         E_(fscache_page_write_wait,             "WtOnWrt")
 116
 117 #define fscache_op_traces                                               \
 118         EM(fscache_op_cancel,                   "Cancel1")              \
 119         EM(fscache_op_cancel_all,               "CancelA")              \
 120         EM(fscache_op_cancelled,                "Canclld")              \
 121         EM(fscache_op_completed,                "Complet")              \
 122         EM(fscache_op_enqueue_async,            "EnqAsyn")              \
 123         EM(fscache_op_enqueue_mythread,         "EnqMyTh")              \
 124         EM(fscache_op_gc,                       "GC     ")              \
 125         EM(fscache_op_init,                     "Init   ")              \
 126         EM(fscache_op_put,                      "Put    ")              \
 127         EM(fscache_op_run,                      "Run    ")              \
 128         EM(fscache_op_signal,                   "Signal ")              \
 129         EM(fscache_op_submit,                   "Submit ")              \
 130         EM(fscache_op_submit_ex,                "SubmitX")              \
 131         E_(fscache_op_work,                     "Work   ")
 132
 133 #define fscache_page_op_traces                                          \
 134         EM(fscache_page_op_alloc_one,           "Alloc1 ")              \
 135         EM(fscache_page_op_attr_changed,        "AttrChg")              \
 136         EM(fscache_page_op_check_consistency,   "CheckCn")              \
 137         EM(fscache_page_op_invalidate,          "Inval  ")              \
 138         EM(fscache_page_op_retr_multi,          "RetrMul")              \
 139         EM(fscache_page_op_retr_one,            "Retr1  ")              \
 140         E_(fscache_page_op_write_one,           "Write1 ")
 141
 142 /*
 143  * Export enum symbols via userspace.
 144  */
 145 #undef EM
 146 #undef E_
 147 #define EM(a, b) TRACE_DEFINE_ENUM(a);
 148 #define E_(a, b) TRACE_DEFINE_ENUM(a);
 149
 150 fscache_cookie_traces;
 151
 152 /*
 153  * Now redefine the EM() and E_() macros to map the enums to the strings that
 154  * will be printed in the output.
 155  */
 156 #undef EM
 157 #undef E_
 158 #define EM(a, b)        { a, b },
 159 #define E_(a, b)        { a, b }
 160
 161
 162 TRACE_EVENT(fscache_cookie,
 163             TP_PROTO(struct fscache_cookie *cookie,
 164                      enum fscache_cookie_trace where,
 165                      int usage),
 166
 167             TP_ARGS(cookie, where, usage),
 168
 169             TP_STRUCT__entry(
 170                     __field(struct fscache_cookie *,    cookie          )
 171                     __field(struct fscache_cookie *,    parent          )
 172                     __field(enum fscache_cookie_trace,  where           )
 173                     __field(int,                        usage           )
 174                     __field(int,                        n_children      )
 175                     __field(int,                        n_active        )
 176                     __field(u8,                         flags           )
 177                              ),
 178
 179             TP_fast_assign(
 180                     __entry->cookie     = cookie;
 181                     __entry->parent     = cookie->parent;
 182                     __entry->where      = where;
 183                     __entry->usage      = usage;
 184                     __entry->n_children = atomic_read(&cookie->n_children);
 185                     __entry->n_active   = atomic_read(&cookie->n_active);
 186                     __entry->flags      = cookie->flags;
 187                            ),
 188
 189             TP_printk("%s c=%p u=%d p=%p Nc=%d Na=%d f=%02x",
 190                       __print_symbolic(__entry->where, fscache_cookie_traces),
 191                       __entry->cookie, __entry->usage,
 192                       __entry->parent, __entry->n_children, __entry->n_active,
 193                       __entry->flags)
 194             );
 195
 196 TRACE_EVENT(fscache_netfs,
 197             TP_PROTO(struct fscache_netfs *netfs),
 198
 199             TP_ARGS(netfs),
 200
 201             TP_STRUCT__entry(
 202                     __field(struct fscache_cookie *,    cookie          )
 203                     __array(char,                       name, 8         )
 204                              ),
 205
 206             TP_fast_assign(
 207                     __entry->cookie             = netfs->primary_index;
 208                     strncpy(__entry->name, netfs->name, 8);
 209                     __entry->name[7]            = 0;
 210                            ),
 211
 212             TP_printk("c=%p n=%s",
 213                       __entry->cookie, __entry->name)
 214             );
 215
 216 TRACE_EVENT(fscache_acquire,
 217             TP_PROTO(struct fscache_cookie *cookie),
 218
 219             TP_ARGS(cookie),
 220
 221             TP_STRUCT__entry(
 222                     __field(struct fscache_cookie *,    cookie          )
 223                     __field(struct fscache_cookie *,    parent          )
 224                     __array(char,                       name, 8         )
 225                     __field(int,                        p_usage         )
 226                     __field(int,                        p_n_children    )
 227                     __field(u8,                         p_flags         )
 228                              ),
 229
 230             TP_fast_assign(
 231                     __entry->cookie             = cookie;
 232                     __entry->parent             = cookie->parent;
 233                     __entry->p_usage            = atomic_read(&cookie->parent->usage);
 234                     __entry->p_n_children       = atomic_read(&cookie->parent->n_children);
 235                     __entry->p_flags            = cookie->parent->flags;
 236                     memcpy(__entry->name, cookie->def->name, 8);
 237                     __entry->name[7]            = 0;
 238                            ),
 239
 240             TP_printk("c=%p p=%p pu=%d pc=%d pf=%02x n=%s",
 241                       __entry->cookie, __entry->parent, __entry->p_usage,
 242                       __entry->p_n_children, __entry->p_flags, __entry->name)
 243             );
 244
 245 TRACE_EVENT(fscache_relinquish,
 246             TP_PROTO(struct fscache_cookie *cookie, bool retire),
 247
 248             TP_ARGS(cookie, retire),
 249
 250             TP_STRUCT__entry(
 251                     __field(struct fscache_cookie *,    cookie          )
 252                     __field(struct fscache_cookie *,    parent          )
 253                     __field(int,                        usage           )
 254                     __field(int,                        n_children      )
 255                     __field(int,                        n_active        )
 256                     __field(u8,                         flags           )
 257                     __field(bool,                       retire          )
 258                              ),
 259
 260             TP_fast_assign(
 261                     __entry->cookie     = cookie;
 262                     __entry->parent     = cookie->parent;
 263                     __entry->usage      = atomic_read(&cookie->usage);
 264                     __entry->n_children = atomic_read(&cookie->n_children);
 265                     __entry->n_active   = atomic_read(&cookie->n_active);
 266                     __entry->flags      = cookie->flags;
 267                     __entry->retire     = retire;
 268                            ),
 269
 270             TP_printk("c=%p u=%d p=%p Nc=%d Na=%d f=%02x r=%u",
 271                       __entry->cookie, __entry->usage,
 272                       __entry->parent, __entry->n_children, __entry->n_active,
 273                       __entry->flags, __entry->retire)
 274             );
 275
 276 TRACE_EVENT(fscache_enable,
 277             TP_PROTO(struct fscache_cookie *cookie),
 278
 279             TP_ARGS(cookie),
 280
 281             TP_STRUCT__entry(
 282                     __field(struct fscache_cookie *,    cookie          )
 283                     __field(int,                        usage           )
 284                     __field(int,                        n_children      )
 285                     __field(int,                        n_active        )
 286                     __field(u8,                         flags           )
 287                              ),
 288
 289             TP_fast_assign(
 290                     __entry->cookie     = cookie;
 291                     __entry->usage      = atomic_read(&cookie->usage);
 292                     __entry->n_children = atomic_read(&cookie->n_children);
 293                     __entry->n_active   = atomic_read(&cookie->n_active);
 294                     __entry->flags      = cookie->flags;
 295                            ),
 296
 297             TP_printk("c=%p u=%d Nc=%d Na=%d f=%02x",
 298                       __entry->cookie, __entry->usage,
 299                       __entry->n_children, __entry->n_active, __entry->flags)
 300             );
 301
 302 TRACE_EVENT(fscache_disable,
 303             TP_PROTO(struct fscache_cookie *cookie),
 304
 305             TP_ARGS(cookie),
 306
 307             TP_STRUCT__entry(
 308                     __field(struct fscache_cookie *,    cookie          )
 309                     __field(int,                        usage           )
 310                     __field(int,                        n_children      )
 311                     __field(int,                        n_active        )
 312                     __field(u8,                         flags           )
 313                              ),
 314
 315             TP_fast_assign(
 316                     __entry->cookie     = cookie;
 317                     __entry->usage      = atomic_read(&cookie->usage);
 318                     __entry->n_children = atomic_read(&cookie->n_children);
 319                     __entry->n_active   = atomic_read(&cookie->n_active);
 320                     __entry->flags      = cookie->flags;
 321                            ),
 322
 323             TP_printk("c=%p u=%d Nc=%d Na=%d f=%02x",
 324                       __entry->cookie, __entry->usage,
 325                       __entry->n_children, __entry->n_active, __entry->flags)
 326             );
 327
 328 TRACE_EVENT(fscache_osm,
 329             TP_PROTO(struct fscache_object *object,
 330                      const struct fscache_state *state,
 331                      bool wait, bool oob, s8 event_num),
 332
 333             TP_ARGS(object, state, wait, oob, event_num),
 334
 335             TP_STRUCT__entry(
 336                     __field(struct fscache_cookie *,    cookie          )
 337                     __field(struct fscache_object *,    object          )
 338                     __array(char,                       state, 8        )
 339                     __field(bool,                       wait            )
 340                     __field(bool,                       oob             )
 341                     __field(s8,                         event_num       )
 342                              ),
 343
 344             TP_fast_assign(
 345                     __entry->cookie             = object->cookie;
 346                     __entry->object             = object;
 347                     __entry->wait               = wait;
 348                     __entry->oob                = oob;
 349                     __entry->event_num          = event_num;
 350                     memcpy(__entry->state, state->short_name, 8);
 351                            ),
 352
 353             TP_printk("c=%p o=%p %s %s%sev=%d",
 354                       __entry->cookie,
 355                       __entry->object,
 356                       __entry->state,
 357                       __print_symbolic(__entry->wait,
 358                                        { true,  "WAIT" },
 359                                        { false, "WORK" }),
 360                       __print_symbolic(__entry->oob,
 361                                        { true,  " OOB " },
 362                                        { false, " " }),
 363                       __entry->event_num)
 364             );
 365
 366 TRACE_EVENT(fscache_page,
 367             TP_PROTO(struct fscache_cookie *cookie, struct page *page,
 368                      enum fscache_page_trace why),
 369
 370             TP_ARGS(cookie, page, why),
 371
 372             TP_STRUCT__entry(
 373                     __field(struct fscache_cookie *,    cookie          )
 374                     __field(pgoff_t,                    page            )
 375                     __field(enum fscache_page_trace,    why             )
 376                              ),
 377
 378             TP_fast_assign(
 379                     __entry->cookie             = cookie;
 380                     __entry->page               = page->index;
 381                     __entry->why                = why;
 382                            ),
 383
 384             TP_printk("c=%p %s pg=%lx",
 385                       __entry->cookie,
 386                       __print_symbolic(__entry->why, fscache_page_traces),
 387                       __entry->page)
 388             );
 389
 390 TRACE_EVENT(fscache_check_page,
 391             TP_PROTO(struct fscache_cookie *cookie, struct page *page,
 392                      void *val, int n),
 393
 394             TP_ARGS(cookie, page, val, n),
 395
 396             TP_STRUCT__entry(
 397                     __field(struct fscache_cookie *,    cookie          )
 398                     __field(void *,                     page            )
 399                     __field(void *,                     val             )
 400                     __field(int,                        n               )
 401                              ),
 402
 403             TP_fast_assign(
 404                     __entry->cookie             = cookie;
 405                     __entry->page               = page;
 406                     __entry->val                = val;
 407                     __entry->n                  = n;
 408                            ),
 409
 410             TP_printk("c=%p pg=%p val=%p n=%d",
 411                       __entry->cookie, __entry->page, __entry->val, __entry->n)
 412             );
 413
 414 TRACE_EVENT(fscache_wake_cookie,
 415             TP_PROTO(struct fscache_cookie *cookie),
 416
 417             TP_ARGS(cookie),
 418
 419             TP_STRUCT__entry(
 420                     __field(struct fscache_cookie *,    cookie          )
 421                              ),
 422
 423             TP_fast_assign(
 424                     __entry->cookie             = cookie;
 425                            ),
 426
 427             TP_printk("c=%p", __entry->cookie)
 428             );
 429
 430 TRACE_EVENT(fscache_op,
 431             TP_PROTO(struct fscache_cookie *cookie, struct fscache_operation *op,
 432                      enum fscache_op_trace why),
 433
 434             TP_ARGS(cookie, op, why),
 435
 436             TP_STRUCT__entry(
 437                     __field(struct fscache_cookie *,    cookie          )
 438                     __field(struct fscache_operation *, op              )
 439                     __field(enum fscache_op_trace,      why             )
 440                              ),
 441
 442             TP_fast_assign(
 443                     __entry->cookie             = cookie;
 444                     __entry->op                 = op;
 445                     __entry->why                = why;
 446                            ),
 447
 448             TP_printk("c=%p op=%p %s",
 449                       __entry->cookie, __entry->op,
 450                       __print_symbolic(__entry->why, fscache_op_traces))
 451             );
 452
 453 TRACE_EVENT(fscache_page_op,
 454             TP_PROTO(struct fscache_cookie *cookie, struct page *page,
 455                      struct fscache_operation *op, enum fscache_page_op_trace what),
 456
 457             TP_ARGS(cookie, page, op, what),
 458
 459             TP_STRUCT__entry(
 460                     __field(struct fscache_cookie *,    cookie          )
 461                     __field(pgoff_t,                    page            )
 462                     __field(struct fscache_operation *, op              )
 463                     __field(enum fscache_page_op_trace, what            )
 464                              ),
 465
 466             TP_fast_assign(
 467                     __entry->cookie             = cookie;
 468                     __entry->page               = page ? page->index : 0;
 469                     __entry->op                 = op;
 470                     __entry->what               = what;
 471                            ),
 472
 473             TP_printk("c=%p %s pg=%lx op=%p",
 474                       __entry->cookie,
 475                       __print_symbolic(__entry->what, fscache_page_op_traces),
 476                       __entry->page, __entry->op)
 477             );
 478
 479 TRACE_EVENT(fscache_wrote_page,
 480             TP_PROTO(struct fscache_cookie *cookie, struct page *page,
 481                      struct fscache_operation *op, int ret),
 482
 483             TP_ARGS(cookie, page, op, ret),
 484
 485             TP_STRUCT__entry(
 486                     __field(struct fscache_cookie *,    cookie          )
 487                     __field(pgoff_t,                    page            )
 488                     __field(struct fscache_operation *, op              )
 489                     __field(int,                        ret             )
 490                              ),
 491
 492             TP_fast_assign(
 493                     __entry->cookie             = cookie;
 494                     __entry->page               = page->index;
 495                     __entry->op                 = op;
 496                     __entry->ret                = ret;
 497                            ),
 498
 499             TP_printk("c=%p pg=%lx op=%p ret=%d",
 500                       __entry->cookie, __entry->page, __entry->op, __entry->ret)
 501             );
 502
 503 TRACE_EVENT(fscache_gang_lookup,
 504             TP_PROTO(struct fscache_cookie *cookie, struct fscache_operation *op,
 505                      void **results, int n, pgoff_t store_limit),
 506
 507             TP_ARGS(cookie, op, results, n, store_limit),
 508
 509             TP_STRUCT__entry(
 510                     __field(struct fscache_cookie *,    cookie          )
 511                     __field(struct fscache_operation *, op              )
 512                     __field(pgoff_t,                    results0        )
 513                     __field(int,                        n               )
 514                     __field(pgoff_t,                    store_limit     )
 515                              ),
 516
 517             TP_fast_assign(
 518                     __entry->cookie             = cookie;
 519                     __entry->op                 = op;
 520                     __entry->results0           = results[0] ? ((struct page *)results[0])->index : (pgoff_t)-1;
 521                     __entry->n                  = n;
 522                     __entry->store_limit        = store_limit;
 523                            ),
 524
 525             TP_printk("c=%p op=%p r0=%lx n=%d sl=%lx",
 526                       __entry->cookie, __entry->op, __entry->results0, __entry->n,
 527                       __entry->store_limit)
 528             );
 529
 530 #endif /* _TRACE_FSCACHE_H */
 531
 532 /* This part must be outside protection */
 533 #include <trace/define_trace.h>