[net-next-2.6.git] / include / trace / events / writeback.h

#undef TRACE_SYSTEM
#define TRACE_SYSTEM writeback

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

#include <linux/backing-dev.h>
#include <linux/device.h>
#include <linux/writeback.h>

struct wb_writeback_work;

DECLARE_EVENT_CLASS(writeback_work_class,
	TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
	TP_ARGS(bdi, work),
	TP_STRUCT__entry(
		__array(char, name, 32)
		__field(long, nr_pages)
		__field(dev_t, sb_dev)
		__field(int, sync_mode)
		__field(int, for_kupdate)
		__field(int, range_cyclic)
		__field(int, for_background)
	),
	TP_fast_assign(
		strncpy(__entry->name, dev_name(bdi->dev), 32);
		__entry->nr_pages = work->nr_pages;
		__entry->sb_dev = work->sb ? work->sb->s_dev : 0;
		__entry->sync_mode = work->sync_mode;
		__entry->for_kupdate = work->for_kupdate;
		__entry->range_cyclic = work->range_cyclic;
		__entry->for_background	= work->for_background;
	),
	TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
		  "kupdate=%d range_cyclic=%d background=%d",
		  __entry->name,
		  MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
		  __entry->nr_pages,
		  __entry->sync_mode,
		  __entry->for_kupdate,
		  __entry->range_cyclic,
		  __entry->for_background
	)
);
#define DEFINE_WRITEBACK_WORK_EVENT(name) \
DEFINE_EVENT(writeback_work_class, name, \
	TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work), \
	TP_ARGS(bdi, work))
DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread);
DEFINE_WRITEBACK_WORK_EVENT(writeback_queue);
DEFINE_WRITEBACK_WORK_EVENT(writeback_exec);

TRACE_EVENT(writeback_pages_written,
	TP_PROTO(long pages_written),
	TP_ARGS(pages_written),
	TP_STRUCT__entry(
		__field(long,		pages)
	),
	TP_fast_assign(
		__entry->pages		= pages_written;
	),
	TP_printk("%ld", __entry->pages)
);

DECLARE_EVENT_CLASS(writeback_class,
	TP_PROTO(struct backing_dev_info *bdi),
	TP_ARGS(bdi),
	TP_STRUCT__entry(
		__array(char, name, 32)
	),
	TP_fast_assign(
		strncpy(__entry->name, dev_name(bdi->dev), 32);
	),
	TP_printk("bdi %s",
		  __entry->name
	)
);
#define DEFINE_WRITEBACK_EVENT(name) \
DEFINE_EVENT(writeback_class, name, \
	TP_PROTO(struct backing_dev_info *bdi), \
	TP_ARGS(bdi))

DEFINE_WRITEBACK_EVENT(writeback_nowork);
DEFINE_WRITEBACK_EVENT(writeback_wake_thread);
DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread);
DEFINE_WRITEBACK_EVENT(writeback_bdi_register);
DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister);
DEFINE_WRITEBACK_EVENT(writeback_thread_start);
DEFINE_WRITEBACK_EVENT(writeback_thread_stop);

DECLARE_EVENT_CLASS(wbc_class,
	TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
	TP_ARGS(wbc, bdi),
	TP_STRUCT__entry(
		__array(char, name, 32)
		__field(long, nr_to_write)
		__field(long, pages_skipped)
		__field(int, sync_mode)
		__field(int, for_kupdate)
		__field(int, for_background)
		__field(int, for_reclaim)
		__field(int, range_cyclic)
		__field(int, more_io)
		__field(unsigned long, older_than_this)
		__field(long, range_start)
		__field(long, range_end)
	),

	TP_fast_assign(
		strncpy(__entry->name, dev_name(bdi->dev), 32);
		__entry->nr_to_write	= wbc->nr_to_write;
		__entry->pages_skipped	= wbc->pages_skipped;
		__entry->sync_mode	= wbc->sync_mode;
		__entry->for_kupdate	= wbc->for_kupdate;
		__entry->for_background	= wbc->for_background;
		__entry->for_reclaim	= wbc->for_reclaim;
		__entry->range_cyclic	= wbc->range_cyclic;
		__entry->more_io	= wbc->more_io;
		__entry->older_than_this = wbc->older_than_this ?
						*wbc->older_than_this : 0;
		__entry->range_start	= (long)wbc->range_start;
		__entry->range_end	= (long)wbc->range_end;
	),

	TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
		"bgrd=%d reclm=%d cyclic=%d more=%d older=0x%lx "
		"start=0x%lx end=0x%lx",
		__entry->name,
		__entry->nr_to_write,
		__entry->pages_skipped,
		__entry->sync_mode,
		__entry->for_kupdate,
		__entry->for_background,
		__entry->for_reclaim,
		__entry->range_cyclic,
		__entry->more_io,
		__entry->older_than_this,
		__entry->range_start,
		__entry->range_end)
)

