kernel/include/trace/events/writeback.h

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