1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #undef TRACE_SYSTEM 3 #define TRACE_SYSTEM bcachefs 4 5 #if !defined(_TRACE_BCACHEFS_H) || defined(TRACE_HEADER_MULTI_READ) 6 7 #include <linux/tracepoint.h> 8 9 #define TRACE_BPOS_entries(name) \ 10 __field(u64, name##_inode ) \ 11 __field(u64, name##_offset ) \ 12 __field(u32, name##_snapshot ) 13 14 #define TRACE_BPOS_assign(dst, src) \ 15 __entry->dst##_inode = (src).inode; \ 16 __entry->dst##_offset = (src).offset; \ 17 __entry->dst##_snapshot = (src).snapshot 18 19 DECLARE_EVENT_CLASS(bpos, 20 TP_PROTO(const struct bpos *p), 21 TP_ARGS(p), 22 23 TP_STRUCT__entry( 24 TRACE_BPOS_entries(p) 25 ), 26 27 TP_fast_assign( 28 TRACE_BPOS_assign(p, *p); 29 ), 30 31 TP_printk("%llu:%llu:%u", __entry->p_inode, __entry->p_offset, __entry->p_snapshot) 32 ); 33 34 DECLARE_EVENT_CLASS(fs_str, 35 TP_PROTO(struct bch_fs *c, const char *str), 36 TP_ARGS(c, str), 37 38 TP_STRUCT__entry( 39 __field(dev_t, dev ) 40 __string(str, str ) 41 ), 42 43 TP_fast_assign( 44 __entry->dev = c->dev; 45 __assign_str(str); 46 ), 47 48 TP_printk("%d,%d\n%s", MAJOR(__entry->dev), MINOR(__entry->dev), __get_str(str)) 49 ); 50 51 DECLARE_EVENT_CLASS(trans_str, 52 TP_PROTO(struct btree_trans *trans, unsigned long caller_ip, const char *str), 53 TP_ARGS(trans, caller_ip, str), 54 55 TP_STRUCT__entry( 56 __field(dev_t, dev ) 57 __array(char, trans_fn, 32 ) 58 __field(unsigned long, caller_ip ) 59 __string(str, str ) 60 ), 61 62 TP_fast_assign( 63 __entry->dev = trans->c->dev; 64 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 65 __entry->caller_ip = caller_ip; 66 __assign_str(str); 67 ), 68 69 TP_printk("%d,%d %s %pS %s", 70 MAJOR(__entry->dev), MINOR(__entry->dev), 71 __entry->trans_fn, (void *) __entry->caller_ip, __get_str(str)) 72 ); 73 74 DECLARE_EVENT_CLASS(trans_str_nocaller, 75 TP_PROTO(struct btree_trans *trans, const char *str), 76 TP_ARGS(trans, str), 77 78 TP_STRUCT__entry( 79 __field(dev_t, dev ) 80 __array(char, trans_fn, 32 ) 81 __string(str, str ) 82 ), 83 84 TP_fast_assign( 85 __entry->dev = trans->c->dev; 86 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 87 __assign_str(str); 88 ), 89 90 TP_printk("%d,%d %s %s", 91 MAJOR(__entry->dev), MINOR(__entry->dev), 92 __entry->trans_fn, __get_str(str)) 93 ); 94 95 DECLARE_EVENT_CLASS(btree_node_nofs, 96 TP_PROTO(struct bch_fs *c, struct btree *b), 97 TP_ARGS(c, b), 98 99 TP_STRUCT__entry( 100 __field(dev_t, dev ) 101 __field(u8, level ) 102 __field(u8, btree_id ) 103 TRACE_BPOS_entries(pos) 104 ), 105 106 TP_fast_assign( 107 __entry->dev = c->dev; 108 __entry->level = b->c.level; 109 __entry->btree_id = b->c.btree_id; 110 TRACE_BPOS_assign(pos, b->key.k.p); 111 ), 112 113 TP_printk("%d,%d %u %s %llu:%llu:%u", 114 MAJOR(__entry->dev), MINOR(__entry->dev), 115 __entry->level, 116 bch2_btree_id_str(__entry->btree_id), 117 __entry->pos_inode, __entry->pos_offset, __entry->pos_snapshot) 118 ); 119 120 DECLARE_EVENT_CLASS(btree_node, 121 TP_PROTO(struct btree_trans *trans, struct btree *b), 122 TP_ARGS(trans, b), 123 124 TP_STRUCT__entry( 125 __field(dev_t, dev ) 126 __array(char, trans_fn, 32 ) 127 __field(u8, level ) 128 __field(u8, btree_id ) 129 TRACE_BPOS_entries(pos) 130 ), 131 132 TP_fast_assign( 133 __entry->dev = trans->c->dev; 134 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 135 __entry->level = b->c.level; 136 __entry->btree_id = b->c.btree_id; 137 TRACE_BPOS_assign(pos, b->key.k.p); 138 ), 139 140 TP_printk("%d,%d %s %u %s %llu:%llu:%u", 141 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->trans_fn, 142 __entry->level, 143 bch2_btree_id_str(__entry->btree_id), 144 __entry->pos_inode, __entry->pos_offset, __entry->pos_snapshot) 145 ); 146 147 DECLARE_EVENT_CLASS(bch_fs, 148 TP_PROTO(struct bch_fs *c), 149 TP_ARGS(c), 150 151 TP_STRUCT__entry( 152 __field(dev_t, dev ) 153 ), 154 155 TP_fast_assign( 156 __entry->dev = c->dev; 157 ), 158 159 TP_printk("%d,%d", MAJOR(__entry->dev), MINOR(__entry->dev)) 160 ); 161 162 DECLARE_EVENT_CLASS(btree_trans, 163 TP_PROTO(struct btree_trans *trans), 164 TP_ARGS(trans), 165 166 TP_STRUCT__entry( 167 __field(dev_t, dev ) 168 __array(char, trans_fn, 32 ) 169 ), 170 171 TP_fast_assign( 172 __entry->dev = trans->c->dev; 173 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 174 ), 175 176 TP_printk("%d,%d %s", MAJOR(__entry->dev), MINOR(__entry->dev), __entry->trans_fn) 177 ); 178 179 DECLARE_EVENT_CLASS(bio, 180 TP_PROTO(struct bio *bio), 181 TP_ARGS(bio), 182 183 TP_STRUCT__entry( 184 __field(dev_t, dev ) 185 __field(sector_t, sector ) 186 __field(unsigned int, nr_sector ) 187 __array(char, rwbs, 6 ) 188 ), 189 190 TP_fast_assign( 191 __entry->dev = bio->bi_bdev ? bio_dev(bio) : 0; 192 __entry->sector = bio->bi_iter.bi_sector; 193 __entry->nr_sector = bio->bi_iter.bi_size >> 9; 194 blk_fill_rwbs(__entry->rwbs, bio->bi_opf); 195 ), 196 197 TP_printk("%d,%d %s %llu + %u", 198 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs, 199 (unsigned long long)__entry->sector, __entry->nr_sector) 200 ); 201 202 /* disk_accounting.c */ 203 204 TRACE_EVENT(accounting_mem_insert, 205 TP_PROTO(struct bch_fs *c, const char *acc), 206 TP_ARGS(c, acc), 207 208 TP_STRUCT__entry( 209 __field(dev_t, dev ) 210 __field(unsigned, new_nr ) 211 __string(acc, acc ) 212 ), 213 214 TP_fast_assign( 215 __entry->dev = c->dev; 216 __entry->new_nr = c->accounting.k.nr; 217 __assign_str(acc); 218 ), 219 220 TP_printk("%d,%d entries %u added %s", 221 MAJOR(__entry->dev), MINOR(__entry->dev), 222 __entry->new_nr, 223 __get_str(acc)) 224 ); 225 226 /* fs.c: */ 227 TRACE_EVENT(bch2_sync_fs, 228 TP_PROTO(struct super_block *sb, int wait), 229 230 TP_ARGS(sb, wait), 231 232 TP_STRUCT__entry( 233 __field( dev_t, dev ) 234 __field( int, wait ) 235 236 ), 237 238 TP_fast_assign( 239 __entry->dev = sb->s_dev; 240 __entry->wait = wait; 241 ), 242 243 TP_printk("dev %d,%d wait %d", 244 MAJOR(__entry->dev), MINOR(__entry->dev), 245 __entry->wait) 246 ); 247 248 /* fs-io.c: */ 249 TRACE_EVENT(bch2_fsync, 250 TP_PROTO(struct file *file, int datasync), 251 252 TP_ARGS(file, datasync), 253 254 TP_STRUCT__entry( 255 __field( dev_t, dev ) 256 __field( ino_t, ino ) 257 __field( ino_t, parent ) 258 __field( int, datasync ) 259 ), 260 261 TP_fast_assign( 262 struct dentry *dentry = file->f_path.dentry; 263 264 __entry->dev = dentry->d_sb->s_dev; 265 __entry->ino = d_inode(dentry)->i_ino; 266 __entry->parent = d_inode(dentry->d_parent)->i_ino; 267 __entry->datasync = datasync; 268 ), 269 270 TP_printk("dev %d,%d ino %lu parent %lu datasync %d ", 271 MAJOR(__entry->dev), MINOR(__entry->dev), 272 (unsigned long) __entry->ino, 273 (unsigned long) __entry->parent, __entry->datasync) 274 ); 275 276 /* super-io.c: */ 277 TRACE_EVENT(write_super, 278 TP_PROTO(struct bch_fs *c, unsigned long ip), 279 TP_ARGS(c, ip), 280 281 TP_STRUCT__entry( 282 __field(dev_t, dev ) 283 __field(unsigned long, ip ) 284 ), 285 286 TP_fast_assign( 287 __entry->dev = c->dev; 288 __entry->ip = ip; 289 ), 290 291 TP_printk("%d,%d for %pS", 292 MAJOR(__entry->dev), MINOR(__entry->dev), 293 (void *) __entry->ip) 294 ); 295 296 /* io.c: */ 297 298 DEFINE_EVENT(bio, read_promote, 299 TP_PROTO(struct bio *bio), 300 TP_ARGS(bio) 301 ); 302 303 TRACE_EVENT(read_nopromote, 304 TP_PROTO(struct bch_fs *c, int ret), 305 TP_ARGS(c, ret), 306 307 TP_STRUCT__entry( 308 __field(dev_t, dev ) 309 __array(char, ret, 32 ) 310 ), 311 312 TP_fast_assign( 313 __entry->dev = c->dev; 314 strscpy(__entry->ret, bch2_err_str(ret), sizeof(__entry->ret)); 315 ), 316 317 TP_printk("%d,%d ret %s", 318 MAJOR(__entry->dev), MINOR(__entry->dev), 319 __entry->ret) 320 ); 321 322 DEFINE_EVENT(bio, read_bounce, 323 TP_PROTO(struct bio *bio), 324 TP_ARGS(bio) 325 ); 326 327 DEFINE_EVENT(bio, read_split, 328 TP_PROTO(struct bio *bio), 329 TP_ARGS(bio) 330 ); 331 332 DEFINE_EVENT(bio, read_retry, 333 TP_PROTO(struct bio *bio), 334 TP_ARGS(bio) 335 ); 336 337 DEFINE_EVENT(bio, read_reuse_race, 338 TP_PROTO(struct bio *bio), 339 TP_ARGS(bio) 340 ); 341 342 /* Journal */ 343 344 DEFINE_EVENT(bch_fs, journal_full, 345 TP_PROTO(struct bch_fs *c), 346 TP_ARGS(c) 347 ); 348 349 DEFINE_EVENT(fs_str, journal_entry_full, 350 TP_PROTO(struct bch_fs *c, const char *str), 351 TP_ARGS(c, str) 352 ); 353 354 DEFINE_EVENT(fs_str, journal_entry_close, 355 TP_PROTO(struct bch_fs *c, const char *str), 356 TP_ARGS(c, str) 357 ); 358 359 DEFINE_EVENT(bio, journal_write, 360 TP_PROTO(struct bio *bio), 361 TP_ARGS(bio) 362 ); 363 364 TRACE_EVENT(journal_reclaim_start, 365 TP_PROTO(struct bch_fs *c, bool direct, bool kicked, 366 u64 min_nr, u64 min_key_cache, 367 u64 btree_cache_dirty, u64 btree_cache_total, 368 u64 btree_key_cache_dirty, u64 btree_key_cache_total), 369 TP_ARGS(c, direct, kicked, min_nr, min_key_cache, 370 btree_cache_dirty, btree_cache_total, 371 btree_key_cache_dirty, btree_key_cache_total), 372 373 TP_STRUCT__entry( 374 __field(dev_t, dev ) 375 __field(bool, direct ) 376 __field(bool, kicked ) 377 __field(u64, min_nr ) 378 __field(u64, min_key_cache ) 379 __field(u64, btree_cache_dirty ) 380 __field(u64, btree_cache_total ) 381 __field(u64, btree_key_cache_dirty ) 382 __field(u64, btree_key_cache_total ) 383 ), 384 385 TP_fast_assign( 386 __entry->dev = c->dev; 387 __entry->direct = direct; 388 __entry->kicked = kicked; 389 __entry->min_nr = min_nr; 390 __entry->min_key_cache = min_key_cache; 391 __entry->btree_cache_dirty = btree_cache_dirty; 392 __entry->btree_cache_total = btree_cache_total; 393 __entry->btree_key_cache_dirty = btree_key_cache_dirty; 394 __entry->btree_key_cache_total = btree_key_cache_total; 395 ), 396 397 TP_printk("%d,%d direct %u kicked %u min %llu key cache %llu btree cache %llu/%llu key cache %llu/%llu", 398 MAJOR(__entry->dev), MINOR(__entry->dev), 399 __entry->direct, 400 __entry->kicked, 401 __entry->min_nr, 402 __entry->min_key_cache, 403 __entry->btree_cache_dirty, 404 __entry->btree_cache_total, 405 __entry->btree_key_cache_dirty, 406 __entry->btree_key_cache_total) 407 ); 408 409 TRACE_EVENT(journal_reclaim_finish, 410 TP_PROTO(struct bch_fs *c, u64 nr_flushed), 411 TP_ARGS(c, nr_flushed), 412 413 TP_STRUCT__entry( 414 __field(dev_t, dev ) 415 __field(u64, nr_flushed ) 416 ), 417 418 TP_fast_assign( 419 __entry->dev = c->dev; 420 __entry->nr_flushed = nr_flushed; 421 ), 422 423 TP_printk("%d,%d flushed %llu", 424 MAJOR(__entry->dev), MINOR(__entry->dev), 425 __entry->nr_flushed) 426 ); 427 428 /* bset.c: */ 429 430 DEFINE_EVENT(bpos, bkey_pack_pos_fail, 431 TP_PROTO(const struct bpos *p), 432 TP_ARGS(p) 433 ); 434 435 /* Btree cache: */ 436 437 TRACE_EVENT(btree_cache_scan, 438 TP_PROTO(long nr_to_scan, long can_free, long ret), 439 TP_ARGS(nr_to_scan, can_free, ret), 440 441 TP_STRUCT__entry( 442 __field(long, nr_to_scan ) 443 __field(long, can_free ) 444 __field(long, ret ) 445 ), 446 447 TP_fast_assign( 448 __entry->nr_to_scan = nr_to_scan; 449 __entry->can_free = can_free; 450 __entry->ret = ret; 451 ), 452 453 TP_printk("scanned for %li nodes, can free %li, ret %li", 454 __entry->nr_to_scan, __entry->can_free, __entry->ret) 455 ); 456 457 DEFINE_EVENT(btree_node_nofs, btree_cache_reap, 458 TP_PROTO(struct bch_fs *c, struct btree *b), 459 TP_ARGS(c, b) 460 ); 461 462 DEFINE_EVENT(btree_trans, btree_cache_cannibalize_lock_fail, 463 TP_PROTO(struct btree_trans *trans), 464 TP_ARGS(trans) 465 ); 466 467 DEFINE_EVENT(btree_trans, btree_cache_cannibalize_lock, 468 TP_PROTO(struct btree_trans *trans), 469 TP_ARGS(trans) 470 ); 471 472 DEFINE_EVENT(btree_trans, btree_cache_cannibalize, 473 TP_PROTO(struct btree_trans *trans), 474 TP_ARGS(trans) 475 ); 476 477 DEFINE_EVENT(btree_trans, btree_cache_cannibalize_unlock, 478 TP_PROTO(struct btree_trans *trans), 479 TP_ARGS(trans) 480 ); 481 482 /* Btree */ 483 484 DEFINE_EVENT(btree_node, btree_node_read, 485 TP_PROTO(struct btree_trans *trans, struct btree *b), 486 TP_ARGS(trans, b) 487 ); 488 489 TRACE_EVENT(btree_node_write, 490 TP_PROTO(struct btree *b, unsigned bytes, unsigned sectors), 491 TP_ARGS(b, bytes, sectors), 492 493 TP_STRUCT__entry( 494 __field(enum btree_node_type, type) 495 __field(unsigned, bytes ) 496 __field(unsigned, sectors ) 497 ), 498 499 TP_fast_assign( 500 __entry->type = btree_node_type(b); 501 __entry->bytes = bytes; 502 __entry->sectors = sectors; 503 ), 504 505 TP_printk("bkey type %u bytes %u sectors %u", 506 __entry->type , __entry->bytes, __entry->sectors) 507 ); 508 509 DEFINE_EVENT(btree_node, btree_node_alloc, 510 TP_PROTO(struct btree_trans *trans, struct btree *b), 511 TP_ARGS(trans, b) 512 ); 513 514 DEFINE_EVENT(btree_node, btree_node_free, 515 TP_PROTO(struct btree_trans *trans, struct btree *b), 516 TP_ARGS(trans, b) 517 ); 518 519 TRACE_EVENT(btree_reserve_get_fail, 520 TP_PROTO(const char *trans_fn, 521 unsigned long caller_ip, 522 size_t required, 523 int ret), 524 TP_ARGS(trans_fn, caller_ip, required, ret), 525 526 TP_STRUCT__entry( 527 __array(char, trans_fn, 32 ) 528 __field(unsigned long, caller_ip ) 529 __field(size_t, required ) 530 __array(char, ret, 32 ) 531 ), 532 533 TP_fast_assign( 534 strscpy(__entry->trans_fn, trans_fn, sizeof(__entry->trans_fn)); 535 __entry->caller_ip = caller_ip; 536 __entry->required = required; 537 strscpy(__entry->ret, bch2_err_str(ret), sizeof(__entry->ret)); 538 ), 539 540 TP_printk("%s %pS required %zu ret %s", 541 __entry->trans_fn, 542 (void *) __entry->caller_ip, 543 __entry->required, 544 __entry->ret) 545 ); 546 547 DEFINE_EVENT(btree_node, btree_node_compact, 548 TP_PROTO(struct btree_trans *trans, struct btree *b), 549 TP_ARGS(trans, b) 550 ); 551 552 DEFINE_EVENT(btree_node, btree_node_merge, 553 TP_PROTO(struct btree_trans *trans, struct btree *b), 554 TP_ARGS(trans, b) 555 ); 556 557 DEFINE_EVENT(btree_node, btree_node_split, 558 TP_PROTO(struct btree_trans *trans, struct btree *b), 559 TP_ARGS(trans, b) 560 ); 561 562 DEFINE_EVENT(btree_node, btree_node_rewrite, 563 TP_PROTO(struct btree_trans *trans, struct btree *b), 564 TP_ARGS(trans, b) 565 ); 566 567 DEFINE_EVENT(btree_node, btree_node_set_root, 568 TP_PROTO(struct btree_trans *trans, struct btree *b), 569 TP_ARGS(trans, b) 570 ); 571 572 TRACE_EVENT(btree_path_relock_fail, 573 TP_PROTO(struct btree_trans *trans, 574 unsigned long caller_ip, 575 struct btree_path *path, 576 unsigned level), 577 TP_ARGS(trans, caller_ip, path, level), 578 579 TP_STRUCT__entry( 580 __array(char, trans_fn, 32 ) 581 __field(unsigned long, caller_ip ) 582 __field(u8, btree_id ) 583 __field(u8, level ) 584 __field(u8, path_idx) 585 TRACE_BPOS_entries(pos) 586 __array(char, node, 24 ) 587 __field(u8, self_read_count ) 588 __field(u8, self_intent_count) 589 __field(u8, read_count ) 590 __field(u8, intent_count ) 591 __field(u32, iter_lock_seq ) 592 __field(u32, node_lock_seq ) 593 ), 594 595 TP_fast_assign( 596 struct btree *b = btree_path_node(path, level); 597 struct six_lock_count c; 598 599 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 600 __entry->caller_ip = caller_ip; 601 __entry->btree_id = path->btree_id; 602 __entry->level = level; 603 __entry->path_idx = path - trans->paths; 604 TRACE_BPOS_assign(pos, path->pos); 605 606 c = bch2_btree_node_lock_counts(trans, NULL, &path->l[level].b->c, level); 607 __entry->self_read_count = c.n[SIX_LOCK_read]; 608 __entry->self_intent_count = c.n[SIX_LOCK_intent]; 609 610 if (IS_ERR(b)) { 611 strscpy(__entry->node, bch2_err_str(PTR_ERR(b)), sizeof(__entry->node)); 612 } else { 613 c = six_lock_counts(&path->l[level].b->c.lock); 614 __entry->read_count = c.n[SIX_LOCK_read]; 615 __entry->intent_count = c.n[SIX_LOCK_intent]; 616 scnprintf(__entry->node, sizeof(__entry->node), "%px", &b->c); 617 } 618 __entry->iter_lock_seq = path->l[level].lock_seq; 619 __entry->node_lock_seq = is_btree_node(path, level) 620 ? six_lock_seq(&path->l[level].b->c.lock) 621 : 0; 622 ), 623 624 TP_printk("%s %pS\nidx %2u btree %s pos %llu:%llu:%u level %u node %s held %u:%u lock count %u:%u iter seq %u lock seq %u", 625 __entry->trans_fn, 626 (void *) __entry->caller_ip, 627 __entry->path_idx, 628 bch2_btree_id_str(__entry->btree_id), 629 __entry->pos_inode, 630 __entry->pos_offset, 631 __entry->pos_snapshot, 632 __entry->level, 633 __entry->node, 634 __entry->self_read_count, 635 __entry->self_intent_count, 636 __entry->read_count, 637 __entry->intent_count, 638 __entry->iter_lock_seq, 639 __entry->node_lock_seq) 640 ); 641 642 TRACE_EVENT(btree_path_upgrade_fail, 643 TP_PROTO(struct btree_trans *trans, 644 unsigned long caller_ip, 645 struct btree_path *path, 646 unsigned level), 647 TP_ARGS(trans, caller_ip, path, level), 648 649 TP_STRUCT__entry( 650 __array(char, trans_fn, 32 ) 651 __field(unsigned long, caller_ip ) 652 __field(u8, btree_id ) 653 __field(u8, level ) 654 __field(u8, path_idx) 655 TRACE_BPOS_entries(pos) 656 __field(u8, locked ) 657 __field(u8, self_read_count ) 658 __field(u8, self_intent_count) 659 __field(u8, read_count ) 660 __field(u8, intent_count ) 661 __field(u32, iter_lock_seq ) 662 __field(u32, node_lock_seq ) 663 ), 664 665 TP_fast_assign( 666 struct six_lock_count c; 667 668 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 669 __entry->caller_ip = caller_ip; 670 __entry->btree_id = path->btree_id; 671 __entry->level = level; 672 __entry->path_idx = path - trans->paths; 673 TRACE_BPOS_assign(pos, path->pos); 674 __entry->locked = btree_node_locked(path, level); 675 676 c = bch2_btree_node_lock_counts(trans, NULL, &path->l[level].b->c, level), 677 __entry->self_read_count = c.n[SIX_LOCK_read]; 678 __entry->self_intent_count = c.n[SIX_LOCK_intent]; 679 c = six_lock_counts(&path->l[level].b->c.lock); 680 __entry->read_count = c.n[SIX_LOCK_read]; 681 __entry->intent_count = c.n[SIX_LOCK_intent]; 682 __entry->iter_lock_seq = path->l[level].lock_seq; 683 __entry->node_lock_seq = is_btree_node(path, level) 684 ? six_lock_seq(&path->l[level].b->c.lock) 685 : 0; 686 ), 687 688 TP_printk("%s %pS\nidx %2u btree %s pos %llu:%llu:%u level %u locked %u held %u:%u lock count %u:%u iter seq %u lock seq %u", 689 __entry->trans_fn, 690 (void *) __entry->caller_ip, 691 __entry->path_idx, 692 bch2_btree_id_str(__entry->btree_id), 693 __entry->pos_inode, 694 __entry->pos_offset, 695 __entry->pos_snapshot, 696 __entry->level, 697 __entry->locked, 698 __entry->self_read_count, 699 __entry->self_intent_count, 700 __entry->read_count, 701 __entry->intent_count, 702 __entry->iter_lock_seq, 703 __entry->node_lock_seq) 704 ); 705 706 /* Garbage collection */ 707 708 DEFINE_EVENT(bch_fs, gc_gens_start, 709 TP_PROTO(struct bch_fs *c), 710 TP_ARGS(c) 711 ); 712 713 DEFINE_EVENT(bch_fs, gc_gens_end, 714 TP_PROTO(struct bch_fs *c), 715 TP_ARGS(c) 716 ); 717 718 /* Allocator */ 719 720 DEFINE_EVENT(fs_str, bucket_alloc, 721 TP_PROTO(struct bch_fs *c, const char *str), 722 TP_ARGS(c, str) 723 ); 724 725 DEFINE_EVENT(fs_str, bucket_alloc_fail, 726 TP_PROTO(struct bch_fs *c, const char *str), 727 TP_ARGS(c, str) 728 ); 729 730 DECLARE_EVENT_CLASS(discard_buckets_class, 731 TP_PROTO(struct bch_fs *c, u64 seen, u64 open, 732 u64 need_journal_commit, u64 discarded, const char *err), 733 TP_ARGS(c, seen, open, need_journal_commit, discarded, err), 734 735 TP_STRUCT__entry( 736 __field(dev_t, dev ) 737 __field(u64, seen ) 738 __field(u64, open ) 739 __field(u64, need_journal_commit ) 740 __field(u64, discarded ) 741 __array(char, err, 16 ) 742 ), 743 744 TP_fast_assign( 745 __entry->dev = c->dev; 746 __entry->seen = seen; 747 __entry->open = open; 748 __entry->need_journal_commit = need_journal_commit; 749 __entry->discarded = discarded; 750 strscpy(__entry->err, err, sizeof(__entry->err)); 751 ), 752 753 TP_printk("%d%d seen %llu open %llu need_journal_commit %llu discarded %llu err %s", 754 MAJOR(__entry->dev), MINOR(__entry->dev), 755 __entry->seen, 756 __entry->open, 757 __entry->need_journal_commit, 758 __entry->discarded, 759 __entry->err) 760 ); 761 762 DEFINE_EVENT(discard_buckets_class, discard_buckets, 763 TP_PROTO(struct bch_fs *c, u64 seen, u64 open, 764 u64 need_journal_commit, u64 discarded, const char *err), 765 TP_ARGS(c, seen, open, need_journal_commit, discarded, err) 766 ); 767 768 DEFINE_EVENT(discard_buckets_class, discard_buckets_fast, 769 TP_PROTO(struct bch_fs *c, u64 seen, u64 open, 770 u64 need_journal_commit, u64 discarded, const char *err), 771 TP_ARGS(c, seen, open, need_journal_commit, discarded, err) 772 ); 773 774 TRACE_EVENT(bucket_invalidate, 775 TP_PROTO(struct bch_fs *c, unsigned dev, u64 bucket, u32 sectors), 776 TP_ARGS(c, dev, bucket, sectors), 777 778 TP_STRUCT__entry( 779 __field(dev_t, dev ) 780 __field(u32, dev_idx ) 781 __field(u32, sectors ) 782 __field(u64, bucket ) 783 ), 784 785 TP_fast_assign( 786 __entry->dev = c->dev; 787 __entry->dev_idx = dev; 788 __entry->sectors = sectors; 789 __entry->bucket = bucket; 790 ), 791 792 TP_printk("%d:%d invalidated %u:%llu cached sectors %u", 793 MAJOR(__entry->dev), MINOR(__entry->dev), 794 __entry->dev_idx, __entry->bucket, 795 __entry->sectors) 796 ); 797 798 /* Moving IO */ 799 800 TRACE_EVENT(bucket_evacuate, 801 TP_PROTO(struct bch_fs *c, struct bpos *bucket), 802 TP_ARGS(c, bucket), 803 804 TP_STRUCT__entry( 805 __field(dev_t, dev ) 806 __field(u32, dev_idx ) 807 __field(u64, bucket ) 808 ), 809 810 TP_fast_assign( 811 __entry->dev = c->dev; 812 __entry->dev_idx = bucket->inode; 813 __entry->bucket = bucket->offset; 814 ), 815 816 TP_printk("%d:%d %u:%llu", 817 MAJOR(__entry->dev), MINOR(__entry->dev), 818 __entry->dev_idx, __entry->bucket) 819 ); 820 821 DEFINE_EVENT(fs_str, move_extent, 822 TP_PROTO(struct bch_fs *c, const char *str), 823 TP_ARGS(c, str) 824 ); 825 826 DEFINE_EVENT(fs_str, move_extent_read, 827 TP_PROTO(struct bch_fs *c, const char *str), 828 TP_ARGS(c, str) 829 ); 830 831 DEFINE_EVENT(fs_str, move_extent_write, 832 TP_PROTO(struct bch_fs *c, const char *str), 833 TP_ARGS(c, str) 834 ); 835 836 DEFINE_EVENT(fs_str, move_extent_finish, 837 TP_PROTO(struct bch_fs *c, const char *str), 838 TP_ARGS(c, str) 839 ); 840 841 DEFINE_EVENT(fs_str, move_extent_fail, 842 TP_PROTO(struct bch_fs *c, const char *str), 843 TP_ARGS(c, str) 844 ); 845 846 DEFINE_EVENT(fs_str, move_extent_start_fail, 847 TP_PROTO(struct bch_fs *c, const char *str), 848 TP_ARGS(c, str) 849 ); 850 851 TRACE_EVENT(move_data, 852 TP_PROTO(struct bch_fs *c, 853 struct bch_move_stats *stats), 854 TP_ARGS(c, stats), 855 856 TP_STRUCT__entry( 857 __field(dev_t, dev ) 858 __field(u64, keys_moved ) 859 __field(u64, keys_raced ) 860 __field(u64, sectors_seen ) 861 __field(u64, sectors_moved ) 862 __field(u64, sectors_raced ) 863 ), 864 865 TP_fast_assign( 866 __entry->dev = c->dev; 867 __entry->keys_moved = atomic64_read(&stats->keys_moved); 868 __entry->keys_raced = atomic64_read(&stats->keys_raced); 869 __entry->sectors_seen = atomic64_read(&stats->sectors_seen); 870 __entry->sectors_moved = atomic64_read(&stats->sectors_moved); 871 __entry->sectors_raced = atomic64_read(&stats->sectors_raced); 872 ), 873 874 TP_printk("%d,%d keys moved %llu raced %llu" 875 "sectors seen %llu moved %llu raced %llu", 876 MAJOR(__entry->dev), MINOR(__entry->dev), 877 __entry->keys_moved, 878 __entry->keys_raced, 879 __entry->sectors_seen, 880 __entry->sectors_moved, 881 __entry->sectors_raced) 882 ); 883 884 TRACE_EVENT(evacuate_bucket, 885 TP_PROTO(struct bch_fs *c, struct bpos *bucket, 886 unsigned sectors, unsigned bucket_size, 887 int ret), 888 TP_ARGS(c, bucket, sectors, bucket_size, ret), 889 890 TP_STRUCT__entry( 891 __field(dev_t, dev ) 892 __field(u64, member ) 893 __field(u64, bucket ) 894 __field(u32, sectors ) 895 __field(u32, bucket_size ) 896 __field(int, ret ) 897 ), 898 899 TP_fast_assign( 900 __entry->dev = c->dev; 901 __entry->member = bucket->inode; 902 __entry->bucket = bucket->offset; 903 __entry->sectors = sectors; 904 __entry->bucket_size = bucket_size; 905 __entry->ret = ret; 906 ), 907 908 TP_printk("%d,%d %llu:%llu sectors %u/%u ret %i", 909 MAJOR(__entry->dev), MINOR(__entry->dev), 910 __entry->member, __entry->bucket, 911 __entry->sectors, __entry->bucket_size, 912 __entry->ret) 913 ); 914 915 TRACE_EVENT(copygc, 916 TP_PROTO(struct bch_fs *c, 917 u64 buckets, 918 u64 sectors_seen, 919 u64 sectors_moved), 920 TP_ARGS(c, buckets, sectors_seen, sectors_moved), 921 922 TP_STRUCT__entry( 923 __field(dev_t, dev ) 924 __field(u64, buckets ) 925 __field(u64, sectors_seen ) 926 __field(u64, sectors_moved ) 927 ), 928 929 TP_fast_assign( 930 __entry->dev = c->dev; 931 __entry->buckets = buckets; 932 __entry->sectors_seen = sectors_seen; 933 __entry->sectors_moved = sectors_moved; 934 ), 935 936 TP_printk("%d,%d buckets %llu sectors seen %llu moved %llu", 937 MAJOR(__entry->dev), MINOR(__entry->dev), 938 __entry->buckets, 939 __entry->sectors_seen, 940 __entry->sectors_moved) 941 ); 942 943 TRACE_EVENT(copygc_wait, 944 TP_PROTO(struct bch_fs *c, 945 u64 wait_amount, u64 until), 946 TP_ARGS(c, wait_amount, until), 947 948 TP_STRUCT__entry( 949 __field(dev_t, dev ) 950 __field(u64, wait_amount ) 951 __field(u64, until ) 952 ), 953 954 TP_fast_assign( 955 __entry->dev = c->dev; 956 __entry->wait_amount = wait_amount; 957 __entry->until = until; 958 ), 959 960 TP_printk("%d,%u waiting for %llu sectors until %llu", 961 MAJOR(__entry->dev), MINOR(__entry->dev), 962 __entry->wait_amount, __entry->until) 963 ); 964 965 /* btree transactions: */ 966 967 DECLARE_EVENT_CLASS(transaction_event, 968 TP_PROTO(struct btree_trans *trans, 969 unsigned long caller_ip), 970 TP_ARGS(trans, caller_ip), 971 972 TP_STRUCT__entry( 973 __array(char, trans_fn, 32 ) 974 __field(unsigned long, caller_ip ) 975 ), 976 977 TP_fast_assign( 978 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 979 __entry->caller_ip = caller_ip; 980 ), 981 982 TP_printk("%s %pS", __entry->trans_fn, (void *) __entry->caller_ip) 983 ); 984 985 DEFINE_EVENT(transaction_event, transaction_commit, 986 TP_PROTO(struct btree_trans *trans, 987 unsigned long caller_ip), 988 TP_ARGS(trans, caller_ip) 989 ); 990 991 DEFINE_EVENT(transaction_event, trans_restart_injected, 992 TP_PROTO(struct btree_trans *trans, 993 unsigned long caller_ip), 994 TP_ARGS(trans, caller_ip) 995 ); 996 997 TRACE_EVENT(trans_restart_split_race, 998 TP_PROTO(struct btree_trans *trans, 999 unsigned long caller_ip, 1000 struct btree *b), 1001 TP_ARGS(trans, caller_ip, b), 1002 1003 TP_STRUCT__entry( 1004 __array(char, trans_fn, 32 ) 1005 __field(unsigned long, caller_ip ) 1006 __field(u8, level ) 1007 __field(u16, written ) 1008 __field(u16, blocks ) 1009 __field(u16, u64s_remaining ) 1010 ), 1011 1012 TP_fast_assign( 1013 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1014 __entry->caller_ip = caller_ip; 1015 __entry->level = b->c.level; 1016 __entry->written = b->written; 1017 __entry->blocks = btree_blocks(trans->c); 1018 __entry->u64s_remaining = bch2_btree_keys_u64s_remaining(b); 1019 ), 1020 1021 TP_printk("%s %pS l=%u written %u/%u u64s remaining %u", 1022 __entry->trans_fn, (void *) __entry->caller_ip, 1023 __entry->level, 1024 __entry->written, __entry->blocks, 1025 __entry->u64s_remaining) 1026 ); 1027 1028 TRACE_EVENT(trans_blocked_journal_reclaim, 1029 TP_PROTO(struct btree_trans *trans, 1030 unsigned long caller_ip), 1031 TP_ARGS(trans, caller_ip), 1032 1033 TP_STRUCT__entry( 1034 __array(char, trans_fn, 32 ) 1035 __field(unsigned long, caller_ip ) 1036 1037 __field(unsigned long, key_cache_nr_keys ) 1038 __field(unsigned long, key_cache_nr_dirty ) 1039 __field(long, must_wait ) 1040 ), 1041 1042 TP_fast_assign( 1043 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1044 __entry->caller_ip = caller_ip; 1045 __entry->key_cache_nr_keys = atomic_long_read(&trans->c->btree_key_cache.nr_keys); 1046 __entry->key_cache_nr_dirty = atomic_long_read(&trans->c->btree_key_cache.nr_dirty); 1047 __entry->must_wait = __bch2_btree_key_cache_must_wait(trans->c); 1048 ), 1049 1050 TP_printk("%s %pS key cache keys %lu dirty %lu must_wait %li", 1051 __entry->trans_fn, (void *) __entry->caller_ip, 1052 __entry->key_cache_nr_keys, 1053 __entry->key_cache_nr_dirty, 1054 __entry->must_wait) 1055 ); 1056 1057 TRACE_EVENT(trans_restart_journal_preres_get, 1058 TP_PROTO(struct btree_trans *trans, 1059 unsigned long caller_ip, 1060 unsigned flags), 1061 TP_ARGS(trans, caller_ip, flags), 1062 1063 TP_STRUCT__entry( 1064 __array(char, trans_fn, 32 ) 1065 __field(unsigned long, caller_ip ) 1066 __field(unsigned, flags ) 1067 ), 1068 1069 TP_fast_assign( 1070 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1071 __entry->caller_ip = caller_ip; 1072 __entry->flags = flags; 1073 ), 1074 1075 TP_printk("%s %pS %x", __entry->trans_fn, 1076 (void *) __entry->caller_ip, 1077 __entry->flags) 1078 ); 1079 1080 DEFINE_EVENT(transaction_event, trans_restart_fault_inject, 1081 TP_PROTO(struct btree_trans *trans, 1082 unsigned long caller_ip), 1083 TP_ARGS(trans, caller_ip) 1084 ); 1085 1086 DEFINE_EVENT(transaction_event, trans_traverse_all, 1087 TP_PROTO(struct btree_trans *trans, 1088 unsigned long caller_ip), 1089 TP_ARGS(trans, caller_ip) 1090 ); 1091 1092 DEFINE_EVENT(transaction_event, trans_restart_key_cache_raced, 1093 TP_PROTO(struct btree_trans *trans, 1094 unsigned long caller_ip), 1095 TP_ARGS(trans, caller_ip) 1096 ); 1097 1098 DEFINE_EVENT(trans_str, trans_restart_too_many_iters, 1099 TP_PROTO(struct btree_trans *trans, 1100 unsigned long caller_ip, 1101 const char *paths), 1102 TP_ARGS(trans, caller_ip, paths) 1103 ); 1104 1105 DECLARE_EVENT_CLASS(transaction_restart_iter, 1106 TP_PROTO(struct btree_trans *trans, 1107 unsigned long caller_ip, 1108 struct btree_path *path), 1109 TP_ARGS(trans, caller_ip, path), 1110 1111 TP_STRUCT__entry( 1112 __array(char, trans_fn, 32 ) 1113 __field(unsigned long, caller_ip ) 1114 __field(u8, btree_id ) 1115 TRACE_BPOS_entries(pos) 1116 ), 1117 1118 TP_fast_assign( 1119 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1120 __entry->caller_ip = caller_ip; 1121 __entry->btree_id = path->btree_id; 1122 TRACE_BPOS_assign(pos, path->pos) 1123 ), 1124 1125 TP_printk("%s %pS btree %s pos %llu:%llu:%u", 1126 __entry->trans_fn, 1127 (void *) __entry->caller_ip, 1128 bch2_btree_id_str(__entry->btree_id), 1129 __entry->pos_inode, 1130 __entry->pos_offset, 1131 __entry->pos_snapshot) 1132 ); 1133 1134 DEFINE_EVENT(transaction_restart_iter, trans_restart_btree_node_reused, 1135 TP_PROTO(struct btree_trans *trans, 1136 unsigned long caller_ip, 1137 struct btree_path *path), 1138 TP_ARGS(trans, caller_ip, path) 1139 ); 1140 1141 DEFINE_EVENT(transaction_restart_iter, trans_restart_btree_node_split, 1142 TP_PROTO(struct btree_trans *trans, 1143 unsigned long caller_ip, 1144 struct btree_path *path), 1145 TP_ARGS(trans, caller_ip, path) 1146 ); 1147 1148 TRACE_EVENT(trans_restart_upgrade, 1149 TP_PROTO(struct btree_trans *trans, 1150 unsigned long caller_ip, 1151 struct btree_path *path, 1152 unsigned old_locks_want, 1153 unsigned new_locks_want, 1154 struct get_locks_fail *f), 1155 TP_ARGS(trans, caller_ip, path, old_locks_want, new_locks_want, f), 1156 1157 TP_STRUCT__entry( 1158 __array(char, trans_fn, 32 ) 1159 __field(unsigned long, caller_ip ) 1160 __field(u8, btree_id ) 1161 __field(u8, old_locks_want ) 1162 __field(u8, new_locks_want ) 1163 __field(u8, level ) 1164 __field(u32, path_seq ) 1165 __field(u32, node_seq ) 1166 TRACE_BPOS_entries(pos) 1167 ), 1168 1169 TP_fast_assign( 1170 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1171 __entry->caller_ip = caller_ip; 1172 __entry->btree_id = path->btree_id; 1173 __entry->old_locks_want = old_locks_want; 1174 __entry->new_locks_want = new_locks_want; 1175 __entry->level = f->l; 1176 __entry->path_seq = path->l[f->l].lock_seq; 1177 __entry->node_seq = IS_ERR_OR_NULL(f->b) ? 0 : f->b->c.lock.seq; 1178 TRACE_BPOS_assign(pos, path->pos) 1179 ), 1180 1181 TP_printk("%s %pS btree %s pos %llu:%llu:%u locks_want %u -> %u level %u path seq %u node seq %u", 1182 __entry->trans_fn, 1183 (void *) __entry->caller_ip, 1184 bch2_btree_id_str(__entry->btree_id), 1185 __entry->pos_inode, 1186 __entry->pos_offset, 1187 __entry->pos_snapshot, 1188 __entry->old_locks_want, 1189 __entry->new_locks_want, 1190 __entry->level, 1191 __entry->path_seq, 1192 __entry->node_seq) 1193 ); 1194 1195 DEFINE_EVENT(trans_str, trans_restart_relock, 1196 TP_PROTO(struct btree_trans *trans, unsigned long caller_ip, const char *str), 1197 TP_ARGS(trans, caller_ip, str) 1198 ); 1199 1200 DEFINE_EVENT(transaction_restart_iter, trans_restart_relock_next_node, 1201 TP_PROTO(struct btree_trans *trans, 1202 unsigned long caller_ip, 1203 struct btree_path *path), 1204 TP_ARGS(trans, caller_ip, path) 1205 ); 1206 1207 DEFINE_EVENT(transaction_restart_iter, trans_restart_relock_parent_for_fill, 1208 TP_PROTO(struct btree_trans *trans, 1209 unsigned long caller_ip, 1210 struct btree_path *path), 1211 TP_ARGS(trans, caller_ip, path) 1212 ); 1213 1214 DEFINE_EVENT(transaction_restart_iter, trans_restart_relock_after_fill, 1215 TP_PROTO(struct btree_trans *trans, 1216 unsigned long caller_ip, 1217 struct btree_path *path), 1218 TP_ARGS(trans, caller_ip, path) 1219 ); 1220 1221 DEFINE_EVENT(transaction_event, trans_restart_key_cache_upgrade, 1222 TP_PROTO(struct btree_trans *trans, 1223 unsigned long caller_ip), 1224 TP_ARGS(trans, caller_ip) 1225 ); 1226 1227 DEFINE_EVENT(transaction_restart_iter, trans_restart_relock_key_cache_fill, 1228 TP_PROTO(struct btree_trans *trans, 1229 unsigned long caller_ip, 1230 struct btree_path *path), 1231 TP_ARGS(trans, caller_ip, path) 1232 ); 1233 1234 DEFINE_EVENT(transaction_restart_iter, trans_restart_relock_path, 1235 TP_PROTO(struct btree_trans *trans, 1236 unsigned long caller_ip, 1237 struct btree_path *path), 1238 TP_ARGS(trans, caller_ip, path) 1239 ); 1240 1241 DEFINE_EVENT(transaction_restart_iter, trans_restart_relock_path_intent, 1242 TP_PROTO(struct btree_trans *trans, 1243 unsigned long caller_ip, 1244 struct btree_path *path), 1245 TP_ARGS(trans, caller_ip, path) 1246 ); 1247 1248 DEFINE_EVENT(transaction_restart_iter, trans_restart_traverse, 1249 TP_PROTO(struct btree_trans *trans, 1250 unsigned long caller_ip, 1251 struct btree_path *path), 1252 TP_ARGS(trans, caller_ip, path) 1253 ); 1254 1255 DEFINE_EVENT(transaction_restart_iter, trans_restart_memory_allocation_failure, 1256 TP_PROTO(struct btree_trans *trans, 1257 unsigned long caller_ip, 1258 struct btree_path *path), 1259 TP_ARGS(trans, caller_ip, path) 1260 ); 1261 1262 DEFINE_EVENT(trans_str_nocaller, trans_restart_would_deadlock, 1263 TP_PROTO(struct btree_trans *trans, 1264 const char *cycle), 1265 TP_ARGS(trans, cycle) 1266 ); 1267 1268 DEFINE_EVENT(transaction_event, trans_restart_would_deadlock_recursion_limit, 1269 TP_PROTO(struct btree_trans *trans, 1270 unsigned long caller_ip), 1271 TP_ARGS(trans, caller_ip) 1272 ); 1273 1274 TRACE_EVENT(trans_restart_would_deadlock_write, 1275 TP_PROTO(struct btree_trans *trans), 1276 TP_ARGS(trans), 1277 1278 TP_STRUCT__entry( 1279 __array(char, trans_fn, 32 ) 1280 ), 1281 1282 TP_fast_assign( 1283 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1284 ), 1285 1286 TP_printk("%s", __entry->trans_fn) 1287 ); 1288 1289 TRACE_EVENT(trans_restart_mem_realloced, 1290 TP_PROTO(struct btree_trans *trans, 1291 unsigned long caller_ip, 1292 unsigned long bytes), 1293 TP_ARGS(trans, caller_ip, bytes), 1294 1295 TP_STRUCT__entry( 1296 __array(char, trans_fn, 32 ) 1297 __field(unsigned long, caller_ip ) 1298 __field(unsigned long, bytes ) 1299 ), 1300 1301 TP_fast_assign( 1302 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1303 __entry->caller_ip = caller_ip; 1304 __entry->bytes = bytes; 1305 ), 1306 1307 TP_printk("%s %pS bytes %lu", 1308 __entry->trans_fn, 1309 (void *) __entry->caller_ip, 1310 __entry->bytes) 1311 ); 1312 1313 TRACE_EVENT(trans_restart_key_cache_key_realloced, 1314 TP_PROTO(struct btree_trans *trans, 1315 unsigned long caller_ip, 1316 struct btree_path *path, 1317 unsigned old_u64s, 1318 unsigned new_u64s), 1319 TP_ARGS(trans, caller_ip, path, old_u64s, new_u64s), 1320 1321 TP_STRUCT__entry( 1322 __array(char, trans_fn, 32 ) 1323 __field(unsigned long, caller_ip ) 1324 __field(enum btree_id, btree_id ) 1325 TRACE_BPOS_entries(pos) 1326 __field(u32, old_u64s ) 1327 __field(u32, new_u64s ) 1328 ), 1329 1330 TP_fast_assign( 1331 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1332 __entry->caller_ip = caller_ip; 1333 1334 __entry->btree_id = path->btree_id; 1335 TRACE_BPOS_assign(pos, path->pos); 1336 __entry->old_u64s = old_u64s; 1337 __entry->new_u64s = new_u64s; 1338 ), 1339 1340 TP_printk("%s %pS btree %s pos %llu:%llu:%u old_u64s %u new_u64s %u", 1341 __entry->trans_fn, 1342 (void *) __entry->caller_ip, 1343 bch2_btree_id_str(__entry->btree_id), 1344 __entry->pos_inode, 1345 __entry->pos_offset, 1346 __entry->pos_snapshot, 1347 __entry->old_u64s, 1348 __entry->new_u64s) 1349 ); 1350 1351 DEFINE_EVENT(transaction_event, trans_restart_write_buffer_flush, 1352 TP_PROTO(struct btree_trans *trans, 1353 unsigned long caller_ip), 1354 TP_ARGS(trans, caller_ip) 1355 ); 1356 1357 TRACE_EVENT(path_downgrade, 1358 TP_PROTO(struct btree_trans *trans, 1359 unsigned long caller_ip, 1360 struct btree_path *path, 1361 unsigned old_locks_want), 1362 TP_ARGS(trans, caller_ip, path, old_locks_want), 1363 1364 TP_STRUCT__entry( 1365 __array(char, trans_fn, 32 ) 1366 __field(unsigned long, caller_ip ) 1367 __field(unsigned, old_locks_want ) 1368 __field(unsigned, new_locks_want ) 1369 __field(unsigned, btree ) 1370 TRACE_BPOS_entries(pos) 1371 ), 1372 1373 TP_fast_assign( 1374 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1375 __entry->caller_ip = caller_ip; 1376 __entry->old_locks_want = old_locks_want; 1377 __entry->new_locks_want = path->locks_want; 1378 __entry->btree = path->btree_id; 1379 TRACE_BPOS_assign(pos, path->pos); 1380 ), 1381 1382 TP_printk("%s %pS locks_want %u -> %u %s %llu:%llu:%u", 1383 __entry->trans_fn, 1384 (void *) __entry->caller_ip, 1385 __entry->old_locks_want, 1386 __entry->new_locks_want, 1387 bch2_btree_id_str(__entry->btree), 1388 __entry->pos_inode, 1389 __entry->pos_offset, 1390 __entry->pos_snapshot) 1391 ); 1392 1393 TRACE_EVENT(key_cache_fill, 1394 TP_PROTO(struct btree_trans *trans, const char *key), 1395 TP_ARGS(trans, key), 1396 1397 TP_STRUCT__entry( 1398 __array(char, trans_fn, 32 ) 1399 __string(key, key ) 1400 ), 1401 1402 TP_fast_assign( 1403 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1404 __assign_str(key); 1405 ), 1406 1407 TP_printk("%s %s", __entry->trans_fn, __get_str(key)) 1408 ); 1409 1410 TRACE_EVENT(write_buffer_flush, 1411 TP_PROTO(struct btree_trans *trans, size_t nr, size_t skipped, size_t fast, size_t size), 1412 TP_ARGS(trans, nr, skipped, fast, size), 1413 1414 TP_STRUCT__entry( 1415 __field(size_t, nr ) 1416 __field(size_t, skipped ) 1417 __field(size_t, fast ) 1418 __field(size_t, size ) 1419 ), 1420 1421 TP_fast_assign( 1422 __entry->nr = nr; 1423 __entry->skipped = skipped; 1424 __entry->fast = fast; 1425 __entry->size = size; 1426 ), 1427 1428 TP_printk("%zu/%zu skipped %zu fast %zu", 1429 __entry->nr, __entry->size, __entry->skipped, __entry->fast) 1430 ); 1431 1432 TRACE_EVENT(write_buffer_flush_sync, 1433 TP_PROTO(struct btree_trans *trans, unsigned long caller_ip), 1434 TP_ARGS(trans, caller_ip), 1435 1436 TP_STRUCT__entry( 1437 __array(char, trans_fn, 32 ) 1438 __field(unsigned long, caller_ip ) 1439 ), 1440 1441 TP_fast_assign( 1442 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1443 __entry->caller_ip = caller_ip; 1444 ), 1445 1446 TP_printk("%s %pS", __entry->trans_fn, (void *) __entry->caller_ip) 1447 ); 1448 1449 TRACE_EVENT(write_buffer_flush_slowpath, 1450 TP_PROTO(struct btree_trans *trans, size_t slowpath, size_t total), 1451 TP_ARGS(trans, slowpath, total), 1452 1453 TP_STRUCT__entry( 1454 __field(size_t, slowpath ) 1455 __field(size_t, total ) 1456 ), 1457 1458 TP_fast_assign( 1459 __entry->slowpath = slowpath; 1460 __entry->total = total; 1461 ), 1462 1463 TP_printk("%zu/%zu", __entry->slowpath, __entry->total) 1464 ); 1465 1466 TRACE_EVENT(write_buffer_maybe_flush, 1467 TP_PROTO(struct btree_trans *trans, unsigned long caller_ip, const char *key), 1468 TP_ARGS(trans, caller_ip, key), 1469 1470 TP_STRUCT__entry( 1471 __array(char, trans_fn, 32 ) 1472 __field(unsigned long, caller_ip ) 1473 __string(key, key ) 1474 ), 1475 1476 TP_fast_assign( 1477 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1478 __assign_str(key); 1479 ), 1480 1481 TP_printk("%s %pS %s", __entry->trans_fn, (void *) __entry->caller_ip, __get_str(key)) 1482 ); 1483 1484 DEFINE_EVENT(fs_str, rebalance_extent, 1485 TP_PROTO(struct bch_fs *c, const char *str), 1486 TP_ARGS(c, str) 1487 ); 1488 1489 DEFINE_EVENT(fs_str, data_update, 1490 TP_PROTO(struct bch_fs *c, const char *str), 1491 TP_ARGS(c, str) 1492 ); 1493 1494 TRACE_EVENT(error_downcast, 1495 TP_PROTO(int bch_err, int std_err, unsigned long ip), 1496 TP_ARGS(bch_err, std_err, ip), 1497 1498 TP_STRUCT__entry( 1499 __array(char, bch_err, 32 ) 1500 __array(char, std_err, 32 ) 1501 __array(char, ip, 32 ) 1502 ), 1503 1504 TP_fast_assign( 1505 strscpy(__entry->bch_err, bch2_err_str(bch_err), sizeof(__entry->bch_err)); 1506 strscpy(__entry->std_err, bch2_err_str(std_err), sizeof(__entry->std_err)); 1507 snprintf(__entry->ip, sizeof(__entry->ip), "%ps", (void *) ip); 1508 ), 1509 1510 TP_printk("%s -> %s %s", __entry->bch_err, __entry->std_err, __entry->ip) 1511 ); 1512 1513 #ifdef CONFIG_BCACHEFS_PATH_TRACEPOINTS 1514 1515 TRACE_EVENT(update_by_path, 1516 TP_PROTO(struct btree_trans *trans, struct btree_path *path, 1517 struct btree_insert_entry *i, bool overwrite), 1518 TP_ARGS(trans, path, i, overwrite), 1519 1520 TP_STRUCT__entry( 1521 __array(char, trans_fn, 32 ) 1522 __field(btree_path_idx_t, path_idx ) 1523 __field(u8, btree_id ) 1524 TRACE_BPOS_entries(pos) 1525 __field(u8, overwrite ) 1526 __field(btree_path_idx_t, update_idx ) 1527 __field(btree_path_idx_t, nr_updates ) 1528 ), 1529 1530 TP_fast_assign( 1531 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1532 __entry->path_idx = path - trans->paths; 1533 __entry->btree_id = path->btree_id; 1534 TRACE_BPOS_assign(pos, path->pos); 1535 __entry->overwrite = overwrite; 1536 __entry->update_idx = i - trans->updates; 1537 __entry->nr_updates = trans->nr_updates; 1538 ), 1539 1540 TP_printk("%s path %3u btree %s pos %llu:%llu:%u overwrite %u update %u/%u", 1541 __entry->trans_fn, 1542 __entry->path_idx, 1543 bch2_btree_id_str(__entry->btree_id), 1544 __entry->pos_inode, 1545 __entry->pos_offset, 1546 __entry->pos_snapshot, 1547 __entry->overwrite, 1548 __entry->update_idx, 1549 __entry->nr_updates) 1550 ); 1551 1552 TRACE_EVENT(btree_path_lock, 1553 TP_PROTO(struct btree_trans *trans, 1554 unsigned long caller_ip, 1555 struct btree_bkey_cached_common *b), 1556 TP_ARGS(trans, caller_ip, b), 1557 1558 TP_STRUCT__entry( 1559 __array(char, trans_fn, 32 ) 1560 __field(unsigned long, caller_ip ) 1561 __field(u8, btree_id ) 1562 __field(u8, level ) 1563 __array(char, node, 24 ) 1564 __field(u32, lock_seq ) 1565 ), 1566 1567 TP_fast_assign( 1568 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1569 __entry->caller_ip = caller_ip; 1570 __entry->btree_id = b->btree_id; 1571 __entry->level = b->level; 1572 1573 scnprintf(__entry->node, sizeof(__entry->node), "%px", b); 1574 __entry->lock_seq = six_lock_seq(&b->lock); 1575 ), 1576 1577 TP_printk("%s %pS\nbtree %s level %u node %s lock seq %u", 1578 __entry->trans_fn, 1579 (void *) __entry->caller_ip, 1580 bch2_btree_id_str(__entry->btree_id), 1581 __entry->level, 1582 __entry->node, 1583 __entry->lock_seq) 1584 ); 1585 1586 DECLARE_EVENT_CLASS(btree_path_ev, 1587 TP_PROTO(struct btree_trans *trans, struct btree_path *path), 1588 TP_ARGS(trans, path), 1589 1590 TP_STRUCT__entry( 1591 __field(u16, idx ) 1592 __field(u8, ref ) 1593 __field(u8, btree_id ) 1594 TRACE_BPOS_entries(pos) 1595 ), 1596 1597 TP_fast_assign( 1598 __entry->idx = path - trans->paths; 1599 __entry->ref = path->ref; 1600 __entry->btree_id = path->btree_id; 1601 TRACE_BPOS_assign(pos, path->pos); 1602 ), 1603 1604 TP_printk("path %3u ref %u btree %s pos %llu:%llu:%u", 1605 __entry->idx, __entry->ref, 1606 bch2_btree_id_str(__entry->btree_id), 1607 __entry->pos_inode, 1608 __entry->pos_offset, 1609 __entry->pos_snapshot) 1610 ); 1611 1612 DEFINE_EVENT(btree_path_ev, btree_path_get_ll, 1613 TP_PROTO(struct btree_trans *trans, struct btree_path *path), 1614 TP_ARGS(trans, path) 1615 ); 1616 1617 DEFINE_EVENT(btree_path_ev, btree_path_put_ll, 1618 TP_PROTO(struct btree_trans *trans, struct btree_path *path), 1619 TP_ARGS(trans, path) 1620 ); 1621 1622 DEFINE_EVENT(btree_path_ev, btree_path_should_be_locked, 1623 TP_PROTO(struct btree_trans *trans, struct btree_path *path), 1624 TP_ARGS(trans, path) 1625 ); 1626 1627 TRACE_EVENT(btree_path_alloc, 1628 TP_PROTO(struct btree_trans *trans, struct btree_path *path), 1629 TP_ARGS(trans, path), 1630 1631 TP_STRUCT__entry( 1632 __field(btree_path_idx_t, idx ) 1633 __field(u8, locks_want ) 1634 __field(u8, btree_id ) 1635 TRACE_BPOS_entries(pos) 1636 ), 1637 1638 TP_fast_assign( 1639 __entry->idx = path - trans->paths; 1640 __entry->locks_want = path->locks_want; 1641 __entry->btree_id = path->btree_id; 1642 TRACE_BPOS_assign(pos, path->pos); 1643 ), 1644 1645 TP_printk("path %3u btree %s locks_want %u pos %llu:%llu:%u", 1646 __entry->idx, 1647 bch2_btree_id_str(__entry->btree_id), 1648 __entry->locks_want, 1649 __entry->pos_inode, 1650 __entry->pos_offset, 1651 __entry->pos_snapshot) 1652 ); 1653 1654 TRACE_EVENT(btree_path_get, 1655 TP_PROTO(struct btree_trans *trans, struct btree_path *path, struct bpos *new_pos), 1656 TP_ARGS(trans, path, new_pos), 1657 1658 TP_STRUCT__entry( 1659 __field(btree_path_idx_t, idx ) 1660 __field(u8, ref ) 1661 __field(u8, preserve ) 1662 __field(u8, locks_want ) 1663 __field(u8, btree_id ) 1664 TRACE_BPOS_entries(old_pos) 1665 TRACE_BPOS_entries(new_pos) 1666 ), 1667 1668 TP_fast_assign( 1669 __entry->idx = path - trans->paths; 1670 __entry->ref = path->ref; 1671 __entry->preserve = path->preserve; 1672 __entry->locks_want = path->locks_want; 1673 __entry->btree_id = path->btree_id; 1674 TRACE_BPOS_assign(old_pos, path->pos); 1675 TRACE_BPOS_assign(new_pos, *new_pos); 1676 ), 1677 1678 TP_printk(" path %3u ref %u preserve %u btree %s locks_want %u pos %llu:%llu:%u -> %llu:%llu:%u", 1679 __entry->idx, 1680 __entry->ref, 1681 __entry->preserve, 1682 bch2_btree_id_str(__entry->btree_id), 1683 __entry->locks_want, 1684 __entry->old_pos_inode, 1685 __entry->old_pos_offset, 1686 __entry->old_pos_snapshot, 1687 __entry->new_pos_inode, 1688 __entry->new_pos_offset, 1689 __entry->new_pos_snapshot) 1690 ); 1691 1692 DECLARE_EVENT_CLASS(btree_path_clone, 1693 TP_PROTO(struct btree_trans *trans, struct btree_path *path, struct btree_path *new), 1694 TP_ARGS(trans, path, new), 1695 1696 TP_STRUCT__entry( 1697 __field(btree_path_idx_t, idx ) 1698 __field(u8, new_idx ) 1699 __field(u8, btree_id ) 1700 __field(u8, ref ) 1701 __field(u8, preserve ) 1702 TRACE_BPOS_entries(pos) 1703 ), 1704 1705 TP_fast_assign( 1706 __entry->idx = path - trans->paths; 1707 __entry->new_idx = new - trans->paths; 1708 __entry->btree_id = path->btree_id; 1709 __entry->ref = path->ref; 1710 __entry->preserve = path->preserve; 1711 TRACE_BPOS_assign(pos, path->pos); 1712 ), 1713 1714 TP_printk(" path %3u ref %u preserve %u btree %s %llu:%llu:%u -> %u", 1715 __entry->idx, 1716 __entry->ref, 1717 __entry->preserve, 1718 bch2_btree_id_str(__entry->btree_id), 1719 __entry->pos_inode, 1720 __entry->pos_offset, 1721 __entry->pos_snapshot, 1722 __entry->new_idx) 1723 ); 1724 1725 DEFINE_EVENT(btree_path_clone, btree_path_clone, 1726 TP_PROTO(struct btree_trans *trans, struct btree_path *path, struct btree_path *new), 1727 TP_ARGS(trans, path, new) 1728 ); 1729 1730 DEFINE_EVENT(btree_path_clone, btree_path_save_pos, 1731 TP_PROTO(struct btree_trans *trans, struct btree_path *path, struct btree_path *new), 1732 TP_ARGS(trans, path, new) 1733 ); 1734 1735 DECLARE_EVENT_CLASS(btree_path_traverse, 1736 TP_PROTO(struct btree_trans *trans, 1737 struct btree_path *path), 1738 TP_ARGS(trans, path), 1739 1740 TP_STRUCT__entry( 1741 __array(char, trans_fn, 32 ) 1742 __field(btree_path_idx_t, idx ) 1743 __field(u8, ref ) 1744 __field(u8, preserve ) 1745 __field(u8, should_be_locked ) 1746 __field(u8, btree_id ) 1747 __field(u8, level ) 1748 TRACE_BPOS_entries(pos) 1749 __field(u8, locks_want ) 1750 __field(u8, nodes_locked ) 1751 __array(char, node0, 24 ) 1752 __array(char, node1, 24 ) 1753 __array(char, node2, 24 ) 1754 __array(char, node3, 24 ) 1755 ), 1756 1757 TP_fast_assign( 1758 strscpy(__entry->trans_fn, trans->fn, sizeof(__entry->trans_fn)); 1759 1760 __entry->idx = path - trans->paths; 1761 __entry->ref = path->ref; 1762 __entry->preserve = path->preserve; 1763 __entry->btree_id = path->btree_id; 1764 __entry->level = path->level; 1765 TRACE_BPOS_assign(pos, path->pos); 1766 1767 __entry->locks_want = path->locks_want; 1768 __entry->nodes_locked = path->nodes_locked; 1769 struct btree *b = path->l[0].b; 1770 if (IS_ERR(b)) 1771 strscpy(__entry->node0, bch2_err_str(PTR_ERR(b)), sizeof(__entry->node0)); 1772 else 1773 scnprintf(__entry->node0, sizeof(__entry->node0), "%px", &b->c); 1774 b = path->l[1].b; 1775 if (IS_ERR(b)) 1776 strscpy(__entry->node1, bch2_err_str(PTR_ERR(b)), sizeof(__entry->node0)); 1777 else 1778 scnprintf(__entry->node1, sizeof(__entry->node0), "%px", &b->c); 1779 b = path->l[2].b; 1780 if (IS_ERR(b)) 1781 strscpy(__entry->node2, bch2_err_str(PTR_ERR(b)), sizeof(__entry->node0)); 1782 else 1783 scnprintf(__entry->node2, sizeof(__entry->node0), "%px", &b->c); 1784 b = path->l[3].b; 1785 if (IS_ERR(b)) 1786 strscpy(__entry->node3, bch2_err_str(PTR_ERR(b)), sizeof(__entry->node0)); 1787 else 1788 scnprintf(__entry->node3, sizeof(__entry->node0), "%px", &b->c); 1789 ), 1790 1791 TP_printk("%s\npath %3u ref %u preserve %u btree %s %llu:%llu:%u level %u locks_want %u\n" 1792 "locks %u %u %u %u node %s %s %s %s", 1793 __entry->trans_fn, 1794 __entry->idx, 1795 __entry->ref, 1796 __entry->preserve, 1797 bch2_btree_id_str(__entry->btree_id), 1798 __entry->pos_inode, 1799 __entry->pos_offset, 1800 __entry->pos_snapshot, 1801 __entry->level, 1802 __entry->locks_want, 1803 (__entry->nodes_locked >> 6) & 3, 1804 (__entry->nodes_locked >> 4) & 3, 1805 (__entry->nodes_locked >> 2) & 3, 1806 (__entry->nodes_locked >> 0) & 3, 1807 __entry->node3, 1808 __entry->node2, 1809 __entry->node1, 1810 __entry->node0) 1811 ); 1812 1813 DEFINE_EVENT(btree_path_traverse, btree_path_traverse_start, 1814 TP_PROTO(struct btree_trans *trans, 1815 struct btree_path *path), 1816 TP_ARGS(trans, path) 1817 ); 1818 1819 DEFINE_EVENT(btree_path_traverse, btree_path_traverse_end, 1820 TP_PROTO(struct btree_trans *trans, struct btree_path *path), 1821 TP_ARGS(trans, path) 1822 ); 1823 1824 TRACE_EVENT(btree_path_set_pos, 1825 TP_PROTO(struct btree_trans *trans, 1826 struct btree_path *path, 1827 struct bpos *new_pos), 1828 TP_ARGS(trans, path, new_pos), 1829 1830 TP_STRUCT__entry( 1831 __field(btree_path_idx_t, idx ) 1832 __field(u8, ref ) 1833 __field(u8, preserve ) 1834 __field(u8, btree_id ) 1835 TRACE_BPOS_entries(old_pos) 1836 TRACE_BPOS_entries(new_pos) 1837 __field(u8, locks_want ) 1838 __field(u8, nodes_locked ) 1839 __array(char, node0, 24 ) 1840 __array(char, node1, 24 ) 1841 __array(char, node2, 24 ) 1842 __array(char, node3, 24 ) 1843 ), 1844 1845 TP_fast_assign( 1846 __entry->idx = path - trans->paths; 1847 __entry->ref = path->ref; 1848 __entry->preserve = path->preserve; 1849 __entry->btree_id = path->btree_id; 1850 TRACE_BPOS_assign(old_pos, path->pos); 1851 TRACE_BPOS_assign(new_pos, *new_pos); 1852 1853 __entry->nodes_locked = path->nodes_locked; 1854 struct btree *b = path->l[0].b; 1855 if (IS_ERR(b)) 1856 strscpy(__entry->node0, bch2_err_str(PTR_ERR(b)), sizeof(__entry->node0)); 1857 else 1858 scnprintf(__entry->node0, sizeof(__entry->node0), "%px", &b->c); 1859 b = path->l[1].b; 1860 if (IS_ERR(b)) 1861 strscpy(__entry->node1, bch2_err_str(PTR_ERR(b)), sizeof(__entry->node0)); 1862 else 1863 scnprintf(__entry->node1, sizeof(__entry->node0), "%px", &b->c); 1864 b = path->l[2].b; 1865 if (IS_ERR(b)) 1866 strscpy(__entry->node2, bch2_err_str(PTR_ERR(b)), sizeof(__entry->node0)); 1867 else 1868 scnprintf(__entry->node2, sizeof(__entry->node0), "%px", &b->c); 1869 b = path->l[3].b; 1870 if (IS_ERR(b)) 1871 strscpy(__entry->node3, bch2_err_str(PTR_ERR(b)), sizeof(__entry->node0)); 1872 else 1873 scnprintf(__entry->node3, sizeof(__entry->node0), "%px", &b->c); 1874 ), 1875 1876 TP_printk("\npath %3u ref %u preserve %u btree %s %llu:%llu:%u -> %llu:%llu:%u\n" 1877 "locks %u %u %u %u node %s %s %s %s", 1878 __entry->idx, 1879 __entry->ref, 1880 __entry->preserve, 1881 bch2_btree_id_str(__entry->btree_id), 1882 __entry->old_pos_inode, 1883 __entry->old_pos_offset, 1884 __entry->old_pos_snapshot, 1885 __entry->new_pos_inode, 1886 __entry->new_pos_offset, 1887 __entry->new_pos_snapshot, 1888 (__entry->nodes_locked >> 6) & 3, 1889 (__entry->nodes_locked >> 4) & 3, 1890 (__entry->nodes_locked >> 2) & 3, 1891 (__entry->nodes_locked >> 0) & 3, 1892 __entry->node3, 1893 __entry->node2, 1894 __entry->node1, 1895 __entry->node0) 1896 ); 1897 1898 TRACE_EVENT(btree_path_free, 1899 TP_PROTO(struct btree_trans *trans, btree_path_idx_t path, struct btree_path *dup), 1900 TP_ARGS(trans, path, dup), 1901 1902 TP_STRUCT__entry( 1903 __field(btree_path_idx_t, idx ) 1904 __field(u8, preserve ) 1905 __field(u8, should_be_locked) 1906 __field(s8, dup ) 1907 __field(u8, dup_locked ) 1908 ), 1909 1910 TP_fast_assign( 1911 __entry->idx = path; 1912 __entry->preserve = trans->paths[path].preserve; 1913 __entry->should_be_locked = trans->paths[path].should_be_locked; 1914 __entry->dup = dup ? dup - trans->paths : -1; 1915 __entry->dup_locked = dup ? btree_node_locked(dup, dup->level) : 0; 1916 ), 1917 1918 TP_printk(" path %3u %c %c dup %2i locked %u", __entry->idx, 1919 __entry->preserve ? 'P' : ' ', 1920 __entry->should_be_locked ? 'S' : ' ', 1921 __entry->dup, 1922 __entry->dup_locked) 1923 ); 1924 1925 TRACE_EVENT(btree_path_free_trans_begin, 1926 TP_PROTO(btree_path_idx_t path), 1927 TP_ARGS(path), 1928 1929 TP_STRUCT__entry( 1930 __field(btree_path_idx_t, idx ) 1931 ), 1932 1933 TP_fast_assign( 1934 __entry->idx = path; 1935 ), 1936 1937 TP_printk(" path %3u", __entry->idx) 1938 ); 1939 1940 #else /* CONFIG_BCACHEFS_PATH_TRACEPOINTS */ 1941 #ifndef _TRACE_BCACHEFS_H 1942 1943 static inline void trace_update_by_path(struct btree_trans *trans, struct btree_path *path, 1944 struct btree_insert_entry *i, bool overwrite) {} 1945 static inline void trace_btree_path_lock(struct btree_trans *trans, unsigned long caller_ip, struct btree_bkey_cached_common *b) {} 1946 static inline void trace_btree_path_get_ll(struct btree_trans *trans, struct btree_path *path) {} 1947 static inline void trace_btree_path_put_ll(struct btree_trans *trans, struct btree_path *path) {} 1948 static inline void trace_btree_path_should_be_locked(struct btree_trans *trans, struct btree_path *path) {} 1949 static inline void trace_btree_path_alloc(struct btree_trans *trans, struct btree_path *path) {} 1950 static inline void trace_btree_path_get(struct btree_trans *trans, struct btree_path *path, struct bpos *new_pos) {} 1951 static inline void trace_btree_path_clone(struct btree_trans *trans, struct btree_path *path, struct btree_path *new) {} 1952 static inline void trace_btree_path_save_pos(struct btree_trans *trans, struct btree_path *path, struct btree_path *new) {} 1953 static inline void trace_btree_path_traverse_start(struct btree_trans *trans, struct btree_path *path) {} 1954 static inline void trace_btree_path_traverse_end(struct btree_trans *trans, struct btree_path *path) {} 1955 static inline void trace_btree_path_set_pos(struct btree_trans *trans, struct btree_path *path, struct bpos *new_pos) {} 1956 static inline void trace_btree_path_free(struct btree_trans *trans, btree_path_idx_t path, struct btree_path *dup) {} 1957 static inline void trace_btree_path_free_trans_begin(btree_path_idx_t path) {} 1958 1959 #endif 1960 #endif /* CONFIG_BCACHEFS_PATH_TRACEPOINTS */ 1961 1962 #define _TRACE_BCACHEFS_H 1963 #endif /* _TRACE_BCACHEFS_H */ 1964 1965 /* This part must be outside protection */ 1966 #undef TRACE_INCLUDE_PATH 1967 #define TRACE_INCLUDE_PATH ../../fs/bcachefs 1968 1969 #undef TRACE_INCLUDE_FILE 1970 #define TRACE_INCLUDE_FILE trace 1971 1972 #include <trace/define_trace.h> 1973