[mirror_ubuntu-bionic-kernel.git] / include / trace / events / bcache.h

#undef TRACE_SYSTEM
#define TRACE_SYSTEM bcache

#if !defined(_TRACE_BCACHE_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_BCACHE_H

#include <linux/tracepoint.h>

DECLARE_EVENT_CLASS(bcache_request,
	TP_PROTO(struct bcache_device *d, struct bio *bio),
	TP_ARGS(d, bio),

	TP_STRUCT__entry(
		__field(dev_t,		dev			)
		__field(unsigned int,	orig_major		)
		__field(unsigned int,	orig_minor		)
		__field(sector_t,	sector			)
		__field(dev_t,		orig_sector		)
		__field(unsigned int,	nr_sector		)
		__array(char,		rwbs,	6		)
	),

	TP_fast_assign(
		__entry->dev		= bio->bi_bdev->bd_dev;
		__entry->orig_major	= d->disk->major;
		__entry->orig_minor	= d->disk->first_minor;
		__entry->sector		= bio->bi_iter.bi_sector;
		__entry->orig_sector	= bio->bi_iter.bi_sector - 16;
		__entry->nr_sector	= bio->bi_iter.bi_size >> 9;
		blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_iter.bi_size);
	),

	TP_printk("%d,%d %s %llu + %u (from %d,%d @ %llu)",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->rwbs, (unsigned long long)__entry->sector,
		  __entry->nr_sector, __entry->orig_major, __entry->orig_minor,
		  (unsigned long long)__entry->orig_sector)
);

DECLARE_EVENT_CLASS(bkey,
	TP_PROTO(struct bkey *k),
	TP_ARGS(k),

	TP_STRUCT__entry(
		__field(u32,	size				)
		__field(u32,	inode				)
		__field(u64,	offset				)
		__field(bool,	dirty				)
	),

	TP_fast_assign(
		__entry->inode	= KEY_INODE(k);
		__entry->offset	= KEY_OFFSET(k);
		__entry->size	= KEY_SIZE(k);
		__entry->dirty	= KEY_DIRTY(k);
	),

	TP_printk("%u:%llu len %u dirty %u", __entry->inode,
		  __entry->offset, __entry->size, __entry->dirty)
);

DECLARE_EVENT_CLASS(btree_node,
	TP_PROTO(struct btree *b),
	TP_ARGS(b),

	TP_STRUCT__entry(
		__field(size_t,		bucket			)
	),

	TP_fast_assign(
		__entry->bucket	= PTR_BUCKET_NR(b->c, &b->key, 0);
	),

	TP_printk("bucket %zu", __entry->bucket)
);

/* request.c */

DEFINE_EVENT(bcache_request, bcache_request_start,
	TP_PROTO(struct bcache_device *d, struct bio *bio),
	TP_ARGS(d, bio)
);

DEFINE_EVENT(bcache_request, bcache_request_end,
	TP_PROTO(struct bcache_device *d, struct bio *bio),
	TP_ARGS(d, bio)
);

DECLARE_EVENT_CLASS(bcache_bio,
	TP_PROTO(struct bio *bio),
	TP_ARGS(bio),

	TP_STRUCT__entry(
		__field(dev_t,		dev			)
		__field(sector_t,	sector			)
		__field(unsigned int,	nr_sector		)
		__array(char,		rwbs,	6		)
	),

	TP_fast_assign(
		__entry->dev		= bio->bi_bdev->bd_dev;
		__entry->sector		= bio->bi_iter.bi_sector;
		__entry->nr_sector	= bio->bi_iter.bi_size >> 9;
		blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_iter.bi_size);
	),

	TP_printk("%d,%d  %s %llu + %u",
		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
		  (unsigned long long)__entry->sector, __entry->nr_sector)
);

DEFINE_EVENT(bcache_bio, bcache_bypass_sequential,
	TP_PROTO(struct bio *bio),
	TP_ARGS(bio)
);

DEFINE_EVENT(bcache_bio, bcache_bypass_congested,
	TP_PROTO(struct bio *bio),
	TP_ARGS(bio)
);

TRACE_EVENT(bcache_read,
	TP_PROTO(struct bio *bio, bool hit, bool bypass),
	TP_ARGS(bio, hit, bypass),

	TP_STRUCT__entry(
		__field(dev_t,		dev			)
		__field(sector_t,	sector			)
		__field(unsigned int,	nr_sector		)
		__array(char,		rwbs,	6		)
		__field(bool,		cache_hit		)
		__field(bool,		bypass			)
	),

	TP_fast_assign(
		__entry->dev		= bio->bi_bdev->bd_dev;
		__entry->sector		= bio->bi_iter.bi_sector;
		__entry->nr_sector	= bio->bi_iter.bi_size >> 9;
		blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_iter.bi_size);
		__entry->cache_hit = hit;
		__entry->bypass = bypass;
	),

	TP_printk("%d,%d  %s %llu + %u hit %u bypass %u",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->rwbs, (unsigned long long)__entry->sector,
		  __entry->nr_sector, __entry->cache_hit, __entry->bypass)
);

