[lttng-modules.git] / instrumentation / events / lttng-module / writeback.h

#undef TRACE_SYSTEM
#define TRACE_SYSTEM writeback

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

#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/tracepoint.h>
#include <linux/backing-dev.h>
#include <linux/writeback.h>
#include <linux/version.h>

#ifndef _TRACE_WRITEBACK_DEF_
#define _TRACE_WRITEBACK_DEF_

#if (LINUX_VERSION_CODE < KERNEL_VERSION(4,0,0))
static inline struct backing_dev_info *inode_to_bdi(struct inode *inode)
{
	struct super_block *sb = inode->i_sb;

	if (strcmp(sb->s_type->name, "bdev") == 0)
		return inode->i_mapping->backing_dev_info;

	return sb->s_bdi;
}
#endif /* #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,0,0)) */

#endif

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0))
#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_DIRTY_TIME,		"I_DIRTY_TIME"},	\
		{I_DIRTY_TIME_EXPIRED,	"I_DIRTY_TIME_EXPIRED"}, \
		{I_REFERENCED,		"I_REFERENCED"}		\
	)
#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */
#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"}		\
	)
#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0))

LTTNG_TRACEPOINT_EVENT(writeback_dirty_page,
	TP_PROTO(struct page *page, struct address_space *mapping),
	TP_ARGS(page, mapping),
	TP_FIELDS(
		ctf_array_text(char, name,
			mapping ? dev_name(inode_to_bdi(mapping->host)->dev) : "(unknown)", 32)
		ctf_integer(unsigned long, ino, mapping ? mapping->host->i_ino : 0)
		ctf_integer(pgoff_t, index, page->index)
	)
)

LTTNG_TRACEPOINT_EVENT_CLASS(writeback_dirty_inode_template,
	TP_PROTO(struct inode *inode, int flags),
	TP_ARGS(inode, flags),
	TP_FIELDS(
		/* may be called for files on pseudo FSes w/ unregistered bdi */
		ctf_array_text(char, name,
			inode_to_bdi(inode)->dev ?
				dev_name(inode_to_bdi(inode)->dev) : "(unknown)", 32)
		ctf_integer(unsigned long, ino, inode->i_ino)
		ctf_integer(unsigned long, state, inode->i_state)
		ctf_integer(unsigned long, flags, flags)
	)
)
#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(name) \
LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_dirty_inode_template, name, \
	TP_PROTO(struct inode *inode, int flags), \
	TP_ARGS(inode, flags))
LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode_start)
LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode)
LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_mark_inode_dirty)

LTTNG_TRACEPOINT_EVENT_CLASS(writeback_write_inode_template,
	TP_PROTO(struct inode *inode, struct writeback_control *wbc),
	TP_ARGS(inode, wbc),
	TP_FIELDS(
		ctf_array_text(char, name,
			dev_name(inode_to_bdi(inode)->dev), 32)
		ctf_integer(unsigned long, ino, inode->i_ino)
		ctf_integer(int, sync_mode, wbc->sync_mode)
	)
)

#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(name) \
LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_write_inode_template, name, \
	TP_PROTO(struct inode *inode, struct writeback_control *wbc), \
	TP_ARGS(inode, wbc))
LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode_start)
LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode)

#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))

LTTNG_TRACEPOINT_EVENT(writeback_dirty_page,
	TP_PROTO(struct page *page, struct address_space *mapping),
	TP_ARGS(page, mapping),
	TP_FIELDS(
		ctf_array_text(char, name,
			mapping ? dev_name(mapping->backing_dev_info->dev) : "(unknown)", 32)
		ctf_integer(unsigned long, ino, mapping ? mapping->host->i_ino : 0)
		ctf_integer(pgoff_t, index, page->index)
	)
)

LTTNG_TRACEPOINT_EVENT_CLASS(writeback_dirty_inode_template,
	TP_PROTO(struct inode *inode, int flags),
	TP_ARGS(inode, flags),
	TP_FIELDS(
		/* may be called for files on pseudo FSes w/ unregistered bdi */
		ctf_array_text(char, name,
			inode->i_mapping->backing_dev_info->dev ?
				dev_name(inode->i_mapping->backing_dev_info->dev)
				: "(unknown)", 32)
		ctf_integer(unsigned long, ino, inode->i_ino)
		ctf_integer(unsigned long, flags, flags)
	)
)
#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(name) \
LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_dirty_inode_template, name, \
	TP_PROTO(struct inode *inode, int flags), \
	TP_ARGS(inode, flags))
LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode_start)
LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode)

LTTNG_TRACEPOINT_EVENT_CLASS(writeback_write_inode_template,
	TP_PROTO(struct inode *inode, struct writeback_control *wbc),
	TP_ARGS(inode, wbc),
	TP_FIELDS(
		ctf_array_text(char, name,
			dev_name(inode->i_mapping->backing_dev_info->dev), 32)
		ctf_integer(unsigned long, ino, inode->i_ino)
		ctf_integer(int, sync_mode, wbc->sync_mode)
	)
)

#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(name) \
LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_write_inode_template, name, \
	TP_PROTO(struct inode *inode, struct writeback_control *wbc), \
	TP_ARGS(inode, wbc))
LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode_start)
LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode)

#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)) */

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0))

