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

#undef TRACE_SYSTEM
#define TRACE_SYSTEM vmscan

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

#include <linux/types.h>
#include <linux/tracepoint.h>
#include <linux/mm.h>
#include <linux/memcontrol.h>
#include <trace/events/gfpflags.h>
#include <linux/version.h>

#ifndef _TRACE_VMSCAN_DEF
#define _TRACE_VMSCAN_DEF
#define RECLAIM_WB_ANON		0x0001u
#define RECLAIM_WB_FILE		0x0002u
#define RECLAIM_WB_MIXED	0x0010u
#define RECLAIM_WB_SYNC		0x0004u /* Unused, all reclaim async */
#define RECLAIM_WB_ASYNC	0x0008u

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
#define show_reclaim_flags(flags)				\
	(flags) ? __print_flags(flags, "|",			\
		{RECLAIM_WB_ANON,	"RECLAIM_WB_ANON"},	\
		{RECLAIM_WB_FILE,	"RECLAIM_WB_FILE"},	\
		{RECLAIM_WB_MIXED,	"RECLAIM_WB_MIXED"},	\
		{RECLAIM_WB_SYNC,	"RECLAIM_WB_SYNC"},	\
		{RECLAIM_WB_ASYNC,	"RECLAIM_WB_ASYNC"}	\
		) : "RECLAIM_WB_NONE"
#else
#define show_reclaim_flags(flags)				\
	(flags) ? __print_flags(flags, "|",			\
		{RECLAIM_WB_ANON,	"RECLAIM_WB_ANON"},	\
		{RECLAIM_WB_FILE,	"RECLAIM_WB_FILE"},	\
		{RECLAIM_WB_SYNC,	"RECLAIM_WB_SYNC"},	\
		{RECLAIM_WB_ASYNC,	"RECLAIM_WB_ASYNC"}	\
		) : "RECLAIM_WB_NONE"
#endif

#if ((LINUX_VERSION_CODE <= KERNEL_VERSION(3,0,38)) || \
	LTTNG_KERNEL_RANGE(3,1,0, 3,2,0))
typedef int isolate_mode_t;
#endif

#endif

TRACE_EVENT(mm_vmscan_kswapd_sleep,

	TP_PROTO(int nid),

	TP_ARGS(nid),

	TP_STRUCT__entry(
		__field(	int,	nid	)
	),

	TP_fast_assign(
		tp_assign(nid, nid)
	),

	TP_printk("nid=%d", __entry->nid)
)

TRACE_EVENT(mm_vmscan_kswapd_wake,

	TP_PROTO(int nid, int order),

	TP_ARGS(nid, order),

	TP_STRUCT__entry(
		__field(	int,	nid	)
		__field(	int,	order	)
	),

	TP_fast_assign(
		tp_assign(nid, nid)
		tp_assign(order, order)
	),

	TP_printk("nid=%d order=%d", __entry->nid, __entry->order)
)

TRACE_EVENT(mm_vmscan_wakeup_kswapd,

	TP_PROTO(int nid, int zid, int order),

	TP_ARGS(nid, zid, order),

	TP_STRUCT__entry(
		__field(	int,		nid	)
		__field(	int,		zid	)
		__field(	int,		order	)
	),

	TP_fast_assign(
		tp_assign(nid, nid)
		tp_assign(zid, zid)
		tp_assign(order, order)
	),

	TP_printk("nid=%d zid=%d order=%d",
		__entry->nid,
		__entry->zid,
		__entry->order)
)

DECLARE_EVENT_CLASS(mm_vmscan_direct_reclaim_begin_template,

	TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),

	TP_ARGS(order, may_writepage, gfp_flags),

	TP_STRUCT__entry(
		__field(	int,	order		)
		__field(	int,	may_writepage	)
		__field(	gfp_t,	gfp_flags	)
	),

	TP_fast_assign(
		tp_assign(order, order)
		tp_assign(may_writepage, may_writepage)
		tp_assign(gfp_flags, gfp_flags)
	),

	TP_printk("order=%d may_writepage=%d gfp_flags=%s",
		__entry->order,
		__entry->may_writepage,
		show_gfp_flags(__entry->gfp_flags))
)

DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_direct_reclaim_begin,

	TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),

	TP_ARGS(order, may_writepage, gfp_flags)
)

DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_reclaim_begin,

	TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),

	TP_ARGS(order, may_writepage, gfp_flags)
)

DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_softlimit_reclaim_begin,

	TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),

	TP_ARGS(order, may_writepage, gfp_flags)
)

DECLARE_EVENT_CLASS(mm_vmscan_direct_reclaim_end_template,

	TP_PROTO(unsigned long nr_reclaimed),

	TP_ARGS(nr_reclaimed),

	TP_STRUCT__entry(
		__field(	unsigned long,	nr_reclaimed	)
	),

	TP_fast_assign(
		tp_assign(nr_reclaimed, nr_reclaimed)
	),

	TP_printk("nr_reclaimed=%lu", __entry->nr_reclaimed)
)

DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_direct_reclaim_end,

	TP_PROTO(unsigned long nr_reclaimed),

	TP_ARGS(nr_reclaimed)
)

DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_reclaim_end,

	TP_PROTO(unsigned long nr_reclaimed),

	TP_ARGS(nr_reclaimed)
)

DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_softlimit_reclaim_end,

	TP_PROTO(unsigned long nr_reclaimed),

	TP_ARGS(nr_reclaimed)
)

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
TRACE_EVENT(mm_shrink_slab_start,
	TP_PROTO(struct shrinker *shr, struct shrink_control *sc,
		long nr_objects_to_shrink, unsigned long pgs_scanned,
		unsigned long lru_pgs, unsigned long cache_items,
		unsigned long long delta, unsigned long total_scan),

	TP_ARGS(shr, sc, nr_objects_to_shrink, pgs_scanned, lru_pgs,
		cache_items, delta, total_scan),

	TP_STRUCT__entry(
		__field(struct shrinker *, shr)
		__field(void *, shrink)
		__field(long, nr_objects_to_shrink)
		__field(gfp_t, gfp_flags)
		__field(unsigned long, pgs_scanned)
		__field(unsigned long, lru_pgs)
		__field(unsigned long, cache_items)
		__field(unsigned long long, delta)
		__field(unsigned long, total_scan)
	),

	TP_fast_assign(
		tp_assign(shr,shr)
		tp_assign(shrink, shr->shrink)
		tp_assign(nr_objects_to_shrink, nr_objects_to_shrink)
		tp_assign(gfp_flags, sc->gfp_mask)
		tp_assign(pgs_scanned, pgs_scanned)
		tp_assign(lru_pgs, lru_pgs)
		tp_assign(cache_items, cache_items)
		tp_assign(delta, delta)
		tp_assign(total_scan, total_scan)
	),

	TP_printk("%pF %p: objects to shrink %ld gfp_flags %s pgs_scanned %ld lru_pgs %ld cache items %ld delta %lld total_scan %ld",
		__entry->shrink,
		__entry->shr,
		__entry->nr_objects_to_shrink,
		show_gfp_flags(__entry->gfp_flags),
		__entry->pgs_scanned,
		__entry->lru_pgs,
		__entry->cache_items,
		__entry->delta,
		__entry->total_scan)
)

TRACE_EVENT(mm_shrink_slab_end,
	TP_PROTO(struct shrinker *shr, int shrinker_retval,
		long unused_scan_cnt, long new_scan_cnt),

	TP_ARGS(shr, shrinker_retval, unused_scan_cnt, new_scan_cnt),

	TP_STRUCT__entry(
		__field(struct shrinker *, shr)
		__field(void *, shrink)
		__field(long, unused_scan)
		__field(long, new_scan)
		__field(int, retval)
		__field(long, total_scan)
	),

	TP_fast_assign(
		tp_assign(shr, shr)
		tp_assign(shrink, shr->shrink)
		tp_assign(unused_scan, unused_scan_cnt)
		tp_assign(new_scan, new_scan_cnt)
		tp_assign(retval, shrinker_retval)
		tp_assign(total_scan, new_scan_cnt - unused_scan_cnt)
	),

	TP_printk("%pF %p: unused scan count %ld new scan count %ld total_scan %ld last shrinker return val %d",
		__entry->shrink,
		__entry->shr,
		__entry->unused_scan,
		__entry->new_scan,
		__entry->total_scan,
		__entry->retval)
)
#endif

DECLARE_EVENT_CLASS(mm_vmscan_lru_isolate_template,

	TP_PROTO(int order,
		unsigned long nr_requested,
		unsigned long nr_scanned,
		unsigned long nr_taken,
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
		unsigned long nr_lumpy_taken,
		unsigned long nr_lumpy_dirty,
		unsigned long nr_lumpy_failed,
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
		isolate_mode_t isolate_mode
#else
		isolate_mode_t isolate_mode,
		int file
#endif
	),

	TP_ARGS(order, nr_requested, nr_scanned, nr_taken,
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
		nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed,
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
		isolate_mode
#else
		isolate_mode, file
#endif
	),


	TP_STRUCT__entry(
		__field(int, order)
		__field(unsigned long, nr_requested)
		__field(unsigned long, nr_scanned)
		__field(unsigned long, nr_taken)
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
		__field(unsigned long, nr_lumpy_taken)
		__field(unsigned long, nr_lumpy_dirty)
		__field(unsigned long, nr_lumpy_failed)
#endif
		__field(isolate_mode_t, isolate_mode)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
		__field(int, file)
#endif
	),

	TP_fast_assign(
		tp_assign(order, order)
		tp_assign(nr_requested, nr_requested)
		tp_assign(nr_scanned, nr_scanned)
		tp_assign(nr_taken, nr_taken)
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
		tp_assign(nr_lumpy_taken, nr_lumpy_taken)
		tp_assign(nr_lumpy_dirty, nr_lumpy_dirty)
		tp_assign(nr_lumpy_failed, nr_lumpy_failed)
#endif
		tp_assign(isolate_mode, isolate_mode)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
		tp_assign(file, file)
#endif
	),

#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
	TP_printk("isolate_mode=%d order=%d nr_requested=%lu nr_scanned=%lu nr_taken=%lu contig_taken=%lu contig_dirty=%lu contig_failed=%lu",
		__entry->isolate_mode,
		__entry->order,
		__entry->nr_requested,
		__entry->nr_scanned,
		__entry->nr_taken,
		__entry->nr_lumpy_taken,
		__entry->nr_lumpy_dirty,
		__entry->nr_lumpy_failed)
#elif (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
	TP_printk("isolate_mode=%d order=%d nr_requested=%lu nr_scanned=%lu nr_taken=%lu contig_taken=%lu contig_dirty=%lu contig_failed=%lu file=%d",
		__entry->isolate_mode,
		__entry->order,
		__entry->nr_requested,
		__entry->nr_scanned,
		__entry->nr_taken,
		__entry->nr_lumpy_taken,
		__entry->nr_lumpy_dirty,
		__entry->nr_lumpy_failed,
		__entry->file)
#else
	TP_printk("isolate_mode=%d order=%d nr_requested=%lu nr_scanned=%lu nr_taken=%lu file=%d",
		__entry->isolate_mode,
		__entry->order,
		__entry->nr_requested,
		__entry->nr_scanned,
		__entry->nr_taken,
		__entry->file)
#endif
)