TRACE_EVENT(bcache_write,
	TP_PROTO(struct bio *bio, bool writeback, bool bypass),
	TP_ARGS(bio, writeback, bypass),

	TP_STRUCT__entry(
		__field(dev_t,		dev			)
		__field(sector_t,	sector			)
		__field(unsigned int,	nr_sector		)
		__array(char,		rwbs,	6		)
		__field(bool,		writeback		)
		__field(bool,		bypass			)
	),

	TP_fast_assign(
		__entry->dev		= bio->bi_bdev->bd_dev;
		__entry->sector		= bio->bi_iter.bi_sector;
		__entry->nr_sector	= bio->bi_iter.bi_size >> 9;
		blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_iter.bi_size);
		__entry->writeback = writeback;
		__entry->bypass = bypass;
	),

	TP_printk("%d,%d  %s %llu + %u hit %u bypass %u",
		  MAJOR(__entry->dev), MINOR(__entry->dev),
		  __entry->rwbs, (unsigned long long)__entry->sector,
		  __entry->nr_sector, __entry->writeback, __entry->bypass)
);

DEFINE_EVENT(bcache_bio, bcache_read_retry,
	TP_PROTO(struct bio *bio),
	TP_ARGS(bio)
);

DEFINE_EVENT(bkey, bcache_cache_insert,
	TP_PROTO(struct bkey *k),
	TP_ARGS(k)
);

/* Journal */

DECLARE_EVENT_CLASS(cache_set,
	TP_PROTO(struct cache_set *c),
	TP_ARGS(c),

	TP_STRUCT__entry(
		__array(char,		uuid,	16 )
	),

	TP_fast_assign(
		memcpy(__entry->uuid, c->sb.set_uuid, 16);
	),

	TP_printk("%pU", __entry->uuid)
);

DEFINE_EVENT(bkey, bcache_journal_replay_key,
	TP_PROTO(struct bkey *k),
	TP_ARGS(k)
);

DEFINE_EVENT(cache_set, bcache_journal_full,
	TP_PROTO(struct cache_set *c),
	TP_ARGS(c)
);

DEFINE_EVENT(cache_set, bcache_journal_entry_full,
	TP_PROTO(struct cache_set *c),
	TP_ARGS(c)
);

DEFINE_EVENT(bcache_bio, bcache_journal_write,
	TP_PROTO(struct bio *bio),
	TP_ARGS(bio)
);

/* Btree */

DEFINE_EVENT(cache_set, bcache_btree_cache_cannibalize,
	TP_PROTO(struct cache_set *c),
	TP_ARGS(c)
);

DEFINE_EVENT(btree_node, bcache_btree_read,
	TP_PROTO(struct btree *b),
	TP_ARGS(b)
);

TRACE_EVENT(bcache_btree_write,
	TP_PROTO(struct btree *b),
	TP_ARGS(b),

	TP_STRUCT__entry(
		__field(size_t,		bucket			)
		__field(unsigned,	block			)
		__field(unsigned,	keys			)
	),

	TP_fast_assign(
		__entry->bucket	= PTR_BUCKET_NR(b->c, &b->key, 0);
		__entry->block	= b->written;
		__entry->keys	= b->keys.set[b->keys.nsets].data->keys;
	),

	TP_printk("bucket %zu", __entry->bucket)
);

DEFINE_EVENT(btree_node, bcache_btree_node_alloc,
	TP_PROTO(struct btree *b),
	TP_ARGS(b)
);

DEFINE_EVENT(btree_node, bcache_btree_node_alloc_fail,
	TP_PROTO(struct btree *b),
	TP_ARGS(b)
);

DEFINE_EVENT(btree_node, bcache_btree_node_free,
	TP_PROTO(struct btree *b),
	TP_ARGS(b)
);

TRACE_EVENT(bcache_btree_gc_coalesce,
	TP_PROTO(unsigned nodes),
	TP_ARGS(nodes),

	TP_STRUCT__entry(
		__field(unsigned,	nodes			)
	),

	TP_fast_assign(
		__entry->nodes	= nodes;
	),

	TP_printk("coalesced %u nodes", __entry->nodes)
);

DEFINE_EVENT(cache_set, bcache_gc_start,
	TP_PROTO(struct cache_set *c),
	TP_ARGS(c)
);