LTTNG_TRACEPOINT_EVENT_CLASS(writeback_work_class,
	TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
	TP_ARGS(bdi, work),
	TP_FIELDS(
		ctf_array_text(char, name, bdi->dev ? dev_name(bdi->dev) :
				"(unknown)", 32)
	)
)

#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */

LTTNG_TRACEPOINT_EVENT_CLASS(writeback_work_class,
	TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
	TP_ARGS(bdi, work),
	TP_FIELDS(
		ctf_array_text(char, name,
			dev_name(bdi->dev ? bdi->dev :
				default_backing_dev_info.dev), 32)
	)
)

#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */

#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(name) \
LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_work_class, name, \
	TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work), \
	TP_ARGS(bdi, work))
LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_nothread)
LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_queue)
LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_exec)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_start)
LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_written)
LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_wait)
#endif

LTTNG_TRACEPOINT_EVENT(writeback_pages_written,
	TP_PROTO(long pages_written),
	TP_ARGS(pages_written),
	TP_FIELDS(
		ctf_integer(long, pages, pages_written)
	)
)

LTTNG_TRACEPOINT_EVENT_CLASS(writeback_class,
	TP_PROTO(struct backing_dev_info *bdi),
	TP_ARGS(bdi),
	TP_FIELDS(
		ctf_array_text(char, name,
			dev_name(bdi->dev), 32)
	)
)
#undef DEFINE_WRITEBACK_EVENT
#define DEFINE_WRITEBACK_EVENT(name) \
LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_class, name, \
	TP_PROTO(struct backing_dev_info *bdi), \
	TP_ARGS(bdi))

#define DEFINE_WRITEBACK_EVENT_MAP(name, map) \
LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_class, name, map, \
	TP_PROTO(struct backing_dev_info *bdi), \
	TP_ARGS(bdi))

DEFINE_WRITEBACK_EVENT(writeback_nowork)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
DEFINE_WRITEBACK_EVENT(writeback_wake_background)
#endif
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)
#if (LTTNG_KERNEL_RANGE(3,1,0, 3,2,0))
DEFINE_WRITEBACK_EVENT_MAP(balance_dirty_start, writeback_balance_dirty_start)
DEFINE_WRITEBACK_EVENT_MAP(balance_dirty_wait, writeback_balance_dirty_wait)

LTTNG_TRACEPOINT_EVENT_MAP(balance_dirty_written,

	writeback_balance_dirty_written,

	TP_PROTO(struct backing_dev_info *bdi, int written),

	TP_ARGS(bdi, written),

	TP_FIELDS(
		ctf_array_text(char, name, dev_name(bdi->dev), 32)
		ctf_integer(int, written, written)
	)
)
#endif

LTTNG_TRACEPOINT_EVENT_CLASS(writeback_wbc_class,
	TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
	TP_ARGS(wbc, bdi),
	TP_FIELDS(
		ctf_array_text(char, name, dev_name(bdi->dev), 32)
		ctf_integer(long, nr_to_write, wbc->nr_to_write)
		ctf_integer(long, pages_skipped, wbc->pages_skipped)
		ctf_integer(int, sync_mode, wbc->sync_mode)
		ctf_integer(int, for_kupdate, wbc->for_kupdate)
		ctf_integer(int, for_background, wbc->for_background)
		ctf_integer(int, for_reclaim, wbc->for_reclaim)
		ctf_integer(int, range_cyclic, wbc->range_cyclic)
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
		ctf_integer(int, more_io, wbc->more_io)
		ctf_integer(unsigned long, older_than_this,
			wbc->older_than_this ? *wbc->older_than_this : 0)
#endif
		ctf_integer(long, range_start, (long) wbc->range_start)
		ctf_integer(long, range_end, (long) wbc->range_end)
	)
)

#undef DEFINE_WBC_EVENT
#define LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(name, map) \
LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_wbc_class, name, map, \
	TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
	TP_ARGS(wbc, bdi))
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_start, writeback_wbc_writeback_start)
LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_written, writeback_wbc_writeback_written)
LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_wait, writeback_wbc_writeback_wait)
LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_start, writeback_wbc_balance_dirty_start)
LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_written, writeback_wbc_balance_dirty_written)
LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_wait, writeback_wbc_balance_dirty_wait)
#endif
LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writepage, writeback_wbc_writepage)

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
LTTNG_TRACEPOINT_EVENT(writeback_queue_io,
	TP_PROTO(struct bdi_writeback *wb,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
		 struct wb_writeback_work *work,
#else
		 unsigned long *older_than_this,
#endif
		 int moved),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
	TP_ARGS(wb, work, moved),
#else
	TP_ARGS(wb, older_than_this, moved),
#endif
	TP_FIELDS(
		ctf_array_text(char, name, dev_name(wb->bdi->dev), 32)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
#else
		ctf_integer(unsigned long, older,
			older_than_this ? *older_than_this : 0)
		ctf_integer(long, age,
			older_than_this ?
				(jiffies - *older_than_this) * 1000 / HZ
				: -1)
#endif
		ctf_integer(int, moved, moved)
	)
)

LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state,

	writeback_global_dirty_state,

	TP_PROTO(unsigned long background_thresh,
		 unsigned long dirty_thresh
	),

	TP_ARGS(background_thresh,
		dirty_thresh
	),

	TP_FIELDS(
		ctf_integer(unsigned long, nr_dirty, global_page_state(NR_FILE_DIRTY))
		ctf_integer(unsigned long, nr_writeback, global_page_state(NR_WRITEBACK))
		ctf_integer(unsigned long, nr_unstable, global_page_state(NR_UNSTABLE_NFS))
		ctf_integer(unsigned long, nr_dirtied, global_page_state(NR_DIRTIED))
		ctf_integer(unsigned long, nr_written, global_page_state(NR_WRITTEN))
		ctf_integer(unsigned long, background_thresh, background_thresh)
		ctf_integer(unsigned long, dirty_thresh, dirty_thresh)
		ctf_integer(unsigned long, dirty_limit, global_dirty_limit)
	)
)
#endif

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))

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

LTTNG_TRACEPOINT_EVENT_MAP(bdi_dirty_ratelimit,

	writeback_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_FIELDS(
		ctf_array_text(char, bdi, dev_name(bdi->dev), 32)
		ctf_integer(unsigned long, write_bw, KBps(bdi->write_bandwidth))
		ctf_integer(unsigned long, avg_write_bw, KBps(bdi->avg_write_bandwidth))
		ctf_integer(unsigned long, dirty_rate, KBps(dirty_rate))
		ctf_integer(unsigned long, dirty_ratelimit, KBps(bdi->dirty_ratelimit))
		ctf_integer(unsigned long, task_ratelimit, KBps(task_ratelimit))
		ctf_integer(unsigned long, balanced_dirty_ratelimit,
					KBps(bdi->balanced_dirty_ratelimit))
	)
)

LTTNG_TRACEPOINT_EVENT_MAP(balance_dirty_pages,

	writeback_balance_dirty_pages,

	TP_PROTO(struct backing_dev_info *bdi,
		 unsigned long thresh,
		 unsigned long bg_thresh,
		 unsigned long dirty,
		 unsigned long bdi_thresh,
		 unsigned long bdi_dirty,
		 unsigned long dirty_ratelimit,
		 unsigned long task_ratelimit,
		 unsigned long dirtied,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
		 unsigned long period,
#endif
		 long pause,
		 unsigned long start_time),

	TP_ARGS(bdi, thresh, bg_thresh, dirty, bdi_thresh, bdi_dirty,
		dirty_ratelimit, task_ratelimit,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
		dirtied, period, pause, start_time
#else
		dirtied, pause, start_time
#endif
	),

	TP_FIELDS(
		ctf_array_text(char, bdi, dev_name(bdi->dev), 32)
		ctf_integer(unsigned long, limit, global_dirty_limit)
		ctf_integer(unsigned long, setpoint,
			(global_dirty_limit + (thresh + bg_thresh) / 2) / 2)
		ctf_integer(unsigned long, dirty, dirty)
		ctf_integer(unsigned long, bdi_setpoint,
			((global_dirty_limit + (thresh + bg_thresh) / 2) / 2) *
				bdi_thresh / (thresh + 1))
		ctf_integer(unsigned long, bdi_dirty, bdi_dirty)
		ctf_integer(unsigned long, dirty_ratelimit,
			KBps(dirty_ratelimit))
		ctf_integer(unsigned long, task_ratelimit,
			KBps(task_ratelimit))
		ctf_integer(unsigned int, dirtied, dirtied)
		ctf_integer(unsigned int, dirtied_pause,
			current->nr_dirtied_pause)
		ctf_integer(unsigned long, paused,
			(jiffies - start_time) * 1000 / HZ)
		ctf_integer(long, pause, pause * 1000 / HZ)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
		ctf_integer(unsigned long, period,
			period * 1000 / HZ)
		ctf_integer(long, think,
			current->dirty_paused_when == 0 ? 0 :
				(long)(jiffies - current->dirty_paused_when) * 1000/HZ)
#endif
	)
)
#endif

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0))
LTTNG_TRACEPOINT_EVENT(writeback_sb_inodes_requeue,

	TP_PROTO(struct inode *inode),
	TP_ARGS(inode),

	TP_FIELDS(
		ctf_array_text(char, name,
			dev_name(inode_to_bdi(inode)->dev), 32)
		ctf_integer(unsigned long, ino, inode->i_ino)
		ctf_integer(unsigned long, state, inode->i_state)
		ctf_integer(unsigned long, dirtied_when, inode->dirtied_when)
	)
)
#endif

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
LTTNG_TRACEPOINT_EVENT_CLASS(writeback_congest_waited_template,

	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),

	TP_ARGS(usec_timeout, usec_delayed),

	TP_FIELDS(
		ctf_integer(unsigned int, usec_timeout, usec_timeout)
		ctf_integer(unsigned int, usec_delayed, usec_delayed)
	)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_congest_waited_template, writeback_congestion_wait,

	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),

	TP_ARGS(usec_timeout, usec_delayed)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE(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

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
LTTNG_TRACEPOINT_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_FIELDS(
		ctf_array_text(char, name,
			dev_name(inode_to_bdi(inode)->dev), 32)
		ctf_integer(unsigned long, ino, inode->i_ino)
		ctf_integer(unsigned long, state, inode->i_state)
		ctf_integer(unsigned long, dirtied_when, inode->dirtied_when)
		ctf_integer(unsigned long, writeback_index,
			inode->i_mapping->writeback_index)
		ctf_integer(long, nr_to_write, nr_to_write)
		ctf_integer(unsigned long, wrote,
			nr_to_write - wbc->nr_to_write)
	)
)

