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