[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>

#define show_inode_state(state)					\
	__print_flags(state, "|",				\
		{I_DIRTY_SYNC,		"I_DIRTY_SYNC"},	\
		{I_DIRTY_DATASYNC,	"I_DIRTY_DATASYNC"},	\
		{I_DIRTY_PAGES,		"I_DIRTY_PAGES"},	\
		{I_NEW,			"I_NEW"},		\
		{I_WILL_FREE,		"I_WILL_FREE"},		\
		{I_FREEING,		"I_FREEING"},		\
		{I_CLEAR,		"I_CLEAR"},		\
		{I_SYNC,		"I_SYNC"},		\
		{I_REFERENCED,		"I_REFERENCED"}		\
	)

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);
DEFINE_WRITEBACK_WORK_EVENT(writeback_start);
DEFINE_WRITEBACK_WORK_EVENT(writeback_written);
DEFINE_WRITEBACK_WORK_EVENT(writeback_wait);

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(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->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 "
		"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->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_writepage);

TRACE_EVENT(writeback_queue_io,
	TP_PROTO(struct bdi_writeback *wb,
		 unsigned long *older_than_this,
		 int moved),
	TP_ARGS(wb, older_than_this, moved),
	TP_STRUCT__entry(
		__array(char,		name, 32)
		__field(unsigned long,	older)
		__field(long,		age)
		__field(int,		moved)
	),
	TP_fast_assign(
		strncpy(__entry->name, dev_name(wb->bdi->dev), 32);
		__entry->older	= older_than_this ?  *older_than_this : 0;
		__entry->age	= older_than_this ?
				  (jiffies - *older_than_this) * 1000 / HZ : -1;
		__entry->moved	= moved;
	),
	TP_printk("bdi %s: older=%lu age=%ld enqueue=%d",
		__entry->name,
		__entry->older,	/* older_than_this in jiffies */
		__entry->age,	/* older_than_this in relative milliseconds */
		__entry->moved)
);

TRACE_EVENT(global_dirty_state,

	TP_PROTO(unsigned long background_thresh,
		 unsigned long dirty_thresh
	),

	TP_ARGS(background_thresh,
		dirty_thresh
	),

	TP_STRUCT__entry(
		__field(unsigned long,	nr_dirty)
		__field(unsigned long,	nr_writeback)
		__field(unsigned long,	nr_unstable)
		__field(unsigned long,	background_thresh)
		__field(unsigned long,	dirty_thresh)
		__field(unsigned long,	dirty_limit)
		__field(unsigned long,	nr_dirtied)
		__field(unsigned long,	nr_written)
	),

	TP_fast_assign(
		__entry->nr_dirty	= global_page_state(NR_FILE_DIRTY);
		__entry->nr_writeback	= global_page_state(NR_WRITEBACK);
		__entry->nr_unstable	= global_page_state(NR_UNSTABLE_NFS);
		__entry->nr_dirtied	= global_page_state(NR_DIRTIED);
		__entry->nr_written	= global_page_state(NR_WRITTEN);
		__entry->background_thresh = background_thresh;
		__entry->dirty_thresh	= dirty_thresh;
		__entry->dirty_limit = global_dirty_limit;
	),

	TP_printk("dirty=%lu writeback=%lu unstable=%lu "
		  "bg_thresh=%lu thresh=%lu limit=%lu "
		  "dirtied=%lu written=%lu",
		  __entry->nr_dirty,
		  __entry->nr_writeback,
		  __entry->nr_unstable,
		  __entry->background_thresh,
		  __entry->dirty_thresh,
		  __entry->dirty_limit,
		  __entry->nr_dirtied,
		  __entry->nr_written
	)
);

#define KBps(x)			((x) << (PAGE_SHIFT - 10))

TRACE_EVENT(bdi_dirty_ratelimit,

	TP_PROTO(struct backing_dev_info *bdi,
		 unsigned long dirty_rate,
		 unsigned long task_ratelimit),

	TP_ARGS(bdi, dirty_rate, task_ratelimit),

	TP_STRUCT__entry(
		__array(char,		bdi, 32)
		__field(unsigned long,	write_bw)
		__field(unsigned long,	avg_write_bw)
		__field(unsigned long,	dirty_rate)
		__field(unsigned long,	dirty_ratelimit)
		__field(unsigned long,	task_ratelimit)
		__field(unsigned long,	balanced_dirty_ratelimit)
	),

	TP_fast_assign(
		strlcpy(__entry->bdi, dev_name(bdi->dev), 32);
		__entry->write_bw	= KBps(bdi->write_bandwidth);
		__entry->avg_write_bw	= KBps(bdi->avg_write_bandwidth);
		__entry->dirty_rate	= KBps(dirty_rate);
		__entry->dirty_ratelimit = KBps(bdi->dirty_ratelimit);
		__entry->task_ratelimit	= KBps(task_ratelimit);
		__entry->balanced_dirty_ratelimit =
					  KBps(bdi->balanced_dirty_ratelimit);
	),

	TP_printk("bdi %s: "
		  "write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
		  "dirty_ratelimit=%lu task_ratelimit=%lu "
		  "balanced_dirty_ratelimit=%lu",
		  __entry->bdi,
		  __entry->write_bw,		/* write bandwidth */
		  __entry->avg_write_bw,	/* avg write bandwidth */
		  __entry->dirty_rate,		/* bdi dirty rate */
		  __entry->dirty_ratelimit,	/* base ratelimit */
		  __entry->task_ratelimit, /* ratelimit with position control */
		  __entry->balanced_dirty_ratelimit /* the balanced ratelimit */
	)
);

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)
);