#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
LTTNG_TRACEPOINT_EVENT_INSTANCE(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)
)
#endif

LTTNG_TRACEPOINT_EVENT_INSTANCE(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

#endif /* LTTNG_TRACE_WRITEBACK_H */

/* This part must be outside protection */
#include "../../../probes/define_trace.h"
Commit	Line	Data
b87700e3 AG	1	#undef TRACE_SYSTEM
	2	#define TRACE_SYSTEM writeback
	3
3bc29f0a MD	4	#if !defined(LTTNG_TRACE_WRITEBACK_H) \|\| defined(TRACE_HEADER_MULTI_READ)
3bc29f0a MD	5	#define LTTNG_TRACE_WRITEBACK_H
b87700e3	6
3bc29f0a	7	#include "../../../probes/lttng-tracepoint-event.h"
aa634cd1	8	#include <linux/tracepoint.h>
b87700e3 AG	9	#include <linux/backing-dev.h>
	10	#include <linux/writeback.h>
	11	#include <linux/version.h>
	12
	13	#ifndef _TRACE_WRITEBACK_DEF_
	14	#define _TRACE_WRITEBACK_DEF_
99a570c8 MD	15
99a570c8 MD	16	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4,0,0))
b87700e3 AG	17	static inline struct backing_dev_info inode_to_bdi(struct inode inode)
	18	{
	19	struct super_block *sb = inode->i_sb;
	20
	21	if (strcmp(sb->s_type->name, "bdev") == 0)
	22	return inode->i_mapping->backing_dev_info;
	23
	24	return sb->s_bdi;
	25	}
99a570c8 MD	26	#endif /* #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,0,0)) */
99a570c8 MD	27
b87700e3 AG	28	#endif
b87700e3 AG	29
99a570c8 MD	30	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0))
	31	#define show_inode_state(state) \
	32	__print_flags(state, "\|", \
	33	{I_DIRTY_SYNC, "I_DIRTY_SYNC"}, \
	34	{I_DIRTY_DATASYNC, "I_DIRTY_DATASYNC"}, \
	35	{I_DIRTY_PAGES, "I_DIRTY_PAGES"}, \
	36	{I_NEW, "I_NEW"}, \
	37	{I_WILL_FREE, "I_WILL_FREE"}, \
	38	{I_FREEING, "I_FREEING"}, \
	39	{I_CLEAR, "I_CLEAR"}, \
	40	{I_SYNC, "I_SYNC"}, \
	41	{I_DIRTY_TIME, "I_DIRTY_TIME"}, \
	42	{I_DIRTY_TIME_EXPIRED, "I_DIRTY_TIME_EXPIRED"}, \
	43	{I_REFERENCED, "I_REFERENCED"} \
	44	)
	45	#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */
b87700e3 AG	46	#define show_inode_state(state) \
	47	__print_flags(state, "\|", \
	48	{I_DIRTY_SYNC, "I_DIRTY_SYNC"}, \
	49	{I_DIRTY_DATASYNC, "I_DIRTY_DATASYNC"}, \
	50	{I_DIRTY_PAGES, "I_DIRTY_PAGES"}, \
	51	{I_NEW, "I_NEW"}, \
	52	{I_WILL_FREE, "I_WILL_FREE"}, \
	53	{I_FREEING, "I_FREEING"}, \
	54	{I_CLEAR, "I_CLEAR"}, \
	55	{I_SYNC, "I_SYNC"}, \
	56	{I_REFERENCED, "I_REFERENCED"} \
	57	)
99a570c8	58	#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */
b87700e3	59
99a570c8 MD	60	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0))
	61
	62	LTTNG_TRACEPOINT_EVENT(writeback_dirty_page,
	63	TP_PROTO(struct page page, struct address_space mapping),
	64	TP_ARGS(page, mapping),
f127e61e MD	65	TP_FIELDS(
f127e61e MD	66	ctf_array_text(char, name,
99a570c8	67	mapping ? dev_name(inode_to_bdi(mapping->host)->dev) : "(unknown)", 32)
f127e61e MD	68	ctf_integer(unsigned long, ino, mapping ? mapping->host->i_ino : 0)
f127e61e MD	69	ctf_integer(pgoff_t, index, page->index)
99a570c8 MD	70	)
	71	)
	72
	73	LTTNG_TRACEPOINT_EVENT_CLASS(writeback_dirty_inode_template,
	74	TP_PROTO(struct inode *inode, int flags),
	75	TP_ARGS(inode, flags),
f127e61e	76	TP_FIELDS(
99a570c8	77	/* may be called for files on pseudo FSes w/ unregistered bdi */
f127e61e	78	ctf_array_text(char, name,
99a570c8 MD	79	inode_to_bdi(inode)->dev ?
99a570c8 MD	80	dev_name(inode_to_bdi(inode)->dev) : "(unknown)", 32)
f127e61e MD	81	ctf_integer(unsigned long, ino, inode->i_ino)
	82	ctf_integer(unsigned long, state, inode->i_state)
	83	ctf_integer(unsigned long, flags, flags)
99a570c8 MD	84	)
	85	)
	86	#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(name) \
	87	LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_dirty_inode_template, name, \
	88	TP_PROTO(struct inode *inode, int flags), \
	89	TP_ARGS(inode, flags))
	90	LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode_start)
	91	LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode)
	92	LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_mark_inode_dirty)
	93
	94	LTTNG_TRACEPOINT_EVENT_CLASS(writeback_write_inode_template,
	95	TP_PROTO(struct inode inode, struct writeback_control wbc),
	96	TP_ARGS(inode, wbc),
f127e61e MD	97	TP_FIELDS(
f127e61e MD	98	ctf_array_text(char, name,
99a570c8	99	dev_name(inode_to_bdi(inode)->dev), 32)
f127e61e MD	100	ctf_integer(unsigned long, ino, inode->i_ino)
f127e61e MD	101	ctf_integer(int, sync_mode, wbc->sync_mode)
99a570c8 MD	102	)
	103	)
	104
	105	#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(name) \
	106	LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_write_inode_template, name, \
	107	TP_PROTO(struct inode inode, struct writeback_control wbc), \
	108	TP_ARGS(inode, wbc))
	109	LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode_start)
	110	LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode)
	111
	112	#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
	113
