git.sesse.net Git - bcachefs-tools-debian/blob - include/trace/events/bcachefs.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #undef TRACE_SYSTEM
   3 #define TRACE_SYSTEM bcachefs
   4
   5 #if !defined(_TRACE_BCACHE_H) || defined(TRACE_HEADER_MULTI_READ)
   6 #define _TRACE_BCACHE_H
   7
   8 #include <linux/tracepoint.h>
   9
  10 DECLARE_EVENT_CLASS(bpos,
  11         TP_PROTO(struct bpos *p),
  12         TP_ARGS(p),
  13
  14         TP_STRUCT__entry(
  15                 __field(u64,    inode                           )
  16                 __field(u64,    offset                          )
  17         ),
  18
  19         TP_fast_assign(
  20                 __entry->inode  = p->inode;
  21                 __entry->offset = p->offset;
  22         ),
  23
  24         TP_printk("%llu:%llu", __entry->inode, __entry->offset)
  25 );
  26
  27 DECLARE_EVENT_CLASS(bkey,
  28         TP_PROTO(const struct bkey *k),
  29         TP_ARGS(k),
  30
  31         TP_STRUCT__entry(
  32                 __field(u64,    inode                           )
  33                 __field(u64,    offset                          )
  34                 __field(u32,    size                            )
  35         ),
  36
  37         TP_fast_assign(
  38                 __entry->inode  = k->p.inode;
  39                 __entry->offset = k->p.offset;
  40                 __entry->size   = k->size;
  41         ),
  42
  43         TP_printk("%llu:%llu len %u", __entry->inode,
  44                   __entry->offset, __entry->size)
  45 );
  46
  47 DECLARE_EVENT_CLASS(bch_fs,
  48         TP_PROTO(struct bch_fs *c),
  49         TP_ARGS(c),
  50
  51         TP_STRUCT__entry(
  52                 __array(char,           uuid,   16 )
  53         ),
  54
  55         TP_fast_assign(
  56                 memcpy(__entry->uuid, c->sb.user_uuid.b, 16);
  57         ),
  58
  59         TP_printk("%pU", __entry->uuid)
  60 );
  61
  62 DECLARE_EVENT_CLASS(bio,
  63         TP_PROTO(struct bio *bio),
  64         TP_ARGS(bio),
  65
  66         TP_STRUCT__entry(
  67                 __field(dev_t,          dev                     )
  68                 __field(sector_t,       sector                  )
  69                 __field(unsigned int,   nr_sector               )
  70                 __array(char,           rwbs,   6               )
  71         ),
  72
  73         TP_fast_assign(
  74                 __entry->dev            = bio->bi_disk ? bio_dev(bio) : 0;
  75                 __entry->sector         = bio->bi_iter.bi_sector;
  76                 __entry->nr_sector      = bio->bi_iter.bi_size >> 9;
  77                 blk_fill_rwbs(__entry->rwbs, bio->bi_opf, bio->bi_iter.bi_size);
  78         ),
  79
  80         TP_printk("%d,%d  %s %llu + %u",
  81                   MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
  82                   (unsigned long long)__entry->sector, __entry->nr_sector)
  83 );
  84
  85 /* io.c: */
  86
  87 DEFINE_EVENT(bio, read_split,
  88         TP_PROTO(struct bio *bio),
  89         TP_ARGS(bio)
  90 );
  91
  92 DEFINE_EVENT(bio, read_bounce,
  93         TP_PROTO(struct bio *bio),
  94         TP_ARGS(bio)
  95 );
  96
  97 DEFINE_EVENT(bio, read_retry,
  98         TP_PROTO(struct bio *bio),
  99         TP_ARGS(bio)
 100 );
 101
 102 DEFINE_EVENT(bio, promote,
 103         TP_PROTO(struct bio *bio),
 104         TP_ARGS(bio)
 105 );
 106
 107 /* Journal */
 108
 109 DEFINE_EVENT(bch_fs, journal_full,
 110         TP_PROTO(struct bch_fs *c),
 111         TP_ARGS(c)
 112 );
 113
 114 DEFINE_EVENT(bch_fs, journal_entry_full,
 115         TP_PROTO(struct bch_fs *c),
 116         TP_ARGS(c)
 117 );
 118
 119 DEFINE_EVENT(bio, journal_write,
 120         TP_PROTO(struct bio *bio),
 121         TP_ARGS(bio)
 122 );
 123
 124 /* bset.c: */
 125
 126 DEFINE_EVENT(bpos, bkey_pack_pos_fail,
 127         TP_PROTO(struct bpos *p),
 128         TP_ARGS(p)
 129 );
 130
 131 /* Btree */
 132
 133 DECLARE_EVENT_CLASS(btree_node,
 134         TP_PROTO(struct bch_fs *c, struct btree *b),
 135         TP_ARGS(c, b),
 136
 137         TP_STRUCT__entry(
 138                 __array(char,           uuid,           16      )
 139                 __field(u8,             level                   )
 140                 __field(u8,             id                      )
 141                 __field(u64,            inode                   )
 142                 __field(u64,            offset                  )
 143         ),
 144
 145         TP_fast_assign(
 146                 memcpy(__entry->uuid, c->sb.user_uuid.b, 16);
 147                 __entry->level          = b->c.level;
 148                 __entry->id             = b->c.btree_id;
 149                 __entry->inode          = b->key.k.p.inode;
 150                 __entry->offset         = b->key.k.p.offset;
 151         ),
 152
 153         TP_printk("%pU  %u id %u %llu:%llu",
 154                   __entry->uuid, __entry->level, __entry->id,
 155                   __entry->inode, __entry->offset)
 156 );
 157
 158 DEFINE_EVENT(btree_node, btree_read,
 159         TP_PROTO(struct bch_fs *c, struct btree *b),
 160         TP_ARGS(c, b)
 161 );
 162
 163 TRACE_EVENT(btree_write,
 164         TP_PROTO(struct btree *b, unsigned bytes, unsigned sectors),
 165         TP_ARGS(b, bytes, sectors),
 166
 167         TP_STRUCT__entry(
 168                 __field(enum btree_node_type,   type)
 169                 __field(unsigned,       bytes                   )
 170                 __field(unsigned,       sectors                 )
 171         ),
 172
 173         TP_fast_assign(
 174                 __entry->type   = btree_node_type(b);
 175                 __entry->bytes  = bytes;
 176                 __entry->sectors = sectors;
 177         ),
 178
 179         TP_printk("bkey type %u bytes %u sectors %u",
 180                   __entry->type , __entry->bytes, __entry->sectors)
 181 );
 182
 183 DEFINE_EVENT(btree_node, btree_node_alloc,
 184         TP_PROTO(struct bch_fs *c, struct btree *b),
 185         TP_ARGS(c, b)
 186 );
 187
 188 DEFINE_EVENT(btree_node, btree_node_free,
 189         TP_PROTO(struct bch_fs *c, struct btree *b),
 190         TP_ARGS(c, b)
 191 );
 192
 193 DEFINE_EVENT(btree_node, btree_node_reap,
 194         TP_PROTO(struct bch_fs *c, struct btree *b),
 195         TP_ARGS(c, b)
 196 );
 197
 198 DECLARE_EVENT_CLASS(btree_node_cannibalize_lock,
 199         TP_PROTO(struct bch_fs *c),
 200         TP_ARGS(c),
 201
 202         TP_STRUCT__entry(
 203                 __array(char,                   uuid,   16      )
 204         ),
 205
 206         TP_fast_assign(
 207                 memcpy(__entry->uuid, c->sb.user_uuid.b, 16);
 208         ),
 209
 210         TP_printk("%pU", __entry->uuid)
 211 );
 212
 213 DEFINE_EVENT(btree_node_cannibalize_lock, btree_node_cannibalize_lock_fail,
 214         TP_PROTO(struct bch_fs *c),
 215         TP_ARGS(c)
 216 );
 217
 218 DEFINE_EVENT(btree_node_cannibalize_lock, btree_node_cannibalize_lock,
 219         TP_PROTO(struct bch_fs *c),
 220         TP_ARGS(c)
 221 );
 222
 223 DEFINE_EVENT(btree_node_cannibalize_lock, btree_node_cannibalize,
 224         TP_PROTO(struct bch_fs *c),
 225         TP_ARGS(c)
 226 );
 227
 228 DEFINE_EVENT(bch_fs, btree_node_cannibalize_unlock,
 229         TP_PROTO(struct bch_fs *c),
 230         TP_ARGS(c)
 231 );
 232
 233 TRACE_EVENT(btree_reserve_get_fail,
 234         TP_PROTO(struct bch_fs *c, size_t required, struct closure *cl),
 235         TP_ARGS(c, required, cl),
 236
 237         TP_STRUCT__entry(
 238                 __array(char,                   uuid,   16      )
 239                 __field(size_t,                 required        )
 240                 __field(struct closure *,       cl              )
 241         ),
 242
 243         TP_fast_assign(
 244                 memcpy(__entry->uuid, c->sb.user_uuid.b, 16);
 245                 __entry->required = required;
 246                 __entry->cl = cl;
 247         ),
 248
 249         TP_printk("%pU required %zu by %p", __entry->uuid,
 250                   __entry->required, __entry->cl)
 251 );
 252
 253 TRACE_EVENT(btree_insert_key,
 254         TP_PROTO(struct bch_fs *c, struct btree *b, struct bkey_i *k),
 255         TP_ARGS(c, b, k),
 256
 257         TP_STRUCT__entry(
 258                 __field(u8,             id                      )
 259                 __field(u64,            inode                   )
 260                 __field(u64,            offset                  )
 261                 __field(u32,            size                    )
 262         ),
 263
 264         TP_fast_assign(
 265                 __entry->id             = b->c.btree_id;
 266                 __entry->inode          = k->k.p.inode;
 267                 __entry->offset         = k->k.p.offset;
 268                 __entry->size           = k->k.size;
 269         ),
 270
 271         TP_printk("btree %u: %llu:%llu len %u", __entry->id,
 272                   __entry->inode, __entry->offset, __entry->size)
 273 );
 274
 275 DEFINE_EVENT(btree_node, btree_split,
 276         TP_PROTO(struct bch_fs *c, struct btree *b),
 277         TP_ARGS(c, b)
 278 );
 279
 280 DEFINE_EVENT(btree_node, btree_compact,
 281         TP_PROTO(struct bch_fs *c, struct btree *b),
 282         TP_ARGS(c, b)
 283 );
 284
 285 DEFINE_EVENT(btree_node, btree_merge,
 286         TP_PROTO(struct bch_fs *c, struct btree *b),
 287         TP_ARGS(c, b)
 288 );
 289
 290 DEFINE_EVENT(btree_node, btree_set_root,
 291         TP_PROTO(struct bch_fs *c, struct btree *b),
 292         TP_ARGS(c, b)
 293 );
 294
 295 /* Garbage collection */
 296
 297 DEFINE_EVENT(btree_node, btree_gc_coalesce,
 298         TP_PROTO(struct bch_fs *c, struct btree *b),
 299         TP_ARGS(c, b)
 300 );
 301
 302 TRACE_EVENT(btree_gc_coalesce_fail,
 303         TP_PROTO(struct bch_fs *c, int reason),
 304         TP_ARGS(c, reason),
 305
 306         TP_STRUCT__entry(
 307                 __field(u8,             reason                  )
 308                 __array(char,           uuid,   16              )
 309         ),
 310
 311         TP_fast_assign(
 312                 __entry->reason         = reason;
 313                 memcpy(__entry->uuid, c->disk_sb.sb->user_uuid.b, 16);
 314         ),
 315
 316         TP_printk("%pU: %u", __entry->uuid, __entry->reason)
 317 );
 318
 319 DEFINE_EVENT(btree_node, btree_gc_rewrite_node,
 320         TP_PROTO(struct bch_fs *c, struct btree *b),
 321         TP_ARGS(c, b)
 322 );
 323
 324 DEFINE_EVENT(btree_node, btree_gc_rewrite_node_fail,
 325         TP_PROTO(struct bch_fs *c, struct btree *b),
 326         TP_ARGS(c, b)
 327 );
 328
 329 DEFINE_EVENT(bch_fs, gc_start,
 330         TP_PROTO(struct bch_fs *c),
 331         TP_ARGS(c)
 332 );
 333
 334 DEFINE_EVENT(bch_fs, gc_end,
 335         TP_PROTO(struct bch_fs *c),
 336         TP_ARGS(c)
 337 );
 338
 339 DEFINE_EVENT(bch_fs, gc_coalesce_start,
 340         TP_PROTO(struct bch_fs *c),
 341         TP_ARGS(c)
 342 );
 343
 344 DEFINE_EVENT(bch_fs, gc_coalesce_end,
 345         TP_PROTO(struct bch_fs *c),
 346         TP_ARGS(c)
 347 );
 348
 349 DEFINE_EVENT(bch_fs, gc_cannot_inc_gens,
 350         TP_PROTO(struct bch_fs *c),
 351         TP_ARGS(c)
 352 );
 353
 354 /* Allocator */
 355
 356 TRACE_EVENT(alloc_batch,
 357         TP_PROTO(struct bch_dev *ca, size_t free, size_t total),
 358         TP_ARGS(ca, free, total),
 359
 360         TP_STRUCT__entry(
 361                 __array(char,           uuid,   16      )
 362                 __field(size_t,         free            )
 363                 __field(size_t,         total           )
 364         ),
 365
 366         TP_fast_assign(
 367                 memcpy(__entry->uuid, ca->uuid.b, 16);
 368                 __entry->free = free;
 369                 __entry->total = total;
 370         ),
 371
 372         TP_printk("%pU free %zu total %zu",
 373                 __entry->uuid, __entry->free, __entry->total)
 374 );
 375
 376 TRACE_EVENT(invalidate,
 377         TP_PROTO(struct bch_dev *ca, u64 offset, unsigned sectors),
 378         TP_ARGS(ca, offset, sectors),
 379
 380         TP_STRUCT__entry(
 381                 __field(unsigned,       sectors                 )
 382                 __field(dev_t,          dev                     )
 383                 __field(__u64,          offset                  )
 384         ),
 385
 386         TP_fast_assign(
 387                 __entry->dev            = ca->disk_sb.bdev->bd_dev;
 388                 __entry->offset         = offset,
 389                 __entry->sectors        = sectors;
 390         ),
 391
 392         TP_printk("invalidated %u sectors at %d,%d sector=%llu",
 393                   __entry->sectors, MAJOR(__entry->dev),
 394                   MINOR(__entry->dev), __entry->offset)
 395 );
 396
 397 DEFINE_EVENT(bch_fs, rescale_prios,
 398         TP_PROTO(struct bch_fs *c),
 399         TP_ARGS(c)
 400 );
 401
 402 DECLARE_EVENT_CLASS(bucket_alloc,
 403         TP_PROTO(struct bch_dev *ca, enum alloc_reserve reserve),
 404         TP_ARGS(ca, reserve),
 405
 406         TP_STRUCT__entry(
 407                 __array(char,                   uuid,   16)
 408                 __field(enum alloc_reserve,     reserve   )
 409         ),
 410
 411         TP_fast_assign(
 412                 memcpy(__entry->uuid, ca->uuid.b, 16);
 413                 __entry->reserve = reserve;
 414         ),
 415
 416         TP_printk("%pU reserve %d", __entry->uuid, __entry->reserve)
 417 );
 418
 419 DEFINE_EVENT(bucket_alloc, bucket_alloc,
 420         TP_PROTO(struct bch_dev *ca, enum alloc_reserve reserve),
 421         TP_ARGS(ca, reserve)
 422 );
 423
 424 DEFINE_EVENT(bucket_alloc, bucket_alloc_fail,
 425         TP_PROTO(struct bch_dev *ca, enum alloc_reserve reserve),
 426         TP_ARGS(ca, reserve)
 427 );
 428
 429 DEFINE_EVENT(bucket_alloc, open_bucket_alloc_fail,
 430         TP_PROTO(struct bch_dev *ca, enum alloc_reserve reserve),
 431         TP_ARGS(ca, reserve)
 432 );
 433
 434 /* Moving IO */
 435
 436 DEFINE_EVENT(bkey, move_extent,
 437         TP_PROTO(const struct bkey *k),
 438         TP_ARGS(k)
 439 );
 440
 441 DEFINE_EVENT(bkey, move_alloc_fail,
 442         TP_PROTO(const struct bkey *k),
 443         TP_ARGS(k)
 444 );
 445
 446 DEFINE_EVENT(bkey, move_race,
 447         TP_PROTO(const struct bkey *k),
 448         TP_ARGS(k)
 449 );
 450
 451 TRACE_EVENT(move_data,
 452         TP_PROTO(struct bch_fs *c, u64 sectors_moved,
 453                  u64 keys_moved),
 454         TP_ARGS(c, sectors_moved, keys_moved),
 455
 456         TP_STRUCT__entry(
 457                 __array(char,           uuid,   16      )
 458                 __field(u64,            sectors_moved   )
 459                 __field(u64,            keys_moved      )
 460         ),
 461
 462         TP_fast_assign(
 463                 memcpy(__entry->uuid, c->sb.user_uuid.b, 16);
 464                 __entry->sectors_moved = sectors_moved;
 465                 __entry->keys_moved = keys_moved;
 466         ),
 467
 468         TP_printk("%pU sectors_moved %llu keys_moved %llu",
 469                 __entry->uuid, __entry->sectors_moved, __entry->keys_moved)
 470 );
 471
 472 TRACE_EVENT(copygc,
 473         TP_PROTO(struct bch_dev *ca,
 474                  u64 sectors_moved, u64 sectors_not_moved,
 475                  u64 buckets_moved, u64 buckets_not_moved),
 476         TP_ARGS(ca,
 477                 sectors_moved, sectors_not_moved,
 478                 buckets_moved, buckets_not_moved),
 479
 480         TP_STRUCT__entry(
 481                 __array(char,           uuid,   16              )
 482                 __field(u64,            sectors_moved           )
 483                 __field(u64,            sectors_not_moved       )
 484                 __field(u64,            buckets_moved           )
 485                 __field(u64,            buckets_not_moved       )
 486         ),
 487
 488         TP_fast_assign(
 489                 memcpy(__entry->uuid, ca->uuid.b, 16);
 490                 __entry->sectors_moved          = sectors_moved;
 491                 __entry->sectors_not_moved      = sectors_not_moved;
 492                 __entry->buckets_moved          = buckets_moved;
 493                 __entry->buckets_not_moved = buckets_moved;
 494         ),
 495
 496         TP_printk("%pU sectors moved %llu remain %llu buckets moved %llu remain %llu",
 497                 __entry->uuid,
 498                 __entry->sectors_moved, __entry->sectors_not_moved,
 499                 __entry->buckets_moved, __entry->buckets_not_moved)
 500 );
 501
 502 TRACE_EVENT(transaction_restart_ip,
 503         TP_PROTO(unsigned long caller, unsigned long ip),
 504         TP_ARGS(caller, ip),
 505
 506         TP_STRUCT__entry(
 507                 __field(unsigned long,          caller  )
 508                 __field(unsigned long,          ip      )
 509         ),
 510
 511         TP_fast_assign(
 512                 __entry->caller = caller;
 513                 __entry->ip     = ip;
 514         ),
 515
 516         TP_printk("%pF %pF", (void *) __entry->caller, (void *) __entry->ip)
 517 );
 518
 519 DECLARE_EVENT_CLASS(transaction_restart,
 520         TP_PROTO(unsigned long ip),
 521         TP_ARGS(ip),
 522
 523         TP_STRUCT__entry(
 524                 __field(unsigned long,          ip      )
 525         ),
 526
 527         TP_fast_assign(
 528                 __entry->ip = ip;
 529         ),
 530
 531         TP_printk("%pf", (void *) __entry->ip)
 532 );
 533
 534 DEFINE_EVENT(transaction_restart,       trans_restart_btree_node_reused,
 535         TP_PROTO(unsigned long ip),
 536         TP_ARGS(ip)
 537 );
 538
 539 DEFINE_EVENT(transaction_restart,       trans_restart_would_deadlock,
 540         TP_PROTO(unsigned long ip),
 541         TP_ARGS(ip)
 542 );
 543
 544 TRACE_EVENT(trans_restart_iters_realloced,
 545         TP_PROTO(unsigned long ip, unsigned nr),
 546         TP_ARGS(ip, nr),
 547
 548         TP_STRUCT__entry(
 549                 __field(unsigned long,          ip      )
 550                 __field(unsigned,               nr      )
 551         ),
 552
 553         TP_fast_assign(
 554                 __entry->ip     = ip;
 555                 __entry->nr     = nr;
 556         ),
 557
 558         TP_printk("%pf nr %u", (void *) __entry->ip, __entry->nr)
 559 );
 560
 561 TRACE_EVENT(trans_restart_mem_realloced,
 562         TP_PROTO(unsigned long ip, unsigned long bytes),
 563         TP_ARGS(ip, bytes),
 564
 565         TP_STRUCT__entry(
 566                 __field(unsigned long,          ip      )
 567                 __field(unsigned long,          bytes   )
 568         ),
 569
 570         TP_fast_assign(
 571                 __entry->ip     = ip;
 572                 __entry->bytes  = bytes;
 573         ),
 574
 575         TP_printk("%pf bytes %lu", (void *) __entry->ip, __entry->bytes)
 576 );
 577
 578 DEFINE_EVENT(transaction_restart,       trans_restart_journal_res_get,
 579         TP_PROTO(unsigned long ip),
 580         TP_ARGS(ip)
 581 );
 582
 583 DEFINE_EVENT(transaction_restart,       trans_restart_journal_preres_get,
 584         TP_PROTO(unsigned long ip),
 585         TP_ARGS(ip)
 586 );
 587
 588 DEFINE_EVENT(transaction_restart,       trans_restart_mark_replicas,
 589         TP_PROTO(unsigned long ip),
 590         TP_ARGS(ip)
 591 );
 592
 593 DEFINE_EVENT(transaction_restart,       trans_restart_fault_inject,
 594         TP_PROTO(unsigned long ip),
 595         TP_ARGS(ip)
 596 );
 597
 598 DEFINE_EVENT(transaction_restart,       trans_restart_btree_node_split,
 599         TP_PROTO(unsigned long ip),
 600         TP_ARGS(ip)
 601 );
 602
 603 DEFINE_EVENT(transaction_restart,       trans_restart_mark,
 604         TP_PROTO(unsigned long ip),
 605         TP_ARGS(ip)
 606 );
 607
 608 DEFINE_EVENT(transaction_restart,       trans_restart_upgrade,
 609         TP_PROTO(unsigned long ip),
 610         TP_ARGS(ip)
 611 );
 612
 613 DEFINE_EVENT(transaction_restart,       trans_restart_iter_upgrade,
 614         TP_PROTO(unsigned long ip),
 615         TP_ARGS(ip)
 616 );
 617
 618 DEFINE_EVENT(transaction_restart,       trans_restart_traverse,
 619         TP_PROTO(unsigned long ip),
 620         TP_ARGS(ip)
 621 );
 622
 623 DEFINE_EVENT(transaction_restart,       trans_restart_atomic,
 624         TP_PROTO(unsigned long ip),
 625         TP_ARGS(ip)
 626 );
 627
 628 DECLARE_EVENT_CLASS(node_lock_fail,
 629         TP_PROTO(unsigned level, u32 iter_seq, unsigned node, u32 node_seq),
 630         TP_ARGS(level, iter_seq, node, node_seq),
 631
 632         TP_STRUCT__entry(
 633                 __field(u32,            level)
 634                 __field(u32,            iter_seq)
 635                 __field(u32,            node)
 636                 __field(u32,            node_seq)
 637         ),
 638
 639         TP_fast_assign(
 640                 __entry->level          = level;
 641                 __entry->iter_seq       = iter_seq;
 642                 __entry->node           = node;
 643                 __entry->node_seq       = node_seq;
 644         ),
 645
 646         TP_printk("level %u iter seq %u node %u node seq %u",
 647                   __entry->level, __entry->iter_seq,
 648                   __entry->node, __entry->node_seq)
 649 );
 650
 651 DEFINE_EVENT(node_lock_fail, node_upgrade_fail,
 652         TP_PROTO(unsigned level, u32 iter_seq, unsigned node, u32 node_seq),
 653         TP_ARGS(level, iter_seq, node, node_seq)
 654 );
 655
 656 DEFINE_EVENT(node_lock_fail, node_relock_fail,
 657         TP_PROTO(unsigned level, u32 iter_seq, unsigned node, u32 node_seq),
 658         TP_ARGS(level, iter_seq, node, node_seq)
 659 );
 660
 661 #endif /* _TRACE_BCACHE_H */
 662
 663 /* This part must be outside protection */
 664 #include <trace/define_trace.h>