DECLARE_EVENT_CLASS(writeback_single_inode_template,

	TP_PROTO(struct inode *inode,
		 struct writeback_control *wbc,
		 unsigned long nr_to_write
	),

	TP_ARGS(inode, wbc, nr_to_write),

	TP_STRUCT__entry(
		__array(char, name, 32)
		__field(unsigned long, ino)
		__field(unsigned long, state)
		__field(unsigned long, dirtied_when)
		__field(unsigned long, writeback_index)
		__field(long, nr_to_write)
		__field(unsigned long, wrote)
	),

	TP_fast_assign(
		strncpy(__entry->name,
			dev_name(inode->i_mapping->backing_dev_info->dev), 32);
		__entry->ino		= inode->i_ino;
		__entry->state		= inode->i_state;
		__entry->dirtied_when	= inode->dirtied_when;
		__entry->writeback_index = inode->i_mapping->writeback_index;
		__entry->nr_to_write	= nr_to_write;
		__entry->wrote		= nr_to_write - wbc->nr_to_write;
	),

	TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu "
		  "index=%lu to_write=%ld wrote=%lu",
		  __entry->name,
		  __entry->ino,
		  show_inode_state(__entry->state),
		  __entry->dirtied_when,
		  (jiffies - __entry->dirtied_when) / HZ,
		  __entry->writeback_index,
		  __entry->nr_to_write,
		  __entry->wrote
	)
);

DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode_requeue,
	TP_PROTO(struct inode *inode,
		 struct writeback_control *wbc,
		 unsigned long nr_to_write),
	TP_ARGS(inode, wbc, nr_to_write)
);

DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode,
	TP_PROTO(struct inode *inode,
		 struct writeback_control *wbc,
		 unsigned long nr_to_write),
	TP_ARGS(inode, wbc, nr_to_write)
);

