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