include/trace/events/writeback.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #undef TRACE_SYSTEM
   3 #define TRACE_SYSTEM writeback
   4
   5 #if !defined(_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ)
   6 #define _TRACE_WRITEBACK_H
   7
   8 #include <linux/tracepoint.h>
   9 #include <linux/backing-dev.h>
  10 #include <linux/writeback.h>
  11
  12 #define show_inode_state(state)                                 \
  13         __print_flags(state, "|",                               \
  14                 {I_DIRTY_SYNC,          "I_DIRTY_SYNC"},        \
  15                 {I_DIRTY_DATASYNC,      "I_DIRTY_DATASYNC"},    \
  16                 {I_DIRTY_PAGES,         "I_DIRTY_PAGES"},       \
  17                 {I_NEW,                 "I_NEW"},               \
  18                 {I_WILL_FREE,           "I_WILL_FREE"},         \
  19                 {I_FREEING,             "I_FREEING"},           \
  20                 {I_CLEAR,               "I_CLEAR"},             \
  21                 {I_SYNC,                "I_SYNC"},              \
  22                 {I_DIRTY_TIME,          "I_DIRTY_TIME"},        \
  23                 {I_REFERENCED,          "I_REFERENCED"},        \
  24                 {I_LINKABLE,            "I_LINKABLE"},          \
  25                 {I_WB_SWITCH,           "I_WB_SWITCH"},         \
  26                 {I_OVL_INUSE,           "I_OVL_INUSE"},         \
  27                 {I_CREATING,            "I_CREATING"},          \
  28                 {I_DONTCACHE,           "I_DONTCACHE"},         \
  29                 {I_SYNC_QUEUED,         "I_SYNC_QUEUED"},       \
  30                 {I_PINNING_NETFS_WB,    "I_PINNING_NETFS_WB"},  \
  31                 {I_LRU_ISOLATING,       "I_LRU_ISOLATING"}      \
  32         )
  33
  34 /* enums need to be exported to user space */
  35 #undef EM
  36 #undef EMe
  37 #define EM(a,b)         TRACE_DEFINE_ENUM(a);
  38 #define EMe(a,b)        TRACE_DEFINE_ENUM(a);
  39
  40 #define WB_WORK_REASON                                                  \
  41         EM( WB_REASON_BACKGROUND,               "background")           \
  42         EM( WB_REASON_VMSCAN,                   "vmscan")               \
  43         EM( WB_REASON_SYNC,                     "sync")                 \
  44         EM( WB_REASON_PERIODIC,                 "periodic")             \
  45         EM( WB_REASON_LAPTOP_TIMER,             "laptop_timer")         \
  46         EM( WB_REASON_FS_FREE_SPACE,            "fs_free_space")        \
  47         EM( WB_REASON_FORKER_THREAD,            "forker_thread")        \
  48         EMe(WB_REASON_FOREIGN_FLUSH,            "foreign_flush")
  49
  50 WB_WORK_REASON
  51
  52 /*
  53  * Now redefine the EM() and EMe() macros to map the enums to the strings
  54  * that will be printed in the output.
  55  */
  56 #undef EM
  57 #undef EMe
  58 #define EM(a,b)         { a, b },
  59 #define EMe(a,b)        { a, b }
  60
  61 struct wb_writeback_work;
  62
  63 DECLARE_EVENT_CLASS(writeback_folio_template,
  64
  65         TP_PROTO(struct folio *folio, struct address_space *mapping),
  66
  67         TP_ARGS(folio, mapping),
  68
  69         TP_STRUCT__entry (
  70                 __array(char, name, 32)
  71                 __field(ino_t, ino)
  72                 __field(pgoff_t, index)
  73         ),
  74
  75         TP_fast_assign(
  76                 strscpy_pad(__entry->name,
  77                             bdi_dev_name(mapping ? inode_to_bdi(mapping->host) :
  78                                          NULL), 32);
  79                 __entry->ino = (mapping && mapping->host) ? mapping->host->i_ino : 0;
  80                 __entry->index = folio->index;
  81         ),
  82
  83         TP_printk("bdi %s: ino=%lu index=%lu",
  84                 __entry->name,
  85                 (unsigned long)__entry->ino,
  86                 __entry->index
  87         )
  88 );
  89
  90 DEFINE_EVENT(writeback_folio_template, writeback_dirty_folio,
  91
  92         TP_PROTO(struct folio *folio, struct address_space *mapping),
  93
  94         TP_ARGS(folio, mapping)
  95 );
  96
  97 DEFINE_EVENT(writeback_folio_template, folio_wait_writeback,
  98
  99         TP_PROTO(struct folio *folio, struct address_space *mapping),
 100
 101         TP_ARGS(folio, mapping)
 102 );
 103
 104 DECLARE_EVENT_CLASS(writeback_dirty_inode_template,
 105
 106         TP_PROTO(struct inode *inode, int flags),
 107
 108         TP_ARGS(inode, flags),
 109
 110         TP_STRUCT__entry (
 111                 __array(char, name, 32)
 112                 __field(ino_t, ino)
 113                 __field(unsigned long, state)
 114                 __field(unsigned long, flags)
 115         ),
 116
 117         TP_fast_assign(
 118                 struct backing_dev_info *bdi = inode_to_bdi(inode);
 119
 120                 /* may be called for files on pseudo FSes w/ unregistered bdi */
 121                 strscpy_pad(__entry->name, bdi_dev_name(bdi), 32);
 122                 __entry->ino            = inode->i_ino;
 123                 __entry->state          = inode->i_state;
 124                 __entry->flags          = flags;
 125         ),
 126
 127         TP_printk("bdi %s: ino=%lu state=%s flags=%s",
 128                 __entry->name,
 129                 (unsigned long)__entry->ino,
 130                 show_inode_state(__entry->state),
 131                 show_inode_state(__entry->flags)
 132         )
 133 );
 134
 135 DEFINE_EVENT(writeback_dirty_inode_template, writeback_mark_inode_dirty,
 136
 137         TP_PROTO(struct inode *inode, int flags),
 138
 139         TP_ARGS(inode, flags)
 140 );
 141
 142 DEFINE_EVENT(writeback_dirty_inode_template, writeback_dirty_inode_start,
 143
 144         TP_PROTO(struct inode *inode, int flags),
 145
 146         TP_ARGS(inode, flags)
 147 );
 148
 149 DEFINE_EVENT(writeback_dirty_inode_template, writeback_dirty_inode,
 150
 151         TP_PROTO(struct inode *inode, int flags),
 152
 153         TP_ARGS(inode, flags)
 154 );
 155
 156 #ifdef CREATE_TRACE_POINTS
 157 #ifdef CONFIG_CGROUP_WRITEBACK
 158
 159 static inline ino_t __trace_wb_assign_cgroup(struct bdi_writeback *wb)
 160 {
 161         return cgroup_ino(wb->memcg_css->cgroup);
 162 }
 163
 164 static inline ino_t __trace_wbc_assign_cgroup(struct writeback_control *wbc)
 165 {
 166         if (wbc->wb)
 167                 return __trace_wb_assign_cgroup(wbc->wb);
 168         else
 169                 return 1;
 170 }
 171 #else   /* CONFIG_CGROUP_WRITEBACK */
 172
 173 static inline ino_t __trace_wb_assign_cgroup(struct bdi_writeback *wb)
 174 {
 175         return 1;
 176 }
 177
 178 static inline ino_t __trace_wbc_assign_cgroup(struct writeback_control *wbc)
 179 {
 180         return 1;
 181 }
 182
 183 #endif  /* CONFIG_CGROUP_WRITEBACK */
 184 #endif  /* CREATE_TRACE_POINTS */
 185
 186 #ifdef CONFIG_CGROUP_WRITEBACK
 187 TRACE_EVENT(inode_foreign_history,
 188
 189         TP_PROTO(struct inode *inode, struct writeback_control *wbc,
 190                  unsigned int history),
 191
 192         TP_ARGS(inode, wbc, history),
 193
 194         TP_STRUCT__entry(
 195                 __array(char,           name, 32)
 196                 __field(ino_t,          ino)
 197                 __field(ino_t,          cgroup_ino)
 198                 __field(unsigned int,   history)
 199         ),
 200
 201         TP_fast_assign(
 202                 strscpy_pad(__entry->name, bdi_dev_name(inode_to_bdi(inode)), 32);
 203                 __entry->ino            = inode->i_ino;
 204                 __entry->cgroup_ino     = __trace_wbc_assign_cgroup(wbc);
 205                 __entry->history        = history;
 206         ),
 207
 208         TP_printk("bdi %s: ino=%lu cgroup_ino=%lu history=0x%x",
 209                 __entry->name,
 210                 (unsigned long)__entry->ino,
 211                 (unsigned long)__entry->cgroup_ino,
 212                 __entry->history
 213         )
 214 );
 215
 216 TRACE_EVENT(inode_switch_wbs,
 217
 218         TP_PROTO(struct inode *inode, struct bdi_writeback *old_wb,
 219                  struct bdi_writeback *new_wb),
 220
 221         TP_ARGS(inode, old_wb, new_wb),
 222
 223         TP_STRUCT__entry(
 224                 __array(char,           name, 32)
 225                 __field(ino_t,          ino)
 226                 __field(ino_t,          old_cgroup_ino)
 227                 __field(ino_t,          new_cgroup_ino)
 228         ),
 229
 230         TP_fast_assign(
 231                 strscpy_pad(__entry->name, bdi_dev_name(old_wb->bdi), 32);
 232                 __entry->ino            = inode->i_ino;
 233                 __entry->old_cgroup_ino = __trace_wb_assign_cgroup(old_wb);
 234                 __entry->new_cgroup_ino = __trace_wb_assign_cgroup(new_wb);
 235         ),
 236
 237         TP_printk("bdi %s: ino=%lu old_cgroup_ino=%lu new_cgroup_ino=%lu",
 238                 __entry->name,
 239                 (unsigned long)__entry->ino,
 240                 (unsigned long)__entry->old_cgroup_ino,
 241                 (unsigned long)__entry->new_cgroup_ino
 242         )
 243 );
 244
 245 TRACE_EVENT(track_foreign_dirty,
 246
 247         TP_PROTO(struct folio *folio, struct bdi_writeback *wb),
 248
 249         TP_ARGS(folio, wb),
 250
 251         TP_STRUCT__entry(
 252                 __array(char,           name, 32)
 253                 __field(u64,            bdi_id)
 254                 __field(ino_t,          ino)
 255                 __field(unsigned int,   memcg_id)
 256                 __field(ino_t,          cgroup_ino)
 257                 __field(ino_t,          page_cgroup_ino)
 258         ),
 259
 260         TP_fast_assign(
 261                 struct address_space *mapping = folio_mapping(folio);
 262                 struct inode *inode = mapping ? mapping->host : NULL;
 263
 264                 strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
 265                 __entry->bdi_id         = wb->bdi->id;
 266                 __entry->ino            = inode ? inode->i_ino : 0;
 267                 __entry->memcg_id       = wb->memcg_css->id;
 268                 __entry->cgroup_ino     = __trace_wb_assign_cgroup(wb);
 269                 __entry->page_cgroup_ino = cgroup_ino(folio_memcg(folio)->css.cgroup);
 270         ),
 271
 272         TP_printk("bdi %s[%llu]: ino=%lu memcg_id=%u cgroup_ino=%lu page_cgroup_ino=%lu",
 273                 __entry->name,
 274                 __entry->bdi_id,
 275                 (unsigned long)__entry->ino,
 276                 __entry->memcg_id,
 277                 (unsigned long)__entry->cgroup_ino,
 278                 (unsigned long)__entry->page_cgroup_ino
 279         )
 280 );
 281
 282 TRACE_EVENT(flush_foreign,
 283
 284         TP_PROTO(struct bdi_writeback *wb, unsigned int frn_bdi_id,
 285                  unsigned int frn_memcg_id),
 286
 287         TP_ARGS(wb, frn_bdi_id, frn_memcg_id),
 288
 289         TP_STRUCT__entry(
 290                 __array(char,           name, 32)
 291                 __field(ino_t,          cgroup_ino)
 292                 __field(unsigned int,   frn_bdi_id)
 293                 __field(unsigned int,   frn_memcg_id)
 294         ),
 295
 296         TP_fast_assign(
 297                 strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
 298                 __entry->cgroup_ino     = __trace_wb_assign_cgroup(wb);
 299                 __entry->frn_bdi_id     = frn_bdi_id;
 300                 __entry->frn_memcg_id   = frn_memcg_id;
 301         ),
 302
 303         TP_printk("bdi %s: cgroup_ino=%lu frn_bdi_id=%u frn_memcg_id=%u",
 304                 __entry->name,
 305                 (unsigned long)__entry->cgroup_ino,
 306                 __entry->frn_bdi_id,
 307                 __entry->frn_memcg_id
 308         )
 309 );
 310 #endif
 311
 312 DECLARE_EVENT_CLASS(writeback_write_inode_template,
 313
 314         TP_PROTO(struct inode *inode, struct writeback_control *wbc),
 315
 316         TP_ARGS(inode, wbc),
 317
 318         TP_STRUCT__entry (
 319                 __array(char, name, 32)
 320                 __field(ino_t, ino)
 321                 __field(int, sync_mode)
 322                 __field(ino_t, cgroup_ino)
 323         ),
 324
 325         TP_fast_assign(
 326                 strscpy_pad(__entry->name,
 327                             bdi_dev_name(inode_to_bdi(inode)), 32);
 328                 __entry->ino            = inode->i_ino;
 329                 __entry->sync_mode      = wbc->sync_mode;
 330                 __entry->cgroup_ino     = __trace_wbc_assign_cgroup(wbc);
 331         ),
 332
 333         TP_printk("bdi %s: ino=%lu sync_mode=%d cgroup_ino=%lu",
 334                 __entry->name,
 335                 (unsigned long)__entry->ino,
 336                 __entry->sync_mode,
 337                 (unsigned long)__entry->cgroup_ino
 338         )
 339 );
 340
 341 DEFINE_EVENT(writeback_write_inode_template, writeback_write_inode_start,
 342
 343         TP_PROTO(struct inode *inode, struct writeback_control *wbc),
 344
 345         TP_ARGS(inode, wbc)
 346 );
 347
 348 DEFINE_EVENT(writeback_write_inode_template, writeback_write_inode,
 349
 350         TP_PROTO(struct inode *inode, struct writeback_control *wbc),
 351
 352         TP_ARGS(inode, wbc)
 353 );
 354
 355 DECLARE_EVENT_CLASS(writeback_work_class,
 356         TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work),
 357         TP_ARGS(wb, work),
 358         TP_STRUCT__entry(
 359                 __array(char, name, 32)
 360                 __field(long, nr_pages)
 361                 __field(dev_t, sb_dev)
 362                 __field(int, sync_mode)
 363                 __field(int, for_kupdate)
 364                 __field(int, range_cyclic)
 365                 __field(int, for_background)
 366                 __field(int, reason)
 367                 __field(ino_t, cgroup_ino)
 368         ),
 369         TP_fast_assign(
 370                 strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
 371                 __entry->nr_pages = work->nr_pages;
 372                 __entry->sb_dev = work->sb ? work->sb->s_dev : 0;
 373                 __entry->sync_mode = work->sync_mode;
 374                 __entry->for_kupdate = work->for_kupdate;
 375                 __entry->range_cyclic = work->range_cyclic;
 376                 __entry->for_background = work->for_background;
 377                 __entry->reason = work->reason;
 378                 __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
 379         ),
 380         TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
 381                   "kupdate=%d range_cyclic=%d background=%d reason=%s cgroup_ino=%lu",
 382                   __entry->name,
 383                   MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
 384                   __entry->nr_pages,
 385                   __entry->sync_mode,
 386                   __entry->for_kupdate,
 387                   __entry->range_cyclic,
 388                   __entry->for_background,
 389                   __print_symbolic(__entry->reason, WB_WORK_REASON),
 390                   (unsigned long)__entry->cgroup_ino
 391         )
 392 );
 393 #define DEFINE_WRITEBACK_WORK_EVENT(name) \
 394 DEFINE_EVENT(writeback_work_class, name, \
 395         TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work), \
 396         TP_ARGS(wb, work))
 397 DEFINE_WRITEBACK_WORK_EVENT(writeback_queue);
 398 DEFINE_WRITEBACK_WORK_EVENT(writeback_exec);
 399 DEFINE_WRITEBACK_WORK_EVENT(writeback_start);
 400 DEFINE_WRITEBACK_WORK_EVENT(writeback_written);
 401 DEFINE_WRITEBACK_WORK_EVENT(writeback_wait);
 402
 403 TRACE_EVENT(writeback_pages_written,
 404         TP_PROTO(long pages_written),
 405         TP_ARGS(pages_written),
 406         TP_STRUCT__entry(
 407                 __field(long,           pages)
 408         ),
 409         TP_fast_assign(
 410                 __entry->pages          = pages_written;
 411         ),
 412         TP_printk("%ld", __entry->pages)
 413 );
 414
 415 DECLARE_EVENT_CLASS(writeback_class,
 416         TP_PROTO(struct bdi_writeback *wb),
 417         TP_ARGS(wb),
 418         TP_STRUCT__entry(
 419                 __array(char, name, 32)
 420                 __field(ino_t, cgroup_ino)
 421         ),
 422         TP_fast_assign(
 423                 strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
 424                 __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
 425         ),
 426         TP_printk("bdi %s: cgroup_ino=%lu",
 427                   __entry->name,
 428                   (unsigned long)__entry->cgroup_ino
 429         )
 430 );
 431 #define DEFINE_WRITEBACK_EVENT(name) \
 432 DEFINE_EVENT(writeback_class, name, \
 433         TP_PROTO(struct bdi_writeback *wb), \
 434         TP_ARGS(wb))
 435
 436 DEFINE_WRITEBACK_EVENT(writeback_wake_background);
 437
 438 TRACE_EVENT(writeback_bdi_register,
 439         TP_PROTO(struct backing_dev_info *bdi),
 440         TP_ARGS(bdi),
 441         TP_STRUCT__entry(
 442                 __array(char, name, 32)
 443         ),
 444         TP_fast_assign(
 445                 strscpy_pad(__entry->name, bdi_dev_name(bdi), 32);
 446         ),
 447         TP_printk("bdi %s",
 448                 __entry->name
 449         )
 450 );
 451
 452 DECLARE_EVENT_CLASS(wbc_class,
 453         TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
 454         TP_ARGS(wbc, bdi),
 455         TP_STRUCT__entry(
 456                 __array(char, name, 32)
 457                 __field(long, nr_to_write)
 458                 __field(long, pages_skipped)
 459                 __field(int, sync_mode)
 460                 __field(int, for_kupdate)
 461                 __field(int, for_background)
 462                 __field(int, for_reclaim)
 463                 __field(int, range_cyclic)
 464                 __field(long, range_start)
 465                 __field(long, range_end)
 466                 __field(ino_t, cgroup_ino)
 467         ),
 468
 469         TP_fast_assign(
 470                 strscpy_pad(__entry->name, bdi_dev_name(bdi), 32);
 471                 __entry->nr_to_write    = wbc->nr_to_write;
 472                 __entry->pages_skipped  = wbc->pages_skipped;
 473                 __entry->sync_mode      = wbc->sync_mode;
 474                 __entry->for_kupdate    = wbc->for_kupdate;
 475                 __entry->for_background = wbc->for_background;
 476                 __entry->for_reclaim    = wbc->for_reclaim;
 477                 __entry->range_cyclic   = wbc->range_cyclic;
 478                 __entry->range_start    = (long)wbc->range_start;
 479                 __entry->range_end      = (long)wbc->range_end;
 480                 __entry->cgroup_ino     = __trace_wbc_assign_cgroup(wbc);
 481         ),
 482
 483         TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
 484                 "bgrd=%d reclm=%d cyclic=%d "
 485                 "start=0x%lx end=0x%lx cgroup_ino=%lu",
 486                 __entry->name,
 487                 __entry->nr_to_write,
 488                 __entry->pages_skipped,
 489                 __entry->sync_mode,
 490                 __entry->for_kupdate,
 491                 __entry->for_background,
 492                 __entry->for_reclaim,
 493                 __entry->range_cyclic,
 494                 __entry->range_start,
 495                 __entry->range_end,
 496                 (unsigned long)__entry->cgroup_ino
 497         )
 498 )
 499
 500 #define DEFINE_WBC_EVENT(name) \
 501 DEFINE_EVENT(wbc_class, name, \
 502         TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
 503         TP_ARGS(wbc, bdi))
 504 DEFINE_WBC_EVENT(wbc_writepage);
 505
 506 TRACE_EVENT(writeback_queue_io,
 507         TP_PROTO(struct bdi_writeback *wb,
 508                  struct wb_writeback_work *work,
 509                  unsigned long dirtied_before,
 510                  int moved),
 511         TP_ARGS(wb, work, dirtied_before, moved),
 512         TP_STRUCT__entry(
 513                 __array(char,           name, 32)
 514                 __field(unsigned long,  older)
 515                 __field(long,           age)
 516                 __field(int,            moved)
 517                 __field(int,            reason)
 518                 __field(ino_t,          cgroup_ino)
 519         ),
 520         TP_fast_assign(
 521                 strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
 522                 __entry->older  = dirtied_before;
 523                 __entry->age    = (jiffies - dirtied_before) * 1000 / HZ;
 524                 __entry->moved  = moved;
 525                 __entry->reason = work->reason;
 526                 __entry->cgroup_ino     = __trace_wb_assign_cgroup(wb);
 527         ),
 528         TP_printk("bdi %s: older=%lu age=%ld enqueue=%d reason=%s cgroup_ino=%lu",
 529                 __entry->name,
 530                 __entry->older, /* dirtied_before in jiffies */
 531                 __entry->age,   /* dirtied_before in relative milliseconds */
 532                 __entry->moved,
 533                 __print_symbolic(__entry->reason, WB_WORK_REASON),
 534                 (unsigned long)__entry->cgroup_ino
 535         )
 536 );
 537
 538 TRACE_EVENT(global_dirty_state,
 539
 540         TP_PROTO(unsigned long background_thresh,
 541                  unsigned long dirty_thresh
 542         ),
 543
 544         TP_ARGS(background_thresh,
 545                 dirty_thresh
 546         ),
 547
 548         TP_STRUCT__entry(
 549                 __field(unsigned long,  nr_dirty)
 550                 __field(unsigned long,  nr_writeback)
 551                 __field(unsigned long,  background_thresh)
 552                 __field(unsigned long,  dirty_thresh)
 553                 __field(unsigned long,  dirty_limit)
 554                 __field(unsigned long,  nr_dirtied)
 555                 __field(unsigned long,  nr_written)
 556         ),
 557
 558         TP_fast_assign(
 559                 __entry->nr_dirty       = global_node_page_state(NR_FILE_DIRTY);
 560                 __entry->nr_writeback   = global_node_page_state(NR_WRITEBACK);
 561                 __entry->nr_dirtied     = global_node_page_state(NR_DIRTIED);
 562                 __entry->nr_written     = global_node_page_state(NR_WRITTEN);
 563                 __entry->background_thresh = background_thresh;
 564                 __entry->dirty_thresh   = dirty_thresh;
 565                 __entry->dirty_limit    = global_wb_domain.dirty_limit;
 566         ),
 567
 568         TP_printk("dirty=%lu writeback=%lu "
 569                   "bg_thresh=%lu thresh=%lu limit=%lu "
 570                   "dirtied=%lu written=%lu",
 571                   __entry->nr_dirty,
 572                   __entry->nr_writeback,
 573                   __entry->background_thresh,
 574                   __entry->dirty_thresh,
 575                   __entry->dirty_limit,
 576                   __entry->nr_dirtied,
 577                   __entry->nr_written
 578         )
 579 );
 580
 581 #define KBps(x)                 ((x) << (PAGE_SHIFT - 10))
 582
 583 TRACE_EVENT(bdi_dirty_ratelimit,
 584
 585         TP_PROTO(struct bdi_writeback *wb,
 586                  unsigned long dirty_rate,
 587                  unsigned long task_ratelimit),
 588
 589         TP_ARGS(wb, dirty_rate, task_ratelimit),
 590
 591         TP_STRUCT__entry(
 592                 __array(char,           bdi, 32)
 593                 __field(unsigned long,  write_bw)
 594                 __field(unsigned long,  avg_write_bw)
 595                 __field(unsigned long,  dirty_rate)
 596                 __field(unsigned long,  dirty_ratelimit)
 597                 __field(unsigned long,  task_ratelimit)
 598                 __field(unsigned long,  balanced_dirty_ratelimit)
 599                 __field(ino_t,          cgroup_ino)
 600         ),
 601
 602         TP_fast_assign(
 603                 strscpy_pad(__entry->bdi, bdi_dev_name(wb->bdi), 32);
 604                 __entry->write_bw       = KBps(wb->write_bandwidth);
 605                 __entry->avg_write_bw   = KBps(wb->avg_write_bandwidth);
 606                 __entry->dirty_rate     = KBps(dirty_rate);
 607                 __entry->dirty_ratelimit = KBps(wb->dirty_ratelimit);
 608                 __entry->task_ratelimit = KBps(task_ratelimit);
 609                 __entry->balanced_dirty_ratelimit =
 610                                         KBps(wb->balanced_dirty_ratelimit);
 611                 __entry->cgroup_ino     = __trace_wb_assign_cgroup(wb);
 612         ),
 613
 614         TP_printk("bdi %s: "
 615                   "write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
 616                   "dirty_ratelimit=%lu task_ratelimit=%lu "
 617                   "balanced_dirty_ratelimit=%lu cgroup_ino=%lu",
 618                   __entry->bdi,
 619                   __entry->write_bw,            /* write bandwidth */
 620                   __entry->avg_write_bw,        /* avg write bandwidth */
 621                   __entry->dirty_rate,          /* bdi dirty rate */
 622                   __entry->dirty_ratelimit,     /* base ratelimit */
 623                   __entry->task_ratelimit, /* ratelimit with position control */
 624                   __entry->balanced_dirty_ratelimit, /* the balanced ratelimit */
 625                   (unsigned long)__entry->cgroup_ino
 626         )
 627 );
 628
 629 TRACE_EVENT(balance_dirty_pages,
 630
 631         TP_PROTO(struct bdi_writeback *wb,
 632                  unsigned long thresh,
 633                  unsigned long bg_thresh,
 634                  unsigned long dirty,
 635                  unsigned long bdi_thresh,
 636                  unsigned long bdi_dirty,
 637                  unsigned long dirty_ratelimit,
 638                  unsigned long task_ratelimit,
 639                  unsigned long dirtied,
 640                  unsigned long period,
 641                  long pause,
 642                  unsigned long start_time),
 643
 644         TP_ARGS(wb, thresh, bg_thresh, dirty, bdi_thresh, bdi_dirty,
 645                 dirty_ratelimit, task_ratelimit,
 646                 dirtied, period, pause, start_time),
 647
 648         TP_STRUCT__entry(
 649                 __array(         char,  bdi, 32)
 650                 __field(unsigned long,  limit)
 651                 __field(unsigned long,  setpoint)
 652                 __field(unsigned long,  dirty)
 653                 __field(unsigned long,  bdi_setpoint)
 654                 __field(unsigned long,  bdi_dirty)
 655                 __field(unsigned long,  dirty_ratelimit)
 656                 __field(unsigned long,  task_ratelimit)
 657                 __field(unsigned int,   dirtied)
 658                 __field(unsigned int,   dirtied_pause)
 659                 __field(unsigned long,  paused)
 660                 __field(         long,  pause)
 661                 __field(unsigned long,  period)
 662                 __field(         long,  think)
 663                 __field(ino_t,          cgroup_ino)
 664         ),
 665
 666         TP_fast_assign(
 667                 unsigned long freerun = (thresh + bg_thresh) / 2;
 668                 strscpy_pad(__entry->bdi, bdi_dev_name(wb->bdi), 32);
 669
 670                 __entry->limit          = global_wb_domain.dirty_limit;
 671                 __entry->setpoint       = (global_wb_domain.dirty_limit +
 672                                                 freerun) / 2;
 673                 __entry->dirty          = dirty;
 674                 __entry->bdi_setpoint   = __entry->setpoint *
 675                                                 bdi_thresh / (thresh + 1);
 676                 __entry->bdi_dirty      = bdi_dirty;
 677                 __entry->dirty_ratelimit = KBps(dirty_ratelimit);
 678                 __entry->task_ratelimit = KBps(task_ratelimit);
 679                 __entry->dirtied        = dirtied;
 680                 __entry->dirtied_pause  = current->nr_dirtied_pause;
 681                 __entry->think          = current->dirty_paused_when == 0 ? 0 :
 682                          (long)(jiffies - current->dirty_paused_when) * 1000/HZ;
 683                 __entry->period         = period * 1000 / HZ;
 684                 __entry->pause          = pause * 1000 / HZ;
 685                 __entry->paused         = (jiffies - start_time) * 1000 / HZ;
 686                 __entry->cgroup_ino     = __trace_wb_assign_cgroup(wb);
 687         ),
 688
 689
 690         TP_printk("bdi %s: "
 691                   "limit=%lu setpoint=%lu dirty=%lu "
 692                   "bdi_setpoint=%lu bdi_dirty=%lu "
 693                   "dirty_ratelimit=%lu task_ratelimit=%lu "
 694                   "dirtied=%u dirtied_pause=%u "
 695                   "paused=%lu pause=%ld period=%lu think=%ld cgroup_ino=%lu",
 696                   __entry->bdi,
 697                   __entry->limit,
 698                   __entry->setpoint,
 699                   __entry->dirty,
 700                   __entry->bdi_setpoint,
 701                   __entry->bdi_dirty,
 702                   __entry->dirty_ratelimit,
 703                   __entry->task_ratelimit,
 704                   __entry->dirtied,
 705                   __entry->dirtied_pause,
 706                   __entry->paused,      /* ms */
 707                   __entry->pause,       /* ms */
 708                   __entry->period,      /* ms */
 709                   __entry->think,       /* ms */
 710                   (unsigned long)__entry->cgroup_ino
 711           )
 712 );
 713
 714 TRACE_EVENT(writeback_sb_inodes_requeue,
 715
 716         TP_PROTO(struct inode *inode),
 717         TP_ARGS(inode),
 718
 719         TP_STRUCT__entry(
 720                 __array(char, name, 32)
 721                 __field(ino_t, ino)
 722                 __field(unsigned long, state)
 723                 __field(unsigned long, dirtied_when)
 724                 __field(ino_t, cgroup_ino)
 725         ),
 726
 727         TP_fast_assign(
 728                 strscpy_pad(__entry->name,
 729                             bdi_dev_name(inode_to_bdi(inode)), 32);
 730                 __entry->ino            = inode->i_ino;
 731                 __entry->state          = inode->i_state;
 732                 __entry->dirtied_when   = inode->dirtied_when;
 733                 __entry->cgroup_ino     = __trace_wb_assign_cgroup(inode_to_wb(inode));
 734         ),
 735
 736         TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu cgroup_ino=%lu",
 737                   __entry->name,
 738                   (unsigned long)__entry->ino,
 739                   show_inode_state(__entry->state),
 740                   __entry->dirtied_when,
 741                   (jiffies - __entry->dirtied_when) / HZ,
 742                   (unsigned long)__entry->cgroup_ino
 743         )
 744 );
 745
 746 DECLARE_EVENT_CLASS(writeback_single_inode_template,
 747
 748         TP_PROTO(struct inode *inode,
 749                  struct writeback_control *wbc,
 750                  unsigned long nr_to_write
 751         ),
 752
 753         TP_ARGS(inode, wbc, nr_to_write),
 754
 755         TP_STRUCT__entry(
 756                 __array(char, name, 32)
 757                 __field(ino_t, ino)
 758                 __field(unsigned long, state)
 759                 __field(unsigned long, dirtied_when)
 760                 __field(unsigned long, writeback_index)
 761                 __field(long, nr_to_write)
 762                 __field(unsigned long, wrote)
 763                 __field(ino_t, cgroup_ino)
 764         ),
 765
 766         TP_fast_assign(
 767                 strscpy_pad(__entry->name,
 768                             bdi_dev_name(inode_to_bdi(inode)), 32);
 769                 __entry->ino            = inode->i_ino;
 770                 __entry->state          = inode->i_state;
 771                 __entry->dirtied_when   = inode->dirtied_when;
 772                 __entry->writeback_index = inode->i_mapping->writeback_index;
 773                 __entry->nr_to_write    = nr_to_write;
 774                 __entry->wrote          = nr_to_write - wbc->nr_to_write;
 775                 __entry->cgroup_ino     = __trace_wbc_assign_cgroup(wbc);
 776         ),
 777
 778         TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu "
 779                   "index=%lu to_write=%ld wrote=%lu cgroup_ino=%lu",
 780                   __entry->name,
 781                   (unsigned long)__entry->ino,
 782                   show_inode_state(__entry->state),
 783                   __entry->dirtied_when,
 784                   (jiffies - __entry->dirtied_when) / HZ,
 785                   __entry->writeback_index,
 786                   __entry->nr_to_write,
 787                   __entry->wrote,
 788                   (unsigned long)__entry->cgroup_ino
 789         )
 790 );
 791
 792 DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode_start,
 793         TP_PROTO(struct inode *inode,
 794                  struct writeback_control *wbc,
 795                  unsigned long nr_to_write),
 796         TP_ARGS(inode, wbc, nr_to_write)
 797 );
 798
 799 DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode,
 800         TP_PROTO(struct inode *inode,
 801                  struct writeback_control *wbc,
 802                  unsigned long nr_to_write),
 803         TP_ARGS(inode, wbc, nr_to_write)
 804 );
 805
 806 DECLARE_EVENT_CLASS(writeback_inode_template,
 807         TP_PROTO(struct inode *inode),
 808
 809         TP_ARGS(inode),
 810
 811         TP_STRUCT__entry(
 812                 __field(        dev_t,  dev                     )
 813                 __field(        ino_t,  ino                     )
 814                 __field(unsigned long,  state                   )
 815                 __field(        __u16, mode                     )
 816                 __field(unsigned long, dirtied_when             )
 817         ),
 818
 819         TP_fast_assign(
 820                 __entry->dev    = inode->i_sb->s_dev;
 821                 __entry->ino    = inode->i_ino;
 822                 __entry->state  = inode->i_state;
 823                 __entry->mode   = inode->i_mode;
 824                 __entry->dirtied_when = inode->dirtied_when;
 825         ),
 826
 827         TP_printk("dev %d,%d ino %lu dirtied %lu state %s mode 0%o",
 828                   MAJOR(__entry->dev), MINOR(__entry->dev),
 829                   (unsigned long)__entry->ino, __entry->dirtied_when,
 830                   show_inode_state(__entry->state), __entry->mode)
 831 );
 832
 833 DEFINE_EVENT(writeback_inode_template, writeback_lazytime,
 834         TP_PROTO(struct inode *inode),
 835
 836         TP_ARGS(inode)
 837 );
 838
 839 DEFINE_EVENT(writeback_inode_template, writeback_lazytime_iput,
 840         TP_PROTO(struct inode *inode),
 841
 842         TP_ARGS(inode)
 843 );
 844
 845 DEFINE_EVENT(writeback_inode_template, writeback_dirty_inode_enqueue,
 846
 847         TP_PROTO(struct inode *inode),
 848
 849         TP_ARGS(inode)
 850 );
 851
 852 /*
 853  * Inode writeback list tracking.
 854  */
 855
 856 DEFINE_EVENT(writeback_inode_template, sb_mark_inode_writeback,
 857         TP_PROTO(struct inode *inode),
 858         TP_ARGS(inode)
 859 );
 860
 861 DEFINE_EVENT(writeback_inode_template, sb_clear_inode_writeback,
 862         TP_PROTO(struct inode *inode),
 863         TP_ARGS(inode)
 864 );
 865
 866 #endif /* _TRACE_WRITEBACK_H */
 867
 868 /* This part must be outside protection */
 869 #include <trace/define_trace.h>