#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>
455b2864 DC	10
251d6a47 WF	11	#define show_inode_state(state) \
	12	__print_flags(state, "\|", \
	13	{I_DIRTY_SYNC, "I_DIRTY_SYNC"}, \
	14	{I_DIRTY_DATASYNC, "I_DIRTY_DATASYNC"}, \
	15	{I_DIRTY_PAGES, "I_DIRTY_PAGES"}, \
	16	{I_NEW, "I_NEW"}, \
	17	{I_WILL_FREE, "I_WILL_FREE"}, \
	18	{I_FREEING, "I_FREEING"}, \
	19	{I_CLEAR, "I_CLEAR"}, \
	20	{I_SYNC, "I_SYNC"}, \
	21	{I_REFERENCED, "I_REFERENCED"} \
	22	)
	23
455b2864 DC	24	struct wb_writeback_work;
	25
	26	DECLARE_EVENT_CLASS(writeback_work_class,
	27	TP_PROTO(struct backing_dev_info bdi, struct wb_writeback_work work),
	28	TP_ARGS(bdi, work),
	29	TP_STRUCT__entry(
	30	__array(char, name, 32)
	31	__field(long, nr_pages)
	32	__field(dev_t, sb_dev)
	33	__field(int, sync_mode)
	34	__field(int, for_kupdate)
	35	__field(int, range_cyclic)
	36	__field(int, for_background)
	37	),
	38	TP_fast_assign(
	39	strncpy(__entry->name, dev_name(bdi->dev), 32);
	40	__entry->nr_pages = work->nr_pages;
	41	__entry->sb_dev = work->sb ? work->sb->s_dev : 0;
	42	__entry->sync_mode = work->sync_mode;
	43	__entry->for_kupdate = work->for_kupdate;
	44	__entry->range_cyclic = work->range_cyclic;
	45	__entry->for_background = work->for_background;
	46	),
	47	TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
	48	"kupdate=%d range_cyclic=%d background=%d",
	49	__entry->name,
	50	MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
	51	__entry->nr_pages,
	52	__entry->sync_mode,
	53	__entry->for_kupdate,
	54	__entry->range_cyclic,
	55	__entry->for_background
	56	)
	57	);
	58	#define DEFINE_WRITEBACK_WORK_EVENT(name) \
	59	DEFINE_EVENT(writeback_work_class, name, \
	60	TP_PROTO(struct backing_dev_info bdi, struct wb_writeback_work work), \
	61	TP_ARGS(bdi, work))
	62	DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread);
	63	DEFINE_WRITEBACK_WORK_EVENT(writeback_queue);
	64	DEFINE_WRITEBACK_WORK_EVENT(writeback_exec);
d46db3d5 WF	65	DEFINE_WRITEBACK_WORK_EVENT(writeback_start);
	66	DEFINE_WRITEBACK_WORK_EVENT(writeback_written);
	67	DEFINE_WRITEBACK_WORK_EVENT(writeback_wait);
455b2864 DC	68
	69	TRACE_EVENT(writeback_pages_written,
	70	TP_PROTO(long pages_written),
	71	TP_ARGS(pages_written),
	72	TP_STRUCT__entry(
	73	__field(long, pages)
	74	),
	75	TP_fast_assign(
	76	__entry->pages = pages_written;
	77	),
	78	TP_printk("%ld", __entry->pages)
	79	);
	80
	81	DECLARE_EVENT_CLASS(writeback_class,
	82	TP_PROTO(struct backing_dev_info *bdi),
	83	TP_ARGS(bdi),
	84	TP_STRUCT__entry(
	85	__array(char, name, 32)
	86	),
	87	TP_fast_assign(
	88	strncpy(__entry->name, dev_name(bdi->dev), 32);
	89	),
	90	TP_printk("bdi %s",
	91	__entry->name
	92	)
	93	);
	94	#define DEFINE_WRITEBACK_EVENT(name) \
	95	DEFINE_EVENT(writeback_class, name, \
	96	TP_PROTO(struct backing_dev_info *bdi), \
	97	TP_ARGS(bdi))
	98
	99	DEFINE_WRITEBACK_EVENT(writeback_nowork);