DEFINE_EVENT(mm_vmscan_lru_isolate_template, mm_vmscan_lru_isolate,

	TP_PROTO(int order,
		unsigned long nr_requested,
		unsigned long nr_scanned,
		unsigned long nr_taken,
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
		unsigned long nr_lumpy_taken,
		unsigned long nr_lumpy_dirty,
		unsigned long nr_lumpy_failed,
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
		isolate_mode_t isolate_mode
#else
		isolate_mode_t isolate_mode,
		int file
#endif
	),

	TP_ARGS(order, nr_requested, nr_scanned, nr_taken,
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
		nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed,
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
		isolate_mode
#else
		isolate_mode, file
#endif
	)

)

DEFINE_EVENT(mm_vmscan_lru_isolate_template, mm_vmscan_memcg_isolate,

	TP_PROTO(int order,
		unsigned long nr_requested,
		unsigned long nr_scanned,
		unsigned long nr_taken,
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
		unsigned long nr_lumpy_taken,
		unsigned long nr_lumpy_dirty,
		unsigned long nr_lumpy_failed,
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
		isolate_mode_t isolate_mode
#else
		isolate_mode_t isolate_mode,
		int file
#endif
	),

	TP_ARGS(order, nr_requested, nr_scanned, nr_taken,
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
		nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed,
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
		isolate_mode
#else
		isolate_mode, file
#endif
	)
)

TRACE_EVENT(mm_vmscan_writepage,

	TP_PROTO(struct page *page,
		int reclaim_flags),

	TP_ARGS(page, reclaim_flags),

	TP_STRUCT__entry(
		__field(struct page *, page)
		__field(int, reclaim_flags)
	),

	TP_fast_assign(
		tp_assign(page, page)
		tp_assign(reclaim_flags, reclaim_flags)
	),

	TP_printk("page=%p pfn=%lu flags=%s",
		__entry->page,
		page_to_pfn(__entry->page),
		show_reclaim_flags(__entry->reclaim_flags))
)

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
TRACE_EVENT(mm_vmscan_lru_shrink_inactive,

	TP_PROTO(int nid, int zid,
			unsigned long nr_scanned, unsigned long nr_reclaimed,
			int priority, int reclaim_flags),

	TP_ARGS(nid, zid, nr_scanned, nr_reclaimed, priority, reclaim_flags),

	TP_STRUCT__entry(
		__field(int, nid)
		__field(int, zid)
		__field(unsigned long, nr_scanned)
		__field(unsigned long, nr_reclaimed)
		__field(int, priority)
		__field(int, reclaim_flags)
	),

	TP_fast_assign(
		tp_assign(nid, nid)
		tp_assign(zid, zid)
		tp_assign(nr_scanned, nr_scanned)
		tp_assign(nr_reclaimed, nr_reclaimed)
		tp_assign(priority, priority)
		tp_assign(reclaim_flags, reclaim_flags)
	),

	TP_printk("nid=%d zid=%d nr_scanned=%ld nr_reclaimed=%ld priority=%d flags=%s",
		__entry->nid, __entry->zid,
		__entry->nr_scanned, __entry->nr_reclaimed,
		__entry->priority,
		show_reclaim_flags(__entry->reclaim_flags))
)
#endif

#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
TRACE_EVENT_MAP(replace_swap_token,

	mm_vmscan_replace_swap_token,

	TP_PROTO(struct mm_struct *old_mm,
		 struct mm_struct *new_mm),

	TP_ARGS(old_mm, new_mm),

	TP_STRUCT__entry(
		__field(struct mm_struct*,	old_mm)
		__field(unsigned int,		old_prio)
		__field(struct mm_struct*,	new_mm)
		__field(unsigned int,		new_prio)
	),

	TP_fast_assign(
		tp_assign(old_mm, old_mm)
		tp_assign(old_prio, old_mm ? old_mm->token_priority : 0)
		tp_assign(new_mm, new_mm)
		tp_assign(new_prio, new_mm->token_priority)
	),

	TP_printk("old_token_mm=%p old_prio=%u new_token_mm=%p new_prio=%u",
		  __entry->old_mm, __entry->old_prio,
		  __entry->new_mm, __entry->new_prio)
)

