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 DEFINE_WRITEBACK_WORK_EVENT(writeback_start); 66 DEFINE_WRITEBACK_WORK_EVENT(writeback_written); 67 DEFINE_WRITEBACK_WORK_EVENT(writeback_wait); 68 69 TRACE_EVENT(writeback_pages_written, 70 TP_PROTO(long pages_written), 71 TP_ARGS(pages_written), 72 TP_STRUCT__entry( 73 __field(long, pages) 74 ), 75 TP_fast_assign( 76 __entry->pages = pages_written; 77 ), 78 TP_printk("%ld", __entry->pages) 79 ); 80 81 DECLARE_EVENT_CLASS(writeback_class, 82 TP_PROTO(struct backing_dev_info *bdi), 83 TP_ARGS(bdi), 84 TP_STRUCT__entry( 85 __array(char, name, 32) 86 ), 87 TP_fast_assign( 88 strncpy(__entry->name, dev_name(bdi->dev), 32); 89 ), 90 TP_printk("bdi %s", 91 __entry->name 92 ) 93 ); 94 #define DEFINE_WRITEBACK_EVENT(name) \ 95 DEFINE_EVENT(writeback_class, name, \ 96 TP_PROTO(struct backing_dev_info *bdi), \ 97 TP_ARGS(bdi)) 98 99 DEFINE_WRITEBACK_EVENT(writeback_nowork); 100 DEFINE_WRITEBACK_EVENT(writeback_wake_background); 101 DEFINE_WRITEBACK_EVENT(writeback_wake_thread); 102 DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread); 103 DEFINE_WRITEBACK_EVENT(writeback_bdi_register); 104 DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister); 105 DEFINE_WRITEBACK_EVENT(writeback_thread_start); 106 DEFINE_WRITEBACK_EVENT(writeback_thread_stop); 107 108 DECLARE_EVENT_CLASS(wbc_class, 109 TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), 110 TP_ARGS(wbc, bdi), 111 TP_STRUCT__entry( 112 __array(char, name, 32) 113 __field(long, nr_to_write) 114 __field(long, pages_skipped) 115 __field(int, sync_mode) 116 __field(int, for_kupdate) 117 __field(int, for_background) 118 __field(int, for_reclaim) 119 __field(int, range_cyclic) 120 __field(long, range_start) 121 __field(long, range_end) 122 ), 123 124 TP_fast_assign( 125 strncpy(__entry->name, dev_name(bdi->dev), 32); 126 __entry->nr_to_write = wbc->nr_to_write; 127 __entry->pages_skipped = wbc->pages_skipped; 128 __entry->sync_mode = wbc->sync_mode; 129 __entry->for_kupdate = wbc->for_kupdate; 130 __entry->for_background = wbc->for_background; 131 __entry->for_reclaim = wbc->for_reclaim; 132 __entry->range_cyclic = wbc->range_cyclic; 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 " 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->range_start, 149 __entry->range_end) 150 ) 151 152 #define DEFINE_WBC_EVENT(name) \ 153 DEFINE_EVENT(wbc_class, name, \ 154 TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \ 155 TP_ARGS(wbc, bdi)) 156 DEFINE_WBC_EVENT(wbc_writepage); 157 158 TRACE_EVENT(writeback_queue_io, 159 TP_PROTO(struct bdi_writeback *wb, 160 struct wb_writeback_work *work, 161 int moved), 162 TP_ARGS(wb, work, moved), 163 TP_STRUCT__entry( 164 __array(char, name, 32) 165 __field(unsigned long, older) 166 __field(long, age) 167 __field(int, moved) 168 ), 169 TP_fast_assign( 170 unsigned long *older_than_this = work->older_than_this; 171 strncpy(__entry->name, dev_name(wb->bdi->dev), 32); 172 __entry->older = older_than_this ? *older_than_this : 0; 173 __entry->age = older_than_this ? 174 (jiffies - *older_than_this) * 1000 / HZ : -1; 175 __entry->moved = moved; 176 ), 177 TP_printk("bdi %s: older=%lu age=%ld enqueue=%d", 178 __entry->name, 179 __entry->older, /* older_than_this in jiffies */ 180 __entry->age, /* older_than_this in relative milliseconds */ 181 __entry->moved) 182 ); 183 184 TRACE_EVENT(global_dirty_state, 185 186 TP_PROTO(unsigned long background_thresh, 187 unsigned long dirty_thresh 188 ), 189 190 TP_ARGS(background_thresh, 191 dirty_thresh 192 ), 193 194 TP_STRUCT__entry( 195 __field(unsigned long, nr_dirty) 196 __field(unsigned long, nr_writeback) 197 __field(unsigned long, nr_unstable) 198 __field(unsigned long, background_thresh) 199 __field(unsigned long, dirty_thresh) 200 __field(unsigned long, dirty_limit) 201 __field(unsigned long, nr_dirtied) 202 __field(unsigned long, nr_written) 203 ), 204 205 TP_fast_assign( 206 __entry->nr_dirty = global_page_state(NR_FILE_DIRTY); 207 __entry->nr_writeback = global_page_state(NR_WRITEBACK); 208 __entry->nr_unstable = global_page_state(NR_UNSTABLE_NFS); 209 __entry->nr_dirtied = global_page_state(NR_DIRTIED); 210 __entry->nr_written = global_page_state(NR_WRITTEN); 211 __entry->background_thresh = background_thresh; 212 __entry->dirty_thresh = dirty_thresh; 213 __entry->dirty_limit = global_dirty_limit; 214 ), 215 216 TP_printk("dirty=%lu writeback=%lu unstable=%lu " 217 "bg_thresh=%lu thresh=%lu limit=%lu " 218 "dirtied=%lu written=%lu", 219 __entry->nr_dirty, 220 __entry->nr_writeback, 221 __entry->nr_unstable, 222 __entry->background_thresh, 223 __entry->dirty_thresh, 224 __entry->dirty_limit, 225 __entry->nr_dirtied, 226 __entry->nr_written 227 ) 228 ); 229 230 #define KBps(x) ((x) << (PAGE_SHIFT - 10)) 231 232 TRACE_EVENT(bdi_dirty_ratelimit, 233 234 TP_PROTO(struct backing_dev_info *bdi, 235 unsigned long dirty_rate, 236 unsigned long task_ratelimit), 237 238 TP_ARGS(bdi, dirty_rate, task_ratelimit), 239 240 TP_STRUCT__entry( 241 __array(char, bdi, 32) 242 __field(unsigned long, write_bw) 243 __field(unsigned long, avg_write_bw) 244 __field(unsigned long, dirty_rate) 245 __field(unsigned long, dirty_ratelimit) 246 __field(unsigned long, task_ratelimit) 247 __field(unsigned long, balanced_dirty_ratelimit) 248 ), 249 250 TP_fast_assign( 251 strlcpy(__entry->bdi, dev_name(bdi->dev), 32); 252 __entry->write_bw = KBps(bdi->write_bandwidth); 253 __entry->avg_write_bw = KBps(bdi->avg_write_bandwidth); 254 __entry->dirty_rate = KBps(dirty_rate); 255 __entry->dirty_ratelimit = KBps(bdi->dirty_ratelimit); 256 __entry->task_ratelimit = KBps(task_ratelimit); 257 __entry->balanced_dirty_ratelimit = 258 KBps(bdi->balanced_dirty_ratelimit); 259 ), 260 261 TP_printk("bdi %s: " 262 "write_bw=%lu awrite_bw=%lu dirty_rate=%lu " 263 "dirty_ratelimit=%lu task_ratelimit=%lu " 264 "balanced_dirty_ratelimit=%lu", 265 __entry->bdi, 266 __entry->write_bw, /* write bandwidth */ 267 __entry->avg_write_bw, /* avg write bandwidth */ 268 __entry->dirty_rate, /* bdi dirty rate */ 269 __entry->dirty_ratelimit, /* base ratelimit */ 270 __entry->task_ratelimit, /* ratelimit with position control */ 271 __entry->balanced_dirty_ratelimit /* the balanced ratelimit */ 272 ) 273 ); 274 275 TRACE_EVENT(balance_dirty_pages, 276 277 TP_PROTO(struct backing_dev_info *bdi, 278 unsigned long thresh, 279 unsigned long bg_thresh, 280 unsigned long dirty, 281 unsigned long bdi_thresh, 282 unsigned long bdi_dirty, 283 unsigned long dirty_ratelimit, 284 unsigned long task_ratelimit, 285 unsigned long dirtied, 286 long pause, 287 unsigned long start_time), 288 289 TP_ARGS(bdi, thresh, bg_thresh, dirty, bdi_thresh, bdi_dirty, 290 dirty_ratelimit, task_ratelimit, 291 dirtied, pause, start_time), 292 293 TP_STRUCT__entry( 294 __array( char, bdi, 32) 295 __field(unsigned long, limit) 296 __field(unsigned long, setpoint) 297 __field(unsigned long, dirty) 298 __field(unsigned long, bdi_setpoint) 299 __field(unsigned long, bdi_dirty) 300 __field(unsigned long, dirty_ratelimit) 301 __field(unsigned long, task_ratelimit) 302 __field(unsigned int, dirtied) 303 __field(unsigned int, dirtied_pause) 304 __field(unsigned long, paused) 305 __field( long, pause) 306 ), 307 308 TP_fast_assign( 309 unsigned long freerun = (thresh + bg_thresh) / 2; 310 strlcpy(__entry->bdi, dev_name(bdi->dev), 32); 311 312 __entry->limit = global_dirty_limit; 313 __entry->setpoint = (global_dirty_limit + freerun) / 2; 314 __entry->dirty = dirty; 315 __entry->bdi_setpoint = __entry->setpoint * 316 bdi_thresh / (thresh + 1); 317 __entry->bdi_dirty = bdi_dirty; 318 __entry->dirty_ratelimit = KBps(dirty_ratelimit); 319 __entry->task_ratelimit = KBps(task_ratelimit); 320 __entry->dirtied = dirtied; 321 __entry->dirtied_pause = current->nr_dirtied_pause; 322 __entry->pause = pause * 1000 / HZ; 323 __entry->paused = (jiffies - start_time) * 1000 / HZ; 324 ), 325 326 327 TP_printk("bdi %s: " 328 "limit=%lu setpoint=%lu dirty=%lu " 329 "bdi_setpoint=%lu bdi_dirty=%lu " 330 "dirty_ratelimit=%lu task_ratelimit=%lu " 331 "dirtied=%u dirtied_pause=%u " 332 "paused=%lu pause=%ld", 333 __entry->bdi, 334 __entry->limit, 335 __entry->setpoint, 336 __entry->dirty, 337 __entry->bdi_setpoint, 338 __entry->bdi_dirty, 339 __entry->dirty_ratelimit, 340 __entry->task_ratelimit, 341 __entry->dirtied, 342 __entry->dirtied_pause, 343 __entry->paused, /* ms */ 344 __entry->pause /* ms */ 345 ) 346 ); 347 348 DECLARE_EVENT_CLASS(writeback_congest_waited_template, 349 350 TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed), 351 352 TP_ARGS(usec_timeout, usec_delayed), 353 354 TP_STRUCT__entry( 355 __field( unsigned int, usec_timeout ) 356 __field( unsigned int, usec_delayed ) 357 ), 358 359 TP_fast_assign( 360 __entry->usec_timeout = usec_timeout; 361 __entry->usec_delayed = usec_delayed; 362 ), 363 364 TP_printk("usec_timeout=%u usec_delayed=%u", 365 __entry->usec_timeout, 366 __entry->usec_delayed) 367 ); 368 369 DEFINE_EVENT(writeback_congest_waited_template, writeback_congestion_wait, 370 371 TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed), 372 373 TP_ARGS(usec_timeout, usec_delayed) 374 ); 375 376 DEFINE_EVENT(writeback_congest_waited_template, writeback_wait_iff_congested, 377 378 TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed), 379 380 TP_ARGS(usec_timeout, usec_delayed) 381 ); 382 383 DECLARE_EVENT_CLASS(writeback_single_inode_template, 384 385 TP_PROTO(struct inode *inode, 386 struct writeback_control *wbc, 387 unsigned long nr_to_write 388 ), 389 390 TP_ARGS(inode, wbc, nr_to_write), 391 392 TP_STRUCT__entry( 393 __array(char, name, 32) 394 __field(unsigned long, ino) 395 __field(unsigned long, state) 396 __field(unsigned long, dirtied_when) 397 __field(unsigned long, writeback_index) 398 __field(long, nr_to_write) 399 __field(unsigned long, wrote) 400 ), 401 402 TP_fast_assign( 403 strncpy(__entry->name, 404 dev_name(inode->i_mapping->backing_dev_info->dev), 32); 405 __entry->ino = inode->i_ino; 406 __entry->state = inode->i_state; 407 __entry->dirtied_when = inode->dirtied_when; 408 __entry->writeback_index = inode->i_mapping->writeback_index; 409 __entry->nr_to_write = nr_to_write; 410 __entry->wrote = nr_to_write - wbc->nr_to_write; 411 ), 412 413 TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu " 414 "index=%lu to_write=%ld wrote=%lu", 415 __entry->name, 416 __entry->ino, 417 show_inode_state(__entry->state), 418 __entry->dirtied_when, 419 (jiffies - __entry->dirtied_when) / HZ, 420 __entry->writeback_index, 421 __entry->nr_to_write, 422 __entry->wrote 423 ) 424 ); 425 426 DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode_requeue, 427 TP_PROTO(struct inode *inode, 428 struct writeback_control *wbc, 429 unsigned long nr_to_write), 430 TP_ARGS(inode, wbc, nr_to_write) 431 ); 432 433 DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode, 434 TP_PROTO(struct inode *inode, 435 struct writeback_control *wbc, 436 unsigned long nr_to_write), 437 TP_ARGS(inode, wbc, nr_to_write) 438 ); 439 440 #endif /* _TRACE_WRITEBACK_H */ 441 442 /* This part must be outside protection */ 443 #include <trace/define_trace.h> 444