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