aa634cd1 JD	114	LTTNG_TRACEPOINT_EVENT(writeback_dirty_page,
	115	TP_PROTO(struct page page, struct address_space mapping),
	116	TP_ARGS(page, mapping),
f127e61e MD	117	TP_FIELDS(
f127e61e MD	118	ctf_array_text(char, name,
aa634cd1	119	mapping ? dev_name(mapping->backing_dev_info->dev) : "(unknown)", 32)
f127e61e MD	120	ctf_integer(unsigned long, ino, mapping ? mapping->host->i_ino : 0)
f127e61e MD	121	ctf_integer(pgoff_t, index, page->index)
aa634cd1 JD	122	)
	123	)
	124
	125	LTTNG_TRACEPOINT_EVENT_CLASS(writeback_dirty_inode_template,
	126	TP_PROTO(struct inode *inode, int flags),
	127	TP_ARGS(inode, flags),
f127e61e	128	TP_FIELDS(
aa634cd1	129	/* may be called for files on pseudo FSes w/ unregistered bdi */
f127e61e	130	ctf_array_text(char, name,
aa634cd1	131	inode->i_mapping->backing_dev_info->dev ?
f127e61e MD	132	dev_name(inode->i_mapping->backing_dev_info->dev)
	133	: "(unknown)", 32)
	134	ctf_integer(unsigned long, ino, inode->i_ino)
	135	ctf_integer(unsigned long, flags, flags)
aa634cd1 JD	136	)
	137	)
	138	#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(name) \
	139	LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_dirty_inode_template, name, \
	140	TP_PROTO(struct inode *inode, int flags), \
	141	TP_ARGS(inode, flags))
	142	LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode_start)
	143	LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode)
	144
	145	LTTNG_TRACEPOINT_EVENT_CLASS(writeback_write_inode_template,
	146	TP_PROTO(struct inode inode, struct writeback_control wbc),
	147	TP_ARGS(inode, wbc),
f127e61e MD	148	TP_FIELDS(
f127e61e MD	149	ctf_array_text(char, name,
aa634cd1	150	dev_name(inode->i_mapping->backing_dev_info->dev), 32)
f127e61e MD	151	ctf_integer(unsigned long, ino, inode->i_ino)
f127e61e MD	152	ctf_integer(int, sync_mode, wbc->sync_mode)
aa634cd1 JD	153	)
	154	)
	155
	156	#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(name) \
	157	LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_write_inode_template, name, \
	158	TP_PROTO(struct inode inode, struct writeback_control wbc), \
	159	TP_ARGS(inode, wbc))
	160	LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode_start)
	161	LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode)
99a570c8	162
aa634cd1 JD	163	#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)) */
aa634cd1 JD	164
99a570c8 MD	165	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0))
	166
	167	LTTNG_TRACEPOINT_EVENT_CLASS(writeback_work_class,
	168	TP_PROTO(struct backing_dev_info bdi, struct wb_writeback_work work),
	169	TP_ARGS(bdi, work),
f127e61e MD	170	TP_FIELDS(
f127e61e MD	171	ctf_array_text(char, name, bdi->dev ? dev_name(bdi->dev) :
99a570c8	172	"(unknown)", 32)
99a570c8 MD	173	)
	174	)
	175
	176	#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */
	177
3bc29f0a	178	LTTNG_TRACEPOINT_EVENT_CLASS(writeback_work_class,
b87700e3 AG	179	TP_PROTO(struct backing_dev_info bdi, struct wb_writeback_work work),
b87700e3 AG	180	TP_ARGS(bdi, work),
f127e61e MD	181	TP_FIELDS(
	182	ctf_array_text(char, name,
	183	dev_name(bdi->dev ? bdi->dev :
b87700e3	184	default_backing_dev_info.dev), 32)
b87700e3	185	)
b87700e3	186	)
99a570c8 MD	187
	188	#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) */
	189
3bc29f0a MD	190	#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(name) \
3bc29f0a MD	191	LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_work_class, name, \
b87700e3 AG	192	TP_PROTO(struct backing_dev_info bdi, struct wb_writeback_work work), \
b87700e3 AG	193	TP_ARGS(bdi, work))
3bc29f0a MD	194	LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_nothread)
	195	LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_queue)
	196	LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_exec)