71927e84	100	DEFINE_WRITEBACK_EVENT(writeback_wake_background);
60332023 AB	101	DEFINE_WRITEBACK_EVENT(writeback_wake_thread);
60332023 AB	102	DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread);
455b2864 DC	103	DEFINE_WRITEBACK_EVENT(writeback_bdi_register);
	104	DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister);
	105	DEFINE_WRITEBACK_EVENT(writeback_thread_start);
	106	DEFINE_WRITEBACK_EVENT(writeback_thread_stop);
	107
028c2dd1 DC	108	DECLARE_EVENT_CLASS(wbc_class,
	109	TP_PROTO(struct writeback_control wbc, struct backing_dev_info bdi),
	110	TP_ARGS(wbc, bdi),
	111	TP_STRUCT__entry(
	112	__array(char, name, 32)
	113	__field(long, nr_to_write)
	114	__field(long, pages_skipped)
	115	__field(int, sync_mode)
028c2dd1 DC	116	__field(int, for_kupdate)
	117	__field(int, for_background)
	118	__field(int, for_reclaim)
	119	__field(int, range_cyclic)
028c2dd1 DC	120	__field(long, range_start)
	121	__field(long, range_end)
	122	),
	123
	124	TP_fast_assign(
	125	strncpy(__entry->name, dev_name(bdi->dev), 32);
	126	__entry->nr_to_write = wbc->nr_to_write;
	127	__entry->pages_skipped = wbc->pages_skipped;
	128	__entry->sync_mode = wbc->sync_mode;
	129	__entry->for_kupdate = wbc->for_kupdate;
	130	__entry->for_background = wbc->for_background;
	131	__entry->for_reclaim = wbc->for_reclaim;
	132	__entry->range_cyclic = wbc->range_cyclic;
028c2dd1 DC	133	__entry->range_start = (long)wbc->range_start;
	134	__entry->range_end = (long)wbc->range_end;
	135	),
	136
	137	TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
d46db3d5	138	"bgrd=%d reclm=%d cyclic=%d "
028c2dd1 DC	139	"start=0x%lx end=0x%lx",
	140	__entry->name,
	141	__entry->nr_to_write,
	142	__entry->pages_skipped,
	143	__entry->sync_mode,
	144	__entry->for_kupdate,
	145	__entry->for_background,
	146	__entry->for_reclaim,
	147	__entry->range_cyclic,
028c2dd1 DC	148	__entry->range_start,
	149	__entry->range_end)
	150	)
	151
	152	#define DEFINE_WBC_EVENT(name) \
	153	DEFINE_EVENT(wbc_class, name, \
	154	TP_PROTO(struct writeback_control wbc, struct backing_dev_info bdi), \
	155	TP_ARGS(wbc, bdi))
9e094383	156	DEFINE_WBC_EVENT(wbc_writepage);
028c2dd1	157
e84d0a4f WF	158	TRACE_EVENT(writeback_queue_io,
	159	TP_PROTO(struct bdi_writeback *wb,
	160	unsigned long *older_than_this,
	161	int moved),
	162	TP_ARGS(wb, older_than_this, moved),
	163	TP_STRUCT__entry(
	164	__array(char, name, 32)
	165	__field(unsigned long, older)
	166	__field(long, age)
	167	__field(int, moved)
	168	),
	169	TP_fast_assign(
	170	strncpy(__entry->name, dev_name(wb->bdi->dev), 32);
	171	__entry->older = older_than_this ? *older_than_this : 0;
	172	__entry->age = older_than_this ?
	173	(jiffies - older_than_this) 1000 / HZ : -1;
	174	__entry->moved = moved;
	175	),
	176	TP_printk("bdi %s: older=%lu age=%ld enqueue=%d",
	177	__entry->name,
	178	__entry->older, /* older_than_this in jiffies */
	179	__entry->age, /* older_than_this in relative milliseconds */
	180	__entry->moved)
	181	);
	182
