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