include/instrumentation/events/lttng-module/writeback.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 #undef TRACE_SYSTEM
   3 #define TRACE_SYSTEM writeback
   4
   5 #if !defined(LTTNG_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ)
   6 #define LTTNG_TRACE_WRITEBACK_H
   7
   8 #include <lttng/lttng-tracepoint-event.h>
   9 #include <linux/tracepoint.h>
  10 #include <linux/backing-dev.h>
  11 #include <linux/writeback.h>
  12
  13 #ifndef _TRACE_WRITEBACK_DEF_
  14 #define _TRACE_WRITEBACK_DEF_
  15
  16 static inline struct backing_dev_info *lttng_inode_to_bdi(struct inode *inode)
  17 {
  18         return inode_to_bdi(inode);
  19 }
  20
  21 #endif
  22
  23 #define show_inode_state(state)                                 \
  24         __print_flags(state, "|",                               \
  25                 {I_DIRTY_SYNC,          "I_DIRTY_SYNC"},        \
  26                 {I_DIRTY_DATASYNC,      "I_DIRTY_DATASYNC"},    \
  27                 {I_DIRTY_PAGES,         "I_DIRTY_PAGES"},       \
  28                 {I_NEW,                 "I_NEW"},               \
  29                 {I_WILL_FREE,           "I_WILL_FREE"},         \
  30                 {I_FREEING,             "I_FREEING"},           \
  31                 {I_CLEAR,               "I_CLEAR"},             \
  32                 {I_SYNC,                "I_SYNC"},              \
  33                 {I_DIRTY_TIME,          "I_DIRTY_TIME"},        \
  34                 {I_DIRTY_TIME_EXPIRED,  "I_DIRTY_TIME_EXPIRED"}, \
  35                 {I_REFERENCED,          "I_REFERENCED"}         \
  36         )
  37
  38 LTTNG_TRACEPOINT_EVENT(writeback_dirty_page,
  39         TP_PROTO(struct page *page, struct address_space *mapping),
  40         TP_ARGS(page, mapping),
  41         TP_FIELDS(
  42                 ctf_array_text(char, name,
  43                         mapping ? dev_name(lttng_inode_to_bdi(mapping->host)->dev) : "(unknown)", 32)
  44                 ctf_integer(unsigned long, ino, mapping ? mapping->host->i_ino : 0)
  45                 ctf_integer(pgoff_t, index, page->index)
  46         )
  47 )
  48
  49 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_dirty_inode_template,
  50         TP_PROTO(struct inode *inode, int flags),
  51         TP_ARGS(inode, flags),
  52         TP_FIELDS(
  53                 /* may be called for files on pseudo FSes w/ unregistered bdi */
  54                 ctf_array_text(char, name,
  55                         lttng_inode_to_bdi(inode)->dev ?
  56                                 dev_name(lttng_inode_to_bdi(inode)->dev) : "(unknown)", 32)
  57                 ctf_integer(unsigned long, ino, inode->i_ino)
  58                 ctf_integer(unsigned long, state, inode->i_state)
  59                 ctf_integer(unsigned long, flags, flags)
  60         )
  61 )
  62 #define LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(name) \
  63 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_dirty_inode_template, name, \
  64         TP_PROTO(struct inode *inode, int flags), \
  65         TP_ARGS(inode, flags))
  66 LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode_start)
  67 LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode)
  68 LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_mark_inode_dirty)
  69
  70 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_write_inode_template,
  71         TP_PROTO(struct inode *inode, struct writeback_control *wbc),
  72         TP_ARGS(inode, wbc),
  73         TP_FIELDS(
  74                 ctf_array_text(char, name,
  75                         dev_name(lttng_inode_to_bdi(inode)->dev), 32)
  76                 ctf_integer(unsigned long, ino, inode->i_ino)
  77                 ctf_integer(int, sync_mode, wbc->sync_mode)
  78         )
  79 )
  80
  81 #define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(name) \
  82 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_write_inode_template, name, \
  83         TP_PROTO(struct inode *inode, struct writeback_control *wbc), \
  84         TP_ARGS(inode, wbc))
  85 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode_start)
  86 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode)
  87
  88 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_work_class,
  89         TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work),
  90         TP_ARGS(wb, work),
  91         TP_FIELDS(
  92                 ctf_array_text(char, name, wb->bdi->dev ? dev_name(wb->bdi->dev) :
  93                                 "(unknown)", 32)
  94         )
  95 )
  96
  97 #define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(name) \
  98 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_work_class, name, \
  99         TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work), \
 100         TP_ARGS(wb, work))
 101
 102 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_nothread)
 103 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_queue)
 104 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_exec)
 105 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_start)
 106 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_written)
 107 LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_wait)
 108
 109 LTTNG_TRACEPOINT_EVENT(writeback_pages_written,
 110         TP_PROTO(long pages_written),
 111         TP_ARGS(pages_written),
 112         TP_FIELDS(
 113                 ctf_integer(long, pages, pages_written)
 114         )
 115 )
 116
 117 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_class,
 118         TP_PROTO(struct bdi_writeback *wb),
 119         TP_ARGS(wb),
 120         TP_FIELDS(
 121                 ctf_array_text(char, name,
 122                         dev_name(wb->bdi->dev), 32)
 123         )
 124 )
 125
 126 #undef DEFINE_WRITEBACK_EVENT
 127 #define DEFINE_WRITEBACK_EVENT(name) \
 128 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_class, name, \
 129         TP_PROTO(struct bdi_writeback *wb), \
 130         TP_ARGS(wb))
 131
 132 #define DEFINE_WRITEBACK_EVENT_MAP(name, map) \
 133 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_class, name, map, \
 134         TP_PROTO(struct bdi_writeback *wb), \
 135         TP_ARGS(wb))
 136
 137 LTTNG_TRACEPOINT_EVENT(writeback_bdi_register,
 138         TP_PROTO(struct backing_dev_info *bdi),
 139         TP_ARGS(bdi),
 140         TP_FIELDS(
 141                 ctf_array_text(char, name,
 142                         dev_name(bdi->dev), 32)
 143         )
 144 )
 145
 146 DEFINE_WRITEBACK_EVENT(writeback_nowork)
 147 DEFINE_WRITEBACK_EVENT(writeback_wake_background)
 148 DEFINE_WRITEBACK_EVENT(writeback_wake_thread)
 149 DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread)
 150 DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister)
 151 DEFINE_WRITEBACK_EVENT(writeback_thread_start)
 152 DEFINE_WRITEBACK_EVENT(writeback_thread_stop)
 153
 154 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_wbc_class,
 155         TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
 156         TP_ARGS(wbc, bdi),
 157         TP_FIELDS(
 158                 ctf_array_text(char, name, dev_name(bdi->dev), 32)
 159                 ctf_integer(long, nr_to_write, wbc->nr_to_write)
 160                 ctf_integer(long, pages_skipped, wbc->pages_skipped)
 161                 ctf_integer(int, sync_mode, wbc->sync_mode)
 162                 ctf_integer(int, for_kupdate, wbc->for_kupdate)
 163                 ctf_integer(int, for_background, wbc->for_background)
 164                 ctf_integer(int, for_reclaim, wbc->for_reclaim)
 165                 ctf_integer(int, range_cyclic, wbc->range_cyclic)
 166                 ctf_integer(long, range_start, (long) wbc->range_start)
 167                 ctf_integer(long, range_end, (long) wbc->range_end)
 168         )
 169 )
 170
 171 #undef DEFINE_WBC_EVENT
 172 #define LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(name, map) \
 173 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_wbc_class, name, map, \
 174         TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
 175         TP_ARGS(wbc, bdi))
 176 LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writepage, writeback_wbc_writepage)
 177
 178 LTTNG_TRACEPOINT_EVENT(writeback_queue_io,
 179         TP_PROTO(struct bdi_writeback *wb,
 180                  struct wb_writeback_work *work,
 181                  int moved),
 182         TP_ARGS(wb, work, moved),
 183         TP_FIELDS(
 184                 ctf_array_text(char, name, dev_name(wb->bdi->dev), 32)
 185                 ctf_integer(int, moved, moved)
 186         )
 187 )
 188
 189 LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state,
 190
 191         writeback_global_dirty_state,
 192
 193         TP_PROTO(struct wb_domain *domain,
 194                  unsigned long background_thresh,
 195                  unsigned long dirty_thresh
 196         ),
 197
 198         TP_ARGS(domain,
 199                 background_thresh,
 200                 dirty_thresh
 201         ),
 202
 203         TP_FIELDS(
 204                 ctf_integer(unsigned long, nr_dirty, global_node_page_state(NR_FILE_DIRTY))
 205                 ctf_integer(unsigned long, nr_writeback, global_node_page_state(NR_WRITEBACK))
 206                 ctf_integer(unsigned long, nr_unstable, global_node_page_state(NR_UNSTABLE_NFS))
 207                 ctf_integer(unsigned long, nr_dirtied, global_node_page_state(NR_DIRTIED))
 208                 ctf_integer(unsigned long, nr_written, global_node_page_state(NR_WRITTEN))
 209                 ctf_integer(unsigned long, background_thresh, background_thresh)
 210                 ctf_integer(unsigned long, dirty_thresh, dirty_thresh)
 211                 ctf_integer(unsigned long, dirty_limit, domain->dirty_limit)
 212         )
 213 )
 214
 215 #define KBps(x)                 ((x) << (PAGE_SHIFT - 10))
 216
 217 LTTNG_TRACEPOINT_EVENT_MAP(bdi_dirty_ratelimit,
 218
 219         writeback_bdi_dirty_ratelimit,
 220
 221         TP_PROTO(struct bdi_writeback *wb,
 222                  unsigned long dirty_rate,
 223                  unsigned long task_ratelimit),
 224
 225         TP_ARGS(wb, dirty_rate, task_ratelimit),
 226
 227         TP_FIELDS(
 228                 ctf_array_text(char, bdi, dev_name(wb->bdi->dev), 32)
 229                 ctf_integer(unsigned long, write_bw, KBps(wb->bdi->wb.write_bandwidth))
 230                 ctf_integer(unsigned long, avg_write_bw, KBps(wb->bdi->wb.avg_write_bandwidth))
 231                 ctf_integer(unsigned long, dirty_rate, KBps(dirty_rate))
 232                 ctf_integer(unsigned long, dirty_ratelimit, KBps(wb->bdi->wb.dirty_ratelimit))
 233                 ctf_integer(unsigned long, task_ratelimit, KBps(task_ratelimit))
 234                 ctf_integer(unsigned long, balanced_dirty_ratelimit,
 235                                         KBps(wb->bdi->wb.balanced_dirty_ratelimit))
 236         )
 237 )
 238
 239 LTTNG_TRACEPOINT_EVENT_MAP(balance_dirty_pages,
 240
 241         writeback_balance_dirty_pages,
 242
 243         TP_PROTO(struct wb_domain *domain,
 244                  struct bdi_writeback *wb,
 245                  struct dirty_throttle_control *sdtc,
 246                  unsigned long dirty_ratelimit,
 247                  unsigned long task_ratelimit,
 248                  unsigned long dirtied,
 249                  unsigned long period,
 250                  long pause,
 251                  unsigned long start_time),
 252
 253         TP_ARGS(domain, wb, sdtc,
 254                 dirty_ratelimit, task_ratelimit,
 255                 dirtied, period, pause, start_time
 256         ),
 257
 258         TP_FIELDS(
 259                 ctf_array_text(char, bdi, dev_name(wb->bdi->dev), 32)
 260                 ctf_integer(unsigned long, limit, domain->dirty_limit)
 261                 ctf_integer(unsigned long, setpoint,
 262                         (domain->dirty_limit + (sdtc->thresh + sdtc->bg_thresh) / 2) / 2)
 263                 ctf_integer(unsigned long, dirty, sdtc->dirty)
 264                 ctf_integer(unsigned long, bdi_setpoint,
 265                         ((domain->dirty_limit + (sdtc->thresh + sdtc->bg_thresh) / 2) / 2) *
 266                                 sdtc->wb_thresh / (sdtc->thresh + 1))
 267                 ctf_integer(unsigned long, bdi_dirty, sdtc->wb_dirty)
 268                 ctf_integer(unsigned long, dirty_ratelimit,
 269                         KBps(dirty_ratelimit))
 270                 ctf_integer(unsigned long, task_ratelimit,
 271                         KBps(task_ratelimit))
 272                 ctf_integer(unsigned int, dirtied, dirtied)
 273                 ctf_integer(unsigned int, dirtied_pause,
 274                         current->nr_dirtied_pause)
 275                 ctf_integer(unsigned long, paused,
 276                         (jiffies - start_time) * 1000 / HZ)
 277                 ctf_integer(long, pause, pause * 1000 / HZ)
 278                 ctf_integer(unsigned long, period,
 279                         period * 1000 / HZ)
 280                 ctf_integer(long, think,
 281                         current->dirty_paused_when == 0 ? 0 :
 282                                 (long)(jiffies - current->dirty_paused_when) * 1000/HZ)
 283         )
 284 )
 285
 286 LTTNG_TRACEPOINT_EVENT(writeback_sb_inodes_requeue,
 287
 288         TP_PROTO(struct inode *inode),
 289         TP_ARGS(inode),
 290
 291         TP_FIELDS(
 292                 ctf_array_text(char, name,
 293                         dev_name(lttng_inode_to_bdi(inode)->dev), 32)
 294                 ctf_integer(unsigned long, ino, inode->i_ino)
 295                 ctf_integer(unsigned long, state, inode->i_state)
 296                 ctf_integer(unsigned long, dirtied_when, inode->dirtied_when)
 297         )
 298 )
 299
 300 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_congest_waited_template,
 301
 302         TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
 303
 304         TP_ARGS(usec_timeout, usec_delayed),
 305
 306         TP_FIELDS(
 307                 ctf_integer(unsigned int, usec_timeout, usec_timeout)
 308                 ctf_integer(unsigned int, usec_delayed, usec_delayed)
 309         )
 310 )
 311
 312 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_congest_waited_template, writeback_congestion_wait,
 313
 314         TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
 315
 316         TP_ARGS(usec_timeout, usec_delayed)
 317 )
 318
 319 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_congest_waited_template, writeback_wait_iff_congested,
 320
 321         TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
 322
 323         TP_ARGS(usec_timeout, usec_delayed)
 324 )
 325
 326 LTTNG_TRACEPOINT_EVENT_CLASS(writeback_single_inode_template,
 327
 328         TP_PROTO(struct inode *inode,
 329                  struct writeback_control *wbc,
 330                  unsigned long nr_to_write
 331         ),
 332
 333         TP_ARGS(inode, wbc, nr_to_write),
 334
 335         TP_FIELDS(
 336                 ctf_array_text(char, name,
 337                         dev_name(lttng_inode_to_bdi(inode)->dev), 32)
 338                 ctf_integer(unsigned long, ino, inode->i_ino)
 339                 ctf_integer(unsigned long, state, inode->i_state)
 340                 ctf_integer(unsigned long, dirtied_when, inode->dirtied_when)
 341                 ctf_integer(unsigned long, writeback_index,
 342                         inode->i_mapping->writeback_index)
 343                 ctf_integer(long, nr_to_write, nr_to_write)
 344                 ctf_integer(unsigned long, wrote,
 345                         nr_to_write - wbc->nr_to_write)
 346         )
 347 )
 348
 349 LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_single_inode_template, writeback_single_inode,
 350         TP_PROTO(struct inode *inode,
 351                  struct writeback_control *wbc,
 352                  unsigned long nr_to_write),
 353         TP_ARGS(inode, wbc, nr_to_write)
 354 )
 355
 356 #endif /* LTTNG_TRACE_WRITEBACK_H */
 357
 358 /* This part must be outside protection */
 359 #include <lttng/define_trace.h>