e1cbe236 WF	183	TRACE_EVENT(global_dirty_state,
	184
	185	TP_PROTO(unsigned long background_thresh,
	186	unsigned long dirty_thresh
	187	),
	188
	189	TP_ARGS(background_thresh,
	190	dirty_thresh
	191	),
	192
	193	TP_STRUCT__entry(
	194	__field(unsigned long, nr_dirty)
	195	__field(unsigned long, nr_writeback)
	196	__field(unsigned long, nr_unstable)
	197	__field(unsigned long, background_thresh)
	198	__field(unsigned long, dirty_thresh)
	199	__field(unsigned long, dirty_limit)
	200	__field(unsigned long, nr_dirtied)
	201	__field(unsigned long, nr_written)
	202	),
	203
	204	TP_fast_assign(
	205	__entry->nr_dirty = global_page_state(NR_FILE_DIRTY);
	206	__entry->nr_writeback = global_page_state(NR_WRITEBACK);
	207	__entry->nr_unstable = global_page_state(NR_UNSTABLE_NFS);
	208	__entry->nr_dirtied = global_page_state(NR_DIRTIED);
	209	__entry->nr_written = global_page_state(NR_WRITTEN);
	210	__entry->background_thresh = background_thresh;
	211	__entry->dirty_thresh = dirty_thresh;
	212	__entry->dirty_limit = global_dirty_limit;
	213	),
	214
	215	TP_printk("dirty=%lu writeback=%lu unstable=%lu "
	216	"bg_thresh=%lu thresh=%lu limit=%lu "
	217	"dirtied=%lu written=%lu",
	218	__entry->nr_dirty,
	219	__entry->nr_writeback,
	220	__entry->nr_unstable,
	221	__entry->background_thresh,
	222	__entry->dirty_thresh,
	223	__entry->dirty_limit,
	224	__entry->nr_dirtied,
	225	__entry->nr_written
	226	)
	227	);
	228
b48c104d WF	229	#define KBps(x) ((x) << (PAGE_SHIFT - 10))
	230
	231	TRACE_EVENT(bdi_dirty_ratelimit,
	232
	233	TP_PROTO(struct backing_dev_info *bdi,
	234	unsigned long dirty_rate,
	235	unsigned long task_ratelimit),
	236
	237	TP_ARGS(bdi, dirty_rate, task_ratelimit),
	238
	239	TP_STRUCT__entry(
	240	__array(char, bdi, 32)
	241	__field(unsigned long, write_bw)
	242	__field(unsigned long, avg_write_bw)
	243	__field(unsigned long, dirty_rate)
	244	__field(unsigned long, dirty_ratelimit)
	245	__field(unsigned long, task_ratelimit)
	246	__field(unsigned long, balanced_dirty_ratelimit)
	247	),
	248
	249	TP_fast_assign(
	250	strlcpy(__entry->bdi, dev_name(bdi->dev), 32);
	251	__entry->write_bw = KBps(bdi->write_bandwidth);
	252	__entry->avg_write_bw = KBps(bdi->avg_write_bandwidth);
	253	__entry->dirty_rate = KBps(dirty_rate);
	254	__entry->dirty_ratelimit = KBps(bdi->dirty_ratelimit);
	255	__entry->task_ratelimit = KBps(task_ratelimit);
	256	__entry->balanced_dirty_ratelimit =
	257	KBps(bdi->balanced_dirty_ratelimit);
	258	),
	259
	260	TP_printk("bdi %s: "
	261	"write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
	262	"dirty_ratelimit=%lu task_ratelimit=%lu "
	263	"balanced_dirty_ratelimit=%lu",
	264	__entry->bdi,
	265	__entry->write_bw, /* write bandwidth */
	266	__entry->avg_write_bw, /* avg write bandwidth */
	267	__entry->dirty_rate, /* bdi dirty rate */
	268	__entry->dirty_ratelimit, /* base ratelimit */
	269	__entry->task_ratelimit, /* ratelimit with position control */
	270	__entry->balanced_dirty_ratelimit /* the balanced ratelimit */
	271	)
	272	);
	273