DEFINE_EVENT(cache_set, bcache_gc_end,
	TP_PROTO(struct cache_set *c),
	TP_ARGS(c)
);

DEFINE_EVENT(bkey, bcache_gc_copy,
	TP_PROTO(struct bkey *k),
	TP_ARGS(k)
);

DEFINE_EVENT(bkey, bcache_gc_copy_collision,
	TP_PROTO(struct bkey *k),
	TP_ARGS(k)
);

TRACE_EVENT(bcache_btree_insert_key,
	TP_PROTO(struct btree *b, struct bkey *k, unsigned op, unsigned status),
	TP_ARGS(b, k, op, status),

	TP_STRUCT__entry(
		__field(u64,	btree_node			)
		__field(u32,	btree_level			)
		__field(u32,	inode				)
		__field(u64,	offset				)
		__field(u32,	size				)
		__field(u8,	dirty				)
		__field(u8,	op				)
		__field(u8,	status				)
	),

	TP_fast_assign(
		__entry->btree_node = PTR_BUCKET_NR(b->c, &b->key, 0);
		__entry->btree_level = b->level;
		__entry->inode	= KEY_INODE(k);
		__entry->offset	= KEY_OFFSET(k);
		__entry->size	= KEY_SIZE(k);
		__entry->dirty	= KEY_DIRTY(k);
		__entry->op = op;
		__entry->status = status;
	),

	TP_printk("%u for %u at %llu(%u): %u:%llu len %u dirty %u",
		  __entry->status, __entry->op,
		  __entry->btree_node, __entry->btree_level,
		  __entry->inode, __entry->offset,
		  __entry->size, __entry->dirty)
);

DECLARE_EVENT_CLASS(btree_split,
	TP_PROTO(struct btree *b, unsigned keys),
	TP_ARGS(b, keys),

	TP_STRUCT__entry(
		__field(size_t,		bucket			)
		__field(unsigned,	keys			)
	),

	TP_fast_assign(
		__entry->bucket	= PTR_BUCKET_NR(b->c, &b->key, 0);
		__entry->keys	= keys;
	),

	TP_printk("bucket %zu keys %u", __entry->bucket, __entry->keys)
);

DEFINE_EVENT(btree_split, bcache_btree_node_split,
	TP_PROTO(struct btree *b, unsigned keys),
	TP_ARGS(b, keys)
);

DEFINE_EVENT(btree_split, bcache_btree_node_compact,
	TP_PROTO(struct btree *b, unsigned keys),
	TP_ARGS(b, keys)
);

DEFINE_EVENT(btree_node, bcache_btree_set_root,
	TP_PROTO(struct btree *b),
	TP_ARGS(b)
);

TRACE_EVENT(bcache_keyscan,
	TP_PROTO(unsigned nr_found,
		 unsigned start_inode, uint64_t start_offset,
		 unsigned end_inode, uint64_t end_offset),
	TP_ARGS(nr_found,
		start_inode, start_offset,
		end_inode, end_offset),

	TP_STRUCT__entry(
		__field(__u32,	nr_found			)
		__field(__u32,	start_inode			)
		__field(__u64,	start_offset			)
		__field(__u32,	end_inode			)
		__field(__u64,	end_offset			)
	),

	TP_fast_assign(
		__entry->nr_found	= nr_found;
		__entry->start_inode	= start_inode;
		__entry->start_offset	= start_offset;
		__entry->end_inode	= end_inode;
		__entry->end_offset	= end_offset;
	),

	TP_printk("found %u keys from %u:%llu to %u:%llu", __entry->nr_found,
		  __entry->start_inode, __entry->start_offset,
		  __entry->end_inode, __entry->end_offset)
);

/* Allocator */

TRACE_EVENT(bcache_invalidate,
	TP_PROTO(struct cache *ca, size_t bucket),
	TP_ARGS(ca, bucket),

	TP_STRUCT__entry(
		__field(unsigned,	sectors			)
		__field(dev_t,		dev			)
		__field(__u64,		offset			)
	),

	TP_fast_assign(
		__entry->dev		= ca->bdev->bd_dev;
		__entry->offset		= bucket << ca->set->bucket_bits;
		__entry->sectors	= GC_SECTORS_USED(&ca->buckets[bucket]);
	),

	TP_printk("invalidated %u sectors at %d,%d sector=%llu",
		  __entry->sectors, MAJOR(__entry->dev),
		  MINOR(__entry->dev), __entry->offset)
);

