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