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