TRACE_EVENT(bcache_alloc,
	TP_PROTO(struct cache *ca, size_t bucket),
	TP_ARGS(ca, bucket),

	TP_STRUCT__entry(
		__field(dev_t,		dev			)
		__field(__u64,		offset			)
	),

	TP_fast_assign(
		__entry->dev		= ca->bdev->bd_dev;
		__entry->offset		= bucket << ca->set->bucket_bits;
	),

	TP_printk("allocated %d,%d sector=%llu", MAJOR(__entry->dev),
		  MINOR(__entry->dev), __entry->offset)
);

TRACE_EVENT(bcache_alloc_fail,
	TP_PROTO(struct cache *ca, unsigned reserve),
	TP_ARGS(ca, reserve),

	TP_STRUCT__entry(
		__field(dev_t,		dev			)
		__field(unsigned,	free			)
		__field(unsigned,	free_inc		)
		__field(unsigned,	unused			)
		__field(unsigned,	blocked			)
	),

	TP_fast_assign(
		__entry->dev		= ca->bdev->bd_dev;
		__entry->free		= fifo_used(&ca->free[reserve]);
		__entry->free_inc	= fifo_used(&ca->free_inc);
		__entry->unused		= fifo_used(&ca->unused);
		__entry->blocked	= atomic_read(&ca->set->prio_blocked);
	),

	TP_printk("alloc fail %d,%d free %u free_inc %u unused %u blocked %u",
		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->free,
		  __entry->free_inc, __entry->unused, __entry->blocked)
);

/* Background writeback */

DEFINE_EVENT(bkey, bcache_writeback,
	TP_PROTO(struct bkey *k),
	TP_ARGS(k)
);

DEFINE_EVENT(bkey, bcache_writeback_collision,
	TP_PROTO(struct bkey *k),
	TP_ARGS(k)
);

#endif /* _TRACE_BCACHE_H */

/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
cafe5635 KO	1	#undef TRACE_SYSTEM
	2	#define TRACE_SYSTEM bcache
	3
	4	#if !defined(_TRACE_BCACHE_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	5	#define _TRACE_BCACHE_H
	6
	7	#include <linux/tracepoint.h>
	8
cafe5635	9	DECLARE_EVENT_CLASS(bcache_request,
220bb38c KO	10	TP_PROTO(struct bcache_device d, struct bio bio),
220bb38c KO	11	TP_ARGS(d, bio),
cafe5635 KO	12
	13	TP_STRUCT__entry(
	14	__field(dev_t, dev )
	15	__field(unsigned int, orig_major )
	16	__field(unsigned int, orig_minor )
	17	__field(sector_t, sector )
	18	__field(dev_t, orig_sector )
	19	__field(unsigned int, nr_sector )
	20	__array(char, rwbs, 6 )
cafe5635 KO	21	),
	22
	23	TP_fast_assign(
	24	__entry->dev = bio->bi_bdev->bd_dev;
220bb38c KO	25	__entry->orig_major = d->disk->major;
220bb38c KO	26	__entry->orig_minor = d->disk->first_minor;
4f024f37 KO	27	__entry->sector = bio->bi_iter.bi_sector;
	28	__entry->orig_sector = bio->bi_iter.bi_sector - 16;
	29	__entry->nr_sector = bio->bi_iter.bi_size >> 9;
	30	blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_iter.bi_size);
cafe5635 KO	31	),
cafe5635 KO	32
c37511b8	33	TP_printk("%d,%d %s %llu + %u (from %d,%d @ %llu)",
cafe5635	34	MAJOR(__entry->dev), MINOR(__entry->dev),
c37511b8 KO	35	__entry->rwbs, (unsigned long long)__entry->sector,
c37511b8 KO	36	__entry->nr_sector, __entry->orig_major, __entry->orig_minor,
cafe5635 KO	37	(unsigned long long)__entry->orig_sector)
	38	);
	39
