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/tracepoint.h> 8 #include <linux/backing-dev.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_DIRTY_TIME, "I_DIRTY_TIME"}, \ 22 {I_DIRTY_TIME_EXPIRED, "I_DIRTY_TIME_EXPIRED"}, \ 23 {I_REFERENCED, "I_REFERENCED"} \ 24 ) 25 26 /* enums need to be exported to user space */ 27 #undef EM 28 #undef EMe 29 #define EM(a,b) TRACE_DEFINE_ENUM(a); 30 #define EMe(a,b) TRACE_DEFINE_ENUM(a); 31 32 #define WB_WORK_REASON \ 33 EM( WB_REASON_BACKGROUND, "background") \ 34 EM( WB_REASON_VMSCAN, "vmscan") \ 35 EM( WB_REASON_SYNC, "sync") \ 36 EM( WB_REASON_PERIODIC, "periodic") \ 37 EM( WB_REASON_LAPTOP_TIMER, "laptop_timer") \ 38 EM( WB_REASON_FREE_MORE_MEM, "free_more_memory") \ 39 EM( WB_REASON_FS_FREE_SPACE, "fs_free_space") \ 40 EMe(WB_REASON_FORKER_THREAD, "forker_thread") 41 42 WB_WORK_REASON 43 44 /* 45 * Now redefine the EM() and EMe() macros to map the enums to the strings 46 * that will be printed in the output. 47 */ 48 #undef EM 49 #undef EMe 50 #define EM(a,b) { a, b }, 51 #define EMe(a,b) { a, b } 52 53 struct wb_writeback_work; 54 55 TRACE_EVENT(writeback_dirty_page, 56 57 TP_PROTO(struct page *page, struct address_space *mapping), 58 59 TP_ARGS(page, mapping), 60 61 TP_STRUCT__entry ( 62 __array(char, name, 32) 63 __field(unsigned long, ino) 64 __field(pgoff_t, index) 65 ), 66 67 TP_fast_assign( 68 strncpy(__entry->name, 69 mapping ? dev_name(inode_to_bdi(mapping->host)->dev) : "(unknown)", 32); 70 __entry->ino = mapping ? mapping->host->i_ino : 0; 71 __entry->index = page->index; 72 ), 73 74 TP_printk("bdi %s: ino=%lu index=%lu", 75 __entry->name, 76 __entry->ino, 77 __entry->index 78 ) 79 ); 80 81 DECLARE_EVENT_CLASS(writeback_dirty_inode_template, 82 83 TP_PROTO(struct inode *inode, int flags), 84 85 TP_ARGS(inode, flags), 86 87 TP_STRUCT__entry ( 88 __array(char, name, 32) 89 __field(unsigned long, ino) 90 __field(unsigned long, state) 91 __field(unsigned long, flags) 92 ), 93 94 TP_fast_assign( 95 struct backing_dev_info *bdi = inode_to_bdi(inode); 96 97 /* may be called for files on pseudo FSes w/ unregistered bdi */ 98 strncpy(__entry->name, 99 bdi->dev ? dev_name(bdi->dev) : "(unknown)", 32); 100 __entry->ino = inode->i_ino; 101 __entry->state = inode->i_state; 102 __entry->flags = flags; 103 ), 104 105 TP_printk("bdi %s: ino=%lu state=%s flags=%s", 106 __entry->name, 107 __entry->ino, 108 show_inode_state(__entry->state), 109 show_inode_state(__entry->flags) 110 ) 111 ); 112 113 DEFINE_EVENT(writeback_dirty_inode_template, writeback_mark_inode_dirty, 114 115 TP_PROTO(struct inode *inode, int flags), 116 117 TP_ARGS(inode, flags) 118 ); 119 120 DEFINE_EVENT(writeback_dirty_inode_template, writeback_dirty_inode_start, 121 122 TP_PROTO(struct inode *inode, int flags), 123 124 TP_ARGS(inode, flags) 125 ); 126 127 DEFINE_EVENT(writeback_dirty_inode_template, writeback_dirty_inode, 128 129 TP_PROTO(struct inode *inode, int flags), 130 131 TP_ARGS(inode, flags) 132 ); 133 134 #ifdef CREATE_TRACE_POINTS 135 #ifdef CONFIG_CGROUP_WRITEBACK 136 137 static inline unsigned int __trace_wb_assign_cgroup(struct bdi_writeback *wb) 138 { 139 return wb->memcg_css->cgroup->kn->id.ino; 140 } 141 142 static inline unsigned int __trace_wbc_assign_cgroup(struct writeback_control *wbc) 143 { 144 if (wbc->wb) 145 return __trace_wb_assign_cgroup(wbc->wb); 146 else 147 return -1U; 148 } 149 #else /* CONFIG_CGROUP_WRITEBACK */ 150 151 static inline unsigned int __trace_wb_assign_cgroup(struct bdi_writeback *wb) 152 { 153 return -1U; 154 } 155 156 static inline unsigned int __trace_wbc_assign_cgroup(struct writeback_control *wbc) 157 { 158 return -1U; 159 } 160 161 #endif /* CONFIG_CGROUP_WRITEBACK */ 162 #endif /* CREATE_TRACE_POINTS */ 163 164 DECLARE_EVENT_CLASS(writeback_write_inode_template, 165 166 TP_PROTO(struct inode *inode, struct writeback_control *wbc), 167 168 TP_ARGS(inode, wbc), 169 170 TP_STRUCT__entry ( 171 __array(char, name, 32) 172 __field(unsigned long, ino) 173 __field(int, sync_mode) 174 __field(unsigned int, cgroup_ino) 175 ), 176 177 TP_fast_assign( 178 strncpy(__entry->name, 179 dev_name(inode_to_bdi(inode)->dev), 32); 180 __entry->ino = inode->i_ino; 181 __entry->sync_mode = wbc->sync_mode; 182 __entry->cgroup_ino = __trace_wbc_assign_cgroup(wbc); 183 ), 184 185 TP_printk("bdi %s: ino=%lu sync_mode=%d cgroup_ino=%u", 186 __entry->name, 187 __entry->ino, 188 __entry->sync_mode, 189 __entry->cgroup_ino 190 ) 191 ); 192 193 DEFINE_EVENT(writeback_write_inode_template, writeback_write_inode_start, 194 195 TP_PROTO(struct inode *inode, struct writeback_control *wbc), 196 197 TP_ARGS(inode, wbc) 198 ); 199 200 DEFINE_EVENT(writeback_write_inode_template, writeback_write_inode, 201 202 TP_PROTO(struct inode *inode, struct writeback_control *wbc), 203 204 TP_ARGS(inode, wbc) 205 ); 206 207 DECLARE_EVENT_CLASS(writeback_work_class, 208 TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work), 209 TP_ARGS(wb, work), 210 TP_STRUCT__entry( 211 __array(char, name, 32) 212 __field(long, nr_pages) 213 __field(dev_t, sb_dev) 214 __field(int, sync_mode) 215 __field(int, for_kupdate) 216 __field(int, range_cyclic) 217 __field(int, for_background) 218 __field(int, reason) 219 __field(unsigned int, cgroup_ino) 220 ), 221 TP_fast_assign( 222 strncpy(__entry->name, 223 wb->bdi->dev ? dev_name(wb->bdi->dev) : "(unknown)", 32); 224 __entry->nr_pages = work->nr_pages; 225 __entry->sb_dev = work->sb ? work->sb->s_dev : 0; 226 __entry->sync_mode = work->sync_mode; 227 __entry->for_kupdate = work->for_kupdate; 228 __entry->range_cyclic = work->range_cyclic; 229 __entry->for_background = work->for_background; 230 __entry->reason = work->reason; 231 __entry->cgroup_ino = __trace_wb_assign_cgroup(wb); 232 ), 233 TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d " 234 "kupdate=%d range_cyclic=%d background=%d reason=%s cgroup_ino=%u", 235 __entry->name, 236 MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev), 237 __entry->nr_pages, 238 __entry->sync_mode, 239 __entry->for_kupdate, 240 __entry->range_cyclic, 241 __entry->for_background, 242 __print_symbolic(__entry->reason, WB_WORK_REASON), 243 __entry->cgroup_ino 244 ) 245 ); 246 #define DEFINE_WRITEBACK_WORK_EVENT(name) \ 247 DEFINE_EVENT(writeback_work_class, name, \ 248 TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work), \ 249 TP_ARGS(wb, work)) 250 DEFINE_WRITEBACK_WORK_EVENT(writeback_queue); 251 DEFINE_WRITEBACK_WORK_EVENT(writeback_exec); 252 DEFINE_WRITEBACK_WORK_EVENT(writeback_start); 253 DEFINE_WRITEBACK_WORK_EVENT(writeback_written); 254 DEFINE_WRITEBACK_WORK_EVENT(writeback_wait); 255 256 TRACE_EVENT(writeback_pages_written, 257 TP_PROTO(long pages_written), 258 TP_ARGS(pages_written), 259 TP_STRUCT__entry( 260 __field(long, pages) 261 ), 262 TP_fast_assign( 263 __entry->pages = pages_written; 264 ), 265 TP_printk("%ld", __entry->pages) 266 ); 267 268 DECLARE_EVENT_CLASS(writeback_class, 269 TP_PROTO(struct bdi_writeback *wb), 270 TP_ARGS(wb), 271 TP_STRUCT__entry( 272 __array(char, name, 32) 273 __field(unsigned int, cgroup_ino) 274 ), 275 TP_fast_assign( 276 strncpy(__entry->name, dev_name(wb->bdi->dev), 32); 277 __entry->cgroup_ino = __trace_wb_assign_cgroup(wb); 278 ), 279 TP_printk("bdi %s: cgroup_ino=%u", 280 __entry->name, 281 __entry->cgroup_ino 282 ) 283 ); 284 #define DEFINE_WRITEBACK_EVENT(name) \ 285 DEFINE_EVENT(writeback_class, name, \ 286 TP_PROTO(struct bdi_writeback *wb), \ 287 TP_ARGS(wb)) 288 289 DEFINE_WRITEBACK_EVENT(writeback_wake_background); 290 291 TRACE_EVENT(writeback_bdi_register, 292 TP_PROTO(struct backing_dev_info *bdi), 293 TP_ARGS(bdi), 294 TP_STRUCT__entry( 295 __array(char, name, 32) 296 ), 297 TP_fast_assign( 298 strncpy(__entry->name, dev_name(bdi->dev), 32); 299 ), 300 TP_printk("bdi %s", 301 __entry->name 302 ) 303 ); 304 305 DECLARE_EVENT_CLASS(wbc_class, 306 TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), 307 TP_ARGS(wbc, bdi), 308 TP_STRUCT__entry( 309 __array(char, name, 32) 310 __field(long, nr_to_write) 311 __field(long, pages_skipped) 312 __field(int, sync_mode) 313 __field(int, for_kupdate) 314 __field(int, for_background) 315 __field(int, for_reclaim) 316 __field(int, range_cyclic) 317 __field(long, range_start) 318 __field(long, range_end) 319 __field(unsigned int, cgroup_ino) 320 ), 321 322 TP_fast_assign( 323 strncpy(__entry->name, dev_name(bdi->dev), 32); 324 __entry->nr_to_write = wbc->nr_to_write; 325 __entry->pages_skipped = wbc->pages_skipped; 326 __entry->sync_mode = wbc->sync_mode; 327 __entry->for_kupdate = wbc->for_kupdate; 328 __entry->for_background = wbc->for_background; 329 __entry->for_reclaim = wbc->for_reclaim; 330 __entry->range_cyclic = wbc->range_cyclic; 331 __entry->range_start = (long)wbc->range_start; 332 __entry->range_end = (long)wbc->range_end; 333 __entry->cgroup_ino = __trace_wbc_assign_cgroup(wbc); 334 ), 335 336 TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d " 337 "bgrd=%d reclm=%d cyclic=%d " 338 "start=0x%lx end=0x%lx cgroup_ino=%u", 339 __entry->name, 340 __entry->nr_to_write, 341 __entry->pages_skipped, 342 __entry->sync_mode, 343 __entry->for_kupdate, 344 __entry->for_background, 345 __entry->for_reclaim, 346 __entry->range_cyclic, 347 __entry->range_start, 348 __entry->range_end, 349 __entry->cgroup_ino 350 ) 351 ) 352 353 #define DEFINE_WBC_EVENT(name) \ 354 DEFINE_EVENT(wbc_class, name, \ 355 TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \ 356 TP_ARGS(wbc, bdi)) 357 DEFINE_WBC_EVENT(wbc_writepage); 358 359 TRACE_EVENT(writeback_queue_io, 360 TP_PROTO(struct bdi_writeback *wb, 361 struct wb_writeback_work *work, 362 int moved), 363 TP_ARGS(wb, work, moved), 364 TP_STRUCT__entry( 365 __array(char, name, 32) 366 __field(unsigned long, older) 367 __field(long, age) 368 __field(int, moved) 369 __field(int, reason) 370 __field(unsigned int, cgroup_ino) 371 ), 372 TP_fast_assign( 373 unsigned long *older_than_this = work->older_than_this; 374 strncpy(__entry->name, dev_name(wb->bdi->dev), 32); 375 __entry->older = older_than_this ? *older_than_this : 0; 376 __entry->age = older_than_this ? 377 (jiffies - *older_than_this) * 1000 / HZ : -1; 378 __entry->moved = moved; 379 __entry->reason = work->reason; 380 __entry->cgroup_ino = __trace_wb_assign_cgroup(wb); 381 ), 382 TP_printk("bdi %s: older=%lu age=%ld enqueue=%d reason=%s cgroup_ino=%u", 383 __entry->name, 384 __entry->older, /* older_than_this in jiffies */ 385 __entry->age, /* older_than_this in relative milliseconds */ 386 __entry->moved, 387 __print_symbolic(__entry->reason, WB_WORK_REASON), 388 __entry->cgroup_ino 389 ) 390 ); 391 392 TRACE_EVENT(global_dirty_state, 393 394 TP_PROTO(unsigned long background_thresh, 395 unsigned long dirty_thresh 396 ), 397 398 TP_ARGS(background_thresh, 399 dirty_thresh 400 ), 401 402 TP_STRUCT__entry( 403 __field(unsigned long, nr_dirty) 404 __field(unsigned long, nr_writeback) 405 __field(unsigned long, nr_unstable) 406 __field(unsigned long, background_thresh) 407 __field(unsigned long, dirty_thresh) 408 __field(unsigned long, dirty_limit) 409 __field(unsigned long, nr_dirtied) 410 __field(unsigned long, nr_written) 411 ), 412 413 TP_fast_assign( 414 __entry->nr_dirty = global_node_page_state(NR_FILE_DIRTY); 415 __entry->nr_writeback = global_node_page_state(NR_WRITEBACK); 416 __entry->nr_unstable = global_node_page_state(NR_UNSTABLE_NFS); 417 __entry->nr_dirtied = global_node_page_state(NR_DIRTIED); 418 __entry->nr_written = global_node_page_state(NR_WRITTEN); 419 __entry->background_thresh = background_thresh; 420 __entry->dirty_thresh = dirty_thresh; 421 __entry->dirty_limit = global_wb_domain.dirty_limit; 422 ), 423 424 TP_printk("dirty=%lu writeback=%lu unstable=%lu " 425 "bg_thresh=%lu thresh=%lu limit=%lu " 426 "dirtied=%lu written=%lu", 427 __entry->nr_dirty, 428 __entry->nr_writeback, 429 __entry->nr_unstable, 430 __entry->background_thresh, 431 __entry->dirty_thresh, 432 __entry->dirty_limit, 433 __entry->nr_dirtied, 434 __entry->nr_written 435 ) 436 ); 437 438 #define KBps(x) ((x) << (PAGE_SHIFT - 10)) 439 440 TRACE_EVENT(bdi_dirty_ratelimit, 441 442 TP_PROTO(struct bdi_writeback *wb, 443 unsigned long dirty_rate, 444 unsigned long task_ratelimit), 445 446 TP_ARGS(wb, dirty_rate, task_ratelimit), 447 448 TP_STRUCT__entry( 449 __array(char, bdi, 32) 450 __field(unsigned long, write_bw) 451 __field(unsigned long, avg_write_bw) 452 __field(unsigned long, dirty_rate) 453 __field(unsigned long, dirty_ratelimit) 454 __field(unsigned long, task_ratelimit) 455 __field(unsigned long, balanced_dirty_ratelimit) 456 __field(unsigned int, cgroup_ino) 457 ), 458 459 TP_fast_assign( 460 strlcpy(__entry->bdi, dev_name(wb->bdi->dev), 32); 461 __entry->write_bw = KBps(wb->write_bandwidth); 462 __entry->avg_write_bw = KBps(wb->avg_write_bandwidth); 463 __entry->dirty_rate = KBps(dirty_rate); 464 __entry->dirty_ratelimit = KBps(wb->dirty_ratelimit); 465 __entry->task_ratelimit = KBps(task_ratelimit); 466 __entry->balanced_dirty_ratelimit = 467 KBps(wb->balanced_dirty_ratelimit); 468 __entry->cgroup_ino = __trace_wb_assign_cgroup(wb); 469 ), 470 471 TP_printk("bdi %s: " 472 "write_bw=%lu awrite_bw=%lu dirty_rate=%lu " 473 "dirty_ratelimit=%lu task_ratelimit=%lu " 474 "balanced_dirty_ratelimit=%lu cgroup_ino=%u", 475 __entry->bdi, 476 __entry->write_bw, /* write bandwidth */ 477 __entry->avg_write_bw, /* avg write bandwidth */ 478 __entry->dirty_rate, /* bdi dirty rate */ 479 __entry->dirty_ratelimit, /* base ratelimit */ 480 __entry->task_ratelimit, /* ratelimit with position control */ 481 __entry->balanced_dirty_ratelimit, /* the balanced ratelimit */ 482 __entry->cgroup_ino 483 ) 484 ); 485 486 TRACE_EVENT(balance_dirty_pages, 487 488 TP_PROTO(struct bdi_writeback *wb, 489 unsigned long thresh, 490 unsigned long bg_thresh, 491 unsigned long dirty, 492 unsigned long bdi_thresh, 493 unsigned long bdi_dirty, 494 unsigned long dirty_ratelimit, 495 unsigned long task_ratelimit, 496 unsigned long dirtied, 497 unsigned long period, 498 long pause, 499 unsigned long start_time), 500 501 TP_ARGS(wb, thresh, bg_thresh, dirty, bdi_thresh, bdi_dirty, 502 dirty_ratelimit, task_ratelimit, 503 dirtied, period, pause, start_time), 504 505 TP_STRUCT__entry( 506 __array( char, bdi, 32) 507 __field(unsigned long, limit) 508 __field(unsigned long, setpoint) 509 __field(unsigned long, dirty) 510 __field(unsigned long, bdi_setpoint) 511 __field(unsigned long, bdi_dirty) 512 __field(unsigned long, dirty_ratelimit) 513 __field(unsigned long, task_ratelimit) 514 __field(unsigned int, dirtied) 515 __field(unsigned int, dirtied_pause) 516 __field(unsigned long, paused) 517 __field( long, pause) 518 __field(unsigned long, period) 519 __field( long, think) 520 __field(unsigned int, cgroup_ino) 521 ), 522 523 TP_fast_assign( 524 unsigned long freerun = (thresh + bg_thresh) / 2; 525 strlcpy(__entry->bdi, dev_name(wb->bdi->dev), 32); 526 527 __entry->limit = global_wb_domain.dirty_limit; 528 __entry->setpoint = (global_wb_domain.dirty_limit + 529 freerun) / 2; 530 __entry->dirty = dirty; 531 __entry->bdi_setpoint = __entry->setpoint * 532 bdi_thresh / (thresh + 1); 533 __entry->bdi_dirty = bdi_dirty; 534 __entry->dirty_ratelimit = KBps(dirty_ratelimit); 535 __entry->task_ratelimit = KBps(task_ratelimit); 536 __entry->dirtied = dirtied; 537 __entry->dirtied_pause = current->nr_dirtied_pause; 538 __entry->think = current->dirty_paused_when == 0 ? 0 : 539 (long)(jiffies - current->dirty_paused_when) * 1000/HZ; 540 __entry->period = period * 1000 / HZ; 541 __entry->pause = pause * 1000 / HZ; 542 __entry->paused = (jiffies - start_time) * 1000 / HZ; 543 __entry->cgroup_ino = __trace_wb_assign_cgroup(wb); 544 ), 545 546 547 TP_printk("bdi %s: " 548 "limit=%lu setpoint=%lu dirty=%lu " 549 "bdi_setpoint=%lu bdi_dirty=%lu " 550 "dirty_ratelimit=%lu task_ratelimit=%lu " 551 "dirtied=%u dirtied_pause=%u " 552 "paused=%lu pause=%ld period=%lu think=%ld cgroup_ino=%u", 553 __entry->bdi, 554 __entry->limit, 555 __entry->setpoint, 556 __entry->dirty, 557 __entry->bdi_setpoint, 558 __entry->bdi_dirty, 559 __entry->dirty_ratelimit, 560 __entry->task_ratelimit, 561 __entry->dirtied, 562 __entry->dirtied_pause, 563 __entry->paused, /* ms */ 564 __entry->pause, /* ms */ 565 __entry->period, /* ms */ 566 __entry->think, /* ms */ 567 __entry->cgroup_ino 568 ) 569 ); 570 571 TRACE_EVENT(writeback_sb_inodes_requeue, 572 573 TP_PROTO(struct inode *inode), 574 TP_ARGS(inode), 575 576 TP_STRUCT__entry( 577 __array(char, name, 32) 578 __field(unsigned long, ino) 579 __field(unsigned long, state) 580 __field(unsigned long, dirtied_when) 581 __field(unsigned int, cgroup_ino) 582 ), 583 584 TP_fast_assign( 585 strncpy(__entry->name, 586 dev_name(inode_to_bdi(inode)->dev), 32); 587 __entry->ino = inode->i_ino; 588 __entry->state = inode->i_state; 589 __entry->dirtied_when = inode->dirtied_when; 590 __entry->cgroup_ino = __trace_wb_assign_cgroup(inode_to_wb(inode)); 591 ), 592 593 TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu cgroup_ino=%u", 594 __entry->name, 595 __entry->ino, 596 show_inode_state(__entry->state), 597 __entry->dirtied_when, 598 (jiffies - __entry->dirtied_when) / HZ, 599 __entry->cgroup_ino 600 ) 601 ); 602 603 DECLARE_EVENT_CLASS(writeback_congest_waited_template, 604 605 TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed), 606 607 TP_ARGS(usec_timeout, usec_delayed), 608 609 TP_STRUCT__entry( 610 __field( unsigned int, usec_timeout ) 611 __field( unsigned int, usec_delayed ) 612 ), 613 614 TP_fast_assign( 615 __entry->usec_timeout = usec_timeout; 616 __entry->usec_delayed = usec_delayed; 617 ), 618 619 TP_printk("usec_timeout=%u usec_delayed=%u", 620 __entry->usec_timeout, 621 __entry->usec_delayed) 622 ); 623 624 DEFINE_EVENT(writeback_congest_waited_template, writeback_congestion_wait, 625 626 TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed), 627 628 TP_ARGS(usec_timeout, usec_delayed) 629 ); 630 631 DEFINE_EVENT(writeback_congest_waited_template, writeback_wait_iff_congested, 632 633 TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed), 634 635 TP_ARGS(usec_timeout, usec_delayed) 636 ); 637 638 DECLARE_EVENT_CLASS(writeback_single_inode_template, 639 640 TP_PROTO(struct inode *inode, 641 struct writeback_control *wbc, 642 unsigned long nr_to_write 643 ), 644 645 TP_ARGS(inode, wbc, nr_to_write), 646 647 TP_STRUCT__entry( 648 __array(char, name, 32) 649 __field(unsigned long, ino) 650 __field(unsigned long, state) 651 __field(unsigned long, dirtied_when) 652 __field(unsigned long, writeback_index) 653 __field(long, nr_to_write) 654 __field(unsigned long, wrote) 655 __field(unsigned int, cgroup_ino) 656 ), 657 658 TP_fast_assign( 659 strncpy(__entry->name, 660 dev_name(inode_to_bdi(inode)->dev), 32); 661 __entry->ino = inode->i_ino; 662 __entry->state = inode->i_state; 663 __entry->dirtied_when = inode->dirtied_when; 664 __entry->writeback_index = inode->i_mapping->writeback_index; 665 __entry->nr_to_write = nr_to_write; 666 __entry->wrote = nr_to_write - wbc->nr_to_write; 667 __entry->cgroup_ino = __trace_wbc_assign_cgroup(wbc); 668 ), 669 670 TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu " 671 "index=%lu to_write=%ld wrote=%lu cgroup_ino=%u", 672 __entry->name, 673 __entry->ino, 674 show_inode_state(__entry->state), 675 __entry->dirtied_when, 676 (jiffies - __entry->dirtied_when) / HZ, 677 __entry->writeback_index, 678 __entry->nr_to_write, 679 __entry->wrote, 680 __entry->cgroup_ino 681 ) 682 ); 683 684 DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode_start, 685 TP_PROTO(struct inode *inode, 686 struct writeback_control *wbc, 687 unsigned long nr_to_write), 688 TP_ARGS(inode, wbc, nr_to_write) 689 ); 690 691 DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode, 692 TP_PROTO(struct inode *inode, 693 struct writeback_control *wbc, 694 unsigned long nr_to_write), 695 TP_ARGS(inode, wbc, nr_to_write) 696 ); 697 698 DECLARE_EVENT_CLASS(writeback_inode_template, 699 TP_PROTO(struct inode *inode), 700 701 TP_ARGS(inode), 702 703 TP_STRUCT__entry( 704 __field( dev_t, dev ) 705 __field(unsigned long, ino ) 706 __field(unsigned long, state ) 707 __field( __u16, mode ) 708 __field(unsigned long, dirtied_when ) 709 ), 710 711 TP_fast_assign( 712 __entry->dev = inode->i_sb->s_dev; 713 __entry->ino = inode->i_ino; 714 __entry->state = inode->i_state; 715 __entry->mode = inode->i_mode; 716 __entry->dirtied_when = inode->dirtied_when; 717 ), 718 719 TP_printk("dev %d,%d ino %lu dirtied %lu state %s mode 0%o", 720 MAJOR(__entry->dev), MINOR(__entry->dev), 721 __entry->ino, __entry->dirtied_when, 722 show_inode_state(__entry->state), __entry->mode) 723 ); 724 725 DEFINE_EVENT(writeback_inode_template, writeback_lazytime, 726 TP_PROTO(struct inode *inode), 727 728 TP_ARGS(inode) 729 ); 730 731 DEFINE_EVENT(writeback_inode_template, writeback_lazytime_iput, 732 TP_PROTO(struct inode *inode), 733 734 TP_ARGS(inode) 735 ); 736 737 DEFINE_EVENT(writeback_inode_template, writeback_dirty_inode_enqueue, 738 739 TP_PROTO(struct inode *inode), 740 741 TP_ARGS(inode) 742 ); 743 744 /* 745 * Inode writeback list tracking. 746 */ 747 748 DEFINE_EVENT(writeback_inode_template, sb_mark_inode_writeback, 749 TP_PROTO(struct inode *inode), 750 TP_ARGS(inode) 751 ); 752 753 DEFINE_EVENT(writeback_inode_template, sb_clear_inode_writeback, 754 TP_PROTO(struct inode *inode), 755 TP_ARGS(inode) 756 ); 757 758 #endif /* _TRACE_WRITEBACK_H */ 759 760 /* This part must be outside protection */ 761 #include <trace/define_trace.h> 762