DECLARE_EVENT_CLASS(mm_vmscan_put_swap_token_template,
	TP_PROTO(struct mm_struct *swap_token_mm),

	TP_ARGS(swap_token_mm),

	TP_STRUCT__entry(
		__field(struct mm_struct*, swap_token_mm)
	),

	TP_fast_assign(
		tp_assign(swap_token_mm, swap_token_mm)
	),

	TP_printk("token_mm=%p", __entry->swap_token_mm)
)

DEFINE_EVENT_MAP(mm_vmscan_put_swap_token_template, put_swap_token,

	mm_vmscan_put_swap_token,

	TP_PROTO(struct mm_struct *swap_token_mm),
	TP_ARGS(swap_token_mm)
)

DEFINE_EVENT_CONDITION_MAP(mm_vmscan_put_swap_token_template, disable_swap_token,

	mm_vmscan_disable_swap_token,

	TP_PROTO(struct mm_struct *swap_token_mm),
	TP_ARGS(swap_token_mm),
	TP_CONDITION(swap_token_mm != NULL)
)

TRACE_EVENT_CONDITION_MAP(update_swap_token_priority,

	mm_vmscan_update_swap_token_priority,

	TP_PROTO(struct mm_struct *mm,
		 unsigned int old_prio,
		 struct mm_struct *swap_token_mm),

	TP_ARGS(mm, old_prio, swap_token_mm),

	TP_CONDITION(mm->token_priority != old_prio),

	TP_STRUCT__entry(
		__field(struct mm_struct*, mm)
		__field(unsigned int, old_prio)
		__field(unsigned int, new_prio)
		__field(struct mm_struct*, swap_token_mm)
		__field(unsigned int, swap_token_prio)
	),

	TP_fast_assign(
		tp_assign(mm, mm)
		tp_assign(old_prio, old_prio)
		tp_assign(new_prio, mm->token_priority)
		tp_assign(swap_token_mm, swap_token_mm)
		tp_assign(swap_token_prio, swap_token_mm ? swap_token_mm->token_priority : 0)
	),

	TP_printk("mm=%p old_prio=%u new_prio=%u swap_token_mm=%p token_prio=%u",
		  __entry->mm, __entry->old_prio, __entry->new_prio,
		  __entry->swap_token_mm, __entry->swap_token_prio)
)
#endif

#endif /* _TRACE_VMSCAN_H */

/* This part must be outside protection */
#include "../../../probes/define_trace.h"
Commit	Line	Data
b283666f PW	1	#undef TRACE_SYSTEM
	2	#define TRACE_SYSTEM vmscan
	3
	4	#if !defined(_TRACE_VMSCAN_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	5	#define _TRACE_VMSCAN_H
	6
7c68b363 AG	7	#include <linux/types.h>
	8	#include <linux/tracepoint.h>
	9	#include <linux/mm.h>
	10	#include <linux/memcontrol.h>
	11	#include <trace/events/gfpflags.h>
	12	#include <linux/version.h>
	13
	14	#ifndef _TRACE_VMSCAN_DEF
	15	#define _TRACE_VMSCAN_DEF
	16	#define RECLAIM_WB_ANON 0x0001u
	17	#define RECLAIM_WB_FILE 0x0002u
	18	#define RECLAIM_WB_MIXED 0x0010u
	19	#define RECLAIM_WB_SYNC 0x0004u /* Unused, all reclaim async */
	20	#define RECLAIM_WB_ASYNC 0x0008u
	21
	22	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
	23	#define show_reclaim_flags(flags) \
	24	(flags) ? __print_flags(flags, "\|", \
	25	{RECLAIM_WB_ANON, "RECLAIM_WB_ANON"}, \
	26	{RECLAIM_WB_FILE, "RECLAIM_WB_FILE"}, \
	27	{RECLAIM_WB_MIXED, "RECLAIM_WB_MIXED"}, \
	28	{RECLAIM_WB_SYNC, "RECLAIM_WB_SYNC"}, \
	29	{RECLAIM_WB_ASYNC, "RECLAIM_WB_ASYNC"} \
	30	) : "RECLAIM_WB_NONE"
	31	#else
	32	#define show_reclaim_flags(flags) \
	33	(flags) ? __print_flags(flags, "\|", \
	34	{RECLAIM_WB_ANON, "RECLAIM_WB_ANON"}, \
	35	{RECLAIM_WB_FILE, "RECLAIM_WB_FILE"}, \
	36	{RECLAIM_WB_SYNC, "RECLAIM_WB_SYNC"}, \
	37	{RECLAIM_WB_ASYNC, "RECLAIM_WB_ASYNC"} \
	38	) : "RECLAIM_WB_NONE"
	39	#endif
	40
	41	#if ((LINUX_VERSION_CODE <= KERNEL_VERSION(3,0,38)) \|\| \
	42	LTTNG_KERNEL_RANGE(3,1,0, 3,2,0))
	43	typedef int isolate_mode_t;
	44	#endif
	45
	46	#endif
	47