b87700e3	197	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
3bc29f0a MD	198	LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_start)
	199	LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_written)
	200	LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_wait)
b87700e3 AG	201	#endif
b87700e3 AG	202
3bc29f0a	203	LTTNG_TRACEPOINT_EVENT(writeback_pages_written,
b87700e3 AG	204	TP_PROTO(long pages_written),
b87700e3 AG	205	TP_ARGS(pages_written),
f127e61e MD	206	TP_FIELDS(
	207	ctf_integer(long, pages, pages_written)
	208	)
b87700e3 AG	209	)
b87700e3 AG	210
3bc29f0a	211	LTTNG_TRACEPOINT_EVENT_CLASS(writeback_class,
b87700e3 AG	212	TP_PROTO(struct backing_dev_info *bdi),
b87700e3 AG	213	TP_ARGS(bdi),
f127e61e MD	214	TP_FIELDS(
	215	ctf_array_text(char, name,
	216	dev_name(bdi->dev), 32)
b87700e3 AG	217	)
b87700e3 AG	218	)
59fecd6c	219	#undef DEFINE_WRITEBACK_EVENT
b87700e3	220	#define DEFINE_WRITEBACK_EVENT(name) \
3bc29f0a	221	LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_class, name, \
b87700e3 AG	222	TP_PROTO(struct backing_dev_info *bdi), \
	223	TP_ARGS(bdi))
	224
9cf29d3e	225	#define DEFINE_WRITEBACK_EVENT_MAP(name, map) \
3bc29f0a	226	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_class, name, map, \
9cf29d3e MD	227	TP_PROTO(struct backing_dev_info *bdi), \
	228	TP_ARGS(bdi))
	229
b87700e3 AG	230	DEFINE_WRITEBACK_EVENT(writeback_nowork)
	231	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
	232	DEFINE_WRITEBACK_EVENT(writeback_wake_background)
	233	#endif
	234	DEFINE_WRITEBACK_EVENT(writeback_wake_thread)
	235	DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread)
	236	DEFINE_WRITEBACK_EVENT(writeback_bdi_register)
	237	DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister)
	238	DEFINE_WRITEBACK_EVENT(writeback_thread_start)
	239	DEFINE_WRITEBACK_EVENT(writeback_thread_stop)
	240	#if (LTTNG_KERNEL_RANGE(3,1,0, 3,2,0))
9cf29d3e MD	241	DEFINE_WRITEBACK_EVENT_MAP(balance_dirty_start, writeback_balance_dirty_start)
	242	DEFINE_WRITEBACK_EVENT_MAP(balance_dirty_wait, writeback_balance_dirty_wait)
	243
3bc29f0a	244	LTTNG_TRACEPOINT_EVENT_MAP(balance_dirty_written,
b87700e3	245
9cf29d3e	246	writeback_balance_dirty_written,
b87700e3 AG	247
	248	TP_PROTO(struct backing_dev_info *bdi, int written),
	249
	250	TP_ARGS(bdi, written),
	251
f127e61e MD	252	TP_FIELDS(
	253	ctf_array_text(char, name, dev_name(bdi->dev), 32)
	254	ctf_integer(int, written, written)
b87700e3 AG	255	)
	256	)
	257	#endif
	258
3bc29f0a	259	LTTNG_TRACEPOINT_EVENT_CLASS(writeback_wbc_class,
b87700e3 AG	260	TP_PROTO(struct writeback_control wbc, struct backing_dev_info bdi),
b87700e3 AG	261	TP_ARGS(wbc, bdi),
f127e61e MD	262	TP_FIELDS(
	263	ctf_array_text(char, name, dev_name(bdi->dev), 32)
	264	ctf_integer(long, nr_to_write, wbc->nr_to_write)
	265	ctf_integer(long, pages_skipped, wbc->pages_skipped)
	266	ctf_integer(int, sync_mode, wbc->sync_mode)
	267	ctf_integer(int, for_kupdate, wbc->for_kupdate)
	268	ctf_integer(int, for_background, wbc->for_background)
	269	ctf_integer(int, for_reclaim, wbc->for_reclaim)
	270	ctf_integer(int, range_cyclic, wbc->range_cyclic)
b87700e3	271	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
f127e61e MD	272	ctf_integer(int, more_io, wbc->more_io)
	273	ctf_integer(unsigned long, older_than_this,
	274	wbc->older_than_this ? *wbc->older_than_this : 0)
b87700e3	275	#endif
f127e61e MD	276	ctf_integer(long, range_start, (long) wbc->range_start)
	277	ctf_integer(long, range_end, (long) wbc->range_end)
	278	)
b87700e3 AG	279	)
b87700e3 AG	280
9cf29d3e	281	#undef DEFINE_WBC_EVENT
3bc29f0a MD	282	#define LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(name, map) \
3bc29f0a MD	283	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_wbc_class, name, map, \
b87700e3 AG	284	TP_PROTO(struct writeback_control wbc, struct backing_dev_info bdi), \
	285	TP_ARGS(wbc, bdi))
	286	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
3bc29f0a MD	287	LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_start, writeback_wbc_writeback_start)
	288	LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_written, writeback_wbc_writeback_written)
	289	LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_wait, writeback_wbc_writeback_wait)
	290	LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_start, writeback_wbc_balance_dirty_start)
	291	LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_written, writeback_wbc_balance_dirty_written)
	292	LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_wait, writeback_wbc_balance_dirty_wait)