#define DEFINE_WBC_EVENT(name) \
DEFINE_EVENT(wbc_class, name, \
	TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
	TP_ARGS(wbc, bdi))
DEFINE_WBC_EVENT(wbc_writeback_start);
DEFINE_WBC_EVENT(wbc_writeback_written);
DEFINE_WBC_EVENT(wbc_writeback_wait);
DEFINE_WBC_EVENT(wbc_balance_dirty_start);
DEFINE_WBC_EVENT(wbc_balance_dirty_written);
DEFINE_WBC_EVENT(wbc_balance_dirty_wait);
DEFINE_WBC_EVENT(wbc_writepage);

DECLARE_EVENT_CLASS(writeback_congest_waited_template,

	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),

	TP_ARGS(usec_timeout, usec_delayed),

	TP_STRUCT__entry(
		__field(	unsigned int,	usec_timeout	)
		__field(	unsigned int,	usec_delayed	)
	),

	TP_fast_assign(
		__entry->usec_timeout	= usec_timeout;
		__entry->usec_delayed	= usec_delayed;
	),

	TP_printk("usec_timeout=%u usec_delayed=%u",
			__entry->usec_timeout,
			__entry->usec_delayed)
);

DEFINE_EVENT(writeback_congest_waited_template, writeback_congestion_wait,

	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),

	TP_ARGS(usec_timeout, usec_delayed)
);

DEFINE_EVENT(writeback_congest_waited_template, writeback_wait_iff_congested,

	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),

	TP_ARGS(usec_timeout, usec_delayed)
);

#endif /* _TRACE_WRITEBACK_H */

/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
455b2864 DC	1	#undef TRACE_SYSTEM
	2	#define TRACE_SYSTEM writeback
	3
	4	#if !defined(_TRACE_WRITEBACK_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	5	#define _TRACE_WRITEBACK_H
	6
	7	#include <linux/backing-dev.h>
96dccab1	8	#include <linux/device.h>
455b2864 DC	9	#include <linux/writeback.h>
	10
	11	struct wb_writeback_work;
	12
	13	DECLARE_EVENT_CLASS(writeback_work_class,
	14	TP_PROTO(struct backing_dev_info bdi, struct wb_writeback_work work),
	15	TP_ARGS(bdi, work),
	16	TP_STRUCT__entry(
	17	__array(char, name, 32)
	18	__field(long, nr_pages)
	19	__field(dev_t, sb_dev)
	20	__field(int, sync_mode)
	21	__field(int, for_kupdate)
	22	__field(int, range_cyclic)
	23	__field(int, for_background)
	24	),
	25	TP_fast_assign(
	26	strncpy(__entry->name, dev_name(bdi->dev), 32);
	27	__entry->nr_pages = work->nr_pages;
	28	__entry->sb_dev = work->sb ? work->sb->s_dev : 0;
	29	__entry->sync_mode = work->sync_mode;
	30	__entry->for_kupdate = work->for_kupdate;
	31	__entry->range_cyclic = work->range_cyclic;
	32	__entry->for_background = work->for_background;
	33	),
	34	TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
	35	"kupdate=%d range_cyclic=%d background=%d",
	36	__entry->name,
	37	MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
	38	__entry->nr_pages,
	39	__entry->sync_mode,
	40	__entry->for_kupdate,
	41	__entry->range_cyclic,
	42	__entry->for_background
	43	)
	44	);
	45	#define DEFINE_WRITEBACK_WORK_EVENT(name) \
	46	DEFINE_EVENT(writeback_work_class, name, \
	47	TP_PROTO(struct backing_dev_info bdi, struct wb_writeback_work work), \
	48	TP_ARGS(bdi, work))
	49	DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread);
	50	DEFINE_WRITEBACK_WORK_EVENT(writeback_queue);
	51	DEFINE_WRITEBACK_WORK_EVENT(writeback_exec);
	52
	53	TRACE_EVENT(writeback_pages_written,
	54	TP_PROTO(long pages_written),
	55	TP_ARGS(pages_written),
	56	TP_STRUCT__entry(
	57	__field(long, pages)
	58	),
	59	TP_fast_assign(
	60	__entry->pages = pages_written;
	61	),
	62	TP_printk("%ld", __entry->pages)
	63	);
	64
	65	DECLARE_EVENT_CLASS(writeback_class,
	66	TP_PROTO(struct backing_dev_info *bdi),
	67	TP_ARGS(bdi),
	68	TP_STRUCT__entry(
	69	__array(char, name, 32)
	70	),
	71	TP_fast_assign(
	72	strncpy(__entry->name, dev_name(bdi->dev), 32);
73	),
74	TP_printk("bdi %s",
75	__entry->name
76	)
77	);
78	#define DEFINE_WRITEBACK_EVENT(name) \
79	DEFINE_EVENT(writeback_class, name, \
80	TP_PROTO(struct backing_dev_info *bdi), \
81	TP_ARGS(bdi))
82
83	DEFINE_WRITEBACK_EVENT(writeback_nowork);
60332023 AB	84	DEFINE_WRITEBACK_EVENT(writeback_wake_thread);
60332023 AB	85	DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread);
455b2864 DC	86	DEFINE_WRITEBACK_EVENT(writeback_bdi_register);
	87	DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister);
	88	DEFINE_WRITEBACK_EVENT(writeback_thread_start);
	89	DEFINE_WRITEBACK_EVENT(writeback_thread_stop);
	90