b283666f PW	48	TRACE_EVENT(mm_vmscan_kswapd_sleep,
	49
	50	TP_PROTO(int nid),
	51
	52	TP_ARGS(nid),
	53
	54	TP_STRUCT__entry(
	55	__field( int, nid )
	56	),
	57
	58	TP_fast_assign(
d3ac4d63	59	tp_assign(nid, nid)
b283666f PW	60	),
	61
	62	TP_printk("nid=%d", __entry->nid)
	63	)
	64
	65	TRACE_EVENT(mm_vmscan_kswapd_wake,
	66
	67	TP_PROTO(int nid, int order),
	68
	69	TP_ARGS(nid, order),
	70
	71	TP_STRUCT__entry(
	72	__field( int, nid )
	73	__field( int, order )
	74	),
	75
	76	TP_fast_assign(
d3ac4d63 PW	77	tp_assign(nid, nid)
d3ac4d63 PW	78	tp_assign(order, order)
b283666f PW	79	),
	80
	81	TP_printk("nid=%d order=%d", __entry->nid, __entry->order)
	82	)
	83
	84	TRACE_EVENT(mm_vmscan_wakeup_kswapd,
	85
	86	TP_PROTO(int nid, int zid, int order),
	87
	88	TP_ARGS(nid, zid, order),
	89
	90	TP_STRUCT__entry(
	91	__field( int, nid )
	92	__field( int, zid )
	93	__field( int, order )
	94	),
	95
	96	TP_fast_assign(
d3ac4d63 PW	97	tp_assign(nid, nid)
	98	tp_assign(zid, zid)
	99	tp_assign(order, order)
b283666f PW	100	),
	101
	102	TP_printk("nid=%d zid=%d order=%d",
	103	__entry->nid,
	104	__entry->zid,
	105	__entry->order)
	106	)
	107
	108	DECLARE_EVENT_CLASS(mm_vmscan_direct_reclaim_begin_template,
	109
	110	TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
	111
	112	TP_ARGS(order, may_writepage, gfp_flags),
	113
	114	TP_STRUCT__entry(
	115	__field( int, order )
	116	__field( int, may_writepage )
	117	__field( gfp_t, gfp_flags )
	118	),
	119
	120	TP_fast_assign(
d3ac4d63 PW	121	tp_assign(order, order)
	122	tp_assign(may_writepage, may_writepage)
	123	tp_assign(gfp_flags, gfp_flags)
b283666f PW	124	),
	125
	126	TP_printk("order=%d may_writepage=%d gfp_flags=%s",
	127	__entry->order,
	128	__entry->may_writepage,
	129	show_gfp_flags(__entry->gfp_flags))
	130	)
	131
	132	DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_direct_reclaim_begin,
	133
	134	TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
	135
	136	TP_ARGS(order, may_writepage, gfp_flags)
	137	)
	138
	139	DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_reclaim_begin,
	140
	141	TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
	142
	143	TP_ARGS(order, may_writepage, gfp_flags)
	144	)
	145
	146	DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_softlimit_reclaim_begin,
	147
	148	TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
	149
	150	TP_ARGS(order, may_writepage, gfp_flags)
	151	)
	152
	153	DECLARE_EVENT_CLASS(mm_vmscan_direct_reclaim_end_template,
	154
	155	TP_PROTO(unsigned long nr_reclaimed),
	156
	157	TP_ARGS(nr_reclaimed),
	158
	159	TP_STRUCT__entry(
	160	__field( unsigned long, nr_reclaimed )
	161	),
	162
	163	TP_fast_assign(
d3ac4d63	164	tp_assign(nr_reclaimed, nr_reclaimed)
b283666f PW	165	),
	166
	167	TP_printk("nr_reclaimed=%lu", __entry->nr_reclaimed)
	168	)
	169
	170	DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_direct_reclaim_end,
	171
	172	TP_PROTO(unsigned long nr_reclaimed),
	173
	174	TP_ARGS(nr_reclaimed)
	175	)
	176
	177	DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_reclaim_end,
	178
	179	TP_PROTO(unsigned long nr_reclaimed),
	180
	181	TP_ARGS(nr_reclaimed)
	182	)
	183
	184	DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_softlimit_reclaim_end,
	185
	186	TP_PROTO(unsigned long nr_reclaimed),
	187
	188	TP_ARGS(nr_reclaimed)
	189	)
	190
