?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 6.13-rc4
[linux.git] / fs / bcachefs / trace.h
blob5597b9d6297f1b330af647c6eeb125ad083fe43a
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>
Linux Kernel