c37511b8 KO	40	DECLARE_EVENT_CLASS(bkey,
	41	TP_PROTO(struct bkey *k),
	42	TP_ARGS(k),
cafe5635	43
c37511b8 KO	44	TP_STRUCT__entry(
	45	__field(u32, size )
	46	__field(u32, inode )
	47	__field(u64, offset )
	48	__field(bool, dirty )
	49	),
cafe5635	50
c37511b8 KO	51	TP_fast_assign(
	52	__entry->inode = KEY_INODE(k);
	53	__entry->offset = KEY_OFFSET(k);
	54	__entry->size = KEY_SIZE(k);
	55	__entry->dirty = KEY_DIRTY(k);
	56	),
	57
	58	TP_printk("%u:%llu len %u dirty %u", __entry->inode,
	59	__entry->offset, __entry->size, __entry->dirty)
cafe5635 KO	60	);
cafe5635 KO	61
c37511b8 KO	62	DECLARE_EVENT_CLASS(btree_node,
	63	TP_PROTO(struct btree *b),
	64	TP_ARGS(b),
	65
	66	TP_STRUCT__entry(
	67	__field(size_t, bucket )
	68	),
	69
	70	TP_fast_assign(
	71	__entry->bucket = PTR_BUCKET_NR(b->c, &b->key, 0);
	72	),
cafe5635	73
c37511b8 KO	74	TP_printk("bucket %zu", __entry->bucket)
	75	);
	76
	77	/* request.c */
	78
	79	DEFINE_EVENT(bcache_request, bcache_request_start,
220bb38c KO	80	TP_PROTO(struct bcache_device d, struct bio bio),
220bb38c KO	81	TP_ARGS(d, bio)
c37511b8	82	);
cafe5635	83
c37511b8	84	DEFINE_EVENT(bcache_request, bcache_request_end,
220bb38c KO	85	TP_PROTO(struct bcache_device d, struct bio bio),
220bb38c KO	86	TP_ARGS(d, bio)
cafe5635 KO	87	);
	88
	89	DECLARE_EVENT_CLASS(bcache_bio,
cafe5635	90	TP_PROTO(struct bio *bio),
cafe5635 KO	91	TP_ARGS(bio),
	92
	93	TP_STRUCT__entry(
	94	__field(dev_t, dev )
	95	__field(sector_t, sector )
	96	__field(unsigned int, nr_sector )
	97	__array(char, rwbs, 6 )
cafe5635 KO	98	),
	99
	100	TP_fast_assign(
	101	__entry->dev = bio->bi_bdev->bd_dev;
4f024f37 KO	102	__entry->sector = bio->bi_iter.bi_sector;
	103	__entry->nr_sector = bio->bi_iter.bi_size >> 9;
	104	blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_iter.bi_size);
cafe5635 KO	105	),
cafe5635 KO	106
c37511b8 KO	107	TP_printk("%d,%d %s %llu + %u",
	108	MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
	109	(unsigned long long)__entry->sector, __entry->nr_sector)
cafe5635 KO	110	);
cafe5635 KO	111
c37511b8	112	DEFINE_EVENT(bcache_bio, bcache_bypass_sequential,
cafe5635	113	TP_PROTO(struct bio *bio),
cafe5635 KO	114	TP_ARGS(bio)
	115	);
	116
c37511b8	117	DEFINE_EVENT(bcache_bio, bcache_bypass_congested,
cafe5635	118	TP_PROTO(struct bio *bio),
cafe5635 KO	119	TP_ARGS(bio)
	120	);
	121
c37511b8 KO	122	TRACE_EVENT(bcache_read,
	123	TP_PROTO(struct bio *bio, bool hit, bool bypass),
	124	TP_ARGS(bio, hit, bypass),
cafe5635	125
c37511b8 KO	126	TP_STRUCT__entry(
	127	__field(dev_t, dev )
	128	__field(sector_t, sector )
	129	__field(unsigned int, nr_sector )
	130	__array(char, rwbs, 6 )
	131	__field(bool, cache_hit )
	132	__field(bool, bypass )
	133	),
cafe5635	134
c37511b8 KO	135	TP_fast_assign(
c37511b8 KO	136	__entry->dev = bio->bi_bdev->bd_dev;
4f024f37 KO	137	__entry->sector = bio->bi_iter.bi_sector;
	138	__entry->nr_sector = bio->bi_iter.bi_size >> 9;
	139	blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_iter.bi_size);
c37511b8 KO	140	__entry->cache_hit = hit;
	141	__entry->bypass = bypass;
	142	),
	143
	144	TP_printk("%d,%d %s %llu + %u hit %u bypass %u",
	145	MAJOR(__entry->dev), MINOR(__entry->dev),
	146	__entry->rwbs, (unsigned long long)__entry->sector,
	147	__entry->nr_sector, __entry->cache_hit, __entry->bypass)
cafe5635 KO	148	);
cafe5635 KO	149
c37511b8 KO	150	TRACE_EVENT(bcache_write,
	151	TP_PROTO(struct bio *bio, bool writeback, bool bypass),
	152	TP_ARGS(bio, writeback, bypass),
cafe5635	153
c37511b8 KO	154	TP_STRUCT__entry(
	155	__field(dev_t, dev )
	156	__field(sector_t, sector )
	157	__field(unsigned int, nr_sector )
	158	__array(char, rwbs, 6 )
	159	__field(bool, writeback )
	160	__field(bool, bypass )
	161	),
cafe5635	162
c37511b8 KO	163	TP_fast_assign(
c37511b8 KO	164	__entry->dev = bio->bi_bdev->bd_dev;
4f024f37 KO	165	__entry->sector = bio->bi_iter.bi_sector;
	166	__entry->nr_sector = bio->bi_iter.bi_size >> 9;
	167	blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_iter.bi_size);
c37511b8 KO	168	__entry->writeback = writeback;
	169	__entry->bypass = bypass;
	170	),