7c68b363	191	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
b283666f PW	192	TRACE_EVENT(mm_shrink_slab_start,
	193	TP_PROTO(struct shrinker shr, struct shrink_control sc,
	194	long nr_objects_to_shrink, unsigned long pgs_scanned,
	195	unsigned long lru_pgs, unsigned long cache_items,
	196	unsigned long long delta, unsigned long total_scan),
	197
	198	TP_ARGS(shr, sc, nr_objects_to_shrink, pgs_scanned, lru_pgs,
	199	cache_items, delta, total_scan),
	200
	201	TP_STRUCT__entry(
	202	__field(struct shrinker *, shr)
	203	__field(void *, shrink)
	204	__field(long, nr_objects_to_shrink)
	205	__field(gfp_t, gfp_flags)
	206	__field(unsigned long, pgs_scanned)
	207	__field(unsigned long, lru_pgs)
	208	__field(unsigned long, cache_items)
	209	__field(unsigned long long, delta)
	210	__field(unsigned long, total_scan)
	211	),
	212
	213	TP_fast_assign(
d3ac4d63 PW	214	tp_assign(shr,shr)
	215	tp_assign(shrink, shr->shrink)
	216	tp_assign(nr_objects_to_shrink, nr_objects_to_shrink)
	217	tp_assign(gfp_flags, sc->gfp_mask)
	218	tp_assign(pgs_scanned, pgs_scanned)
	219	tp_assign(lru_pgs, lru_pgs)
	220	tp_assign(cache_items, cache_items)
	221	tp_assign(delta, delta)
	222	tp_assign(total_scan, total_scan)
b283666f PW	223	),
	224
	225	TP_printk("%pF %p: objects to shrink %ld gfp_flags %s pgs_scanned %ld lru_pgs %ld cache items %ld delta %lld total_scan %ld",
	226	__entry->shrink,
	227	__entry->shr,
	228	__entry->nr_objects_to_shrink,
	229	show_gfp_flags(__entry->gfp_flags),
	230	__entry->pgs_scanned,
	231	__entry->lru_pgs,
	232	__entry->cache_items,
	233	__entry->delta,
	234	__entry->total_scan)
	235	)
	236
	237	TRACE_EVENT(mm_shrink_slab_end,
	238	TP_PROTO(struct shrinker *shr, int shrinker_retval,
	239	long unused_scan_cnt, long new_scan_cnt),
	240
	241	TP_ARGS(shr, shrinker_retval, unused_scan_cnt, new_scan_cnt),
	242
	243	TP_STRUCT__entry(
	244	__field(struct shrinker *, shr)
	245	__field(void *, shrink)
	246	__field(long, unused_scan)
	247	__field(long, new_scan)
	248	__field(int, retval)
	249	__field(long, total_scan)
	250	),
	251
	252	TP_fast_assign(
d3ac4d63 PW	253	tp_assign(shr, shr)
	254	tp_assign(shrink, shr->shrink)
	255	tp_assign(unused_scan, unused_scan_cnt)
	256	tp_assign(new_scan, new_scan_cnt)
	257	tp_assign(retval, shrinker_retval)
	258	tp_assign(total_scan, new_scan_cnt - unused_scan_cnt)
b283666f PW	259	),
	260
	261	TP_printk("%pF %p: unused scan count %ld new scan count %ld total_scan %ld last shrinker return val %d",
	262	__entry->shrink,
	263	__entry->shr,
	264	__entry->unused_scan,
	265	__entry->new_scan,
	266	__entry->total_scan,
	267	__entry->retval)
	268	)