b87700e3	293	#endif
3bc29f0a	294	LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writepage, writeback_wbc_writepage)
b87700e3 AG	295
b87700e3 AG	296	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
3bc29f0a	297	LTTNG_TRACEPOINT_EVENT(writeback_queue_io,
b87700e3 AG	298	TP_PROTO(struct bdi_writeback *wb,
	299	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
	300	struct wb_writeback_work *work,
	301	#else
	302	unsigned long *older_than_this,
	303	#endif
	304	int moved),
	305	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
	306	TP_ARGS(wb, work, moved),
	307	#else
	308	TP_ARGS(wb, older_than_this, moved),
	309	#endif
f127e61e MD	310	TP_FIELDS(
f127e61e MD	311	ctf_array_text(char, name, dev_name(wb->bdi->dev), 32)
b87700e3	312	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
b87700e3	313	#else
f127e61e MD	314	ctf_integer(unsigned long, older,
	315	older_than_this ? *older_than_this : 0)
	316	ctf_integer(long, age,
	317	older_than_this ?
	318	(jiffies - older_than_this) 1000 / HZ
	319	: -1)
b87700e3	320	#endif
f127e61e	321	ctf_integer(int, moved, moved)
b87700e3	322	)
b87700e3 AG	323	)
b87700e3 AG	324
3bc29f0a	325	LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state,
9cf29d3e MD	326
9cf29d3e MD	327	writeback_global_dirty_state,
b87700e3 AG	328
	329	TP_PROTO(unsigned long background_thresh,
	330	unsigned long dirty_thresh
	331	),
	332
	333	TP_ARGS(background_thresh,
	334	dirty_thresh
	335	),
	336
f127e61e MD	337	TP_FIELDS(
	338	ctf_integer(unsigned long, nr_dirty, global_page_state(NR_FILE_DIRTY))
	339	ctf_integer(unsigned long, nr_writeback, global_page_state(NR_WRITEBACK))
	340	ctf_integer(unsigned long, nr_unstable, global_page_state(NR_UNSTABLE_NFS))
	341	ctf_integer(unsigned long, nr_dirtied, global_page_state(NR_DIRTIED))
	342	ctf_integer(unsigned long, nr_written, global_page_state(NR_WRITTEN))
	343	ctf_integer(unsigned long, background_thresh, background_thresh)
	344	ctf_integer(unsigned long, dirty_thresh, dirty_thresh)
	345	ctf_integer(unsigned long, dirty_limit, global_dirty_limit)
b87700e3 AG	346	)
	347	)
	348	#endif
	349
	350	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
	351
	352	#define KBps(x) ((x) << (PAGE_SHIFT - 10))
	353
3bc29f0a	354	LTTNG_TRACEPOINT_EVENT_MAP(bdi_dirty_ratelimit,
9cf29d3e MD	355
9cf29d3e MD	356	writeback_bdi_dirty_ratelimit,
b87700e3 AG	357
	358	TP_PROTO(struct backing_dev_info *bdi,
	359	unsigned long dirty_rate,
	360	unsigned long task_ratelimit),
	361
	362	TP_ARGS(bdi, dirty_rate, task_ratelimit),
	363
f127e61e MD	364	TP_FIELDS(
	365	ctf_array_text(char, bdi, dev_name(bdi->dev), 32)
	366	ctf_integer(unsigned long, write_bw, KBps(bdi->write_bandwidth))
	367	ctf_integer(unsigned long, avg_write_bw, KBps(bdi->avg_write_bandwidth))
	368	ctf_integer(unsigned long, dirty_rate, KBps(dirty_rate))
	369	ctf_integer(unsigned long, dirty_ratelimit, KBps(bdi->dirty_ratelimit))
	370	ctf_integer(unsigned long, task_ratelimit, KBps(task_ratelimit))
	371	ctf_integer(unsigned long, balanced_dirty_ratelimit,
b87700e3	372	KBps(bdi->balanced_dirty_ratelimit))
b87700e3 AG	373	)
	374	)
	375
