[mirror_ubuntu-artful-kernel.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_background);
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(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->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 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->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);
71927e84	84	DEFINE_WRITEBACK_EVENT(writeback_wake_background);
60332023 AB	85	DEFINE_WRITEBACK_EVENT(writeback_wake_thread);
60332023 AB	86	DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread);
455b2864 DC	87	DEFINE_WRITEBACK_EVENT(writeback_bdi_register);
	88	DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister);
	89	DEFINE_WRITEBACK_EVENT(writeback_thread_start);
	90	DEFINE_WRITEBACK_EVENT(writeback_thread_stop);
	91
028c2dd1 DC	92	DECLARE_EVENT_CLASS(wbc_class,
	93	TP_PROTO(struct writeback_control wbc, struct backing_dev_info bdi),
	94	TP_ARGS(wbc, bdi),
	95	TP_STRUCT__entry(
	96	__array(char, name, 32)
	97	__field(long, nr_to_write)
	98	__field(long, pages_skipped)
	99	__field(int, sync_mode)
028c2dd1 DC	100	__field(int, for_kupdate)
	101	__field(int, for_background)
	102	__field(int, for_reclaim)
	103	__field(int, range_cyclic)
028c2dd1 DC	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;
028c2dd1 DC	118	__entry->older_than_this = wbc->older_than_this ?
	119	*wbc->older_than_this : 0;
	120	__entry->range_start = (long)wbc->range_start;
	121	__entry->range_end = (long)wbc->range_end;
	122	),
	123
	124	TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
b7a2441f	125	"bgrd=%d reclm=%d cyclic=%d older=0x%lx "
028c2dd1 DC	126	"start=0x%lx end=0x%lx",
	127	__entry->name,
	128	__entry->nr_to_write,
	129	__entry->pages_skipped,
	130	__entry->sync_mode,
	131	__entry->for_kupdate,
	132	__entry->for_background,
	133	__entry->for_reclaim,
	134	__entry->range_cyclic,
028c2dd1 DC	135	__entry->older_than_this,
	136	__entry->range_start,
	137	__entry->range_end)
	138	)
	139
	140	#define DEFINE_WBC_EVENT(name) \
	141	DEFINE_EVENT(wbc_class, name, \
	142	TP_PROTO(struct writeback_control wbc, struct backing_dev_info bdi), \
	143	TP_ARGS(wbc, bdi))
	144	DEFINE_WBC_EVENT(wbc_writeback_start);
	145	DEFINE_WBC_EVENT(wbc_writeback_written);
	146	DEFINE_WBC_EVENT(wbc_writeback_wait);
	147	DEFINE_WBC_EVENT(wbc_balance_dirty_start);
	148	DEFINE_WBC_EVENT(wbc_balance_dirty_written);
	149	DEFINE_WBC_EVENT(wbc_balance_dirty_wait);
9e094383	150	DEFINE_WBC_EVENT(wbc_writepage);
028c2dd1	151
52bb9198 MG	152	DECLARE_EVENT_CLASS(writeback_congest_waited_template,
	153
	154	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
	155
	156	TP_ARGS(usec_timeout, usec_delayed),
	157
	158	TP_STRUCT__entry(
	159	__field( unsigned int, usec_timeout )
	160	__field( unsigned int, usec_delayed )
	161	),
	162
	163	TP_fast_assign(
	164	__entry->usec_timeout = usec_timeout;
	165	__entry->usec_delayed = usec_delayed;
	166	),
	167
	168	TP_printk("usec_timeout=%u usec_delayed=%u",
	169	__entry->usec_timeout,
	170	__entry->usec_delayed)
	171	);
	172
	173	DEFINE_EVENT(writeback_congest_waited_template, writeback_congestion_wait,
	174
	175	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
	176
	177	TP_ARGS(usec_timeout, usec_delayed)
	178	);
	179
0e093d99 MG	180	DEFINE_EVENT(writeback_congest_waited_template, writeback_wait_iff_congested,
	181
	182	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
	183
	184	TP_ARGS(usec_timeout, usec_delayed)
	185	);
	186
455b2864 DC	187	#endif /* _TRACE_WRITEBACK_H */
	188
	189	/* This part must be outside protection */
	190	#include <trace/define_trace.h>