7c68b363	269	#endif
b283666f PW	270
	271	DECLARE_EVENT_CLASS(mm_vmscan_lru_isolate_template,
	272
	273	TP_PROTO(int order,
	274	unsigned long nr_requested,
	275	unsigned long nr_scanned,
	276	unsigned long nr_taken,
7c68b363	277	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
b283666f PW	278	unsigned long nr_lumpy_taken,
	279	unsigned long nr_lumpy_dirty,
	280	unsigned long nr_lumpy_failed,
7c68b363	281	#endif
b283666f	282	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
7c68b363	283	isolate_mode_t isolate_mode
b283666f PW	284	#else
b283666f PW	285	isolate_mode_t isolate_mode,
7c68b363	286	int file
b283666f	287	#endif
7c68b363	288	),
b283666f	289
7c68b363 AG	290	TP_ARGS(order, nr_requested, nr_scanned, nr_taken,
	291	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
	292	nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed,
	293	#endif
b283666f	294	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
7c68b363	295	isolate_mode
b283666f	296	#else
7c68b363	297	isolate_mode, file
b283666f	298	#endif
7c68b363 AG	299	),
7c68b363 AG	300
b283666f PW	301
	302	TP_STRUCT__entry(
	303	__field(int, order)
	304	__field(unsigned long, nr_requested)
	305	__field(unsigned long, nr_scanned)
	306	__field(unsigned long, nr_taken)
7c68b363	307	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
b283666f PW	308	__field(unsigned long, nr_lumpy_taken)
	309	__field(unsigned long, nr_lumpy_dirty)
	310	__field(unsigned long, nr_lumpy_failed)
7c68b363	311	#endif
b283666f PW	312	__field(isolate_mode_t, isolate_mode)
	313	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
	314	__field(int, file)
	315	#endif
	316	),
	317
	318	TP_fast_assign(
d3ac4d63 PW	319	tp_assign(order, order)
	320	tp_assign(nr_requested, nr_requested)
	321	tp_assign(nr_scanned, nr_scanned)
	322	tp_assign(nr_taken, nr_taken)
7c68b363	323	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
d3ac4d63 PW	324	tp_assign(nr_lumpy_taken, nr_lumpy_taken)
	325	tp_assign(nr_lumpy_dirty, nr_lumpy_dirty)
	326	tp_assign(nr_lumpy_failed, nr_lumpy_failed)
7c68b363	327	#endif
d3ac4d63	328	tp_assign(isolate_mode, isolate_mode)
b283666f	329	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
d3ac4d63	330	tp_assign(file, file)
b283666f PW	331	#endif
	332	),
	333
	334	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
	335	TP_printk("isolate_mode=%d order=%d nr_requested=%lu nr_scanned=%lu nr_taken=%lu contig_taken=%lu contig_dirty=%lu contig_failed=%lu",
b283666f PW	336	__entry->isolate_mode,
	337	__entry->order,
	338	__entry->nr_requested,
	339	__entry->nr_scanned,
	340	__entry->nr_taken,
	341	__entry->nr_lumpy_taken,
	342	__entry->nr_lumpy_dirty,
b283666f	343	__entry->nr_lumpy_failed)
7c68b363 AG	344	#elif (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
	345	TP_printk("isolate_mode=%d order=%d nr_requested=%lu nr_scanned=%lu nr_taken=%lu contig_taken=%lu contig_dirty=%lu contig_failed=%lu file=%d",
	346	__entry->isolate_mode,
	347	__entry->order,
	348	__entry->nr_requested,
	349	__entry->nr_scanned,
	350	__entry->nr_taken,
	351	__entry->nr_lumpy_taken,
	352	__entry->nr_lumpy_dirty,
b283666f PW	353	__entry->nr_lumpy_failed,
b283666f PW	354	__entry->file)
7c68b363 AG	355	#else
	356	TP_printk("isolate_mode=%d order=%d nr_requested=%lu nr_scanned=%lu nr_taken=%lu file=%d",
	357	__entry->isolate_mode,
	358	__entry->order,
	359	__entry->nr_requested,
	360	__entry->nr_scanned,
	361	__entry->nr_taken,
	362	__entry->file)
b283666f PW	363	#endif
	364	)
	365
	366	DEFINE_EVENT(mm_vmscan_lru_isolate_template, mm_vmscan_lru_isolate,
	367
	368	TP_PROTO(int order,
	369	unsigned long nr_requested,
	370	unsigned long nr_scanned,
	371	unsigned long nr_taken,
	372	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
	373	unsigned long nr_lumpy_taken,
	374	unsigned long nr_lumpy_dirty,
	375	unsigned long nr_lumpy_failed,
	376	#endif
	377	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
7c68b363	378	isolate_mode_t isolate_mode
b283666f PW	379	#else
b283666f PW	380	isolate_mode_t isolate_mode,
7c68b363	381	int file
b283666f	382	#endif
7c68b363	383	),
b283666f	384
7c68b363 AG	385	TP_ARGS(order, nr_requested, nr_scanned, nr_taken,
	386	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
	387	nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed,
	388	#endif
b283666f	389	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
7c68b363	390	isolate_mode
b283666f	391	#else
7c68b363	392	isolate_mode, file
b283666f	393	#endif
7c68b363	394	)
b283666f PW	395
	396	)
	397
	398	DEFINE_EVENT(mm_vmscan_lru_isolate_template, mm_vmscan_memcg_isolate,
	399
	400	TP_PROTO(int order,
	401	unsigned long nr_requested,
	402	unsigned long nr_scanned,
	403	unsigned long nr_taken,
	404	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
	405	unsigned long nr_lumpy_taken,
	406	unsigned long nr_lumpy_dirty,
	407	unsigned long nr_lumpy_failed,
	408	#endif
	409	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
7c68b363	410	isolate_mode_t isolate_mode
b283666f PW	411	#else
b283666f PW	412	isolate_mode_t isolate_mode,
7c68b363	413	int file
b283666f	414	#endif
7c68b363	415	),
b283666f	416
7c68b363 AG	417	TP_ARGS(order, nr_requested, nr_scanned, nr_taken,
	418	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
	419	nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed,
	420	#endif
b283666f	421	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
7c68b363	422	isolate_mode
b283666f	423	#else
7c68b363	424	isolate_mode, file
b283666f	425	#endif
7c68b363	426	)
b283666f PW	427	)
	428
	429	TRACE_EVENT(mm_vmscan_writepage,
	430
	431	TP_PROTO(struct page *page,
	432	int reclaim_flags),
	433
	434	TP_ARGS(page, reclaim_flags),
	435
	436	TP_STRUCT__entry(
	437	__field(struct page *, page)
	438	__field(int, reclaim_flags)
	439	),
	440
	441	TP_fast_assign(
d3ac4d63 PW	442	tp_assign(page, page)
d3ac4d63 PW	443	tp_assign(reclaim_flags, reclaim_flags)
b283666f PW	444	),
	445
	446	TP_printk("page=%p pfn=%lu flags=%s",
	447	__entry->page,
	448	page_to_pfn(__entry->page),
	449	show_reclaim_flags(__entry->reclaim_flags))
	450	)
	451