028c2dd1 DC	91	DECLARE_EVENT_CLASS(wbc_class,
	92	TP_PROTO(struct writeback_control wbc, struct backing_dev_info bdi),
	93	TP_ARGS(wbc, bdi),
	94	TP_STRUCT__entry(
	95	__array(char, name, 32)
	96	__field(long, nr_to_write)
	97	__field(long, pages_skipped)
	98	__field(int, sync_mode)
028c2dd1 DC	99	__field(int, for_kupdate)
	100	__field(int, for_background)
	101	__field(int, for_reclaim)
	102	__field(int, range_cyclic)
	103	__field(int, more_io)
	104	__field(unsigned long, older_than_this)
	105	__field(long, range_start)
	106	__field(long, range_end)
	107	),
	108
	109	TP_fast_assign(
	110	strncpy(__entry->name, dev_name(bdi->dev), 32);
	111	__entry->nr_to_write = wbc->nr_to_write;
	112	__entry->pages_skipped = wbc->pages_skipped;
	113	__entry->sync_mode = wbc->sync_mode;
	114	__entry->for_kupdate = wbc->for_kupdate;
	115	__entry->for_background = wbc->for_background;
	116	__entry->for_reclaim = wbc->for_reclaim;
	117	__entry->range_cyclic = wbc->range_cyclic;
	118	__entry->more_io = wbc->more_io;
	119	__entry->older_than_this = wbc->older_than_this ?
	120	*wbc->older_than_this : 0;
	121	__entry->range_start = (long)wbc->range_start;
	122	__entry->range_end = (long)wbc->range_end;
	123	),
	124
	125	TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
	126	"bgrd=%d reclm=%d cyclic=%d more=%d older=0x%lx "
	127	"start=0x%lx end=0x%lx",
	128	__entry->name,
	129	__entry->nr_to_write,
	130	__entry->pages_skipped,
	131	__entry->sync_mode,
	132	__entry->for_kupdate,
	133	__entry->for_background,
	134	__entry->for_reclaim,
	135	__entry->range_cyclic,
	136	__entry->more_io,
	137	__entry->older_than_this,
	138	__entry->range_start,
	139	__entry->range_end)
	140	)
	141
	142	#define DEFINE_WBC_EVENT(name) \
	143	DEFINE_EVENT(wbc_class, name, \
	144	TP_PROTO(struct writeback_control wbc, struct backing_dev_info bdi), \
	145	TP_ARGS(wbc, bdi))
	146	DEFINE_WBC_EVENT(wbc_writeback_start);
	147	DEFINE_WBC_EVENT(wbc_writeback_written);
	148	DEFINE_WBC_EVENT(wbc_writeback_wait);
	149	DEFINE_WBC_EVENT(wbc_balance_dirty_start);
	150	DEFINE_WBC_EVENT(wbc_balance_dirty_written);
	151	DEFINE_WBC_EVENT(wbc_balance_dirty_wait);
9e094383	152	DEFINE_WBC_EVENT(wbc_writepage);
028c2dd1	153
52bb9198 MG	154	DECLARE_EVENT_CLASS(writeback_congest_waited_template,
	155
	156	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
	157
	158	TP_ARGS(usec_timeout, usec_delayed),
	159
	160	TP_STRUCT__entry(
	161	__field( unsigned int, usec_timeout )
	162	__field( unsigned int, usec_delayed )
	163	),
	164
	165	TP_fast_assign(
	166	__entry->usec_timeout = usec_timeout;
	167	__entry->usec_delayed = usec_delayed;
	168	),
	169
	170	TP_printk("usec_timeout=%u usec_delayed=%u",
	171	__entry->usec_timeout,
	172	__entry->usec_delayed)
	173	);
	174
	175	DEFINE_EVENT(writeback_congest_waited_template, writeback_congestion_wait,
	176
	177	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
	178
	179	TP_ARGS(usec_timeout, usec_delayed)
	180	);
	181
0e093d99 MG	182	DEFINE_EVENT(writeback_congest_waited_template, writeback_wait_iff_congested,
	183
	184	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
	185
	186	TP_ARGS(usec_timeout, usec_delayed)
	187	);
	188
455b2864 DC	189	#endif /* _TRACE_WRITEBACK_H */
	190
	191	/* This part must be outside protection */
	192	#include <trace/define_trace.h>