Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 #undef TRACE_SYSTEM
0003 #define TRACE_SYSTEM writeback
0004 
0005 #if !defined(_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ)
0006 #define _TRACE_WRITEBACK_H
0007 
0008 #include <linux/tracepoint.h>
0009 #include <linux/backing-dev.h>
0010 #include <linux/writeback.h>
0011 
0012 #define show_inode_state(state)                 \
0013     __print_flags(state, "|",               \
0014         {I_DIRTY_SYNC,      "I_DIRTY_SYNC"},    \
0015         {I_DIRTY_DATASYNC,  "I_DIRTY_DATASYNC"},    \
0016         {I_DIRTY_PAGES,     "I_DIRTY_PAGES"},   \
0017         {I_NEW,         "I_NEW"},       \
0018         {I_WILL_FREE,       "I_WILL_FREE"},     \
0019         {I_FREEING,     "I_FREEING"},       \
0020         {I_CLEAR,       "I_CLEAR"},     \
0021         {I_SYNC,        "I_SYNC"},      \
0022         {I_DIRTY_TIME,      "I_DIRTY_TIME"},    \
0023         {I_REFERENCED,      "I_REFERENCED"}     \
0024     )
0025 
0026 /* enums need to be exported to user space */
0027 #undef EM
0028 #undef EMe
0029 #define EM(a,b)     TRACE_DEFINE_ENUM(a);
0030 #define EMe(a,b)    TRACE_DEFINE_ENUM(a);
0031 
0032 #define WB_WORK_REASON                          \
0033     EM( WB_REASON_BACKGROUND,       "background")       \
0034     EM( WB_REASON_VMSCAN,           "vmscan")       \
0035     EM( WB_REASON_SYNC,         "sync")         \
0036     EM( WB_REASON_PERIODIC,         "periodic")     \
0037     EM( WB_REASON_LAPTOP_TIMER,     "laptop_timer")     \
0038     EM( WB_REASON_FS_FREE_SPACE,        "fs_free_space")    \
0039     EM( WB_REASON_FORKER_THREAD,        "forker_thread")    \
0040     EMe(WB_REASON_FOREIGN_FLUSH,        "foreign_flush")
0041 
0042 WB_WORK_REASON
0043 
0044 /*
0045  * Now redefine the EM() and EMe() macros to map the enums to the strings
0046  * that will be printed in the output.
0047  */
0048 #undef EM
0049 #undef EMe
0050 #define EM(a,b)     { a, b },
0051 #define EMe(a,b)    { a, b }
0052 
0053 struct wb_writeback_work;
0054 
0055 DECLARE_EVENT_CLASS(writeback_folio_template,
0056 
0057     TP_PROTO(struct folio *folio, struct address_space *mapping),
0058 
0059     TP_ARGS(folio, mapping),
0060 
0061     TP_STRUCT__entry (
0062         __array(char, name, 32)
0063         __field(ino_t, ino)
0064         __field(pgoff_t, index)
0065     ),
0066 
0067     TP_fast_assign(
0068         strscpy_pad(__entry->name,
0069                 bdi_dev_name(mapping ? inode_to_bdi(mapping->host) :
0070                      NULL), 32);
0071         __entry->ino = mapping ? mapping->host->i_ino : 0;
0072         __entry->index = folio->index;
0073     ),
0074 
0075     TP_printk("bdi %s: ino=%lu index=%lu",
0076         __entry->name,
0077         (unsigned long)__entry->ino,
0078         __entry->index
0079     )
0080 );
0081 
0082 DEFINE_EVENT(writeback_folio_template, writeback_dirty_folio,
0083 
0084     TP_PROTO(struct folio *folio, struct address_space *mapping),
0085 
0086     TP_ARGS(folio, mapping)
0087 );
0088 
0089 DEFINE_EVENT(writeback_folio_template, folio_wait_writeback,
0090 
0091     TP_PROTO(struct folio *folio, struct address_space *mapping),
0092 
0093     TP_ARGS(folio, mapping)
0094 );
0095 
0096 DECLARE_EVENT_CLASS(writeback_dirty_inode_template,
0097 
0098     TP_PROTO(struct inode *inode, int flags),
0099 
0100     TP_ARGS(inode, flags),
0101 
0102     TP_STRUCT__entry (
0103         __array(char, name, 32)
0104         __field(ino_t, ino)
0105         __field(unsigned long, state)
0106         __field(unsigned long, flags)
0107     ),
0108 
0109     TP_fast_assign(
0110         struct backing_dev_info *bdi = inode_to_bdi(inode);
0111 
0112         /* may be called for files on pseudo FSes w/ unregistered bdi */
0113         strscpy_pad(__entry->name, bdi_dev_name(bdi), 32);
0114         __entry->ino        = inode->i_ino;
0115         __entry->state      = inode->i_state;
0116         __entry->flags      = flags;
0117     ),
0118 
0119     TP_printk("bdi %s: ino=%lu state=%s flags=%s",
0120         __entry->name,
0121         (unsigned long)__entry->ino,
0122         show_inode_state(__entry->state),
0123         show_inode_state(__entry->flags)
0124     )
0125 );
0126 
0127 DEFINE_EVENT(writeback_dirty_inode_template, writeback_mark_inode_dirty,
0128 
0129     TP_PROTO(struct inode *inode, int flags),
0130 
0131     TP_ARGS(inode, flags)
0132 );
0133 
0134 DEFINE_EVENT(writeback_dirty_inode_template, writeback_dirty_inode_start,
0135 
0136     TP_PROTO(struct inode *inode, int flags),
0137 
0138     TP_ARGS(inode, flags)
0139 );
0140 
0141 DEFINE_EVENT(writeback_dirty_inode_template, writeback_dirty_inode,
0142 
0143     TP_PROTO(struct inode *inode, int flags),
0144 
0145     TP_ARGS(inode, flags)
0146 );
0147 
0148 #ifdef CREATE_TRACE_POINTS
0149 #ifdef CONFIG_CGROUP_WRITEBACK
0150 
0151 static inline ino_t __trace_wb_assign_cgroup(struct bdi_writeback *wb)
0152 {
0153     return cgroup_ino(wb->memcg_css->cgroup);
0154 }
0155 
0156 static inline ino_t __trace_wbc_assign_cgroup(struct writeback_control *wbc)
0157 {
0158     if (wbc->wb)
0159         return __trace_wb_assign_cgroup(wbc->wb);
0160     else
0161         return 1;
0162 }
0163 #else   /* CONFIG_CGROUP_WRITEBACK */
0164 
0165 static inline ino_t __trace_wb_assign_cgroup(struct bdi_writeback *wb)
0166 {
0167     return 1;
0168 }
0169 
0170 static inline ino_t __trace_wbc_assign_cgroup(struct writeback_control *wbc)
0171 {
0172     return 1;
0173 }
0174 
0175 #endif  /* CONFIG_CGROUP_WRITEBACK */
0176 #endif  /* CREATE_TRACE_POINTS */
0177 
0178 #ifdef CONFIG_CGROUP_WRITEBACK
0179 TRACE_EVENT(inode_foreign_history,
0180 
0181     TP_PROTO(struct inode *inode, struct writeback_control *wbc,
0182          unsigned int history),
0183 
0184     TP_ARGS(inode, wbc, history),
0185 
0186     TP_STRUCT__entry(
0187         __array(char,       name, 32)
0188         __field(ino_t,      ino)
0189         __field(ino_t,      cgroup_ino)
0190         __field(unsigned int,   history)
0191     ),
0192 
0193     TP_fast_assign(
0194         strscpy_pad(__entry->name, bdi_dev_name(inode_to_bdi(inode)), 32);
0195         __entry->ino        = inode->i_ino;
0196         __entry->cgroup_ino = __trace_wbc_assign_cgroup(wbc);
0197         __entry->history    = history;
0198     ),
0199 
0200     TP_printk("bdi %s: ino=%lu cgroup_ino=%lu history=0x%x",
0201         __entry->name,
0202         (unsigned long)__entry->ino,
0203         (unsigned long)__entry->cgroup_ino,
0204         __entry->history
0205     )
0206 );
0207 
0208 TRACE_EVENT(inode_switch_wbs,
0209 
0210     TP_PROTO(struct inode *inode, struct bdi_writeback *old_wb,
0211          struct bdi_writeback *new_wb),
0212 
0213     TP_ARGS(inode, old_wb, new_wb),
0214 
0215     TP_STRUCT__entry(
0216         __array(char,       name, 32)
0217         __field(ino_t,      ino)
0218         __field(ino_t,      old_cgroup_ino)
0219         __field(ino_t,      new_cgroup_ino)
0220     ),
0221 
0222     TP_fast_assign(
0223         strscpy_pad(__entry->name, bdi_dev_name(old_wb->bdi), 32);
0224         __entry->ino        = inode->i_ino;
0225         __entry->old_cgroup_ino = __trace_wb_assign_cgroup(old_wb);
0226         __entry->new_cgroup_ino = __trace_wb_assign_cgroup(new_wb);
0227     ),
0228 
0229     TP_printk("bdi %s: ino=%lu old_cgroup_ino=%lu new_cgroup_ino=%lu",
0230         __entry->name,
0231         (unsigned long)__entry->ino,
0232         (unsigned long)__entry->old_cgroup_ino,
0233         (unsigned long)__entry->new_cgroup_ino
0234     )
0235 );
0236 
0237 TRACE_EVENT(track_foreign_dirty,
0238 
0239     TP_PROTO(struct folio *folio, struct bdi_writeback *wb),
0240 
0241     TP_ARGS(folio, wb),
0242 
0243     TP_STRUCT__entry(
0244         __array(char,       name, 32)
0245         __field(u64,        bdi_id)
0246         __field(ino_t,      ino)
0247         __field(unsigned int,   memcg_id)
0248         __field(ino_t,      cgroup_ino)
0249         __field(ino_t,      page_cgroup_ino)
0250     ),
0251 
0252     TP_fast_assign(
0253         struct address_space *mapping = folio_mapping(folio);
0254         struct inode *inode = mapping ? mapping->host : NULL;
0255 
0256         strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
0257         __entry->bdi_id     = wb->bdi->id;
0258         __entry->ino        = inode ? inode->i_ino : 0;
0259         __entry->memcg_id   = wb->memcg_css->id;
0260         __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
0261         __entry->page_cgroup_ino = cgroup_ino(folio_memcg(folio)->css.cgroup);
0262     ),
0263 
0264     TP_printk("bdi %s[%llu]: ino=%lu memcg_id=%u cgroup_ino=%lu page_cgroup_ino=%lu",
0265         __entry->name,
0266         __entry->bdi_id,
0267         (unsigned long)__entry->ino,
0268         __entry->memcg_id,
0269         (unsigned long)__entry->cgroup_ino,
0270         (unsigned long)__entry->page_cgroup_ino
0271     )
0272 );
0273 
0274 TRACE_EVENT(flush_foreign,
0275 
0276     TP_PROTO(struct bdi_writeback *wb, unsigned int frn_bdi_id,
0277          unsigned int frn_memcg_id),
0278 
0279     TP_ARGS(wb, frn_bdi_id, frn_memcg_id),
0280 
0281     TP_STRUCT__entry(
0282         __array(char,       name, 32)
0283         __field(ino_t,      cgroup_ino)
0284         __field(unsigned int,   frn_bdi_id)
0285         __field(unsigned int,   frn_memcg_id)
0286     ),
0287 
0288     TP_fast_assign(
0289         strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
0290         __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
0291         __entry->frn_bdi_id = frn_bdi_id;
0292         __entry->frn_memcg_id   = frn_memcg_id;
0293     ),
0294 
0295     TP_printk("bdi %s: cgroup_ino=%lu frn_bdi_id=%u frn_memcg_id=%u",
0296         __entry->name,
0297         (unsigned long)__entry->cgroup_ino,
0298         __entry->frn_bdi_id,
0299         __entry->frn_memcg_id
0300     )
0301 );
0302 #endif
0303 
0304 DECLARE_EVENT_CLASS(writeback_write_inode_template,
0305 
0306     TP_PROTO(struct inode *inode, struct writeback_control *wbc),
0307 
0308     TP_ARGS(inode, wbc),
0309 
0310     TP_STRUCT__entry (
0311         __array(char, name, 32)
0312         __field(ino_t, ino)
0313         __field(int, sync_mode)
0314         __field(ino_t, cgroup_ino)
0315     ),
0316 
0317     TP_fast_assign(
0318         strscpy_pad(__entry->name,
0319                 bdi_dev_name(inode_to_bdi(inode)), 32);
0320         __entry->ino        = inode->i_ino;
0321         __entry->sync_mode  = wbc->sync_mode;
0322         __entry->cgroup_ino = __trace_wbc_assign_cgroup(wbc);
0323     ),
0324 
0325     TP_printk("bdi %s: ino=%lu sync_mode=%d cgroup_ino=%lu",
0326         __entry->name,
0327         (unsigned long)__entry->ino,
0328         __entry->sync_mode,
0329         (unsigned long)__entry->cgroup_ino
0330     )
0331 );
0332 
0333 DEFINE_EVENT(writeback_write_inode_template, writeback_write_inode_start,
0334 
0335     TP_PROTO(struct inode *inode, struct writeback_control *wbc),
0336 
0337     TP_ARGS(inode, wbc)
0338 );
0339 
0340 DEFINE_EVENT(writeback_write_inode_template, writeback_write_inode,
0341 
0342     TP_PROTO(struct inode *inode, struct writeback_control *wbc),
0343 
0344     TP_ARGS(inode, wbc)
0345 );
0346 
0347 DECLARE_EVENT_CLASS(writeback_work_class,
0348     TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work),
0349     TP_ARGS(wb, work),
0350     TP_STRUCT__entry(
0351         __array(char, name, 32)
0352         __field(long, nr_pages)
0353         __field(dev_t, sb_dev)
0354         __field(int, sync_mode)
0355         __field(int, for_kupdate)
0356         __field(int, range_cyclic)
0357         __field(int, for_background)
0358         __field(int, reason)
0359         __field(ino_t, cgroup_ino)
0360     ),
0361     TP_fast_assign(
0362         strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
0363         __entry->nr_pages = work->nr_pages;
0364         __entry->sb_dev = work->sb ? work->sb->s_dev : 0;
0365         __entry->sync_mode = work->sync_mode;
0366         __entry->for_kupdate = work->for_kupdate;
0367         __entry->range_cyclic = work->range_cyclic;
0368         __entry->for_background = work->for_background;
0369         __entry->reason = work->reason;
0370         __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
0371     ),
0372     TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
0373           "kupdate=%d range_cyclic=%d background=%d reason=%s cgroup_ino=%lu",
0374           __entry->name,
0375           MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
0376           __entry->nr_pages,
0377           __entry->sync_mode,
0378           __entry->for_kupdate,
0379           __entry->range_cyclic,
0380           __entry->for_background,
0381           __print_symbolic(__entry->reason, WB_WORK_REASON),
0382           (unsigned long)__entry->cgroup_ino
0383     )
0384 );
0385 #define DEFINE_WRITEBACK_WORK_EVENT(name) \
0386 DEFINE_EVENT(writeback_work_class, name, \
0387     TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work), \
0388     TP_ARGS(wb, work))
0389 DEFINE_WRITEBACK_WORK_EVENT(writeback_queue);
0390 DEFINE_WRITEBACK_WORK_EVENT(writeback_exec);
0391 DEFINE_WRITEBACK_WORK_EVENT(writeback_start);
0392 DEFINE_WRITEBACK_WORK_EVENT(writeback_written);
0393 DEFINE_WRITEBACK_WORK_EVENT(writeback_wait);
0394 
0395 TRACE_EVENT(writeback_pages_written,
0396     TP_PROTO(long pages_written),
0397     TP_ARGS(pages_written),
0398     TP_STRUCT__entry(
0399         __field(long,       pages)
0400     ),
0401     TP_fast_assign(
0402         __entry->pages      = pages_written;
0403     ),
0404     TP_printk("%ld", __entry->pages)
0405 );
0406 
0407 DECLARE_EVENT_CLASS(writeback_class,
0408     TP_PROTO(struct bdi_writeback *wb),
0409     TP_ARGS(wb),
0410     TP_STRUCT__entry(
0411         __array(char, name, 32)
0412         __field(ino_t, cgroup_ino)
0413     ),
0414     TP_fast_assign(
0415         strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
0416         __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
0417     ),
0418     TP_printk("bdi %s: cgroup_ino=%lu",
0419           __entry->name,
0420           (unsigned long)__entry->cgroup_ino
0421     )
0422 );
0423 #define DEFINE_WRITEBACK_EVENT(name) \
0424 DEFINE_EVENT(writeback_class, name, \
0425     TP_PROTO(struct bdi_writeback *wb), \
0426     TP_ARGS(wb))
0427 
0428 DEFINE_WRITEBACK_EVENT(writeback_wake_background);
0429 
0430 TRACE_EVENT(writeback_bdi_register,
0431     TP_PROTO(struct backing_dev_info *bdi),
0432     TP_ARGS(bdi),
0433     TP_STRUCT__entry(
0434         __array(char, name, 32)
0435     ),
0436     TP_fast_assign(
0437         strscpy_pad(__entry->name, bdi_dev_name(bdi), 32);
0438     ),
0439     TP_printk("bdi %s",
0440         __entry->name
0441     )
0442 );
0443 
0444 DECLARE_EVENT_CLASS(wbc_class,
0445     TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
0446     TP_ARGS(wbc, bdi),
0447     TP_STRUCT__entry(
0448         __array(char, name, 32)
0449         __field(long, nr_to_write)
0450         __field(long, pages_skipped)
0451         __field(int, sync_mode)
0452         __field(int, for_kupdate)
0453         __field(int, for_background)
0454         __field(int, for_reclaim)
0455         __field(int, range_cyclic)
0456         __field(long, range_start)
0457         __field(long, range_end)
0458         __field(ino_t, cgroup_ino)
0459     ),
0460 
0461     TP_fast_assign(
0462         strscpy_pad(__entry->name, bdi_dev_name(bdi), 32);
0463         __entry->nr_to_write    = wbc->nr_to_write;
0464         __entry->pages_skipped  = wbc->pages_skipped;
0465         __entry->sync_mode  = wbc->sync_mode;
0466         __entry->for_kupdate    = wbc->for_kupdate;
0467         __entry->for_background = wbc->for_background;
0468         __entry->for_reclaim    = wbc->for_reclaim;
0469         __entry->range_cyclic   = wbc->range_cyclic;
0470         __entry->range_start    = (long)wbc->range_start;
0471         __entry->range_end  = (long)wbc->range_end;
0472         __entry->cgroup_ino = __trace_wbc_assign_cgroup(wbc);
0473     ),
0474 
0475     TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
0476         "bgrd=%d reclm=%d cyclic=%d "
0477         "start=0x%lx end=0x%lx cgroup_ino=%lu",
0478         __entry->name,
0479         __entry->nr_to_write,
0480         __entry->pages_skipped,
0481         __entry->sync_mode,
0482         __entry->for_kupdate,
0483         __entry->for_background,
0484         __entry->for_reclaim,
0485         __entry->range_cyclic,
0486         __entry->range_start,
0487         __entry->range_end,
0488         (unsigned long)__entry->cgroup_ino
0489     )
0490 )
0491 
0492 #define DEFINE_WBC_EVENT(name) \
0493 DEFINE_EVENT(wbc_class, name, \
0494     TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
0495     TP_ARGS(wbc, bdi))
0496 DEFINE_WBC_EVENT(wbc_writepage);
0497 
0498 TRACE_EVENT(writeback_queue_io,
0499     TP_PROTO(struct bdi_writeback *wb,
0500          struct wb_writeback_work *work,
0501          unsigned long dirtied_before,
0502          int moved),
0503     TP_ARGS(wb, work, dirtied_before, moved),
0504     TP_STRUCT__entry(
0505         __array(char,       name, 32)
0506         __field(unsigned long,  older)
0507         __field(long,       age)
0508         __field(int,        moved)
0509         __field(int,        reason)
0510         __field(ino_t,      cgroup_ino)
0511     ),
0512     TP_fast_assign(
0513         strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
0514         __entry->older  = dirtied_before;
0515         __entry->age    = (jiffies - dirtied_before) * 1000 / HZ;
0516         __entry->moved  = moved;
0517         __entry->reason = work->reason;
0518         __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
0519     ),
0520     TP_printk("bdi %s: older=%lu age=%ld enqueue=%d reason=%s cgroup_ino=%lu",
0521         __entry->name,
0522         __entry->older, /* dirtied_before in jiffies */
0523         __entry->age,   /* dirtied_before in relative milliseconds */
0524         __entry->moved,
0525         __print_symbolic(__entry->reason, WB_WORK_REASON),
0526         (unsigned long)__entry->cgroup_ino
0527     )
0528 );
0529 
0530 TRACE_EVENT(global_dirty_state,
0531 
0532     TP_PROTO(unsigned long background_thresh,
0533          unsigned long dirty_thresh
0534     ),
0535 
0536     TP_ARGS(background_thresh,
0537         dirty_thresh
0538     ),
0539 
0540     TP_STRUCT__entry(
0541         __field(unsigned long,  nr_dirty)
0542         __field(unsigned long,  nr_writeback)
0543         __field(unsigned long,  background_thresh)
0544         __field(unsigned long,  dirty_thresh)
0545         __field(unsigned long,  dirty_limit)
0546         __field(unsigned long,  nr_dirtied)
0547         __field(unsigned long,  nr_written)
0548     ),
0549 
0550     TP_fast_assign(
0551         __entry->nr_dirty   = global_node_page_state(NR_FILE_DIRTY);
0552         __entry->nr_writeback   = global_node_page_state(NR_WRITEBACK);
0553         __entry->nr_dirtied = global_node_page_state(NR_DIRTIED);
0554         __entry->nr_written = global_node_page_state(NR_WRITTEN);
0555         __entry->background_thresh = background_thresh;
0556         __entry->dirty_thresh   = dirty_thresh;
0557         __entry->dirty_limit    = global_wb_domain.dirty_limit;
0558     ),
0559 
0560     TP_printk("dirty=%lu writeback=%lu "
0561           "bg_thresh=%lu thresh=%lu limit=%lu "
0562           "dirtied=%lu written=%lu",
0563           __entry->nr_dirty,
0564           __entry->nr_writeback,
0565           __entry->background_thresh,
0566           __entry->dirty_thresh,
0567           __entry->dirty_limit,
0568           __entry->nr_dirtied,
0569           __entry->nr_written
0570     )
0571 );
0572 
0573 #define KBps(x)         ((x) << (PAGE_SHIFT - 10))
0574 
0575 TRACE_EVENT(bdi_dirty_ratelimit,
0576 
0577     TP_PROTO(struct bdi_writeback *wb,
0578          unsigned long dirty_rate,
0579          unsigned long task_ratelimit),
0580 
0581     TP_ARGS(wb, dirty_rate, task_ratelimit),
0582 
0583     TP_STRUCT__entry(
0584         __array(char,       bdi, 32)
0585         __field(unsigned long,  write_bw)
0586         __field(unsigned long,  avg_write_bw)
0587         __field(unsigned long,  dirty_rate)
0588         __field(unsigned long,  dirty_ratelimit)
0589         __field(unsigned long,  task_ratelimit)
0590         __field(unsigned long,  balanced_dirty_ratelimit)
0591         __field(ino_t,      cgroup_ino)
0592     ),
0593 
0594     TP_fast_assign(
0595         strscpy_pad(__entry->bdi, bdi_dev_name(wb->bdi), 32);
0596         __entry->write_bw   = KBps(wb->write_bandwidth);
0597         __entry->avg_write_bw   = KBps(wb->avg_write_bandwidth);
0598         __entry->dirty_rate = KBps(dirty_rate);
0599         __entry->dirty_ratelimit = KBps(wb->dirty_ratelimit);
0600         __entry->task_ratelimit = KBps(task_ratelimit);
0601         __entry->balanced_dirty_ratelimit =
0602                     KBps(wb->balanced_dirty_ratelimit);
0603         __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
0604     ),
0605 
0606     TP_printk("bdi %s: "
0607           "write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
0608           "dirty_ratelimit=%lu task_ratelimit=%lu "
0609           "balanced_dirty_ratelimit=%lu cgroup_ino=%lu",
0610           __entry->bdi,
0611           __entry->write_bw,        /* write bandwidth */
0612           __entry->avg_write_bw,    /* avg write bandwidth */
0613           __entry->dirty_rate,      /* bdi dirty rate */
0614           __entry->dirty_ratelimit, /* base ratelimit */
0615           __entry->task_ratelimit, /* ratelimit with position control */
0616           __entry->balanced_dirty_ratelimit, /* the balanced ratelimit */
0617           (unsigned long)__entry->cgroup_ino
0618     )
0619 );
0620 
0621 TRACE_EVENT(balance_dirty_pages,
0622 
0623     TP_PROTO(struct bdi_writeback *wb,
0624          unsigned long thresh,
0625          unsigned long bg_thresh,
0626          unsigned long dirty,
0627          unsigned long bdi_thresh,
0628          unsigned long bdi_dirty,
0629          unsigned long dirty_ratelimit,
0630          unsigned long task_ratelimit,
0631          unsigned long dirtied,
0632          unsigned long period,
0633          long pause,
0634          unsigned long start_time),
0635 
0636     TP_ARGS(wb, thresh, bg_thresh, dirty, bdi_thresh, bdi_dirty,
0637         dirty_ratelimit, task_ratelimit,
0638         dirtied, period, pause, start_time),
0639 
0640     TP_STRUCT__entry(
0641         __array(     char,  bdi, 32)
0642         __field(unsigned long,  limit)
0643         __field(unsigned long,  setpoint)
0644         __field(unsigned long,  dirty)
0645         __field(unsigned long,  bdi_setpoint)
0646         __field(unsigned long,  bdi_dirty)
0647         __field(unsigned long,  dirty_ratelimit)
0648         __field(unsigned long,  task_ratelimit)
0649         __field(unsigned int,   dirtied)
0650         __field(unsigned int,   dirtied_pause)
0651         __field(unsigned long,  paused)
0652         __field(     long,  pause)
0653         __field(unsigned long,  period)
0654         __field(     long,  think)
0655         __field(ino_t,      cgroup_ino)
0656     ),
0657 
0658     TP_fast_assign(
0659         unsigned long freerun = (thresh + bg_thresh) / 2;
0660         strscpy_pad(__entry->bdi, bdi_dev_name(wb->bdi), 32);
0661 
0662         __entry->limit      = global_wb_domain.dirty_limit;
0663         __entry->setpoint   = (global_wb_domain.dirty_limit +
0664                         freerun) / 2;
0665         __entry->dirty      = dirty;
0666         __entry->bdi_setpoint   = __entry->setpoint *
0667                         bdi_thresh / (thresh + 1);
0668         __entry->bdi_dirty  = bdi_dirty;
0669         __entry->dirty_ratelimit = KBps(dirty_ratelimit);
0670         __entry->task_ratelimit = KBps(task_ratelimit);
0671         __entry->dirtied    = dirtied;
0672         __entry->dirtied_pause  = current->nr_dirtied_pause;
0673         __entry->think      = current->dirty_paused_when == 0 ? 0 :
0674              (long)(jiffies - current->dirty_paused_when) * 1000/HZ;
0675         __entry->period     = period * 1000 / HZ;
0676         __entry->pause      = pause * 1000 / HZ;
0677         __entry->paused     = (jiffies - start_time) * 1000 / HZ;
0678         __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
0679     ),
0680 
0681 
0682     TP_printk("bdi %s: "
0683           "limit=%lu setpoint=%lu dirty=%lu "
0684           "bdi_setpoint=%lu bdi_dirty=%lu "
0685           "dirty_ratelimit=%lu task_ratelimit=%lu "
0686           "dirtied=%u dirtied_pause=%u "
0687           "paused=%lu pause=%ld period=%lu think=%ld cgroup_ino=%lu",
0688           __entry->bdi,
0689           __entry->limit,
0690           __entry->setpoint,
0691           __entry->dirty,
0692           __entry->bdi_setpoint,
0693           __entry->bdi_dirty,
0694           __entry->dirty_ratelimit,
0695           __entry->task_ratelimit,
0696           __entry->dirtied,
0697           __entry->dirtied_pause,
0698           __entry->paused,  /* ms */
0699           __entry->pause,   /* ms */
0700           __entry->period,  /* ms */
0701           __entry->think,   /* ms */
0702           (unsigned long)__entry->cgroup_ino
0703       )
0704 );
0705 
0706 TRACE_EVENT(writeback_sb_inodes_requeue,
0707 
0708     TP_PROTO(struct inode *inode),
0709     TP_ARGS(inode),
0710 
0711     TP_STRUCT__entry(
0712         __array(char, name, 32)
0713         __field(ino_t, ino)
0714         __field(unsigned long, state)
0715         __field(unsigned long, dirtied_when)
0716         __field(ino_t, cgroup_ino)
0717     ),
0718 
0719     TP_fast_assign(
0720         strscpy_pad(__entry->name,
0721                 bdi_dev_name(inode_to_bdi(inode)), 32);
0722         __entry->ino        = inode->i_ino;
0723         __entry->state      = inode->i_state;
0724         __entry->dirtied_when   = inode->dirtied_when;
0725         __entry->cgroup_ino = __trace_wb_assign_cgroup(inode_to_wb(inode));
0726     ),
0727 
0728     TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu cgroup_ino=%lu",
0729           __entry->name,
0730           (unsigned long)__entry->ino,
0731           show_inode_state(__entry->state),
0732           __entry->dirtied_when,
0733           (jiffies - __entry->dirtied_when) / HZ,
0734           (unsigned long)__entry->cgroup_ino
0735     )
0736 );
0737 
0738 DECLARE_EVENT_CLASS(writeback_single_inode_template,
0739 
0740     TP_PROTO(struct inode *inode,
0741          struct writeback_control *wbc,
0742          unsigned long nr_to_write
0743     ),
0744 
0745     TP_ARGS(inode, wbc, nr_to_write),
0746 
0747     TP_STRUCT__entry(
0748         __array(char, name, 32)
0749         __field(ino_t, ino)
0750         __field(unsigned long, state)
0751         __field(unsigned long, dirtied_when)
0752         __field(unsigned long, writeback_index)
0753         __field(long, nr_to_write)
0754         __field(unsigned long, wrote)
0755         __field(ino_t, cgroup_ino)
0756     ),
0757 
0758     TP_fast_assign(
0759         strscpy_pad(__entry->name,
0760                 bdi_dev_name(inode_to_bdi(inode)), 32);
0761         __entry->ino        = inode->i_ino;
0762         __entry->state      = inode->i_state;
0763         __entry->dirtied_when   = inode->dirtied_when;
0764         __entry->writeback_index = inode->i_mapping->writeback_index;
0765         __entry->nr_to_write    = nr_to_write;
0766         __entry->wrote      = nr_to_write - wbc->nr_to_write;
0767         __entry->cgroup_ino = __trace_wbc_assign_cgroup(wbc);
0768     ),
0769 
0770     TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu "
0771           "index=%lu to_write=%ld wrote=%lu cgroup_ino=%lu",
0772           __entry->name,
0773           (unsigned long)__entry->ino,
0774           show_inode_state(__entry->state),
0775           __entry->dirtied_when,
0776           (jiffies - __entry->dirtied_when) / HZ,
0777           __entry->writeback_index,
0778           __entry->nr_to_write,
0779           __entry->wrote,
0780           (unsigned long)__entry->cgroup_ino
0781     )
0782 );
0783 
0784 DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode_start,
0785     TP_PROTO(struct inode *inode,
0786          struct writeback_control *wbc,
0787          unsigned long nr_to_write),
0788     TP_ARGS(inode, wbc, nr_to_write)
0789 );
0790 
0791 DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode,
0792     TP_PROTO(struct inode *inode,
0793          struct writeback_control *wbc,
0794          unsigned long nr_to_write),
0795     TP_ARGS(inode, wbc, nr_to_write)
0796 );
0797 
0798 DECLARE_EVENT_CLASS(writeback_inode_template,
0799     TP_PROTO(struct inode *inode),
0800 
0801     TP_ARGS(inode),
0802 
0803     TP_STRUCT__entry(
0804         __field(    dev_t,  dev         )
0805         __field(    ino_t,  ino         )
0806         __field(unsigned long,  state           )
0807         __field(    __u16, mode         )
0808         __field(unsigned long, dirtied_when     )
0809     ),
0810 
0811     TP_fast_assign(
0812         __entry->dev    = inode->i_sb->s_dev;
0813         __entry->ino    = inode->i_ino;
0814         __entry->state  = inode->i_state;
0815         __entry->mode   = inode->i_mode;
0816         __entry->dirtied_when = inode->dirtied_when;
0817     ),
0818 
0819     TP_printk("dev %d,%d ino %lu dirtied %lu state %s mode 0%o",
0820           MAJOR(__entry->dev), MINOR(__entry->dev),
0821           (unsigned long)__entry->ino, __entry->dirtied_when,
0822           show_inode_state(__entry->state), __entry->mode)
0823 );
0824 
0825 DEFINE_EVENT(writeback_inode_template, writeback_lazytime,
0826     TP_PROTO(struct inode *inode),
0827 
0828     TP_ARGS(inode)
0829 );
0830 
0831 DEFINE_EVENT(writeback_inode_template, writeback_lazytime_iput,
0832     TP_PROTO(struct inode *inode),
0833 
0834     TP_ARGS(inode)
0835 );
0836 
0837 DEFINE_EVENT(writeback_inode_template, writeback_dirty_inode_enqueue,
0838 
0839     TP_PROTO(struct inode *inode),
0840 
0841     TP_ARGS(inode)
0842 );
0843 
0844 /*
0845  * Inode writeback list tracking.
0846  */
0847 
0848 DEFINE_EVENT(writeback_inode_template, sb_mark_inode_writeback,
0849     TP_PROTO(struct inode *inode),
0850     TP_ARGS(inode)
0851 );
0852 
0853 DEFINE_EVENT(writeback_inode_template, sb_clear_inode_writeback,
0854     TP_PROTO(struct inode *inode),
0855     TP_ARGS(inode)
0856 );
0857 
0858 #endif /* _TRACE_WRITEBACK_H */
0859 
0860 /* This part must be outside protection */
0861 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!