[mirror_ubuntu-artful-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_op(bio), 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_op(bio), 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_op(bio), 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 cache_set *c, u64 inode, struct bio *bio,
		bool writeback, bool bypass),
	TP_ARGS(c, inode, bio, writeback, bypass),

	TP_STRUCT__entry(
		__array(char,		uuid,	16		)
		__field(u64,		inode			)
		__field(sector_t,	sector			)
		__field(unsigned int,	nr_sector		)
		__array(char,		rwbs,	6		)
		__field(bool,		writeback		)
		__field(bool,		bypass			)
	),

	TP_fast_assign(
		memcpy(__entry->uuid, c->sb.set_uuid, 16);
		__entry->inode		= inode;
		__entry->sector		= bio->bi_iter.bi_sector;
		__entry->nr_sector	= bio->bi_iter.bi_size >> 9;
		blk_fill_rwbs(__entry->rwbs, bio_op(bio), bio->bi_rw,
			      bio->bi_iter.bi_size);
		__entry->writeback = writeback;
		__entry->bypass = bypass;
	),

	TP_printk("%pU inode %llu  %s %llu + %u hit %u bypass %u",
		  __entry->uuid, __entry->inode,
		  __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(cache_set, bcache_btree_node_alloc_fail,
	TP_PROTO(struct cache_set *c),
	TP_ARGS(c)
);

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,	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->blocked	= atomic_read(&ca->set->prio_blocked);
	),

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