fs/bcachefs/trace.h

   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>