cafe5635	171
c37511b8 KO	172	TP_printk("%d,%d %s %llu + %u hit %u bypass %u",
	173	MAJOR(__entry->dev), MINOR(__entry->dev),
	174	__entry->rwbs, (unsigned long long)__entry->sector,
	175	__entry->nr_sector, __entry->writeback, __entry->bypass)
	176	);
cafe5635	177
c37511b8	178	DEFINE_EVENT(bcache_bio, bcache_read_retry,
cafe5635	179	TP_PROTO(struct bio *bio),
cafe5635 KO	180	TP_ARGS(bio)
	181	);
	182
c37511b8 KO	183	DEFINE_EVENT(bkey, bcache_cache_insert,
	184	TP_PROTO(struct bkey *k),
	185	TP_ARGS(k)
	186	);
cafe5635	187
c37511b8	188	/* Journal */
cafe5635	189
c37511b8 KO	190	DECLARE_EVENT_CLASS(cache_set,
	191	TP_PROTO(struct cache_set *c),
	192	TP_ARGS(c),
cafe5635	193
c37511b8 KO	194	TP_STRUCT__entry(
	195	__array(char, uuid, 16 )
	196	),
cafe5635	197
c37511b8 KO	198	TP_fast_assign(
	199	memcpy(__entry->uuid, c->sb.set_uuid, 16);
	200	),
cafe5635	201
c37511b8	202	TP_printk("%pU", __entry->uuid)
cafe5635 KO	203	);
cafe5635 KO	204
c37511b8 KO	205	DEFINE_EVENT(bkey, bcache_journal_replay_key,
	206	TP_PROTO(struct bkey *k),
	207	TP_ARGS(k)
	208	);
cafe5635	209
c37511b8 KO	210	DEFINE_EVENT(cache_set, bcache_journal_full,
	211	TP_PROTO(struct cache_set *c),
	212	TP_ARGS(c)
cafe5635 KO	213	);
cafe5635 KO	214
c37511b8 KO	215	DEFINE_EVENT(cache_set, bcache_journal_entry_full,
	216	TP_PROTO(struct cache_set *c),
	217	TP_ARGS(c)
	218	);
cafe5635	219
c37511b8	220	DEFINE_EVENT(bcache_bio, bcache_journal_write,
cafe5635	221	TP_PROTO(struct bio *bio),
cafe5635 KO	222	TP_ARGS(bio)
	223	);
	224
c37511b8	225	/* Btree */
cafe5635	226
c37511b8 KO	227	DEFINE_EVENT(cache_set, bcache_btree_cache_cannibalize,
	228	TP_PROTO(struct cache_set *c),
	229	TP_ARGS(c)
	230	);
cafe5635	231
c37511b8 KO	232	DEFINE_EVENT(btree_node, bcache_btree_read,
	233	TP_PROTO(struct btree *b),
	234	TP_ARGS(b)
cafe5635 KO	235	);
cafe5635 KO	236
c37511b8 KO	237	TRACE_EVENT(bcache_btree_write,
	238	TP_PROTO(struct btree *b),
	239	TP_ARGS(b),
cafe5635	240
c37511b8 KO	241	TP_STRUCT__entry(
	242	__field(size_t, bucket )
	243	__field(unsigned, block )
	244	__field(unsigned, keys )
	245	),
cafe5635	246
c37511b8 KO	247	TP_fast_assign(
	248	__entry->bucket = PTR_BUCKET_NR(b->c, &b->key, 0);
	249	__entry->block = b->written;
a85e968e	250	__entry->keys = b->keys.set[b->keys.nsets].data->keys;
c37511b8 KO	251	),
	252
	253	TP_printk("bucket %zu", __entry->bucket)
cafe5635 KO	254	);
cafe5635 KO	255
c37511b8 KO	256	DEFINE_EVENT(btree_node, bcache_btree_node_alloc,
	257	TP_PROTO(struct btree *b),
	258	TP_ARGS(b)
	259	);
cafe5635	260
c37511b8 KO	261	DEFINE_EVENT(btree_node, bcache_btree_node_alloc_fail,
	262	TP_PROTO(struct btree *b),
	263	TP_ARGS(b)
	264	);