52bb9198 MG	274	DECLARE_EVENT_CLASS(writeback_congest_waited_template,
	275
	276	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
	277
	278	TP_ARGS(usec_timeout, usec_delayed),
	279
	280	TP_STRUCT__entry(
	281	__field( unsigned int, usec_timeout )
	282	__field( unsigned int, usec_delayed )
	283	),
	284
	285	TP_fast_assign(
	286	__entry->usec_timeout = usec_timeout;
	287	__entry->usec_delayed = usec_delayed;
	288	),
	289
	290	TP_printk("usec_timeout=%u usec_delayed=%u",
	291	__entry->usec_timeout,
	292	__entry->usec_delayed)
	293	);
	294
	295	DEFINE_EVENT(writeback_congest_waited_template, writeback_congestion_wait,
	296
	297	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
	298
	299	TP_ARGS(usec_timeout, usec_delayed)
	300	);
	301
0e093d99 MG	302	DEFINE_EVENT(writeback_congest_waited_template, writeback_wait_iff_congested,
	303
	304	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
	305
	306	TP_ARGS(usec_timeout, usec_delayed)
	307	);
	308
251d6a47 WF	309	DECLARE_EVENT_CLASS(writeback_single_inode_template,
	310
	311	TP_PROTO(struct inode *inode,
	312	struct writeback_control *wbc,
	313	unsigned long nr_to_write
	314	),
	315
	316	TP_ARGS(inode, wbc, nr_to_write),
	317
	318	TP_STRUCT__entry(
	319	__array(char, name, 32)
	320	__field(unsigned long, ino)
	321	__field(unsigned long, state)
c8ad6206	322	__field(unsigned long, dirtied_when)
251d6a47 WF	323	__field(unsigned long, writeback_index)
	324	__field(long, nr_to_write)
	325	__field(unsigned long, wrote)
	326	),
	327
	328	TP_fast_assign(
	329	strncpy(__entry->name,
	330	dev_name(inode->i_mapping->backing_dev_info->dev), 32);
	331	__entry->ino = inode->i_ino;
	332	__entry->state = inode->i_state;
c8ad6206	333	__entry->dirtied_when = inode->dirtied_when;
251d6a47 WF	334	__entry->writeback_index = inode->i_mapping->writeback_index;
	335	__entry->nr_to_write = nr_to_write;
	336	__entry->wrote = nr_to_write - wbc->nr_to_write;
	337	),
	338
c8ad6206	339	TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu "
251d6a47 WF	340	"index=%lu to_write=%ld wrote=%lu",
	341	__entry->name,
	342	__entry->ino,
	343	show_inode_state(__entry->state),
c8ad6206 WF	344	__entry->dirtied_when,
c8ad6206 WF	345	(jiffies - __entry->dirtied_when) / HZ,
251d6a47 WF	346	__entry->writeback_index,
	347	__entry->nr_to_write,
	348	__entry->wrote
	349	)
	350	);
	351
	352	DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode_requeue,
	353	TP_PROTO(struct inode *inode,
	354	struct writeback_control *wbc,
	355	unsigned long nr_to_write),
	356	TP_ARGS(inode, wbc, nr_to_write)
	357	);
	358
	359	DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode,
	360	TP_PROTO(struct inode *inode,
	361	struct writeback_control *wbc,
	362	unsigned long nr_to_write),
	363	TP_ARGS(inode, wbc, nr_to_write)
	364	);
	365
455b2864 DC	366	#endif /* _TRACE_WRITEBACK_H */
	367
	368	/* This part must be outside protection */
	369	#include <trace/define_trace.h>