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/backing-dev.h>
   8 #include <linux/device.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_REFERENCED,          "I_REFERENCED"}         \
  22         )
  23
  24 struct wb_writeback_work;
  25
  26 DECLARE_EVENT_CLASS(writeback_work_class,
  27         TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
  28         TP_ARGS(bdi, work),
  29         TP_STRUCT__entry(
  30                 __array(char, name, 32)
  31                 __field(long, nr_pages)
  32                 __field(dev_t, sb_dev)
  33                 __field(int, sync_mode)
  34                 __field(int, for_kupdate)
  35                 __field(int, range_cyclic)
  36                 __field(int, for_background)
  37         ),
  38         TP_fast_assign(
  39                 strncpy(__entry->name, dev_name(bdi->dev), 32);
  40                 __entry->nr_pages = work->nr_pages;
  41                 __entry->sb_dev = work->sb ? work->sb->s_dev : 0;
  42                 __entry->sync_mode = work->sync_mode;
  43                 __entry->for_kupdate = work->for_kupdate;
  44                 __entry->range_cyclic = work->range_cyclic;
  45                 __entry->for_background = work->for_background;
  46         ),
  47         TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
  48                   "kupdate=%d range_cyclic=%d background=%d",
  49                   __entry->name,
  50                   MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
  51                   __entry->nr_pages,
  52                   __entry->sync_mode,
  53                   __entry->for_kupdate,
  54                   __entry->range_cyclic,
  55                   __entry->for_background
  56         )
  57 );
  58 #define DEFINE_WRITEBACK_WORK_EVENT(name) \
  59 DEFINE_EVENT(writeback_work_class, name, \
  60         TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work), \
  61         TP_ARGS(bdi, work))
  62 DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread);
  63 DEFINE_WRITEBACK_WORK_EVENT(writeback_queue);
  64 DEFINE_WRITEBACK_WORK_EVENT(writeback_exec);
  65
  66 TRACE_EVENT(writeback_pages_written,
  67         TP_PROTO(long pages_written),
  68         TP_ARGS(pages_written),
  69         TP_STRUCT__entry(
  70                 __field(long,           pages)
  71         ),
  72         TP_fast_assign(
  73                 __entry->pages          = pages_written;
  74         ),
  75         TP_printk("%ld", __entry->pages)
  76 );
  77
  78 DECLARE_EVENT_CLASS(writeback_class,
  79         TP_PROTO(struct backing_dev_info *bdi),
  80         TP_ARGS(bdi),
  81         TP_STRUCT__entry(
  82                 __array(char, name, 32)
  83         ),
  84         TP_fast_assign(
  85                 strncpy(__entry->name, dev_name(bdi->dev), 32);
  86         ),
  87         TP_printk("bdi %s",
  88                   __entry->name
  89         )
  90 );
  91 #define DEFINE_WRITEBACK_EVENT(name) \
  92 DEFINE_EVENT(writeback_class, name, \
  93         TP_PROTO(struct backing_dev_info *bdi), \
  94         TP_ARGS(bdi))
  95
  96 DEFINE_WRITEBACK_EVENT(writeback_nowork);
  97 DEFINE_WRITEBACK_EVENT(writeback_wake_background);
  98 DEFINE_WRITEBACK_EVENT(writeback_wake_thread);
  99 DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread);
 100 DEFINE_WRITEBACK_EVENT(writeback_bdi_register);
 101 DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister);
 102 DEFINE_WRITEBACK_EVENT(writeback_thread_start);
 103 DEFINE_WRITEBACK_EVENT(writeback_thread_stop);
 104
 105 DECLARE_EVENT_CLASS(wbc_class,
 106         TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
 107         TP_ARGS(wbc, bdi),
 108         TP_STRUCT__entry(
 109                 __array(char, name, 32)
 110                 __field(long, nr_to_write)
 111                 __field(long, pages_skipped)
 112                 __field(int, sync_mode)
 113                 __field(int, for_kupdate)
 114                 __field(int, for_background)
 115                 __field(int, for_reclaim)
 116                 __field(int, range_cyclic)
 117                 __field(unsigned long, older_than_this)
 118                 __field(long, range_start)
 119                 __field(long, range_end)
 120         ),
 121
 122         TP_fast_assign(
 123                 strncpy(__entry->name, dev_name(bdi->dev), 32);
 124                 __entry->nr_to_write    = wbc->nr_to_write;
 125                 __entry->pages_skipped  = wbc->pages_skipped;
 126                 __entry->sync_mode      = wbc->sync_mode;
 127                 __entry->for_kupdate    = wbc->for_kupdate;
 128                 __entry->for_background = wbc->for_background;
 129                 __entry->for_reclaim    = wbc->for_reclaim;
 130                 __entry->range_cyclic   = wbc->range_cyclic;
 131                 __entry->older_than_this = wbc->older_than_this ?
 132                                                 *wbc->older_than_this : 0;
 133                 __entry->range_start    = (long)wbc->range_start;
 134                 __entry->range_end      = (long)wbc->range_end;
 135         ),
 136
 137         TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
 138                 "bgrd=%d reclm=%d cyclic=%d older=0x%lx "
 139                 "start=0x%lx end=0x%lx",
 140                 __entry->name,
 141                 __entry->nr_to_write,
 142                 __entry->pages_skipped,
 143                 __entry->sync_mode,
 144                 __entry->for_kupdate,
 145                 __entry->for_background,
 146                 __entry->for_reclaim,
 147                 __entry->range_cyclic,
 148                 __entry->older_than_this,
 149                 __entry->range_start,
 150                 __entry->range_end)
 151 )
 152
 153 #define DEFINE_WBC_EVENT(name) \
 154 DEFINE_EVENT(wbc_class, name, \
 155         TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
 156         TP_ARGS(wbc, bdi))
 157 DEFINE_WBC_EVENT(wbc_writeback_start);
 158 DEFINE_WBC_EVENT(wbc_writeback_written);
 159 DEFINE_WBC_EVENT(wbc_writeback_wait);
 160 DEFINE_WBC_EVENT(wbc_balance_dirty_start);
 161 DEFINE_WBC_EVENT(wbc_balance_dirty_written);
 162 DEFINE_WBC_EVENT(wbc_balance_dirty_wait);
 163 DEFINE_WBC_EVENT(wbc_writepage);
 164
 165 DECLARE_EVENT_CLASS(writeback_congest_waited_template,
 166
 167         TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
 168
 169         TP_ARGS(usec_timeout, usec_delayed),
 170
 171         TP_STRUCT__entry(
 172                 __field(        unsigned int,   usec_timeout    )
 173                 __field(        unsigned int,   usec_delayed    )
 174         ),
 175
 176         TP_fast_assign(
 177                 __entry->usec_timeout   = usec_timeout;
 178                 __entry->usec_delayed   = usec_delayed;
 179         ),
 180
 181         TP_printk("usec_timeout=%u usec_delayed=%u",
 182                         __entry->usec_timeout,
 183                         __entry->usec_delayed)
 184 );
 185
 186 DEFINE_EVENT(writeback_congest_waited_template, writeback_congestion_wait,
 187
 188         TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
 189
 190         TP_ARGS(usec_timeout, usec_delayed)
 191 );
 192
 193 DEFINE_EVENT(writeback_congest_waited_template, writeback_wait_iff_congested,
 194
 195         TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
 196
 197         TP_ARGS(usec_timeout, usec_delayed)
 198 );
 199
 200 DECLARE_EVENT_CLASS(writeback_single_inode_template,
 201
 202         TP_PROTO(struct inode *inode,
 203                  struct writeback_control *wbc,
 204                  unsigned long nr_to_write
 205         ),
 206
 207         TP_ARGS(inode, wbc, nr_to_write),
 208
 209         TP_STRUCT__entry(
 210                 __array(char, name, 32)
 211                 __field(unsigned long, ino)
 212                 __field(unsigned long, state)
 213                 __field(unsigned long, age)
 214                 __field(unsigned long, writeback_index)
 215                 __field(long, nr_to_write)
 216                 __field(unsigned long, wrote)
 217         ),
 218
 219         TP_fast_assign(
 220                 strncpy(__entry->name,
 221                         dev_name(inode->i_mapping->backing_dev_info->dev), 32);
 222                 __entry->ino            = inode->i_ino;
 223                 __entry->state          = inode->i_state;
 224                 __entry->age            = (jiffies - inode->dirtied_when) *
 225                                                                 1000 / HZ;
 226                 __entry->writeback_index = inode->i_mapping->writeback_index;
 227                 __entry->nr_to_write    = nr_to_write;
 228                 __entry->wrote          = nr_to_write - wbc->nr_to_write;
 229         ),
 230
 231         TP_printk("bdi %s: ino=%lu state=%s age=%lu "
 232                   "index=%lu to_write=%ld wrote=%lu",
 233                   __entry->name,
 234                   __entry->ino,
 235                   show_inode_state(__entry->state),
 236                   __entry->age,
 237                   __entry->writeback_index,
 238                   __entry->nr_to_write,
 239                   __entry->wrote
 240         )
 241 );
 242
 243 DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode_requeue,
 244         TP_PROTO(struct inode *inode,
 245                  struct writeback_control *wbc,
 246                  unsigned long nr_to_write),
 247         TP_ARGS(inode, wbc, nr_to_write)
 248 );
 249
 250 DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode,
 251         TP_PROTO(struct inode *inode,
 252                  struct writeback_control *wbc,
 253                  unsigned long nr_to_write),
 254         TP_ARGS(inode, wbc, nr_to_write)
 255 );
 256
 257 #endif /* _TRACE_WRITEBACK_H */
 258
 259 /* This part must be outside protection */
 260 #include <trace/define_trace.h>