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