3bc29f0a	376	LTTNG_TRACEPOINT_EVENT_MAP(balance_dirty_pages,
9cf29d3e MD	377
9cf29d3e MD	378	writeback_balance_dirty_pages,
b87700e3 AG	379
	380	TP_PROTO(struct backing_dev_info *bdi,
	381	unsigned long thresh,
	382	unsigned long bg_thresh,
	383	unsigned long dirty,
	384	unsigned long bdi_thresh,
	385	unsigned long bdi_dirty,
	386	unsigned long dirty_ratelimit,
	387	unsigned long task_ratelimit,
	388	unsigned long dirtied,
	389	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
	390	unsigned long period,
	391	#endif
	392	long pause,
	393	unsigned long start_time),
	394
	395	TP_ARGS(bdi, thresh, bg_thresh, dirty, bdi_thresh, bdi_dirty,
	396	dirty_ratelimit, task_ratelimit,
	397	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
f127e61e	398	dirtied, period, pause, start_time
b87700e3	399	#else
f127e61e	400	dirtied, pause, start_time
b87700e3 AG	401	#endif
	402	),
	403
f127e61e MD	404	TP_FIELDS(
	405	ctf_array_text(char, bdi, dev_name(bdi->dev), 32)
	406	ctf_integer(unsigned long, limit, global_dirty_limit)
	407	ctf_integer(unsigned long, setpoint,
b87700e3	408	(global_dirty_limit + (thresh + bg_thresh) / 2) / 2)
f127e61e MD	409	ctf_integer(unsigned long, dirty, dirty)
f127e61e MD	410	ctf_integer(unsigned long, bdi_setpoint,
b87700e3	411	((global_dirty_limit + (thresh + bg_thresh) / 2) / 2) *
f127e61e MD	412	bdi_thresh / (thresh + 1))
	413	ctf_integer(unsigned long, bdi_dirty, bdi_dirty)
	414	ctf_integer(unsigned long, dirty_ratelimit,
	415	KBps(dirty_ratelimit))
	416	ctf_integer(unsigned long, task_ratelimit,
	417	KBps(task_ratelimit))
	418	ctf_integer(unsigned int, dirtied, dirtied)
	419	ctf_integer(unsigned int, dirtied_pause,
	420	current->nr_dirtied_pause)
	421	ctf_integer(unsigned long, paused,
	422	(jiffies - start_time) * 1000 / HZ)
	423	ctf_integer(long, pause, pause * 1000 / HZ)
b87700e3	424	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
f127e61e MD	425	ctf_integer(unsigned long, period,
	426	period * 1000 / HZ)
	427	ctf_integer(long, think,
	428	current->dirty_paused_when == 0 ? 0 :
	429	(long)(jiffies - current->dirty_paused_when) * 1000/HZ)
b87700e3	430	#endif
f127e61e	431	)
b87700e3 AG	432	)
	433	#endif
	434
	435	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0))
3bc29f0a	436	LTTNG_TRACEPOINT_EVENT(writeback_sb_inodes_requeue,
b87700e3 AG	437
	438	TP_PROTO(struct inode *inode),
	439	TP_ARGS(inode),
	440
f127e61e MD	441	TP_FIELDS(
	442	ctf_array_text(char, name,
	443	dev_name(inode_to_bdi(inode)->dev), 32)
	444	ctf_integer(unsigned long, ino, inode->i_ino)
	445	ctf_integer(unsigned long, state, inode->i_state)
	446	ctf_integer(unsigned long, dirtied_when, inode->dirtied_when)
b87700e3 AG	447	)
	448	)
	449	#endif
	450
	451	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
3bc29f0a	452	LTTNG_TRACEPOINT_EVENT_CLASS(writeback_congest_waited_template,
b87700e3 AG	453
	454	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
	455
	456	TP_ARGS(usec_timeout, usec_delayed),
	457
f127e61e MD	458	TP_FIELDS(
	459	ctf_integer(unsigned int, usec_timeout, usec_timeout)
	460	ctf_integer(unsigned int, usec_delayed, usec_delayed)
	461	)
b87700e3 AG	462	)
b87700e3 AG	463
3bc29f0a	464	LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_congest_waited_template, writeback_congestion_wait,
b87700e3 AG	465
	466	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
	467
	468	TP_ARGS(usec_timeout, usec_delayed)
	469	)
	470
3bc29f0a	471	LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_congest_waited_template, writeback_wait_iff_congested,
b87700e3 AG	472
	473	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
	474
	475	TP_ARGS(usec_timeout, usec_delayed)
	476	)
	477	#endif
	478
	479	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
3bc29f0a	480	LTTNG_TRACEPOINT_EVENT_CLASS(writeback_single_inode_template,
b87700e3 AG	481
	482	TP_PROTO(struct inode *inode,
	483	struct writeback_control *wbc,
	484	unsigned long nr_to_write
	485	),
	486
	487	TP_ARGS(inode, wbc, nr_to_write),
	488
f127e61e MD	489	TP_FIELDS(
	490	ctf_array_text(char, name,
	491	dev_name(inode_to_bdi(inode)->dev), 32)
	492	ctf_integer(unsigned long, ino, inode->i_ino)
	493	ctf_integer(unsigned long, state, inode->i_state)
	494	ctf_integer(unsigned long, dirtied_when, inode->dirtied_when)
	495	ctf_integer(unsigned long, writeback_index,
	496	inode->i_mapping->writeback_index)
	497	ctf_integer(long, nr_to_write, nr_to_write)
	498	ctf_integer(unsigned long, wrote,
	499	nr_to_write - wbc->nr_to_write)
b87700e3 AG	500	)
	501	)
	502
	503	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
3bc29f0a	504	LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_single_inode_template, writeback_single_inode_requeue,
b87700e3 AG	505	TP_PROTO(struct inode *inode,
	506	struct writeback_control *wbc,
	507	unsigned long nr_to_write),
	508	TP_ARGS(inode, wbc, nr_to_write)
	509	)
	510	#endif
	511
3bc29f0a	512	LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_single_inode_template, writeback_single_inode,
b87700e3 AG	513	TP_PROTO(struct inode *inode,
	514	struct writeback_control *wbc,
	515	unsigned long nr_to_write),
	516	TP_ARGS(inode, wbc, nr_to_write)
	517	)
	518	#endif
	519
3bc29f0a	520	#endif /* LTTNG_TRACE_WRITEBACK_H */
b87700e3 AG	521
	522	/* This part must be outside protection */
	523	#include "../../../probes/define_trace.h"