cafe5635	265
c37511b8 KO	266	DEFINE_EVENT(btree_node, bcache_btree_node_free,
	267	TP_PROTO(struct btree *b),
	268	TP_ARGS(b)
cafe5635 KO	269	);
cafe5635 KO	270
c37511b8 KO	271	TRACE_EVENT(bcache_btree_gc_coalesce,
	272	TP_PROTO(unsigned nodes),
	273	TP_ARGS(nodes),
cafe5635	274
c37511b8 KO	275	TP_STRUCT__entry(
	276	__field(unsigned, nodes )
	277	),
cafe5635	278
c37511b8 KO	279	TP_fast_assign(
	280	__entry->nodes = nodes;
	281	),
cafe5635	282
c37511b8 KO	283	TP_printk("coalesced %u nodes", __entry->nodes)
c37511b8 KO	284	);
cafe5635	285
c37511b8 KO	286	DEFINE_EVENT(cache_set, bcache_gc_start,
	287	TP_PROTO(struct cache_set *c),
	288	TP_ARGS(c)
	289	);
cafe5635	290
c37511b8 KO	291	DEFINE_EVENT(cache_set, bcache_gc_end,
	292	TP_PROTO(struct cache_set *c),
	293	TP_ARGS(c)
cafe5635 KO	294	);
cafe5635 KO	295
c37511b8 KO	296	DEFINE_EVENT(bkey, bcache_gc_copy,
	297	TP_PROTO(struct bkey *k),
	298	TP_ARGS(k)
	299	);
cafe5635	300
c37511b8 KO	301	DEFINE_EVENT(bkey, bcache_gc_copy_collision,
	302	TP_PROTO(struct bkey *k),
	303	TP_ARGS(k)
	304	);
cafe5635	305
85b1492e KO	306	TRACE_EVENT(bcache_btree_insert_key,
	307	TP_PROTO(struct btree b, struct bkey k, unsigned op, unsigned status),
	308	TP_ARGS(b, k, op, status),
	309
	310	TP_STRUCT__entry(
	311	__field(u64, btree_node )
	312	__field(u32, btree_level )
	313	__field(u32, inode )
	314	__field(u64, offset )
	315	__field(u32, size )
	316	__field(u8, dirty )
	317	__field(u8, op )
	318	__field(u8, status )
	319	),
	320
	321	TP_fast_assign(
	322	__entry->btree_node = PTR_BUCKET_NR(b->c, &b->key, 0);
	323	__entry->btree_level = b->level;
	324	__entry->inode = KEY_INODE(k);
	325	__entry->offset = KEY_OFFSET(k);
	326	__entry->size = KEY_SIZE(k);
	327	__entry->dirty = KEY_DIRTY(k);
	328	__entry->op = op;
	329	__entry->status = status;
	330	),
	331
	332	TP_printk("%u for %u at %llu(%u): %u:%llu len %u dirty %u",
	333	__entry->status, __entry->op,
	334	__entry->btree_node, __entry->btree_level,
	335	__entry->inode, __entry->offset,
	336	__entry->size, __entry->dirty)
	337	);
	338
c37511b8 KO	339	DECLARE_EVENT_CLASS(btree_split,
	340	TP_PROTO(struct btree *b, unsigned keys),
	341	TP_ARGS(b, keys),
cafe5635 KO	342
cafe5635 KO	343	TP_STRUCT__entry(
c37511b8 KO	344	__field(size_t, bucket )
c37511b8 KO	345	__field(unsigned, keys )
cafe5635 KO	346	),
	347
	348	TP_fast_assign(
c37511b8 KO	349	__entry->bucket = PTR_BUCKET_NR(b->c, &b->key, 0);
c37511b8 KO	350	__entry->keys = keys;
cafe5635 KO	351	),
cafe5635 KO	352
c37511b8	353	TP_printk("bucket %zu keys %u", __entry->bucket, __entry->keys)
cafe5635 KO	354	);
cafe5635 KO	355
c37511b8 KO	356	DEFINE_EVENT(btree_split, bcache_btree_node_split,
	357	TP_PROTO(struct btree *b, unsigned keys),
	358	TP_ARGS(b, keys)
	359	);
cafe5635	360
c37511b8 KO	361	DEFINE_EVENT(btree_split, bcache_btree_node_compact,
	362	TP_PROTO(struct btree *b, unsigned keys),
	363	TP_ARGS(b, keys)
cafe5635 KO	364	);
cafe5635 KO	365
c37511b8 KO	366	DEFINE_EVENT(btree_node, bcache_btree_set_root,
	367	TP_PROTO(struct btree *b),
	368	TP_ARGS(b)
	369	);
