[deliverable/linux.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>

struct search;

DECLARE_EVENT_CLASS(bcache_request,
	TP_PROTO(struct search *s, struct bio *bio),
	TP_ARGS(s, 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	= s->d->disk->major;
		__entry->orig_minor	= s->d->disk->first_minor;
		__entry->sector		= bio->bi_sector;
		__entry->orig_sector	= bio->bi_sector - 16;
		__entry->nr_sector	= bio->bi_size >> 9;
		blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->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 search *s, struct bio *bio),
	TP_ARGS(s, bio)
);

DEFINE_EVENT(bcache_request, bcache_request_end,
	TP_PROTO(struct search *s, struct bio *bio),
	TP_ARGS(s, 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_sector;
		__entry->nr_sector	= bio->bi_size >> 9;
		blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->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_sector;
		__entry->nr_sector	= bio->bi_size >> 9;
		blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->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_sector;
		__entry->nr_sector	= bio->bi_size >> 9;
		blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->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->sets[b->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)
);

/* Allocator */

TRACE_EVENT(bcache_alloc_invalidate,
	TP_PROTO(struct cache *ca),
	TP_ARGS(ca),

	TP_STRUCT__entry(
		__field(unsigned,	free			)
		__field(unsigned,	free_inc		)
		__field(unsigned,	free_inc_size		)
		__field(unsigned,	unused			)
	),

	TP_fast_assign(
		__entry->free		= fifo_used(&ca->free);
		__entry->free_inc	= fifo_used(&ca->free_inc);
		__entry->free_inc_size	= ca->free_inc.size;
		__entry->unused		= fifo_used(&ca->unused);
	),

	TP_printk("free %u free_inc %u/%u unused %u", __entry->free,
		  __entry->free_inc, __entry->free_inc_size, __entry->unused)
);

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

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

	TP_fast_assign(
		__entry->free		= fifo_used(&ca->free);
		__entry->free_inc	= fifo_used(&ca->free_inc);
		__entry->unused		= fifo_used(&ca->unused);
		__entry->blocked	= atomic_read(&ca->set->prio_blocked);
	),

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