7c68b363	452	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
b283666f PW	453	TRACE_EVENT(mm_vmscan_lru_shrink_inactive,
	454
	455	TP_PROTO(int nid, int zid,
	456	unsigned long nr_scanned, unsigned long nr_reclaimed,
	457	int priority, int reclaim_flags),
	458
	459	TP_ARGS(nid, zid, nr_scanned, nr_reclaimed, priority, reclaim_flags),
	460
	461	TP_STRUCT__entry(
	462	__field(int, nid)
	463	__field(int, zid)
	464	__field(unsigned long, nr_scanned)
	465	__field(unsigned long, nr_reclaimed)
	466	__field(int, priority)
	467	__field(int, reclaim_flags)
	468	),
	469
	470	TP_fast_assign(
d3ac4d63 PW	471	tp_assign(nid, nid)
	472	tp_assign(zid, zid)
	473	tp_assign(nr_scanned, nr_scanned)
	474	tp_assign(nr_reclaimed, nr_reclaimed)
	475	tp_assign(priority, priority)
	476	tp_assign(reclaim_flags, reclaim_flags)
b283666f PW	477	),
	478
	479	TP_printk("nid=%d zid=%d nr_scanned=%ld nr_reclaimed=%ld priority=%d flags=%s",
	480	__entry->nid, __entry->zid,
	481	__entry->nr_scanned, __entry->nr_reclaimed,
	482	__entry->priority,
	483	show_reclaim_flags(__entry->reclaim_flags))
	484	)
7c68b363	485	#endif
b283666f PW	486
b283666f PW	487	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
9cf29d3e MD	488	TRACE_EVENT_MAP(replace_swap_token,
	489
	490	mm_vmscan_replace_swap_token,
	491
b283666f PW	492	TP_PROTO(struct mm_struct *old_mm,
	493	struct mm_struct *new_mm),
	494
	495	TP_ARGS(old_mm, new_mm),
	496
	497	TP_STRUCT__entry(
	498	__field(struct mm_struct*, old_mm)
	499	__field(unsigned int, old_prio)
	500	__field(struct mm_struct*, new_mm)
	501	__field(unsigned int, new_prio)
	502	),
	503
	504	TP_fast_assign(
d3ac4d63 PW	505	tp_assign(old_mm, old_mm)
	506	tp_assign(old_prio, old_mm ? old_mm->token_priority : 0)
	507	tp_assign(new_mm, new_mm)
	508	tp_assign(new_prio, new_mm->token_priority)
b283666f PW	509	),
	510
	511	TP_printk("old_token_mm=%p old_prio=%u new_token_mm=%p new_prio=%u",
	512	__entry->old_mm, __entry->old_prio,
	513	__entry->new_mm, __entry->new_prio)
	514	)
	515
9cf29d3e	516	DECLARE_EVENT_CLASS(mm_vmscan_put_swap_token_template,
b283666f PW	517	TP_PROTO(struct mm_struct *swap_token_mm),
	518
	519	TP_ARGS(swap_token_mm),
	520
	521	TP_STRUCT__entry(
	522	__field(struct mm_struct*, swap_token_mm)
	523	),
	524
	525	TP_fast_assign(
d3ac4d63	526	tp_assign(swap_token_mm, swap_token_mm)
b283666f PW	527	),
	528
	529	TP_printk("token_mm=%p", __entry->swap_token_mm)
	530	)
	531
2dd3af12	532	DEFINE_EVENT_MAP(mm_vmscan_put_swap_token_template, put_swap_token,
9cf29d3e MD	533
	534	mm_vmscan_put_swap_token,
	535
b283666f PW	536	TP_PROTO(struct mm_struct *swap_token_mm),
	537	TP_ARGS(swap_token_mm)
	538	)
	539
2dd3af12	540	DEFINE_EVENT_CONDITION_MAP(mm_vmscan_put_swap_token_template, disable_swap_token,
9cf29d3e MD	541
	542	mm_vmscan_disable_swap_token,
	543
b283666f PW	544	TP_PROTO(struct mm_struct *swap_token_mm),
	545	TP_ARGS(swap_token_mm),
	546	TP_CONDITION(swap_token_mm != NULL)
	547	)
	548
9cf29d3e MD	549	TRACE_EVENT_CONDITION_MAP(update_swap_token_priority,
	550
	551	mm_vmscan_update_swap_token_priority,
	552
b283666f PW	553	TP_PROTO(struct mm_struct *mm,
	554	unsigned int old_prio,
	555	struct mm_struct *swap_token_mm),
	556
	557	TP_ARGS(mm, old_prio, swap_token_mm),
	558
	559	TP_CONDITION(mm->token_priority != old_prio),
	560
	561	TP_STRUCT__entry(
	562	__field(struct mm_struct*, mm)
	563	__field(unsigned int, old_prio)
	564	__field(unsigned int, new_prio)
	565	__field(struct mm_struct*, swap_token_mm)
	566	__field(unsigned int, swap_token_prio)
	567	),
	568
	569	TP_fast_assign(
d3ac4d63 PW	570	tp_assign(mm, mm)
	571	tp_assign(old_prio, old_prio)
	572	tp_assign(new_prio, mm->token_priority)
	573	tp_assign(swap_token_mm, swap_token_mm)
	574	tp_assign(swap_token_prio, swap_token_mm ? swap_token_mm->token_priority : 0)
b283666f PW	575	),
	576
	577	TP_printk("mm=%p old_prio=%u new_prio=%u swap_token_mm=%p token_prio=%u",
	578	__entry->mm, __entry->old_prio, __entry->new_prio,
	579	__entry->swap_token_mm, __entry->swap_token_prio)
	580	)
b283666f PW	581	#endif
	582
	583	#endif /* _TRACE_VMSCAN_H */
	584
	585	/* This part must be outside protection */
	586	#include "../../../probes/define_trace.h"