cafe5635	370
48a915a8 KO	371	TRACE_EVENT(bcache_keyscan,
	372	TP_PROTO(unsigned nr_found,
	373	unsigned start_inode, uint64_t start_offset,
	374	unsigned end_inode, uint64_t end_offset),
	375	TP_ARGS(nr_found,
	376	start_inode, start_offset,
	377	end_inode, end_offset),
	378
	379	TP_STRUCT__entry(
	380	__field(__u32, nr_found )
	381	__field(__u32, start_inode )
	382	__field(__u64, start_offset )
	383	__field(__u32, end_inode )
	384	__field(__u64, end_offset )
	385	),
	386
	387	TP_fast_assign(
	388	__entry->nr_found = nr_found;
	389	__entry->start_inode = start_inode;
	390	__entry->start_offset = start_offset;
	391	__entry->end_inode = end_inode;
	392	__entry->end_offset = end_offset;
	393	),
	394
	395	TP_printk("found %u keys from %u:%llu to %u:%llu", __entry->nr_found,
	396	__entry->start_inode, __entry->start_offset,
	397	__entry->end_inode, __entry->end_offset)
	398	);
	399
c37511b8	400	/* Allocator */
cafe5635	401
7159b1ad KO	402	TRACE_EVENT(bcache_invalidate,
	403	TP_PROTO(struct cache *ca, size_t bucket),
	404	TP_ARGS(ca, bucket),
cafe5635 KO	405
cafe5635 KO	406	TP_STRUCT__entry(
7159b1ad KO	407	__field(unsigned, sectors )
	408	__field(dev_t, dev )
	409	__field(__u64, offset )
cafe5635 KO	410	),
	411
	412	TP_fast_assign(
7159b1ad KO	413	__entry->dev = ca->bdev->bd_dev;
	414	__entry->offset = bucket << ca->set->bucket_bits;
	415	__entry->sectors = GC_SECTORS_USED(&ca->buckets[bucket]);
cafe5635 KO	416	),
cafe5635 KO	417
7159b1ad KO	418	TP_printk("invalidated %u sectors at %d,%d sector=%llu",
	419	__entry->sectors, MAJOR(__entry->dev),
	420	MINOR(__entry->dev), __entry->offset)
	421	);
	422
	423	TRACE_EVENT(bcache_alloc,
	424	TP_PROTO(struct cache *ca, size_t bucket),
	425	TP_ARGS(ca, bucket),
	426
	427	TP_STRUCT__entry(
	428	__field(dev_t, dev )
	429	__field(__u64, offset )
	430	),
	431
	432	TP_fast_assign(
	433	__entry->dev = ca->bdev->bd_dev;
	434	__entry->offset = bucket << ca->set->bucket_bits;
	435	),
	436
	437	TP_printk("allocated %d,%d sector=%llu", MAJOR(__entry->dev),
	438	MINOR(__entry->dev), __entry->offset)
cafe5635 KO	439	);
cafe5635 KO	440
c37511b8	441	TRACE_EVENT(bcache_alloc_fail,
78365411 KO	442	TP_PROTO(struct cache *ca, unsigned reserve),
78365411 KO	443	TP_ARGS(ca, reserve),
cafe5635	444
c37511b8	445	TP_STRUCT__entry(
7159b1ad	446	__field(dev_t, dev )
c37511b8 KO	447	__field(unsigned, free )
	448	__field(unsigned, free_inc )
	449	__field(unsigned, unused )
	450	__field(unsigned, blocked )
	451	),
cafe5635	452
c37511b8	453	TP_fast_assign(
7159b1ad	454	__entry->dev = ca->bdev->bd_dev;
78365411	455	__entry->free = fifo_used(&ca->free[reserve]);
c37511b8 KO	456	__entry->free_inc = fifo_used(&ca->free_inc);
	457	__entry->unused = fifo_used(&ca->unused);
	458	__entry->blocked = atomic_read(&ca->set->prio_blocked);
	459	),
cafe5635	460
7159b1ad KO	461	TP_printk("alloc fail %d,%d free %u free_inc %u unused %u blocked %u",
7159b1ad KO	462	MAJOR(__entry->dev), MINOR(__entry->dev), __entry->free,
c37511b8	463	__entry->free_inc, __entry->unused, __entry->blocked)
cafe5635 KO	464	);
cafe5635 KO	465
c37511b8	466	/* Background writeback */
cafe5635	467
c37511b8 KO	468	DEFINE_EVENT(bkey, bcache_writeback,
	469	TP_PROTO(struct bkey *k),
	470	TP_ARGS(k)
	471	);
cafe5635	472
c37511b8 KO	473	DEFINE_EVENT(bkey, bcache_writeback_collision,
	474	TP_PROTO(struct bkey *k),
	475	TP_ARGS(k)
cafe5635 KO	476	);
	477
	478	#endif /* _TRACE_BCACHE_H */
	479
	480	/* This part must be outside protection */
	481	#include <trace/define_trace.h>