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

#undef TRACE_SYSTEM
#define TRACE_SYSTEM vmscan

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

#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/types.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

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

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

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

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

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

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

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

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

LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_direct_reclaim_end,

	TP_PROTO(unsigned long nr_reclaimed),

	TP_ARGS(nr_reclaimed)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_reclaim_end,

	TP_PROTO(unsigned long nr_reclaimed),

	TP_ARGS(nr_reclaimed)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE(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))
LTTNG_TRACEPOINT_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)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
		tp_assign(shrink, shr->scan_objects)
#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0)) */
		tp_assign(shrink, shr->shrink)
#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0)) */
		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)
)

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0))
LTTNG_TRACEPOINT_EVENT(mm_shrink_slab_end,
	TP_PROTO(struct shrinker *shr, int nid, int shrinker_retval,
		long unused_scan_cnt, long new_scan_cnt, long total_scan),

	TP_ARGS(shr, nid, shrinker_retval, unused_scan_cnt, new_scan_cnt,
		total_scan),

	TP_STRUCT__entry(
		__field(struct shrinker *, shr)
		__field(int, nid)
		__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(nid, nid)
		tp_assign(shrink, shr->scan_objects)
		tp_assign(unused_scan, unused_scan_cnt)
		tp_assign(new_scan, new_scan_cnt)
		tp_assign(retval, shrinker_retval)
		tp_assign(total_scan, total_scan)
	),

	TP_printk("%pF %p: nid %d unused scan count %ld new scan count %ld total_scan %ld last shrinker return val %d",
		__entry->shrink,
		__entry->shr,
		__entry->nid,
		__entry->unused_scan,
		__entry->new_scan,
		__entry->total_scan,
		__entry->retval)
)
#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0)) */
LTTNG_TRACEPOINT_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)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
		tp_assign(shrink, shr->scan_objects)
#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0)) */
		tp_assign(shrink, shr->shrink)
#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0)) */
		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 /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0)) */
#endif

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

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

)

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

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

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

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

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

LTTNG_TRACEPOINT_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 /* LTTNG_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
3bc29f0a MD	4	#if !defined(LTTNG_TRACE_VMSCAN_H) \|\| defined(TRACE_HEADER_MULTI_READ)
3bc29f0a MD	5	#define LTTNG_TRACE_VMSCAN_H
b283666f	6
3bc29f0a	7	#include "../../../probes/lttng-tracepoint-event.h"
7c68b363	8	#include <linux/types.h>
7c68b363 AG	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
3bc29f0a	48	LTTNG_TRACEPOINT_EVENT(mm_vmscan_kswapd_sleep,
b283666f PW	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
3bc29f0a	65	LTTNG_TRACEPOINT_EVENT(mm_vmscan_kswapd_wake,
b283666f PW	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
3bc29f0a	84	LTTNG_TRACEPOINT_EVENT(mm_vmscan_wakeup_kswapd,
b283666f PW	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
3bc29f0a	108	LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_direct_reclaim_begin_template,
b283666f PW	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
3bc29f0a	132	LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_direct_reclaim_begin,
b283666f PW	133
	134	TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
	135
	136	TP_ARGS(order, may_writepage, gfp_flags)
	137	)
	138
3bc29f0a	139	LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_reclaim_begin,
b283666f PW	140
	141	TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
	142
	143	TP_ARGS(order, may_writepage, gfp_flags)
	144	)
	145
3bc29f0a	146	LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_softlimit_reclaim_begin,
b283666f PW	147
	148	TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
	149
	150	TP_ARGS(order, may_writepage, gfp_flags)
	151	)
	152
3bc29f0a	153	LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_direct_reclaim_end_template,
b283666f PW	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
3bc29f0a	170	LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_direct_reclaim_end,
b283666f PW	171
	172	TP_PROTO(unsigned long nr_reclaimed),
	173
	174	TP_ARGS(nr_reclaimed)
	175	)
	176
3bc29f0a	177	LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_reclaim_end,
b283666f PW	178
	179	TP_PROTO(unsigned long nr_reclaimed),
	180
	181	TP_ARGS(nr_reclaimed)
	182	)
	183
3bc29f0a	184	LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_softlimit_reclaim_end,
b283666f PW	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))
3bc29f0a	192	LTTNG_TRACEPOINT_EVENT(mm_shrink_slab_start,
b283666f PW	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	214	tp_assign(shr,shr)
5465fedd MD	215	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
	216	tp_assign(shrink, shr->scan_objects)
	217	#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0)) */
d3ac4d63	218	tp_assign(shrink, shr->shrink)
5465fedd	219	#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0)) */
d3ac4d63 PW	220	tp_assign(nr_objects_to_shrink, nr_objects_to_shrink)
	221	tp_assign(gfp_flags, sc->gfp_mask)
	222	tp_assign(pgs_scanned, pgs_scanned)
	223	tp_assign(lru_pgs, lru_pgs)
	224	tp_assign(cache_items, cache_items)
	225	tp_assign(delta, delta)
	226	tp_assign(total_scan, total_scan)
b283666f PW	227	),
	228
	229	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",
	230	__entry->shrink,
	231	__entry->shr,
	232	__entry->nr_objects_to_shrink,
	233	show_gfp_flags(__entry->gfp_flags),
	234	__entry->pgs_scanned,
	235	__entry->lru_pgs,
	236	__entry->cache_items,
	237	__entry->delta,
	238	__entry->total_scan)
	239	)
	240
5defe623	241	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0))
3bc29f0a	242	LTTNG_TRACEPOINT_EVENT(mm_shrink_slab_end,
5defe623 MD	243	TP_PROTO(struct shrinker *shr, int nid, int shrinker_retval,
	244	long unused_scan_cnt, long new_scan_cnt, long total_scan),
	245
	246	TP_ARGS(shr, nid, shrinker_retval, unused_scan_cnt, new_scan_cnt,
	247	total_scan),
	248
	249	TP_STRUCT__entry(
	250	__field(struct shrinker *, shr)
	251	__field(int, nid)
	252	__field(void *, shrink)
	253	__field(long, unused_scan)
	254	__field(long, new_scan)
	255	__field(int, retval)
	256	__field(long, total_scan)
	257	),
	258
	259	TP_fast_assign(
	260	tp_assign(shr, shr)
	261	tp_assign(nid, nid)
	262	tp_assign(shrink, shr->scan_objects)
	263	tp_assign(unused_scan, unused_scan_cnt)
	264	tp_assign(new_scan, new_scan_cnt)
	265	tp_assign(retval, shrinker_retval)
	266	tp_assign(total_scan, total_scan)
	267	),
	268
	269	TP_printk("%pF %p: nid %d unused scan count %ld new scan count %ld total_scan %ld last shrinker return val %d",
	270	__entry->shrink,
	271	__entry->shr,
	272	__entry->nid,
	273	__entry->unused_scan,
	274	__entry->new_scan,
	275	__entry->total_scan,
	276	__entry->retval)
	277	)
	278	#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0)) */
3bc29f0a	279	LTTNG_TRACEPOINT_EVENT(mm_shrink_slab_end,
b283666f PW	280	TP_PROTO(struct shrinker *shr, int shrinker_retval,
	281	long unused_scan_cnt, long new_scan_cnt),
	282
	283	TP_ARGS(shr, shrinker_retval, unused_scan_cnt, new_scan_cnt),
	284
	285	TP_STRUCT__entry(
	286	__field(struct shrinker *, shr)
	287	__field(void *, shrink)
	288	__field(long, unused_scan)
	289	__field(long, new_scan)
	290	__field(int, retval)
	291	__field(long, total_scan)
	292	),
	293
	294	TP_fast_assign(
d3ac4d63	295	tp_assign(shr, shr)
5465fedd MD	296	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
	297	tp_assign(shrink, shr->scan_objects)
	298	#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0)) */
d3ac4d63	299	tp_assign(shrink, shr->shrink)
5465fedd	300	#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0)) */
d3ac4d63 PW	301	tp_assign(unused_scan, unused_scan_cnt)
	302	tp_assign(new_scan, new_scan_cnt)
	303	tp_assign(retval, shrinker_retval)
	304	tp_assign(total_scan, new_scan_cnt - unused_scan_cnt)
b283666f PW	305	),
	306
	307	TP_printk("%pF %p: unused scan count %ld new scan count %ld total_scan %ld last shrinker return val %d",
	308	__entry->shrink,
	309	__entry->shr,
	310	__entry->unused_scan,
	311	__entry->new_scan,
	312	__entry->total_scan,
	313	__entry->retval)
	314	)
5defe623	315	#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0)) */
7c68b363	316	#endif
b283666f	317
3bc29f0a	318	LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_lru_isolate_template,
b283666f PW	319
	320	TP_PROTO(int order,
	321	unsigned long nr_requested,
	322	unsigned long nr_scanned,
	323	unsigned long nr_taken,
7c68b363	324	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
b283666f PW	325	unsigned long nr_lumpy_taken,
	326	unsigned long nr_lumpy_dirty,
	327	unsigned long nr_lumpy_failed,
7c68b363	328	#endif
b283666f	329	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
7c68b363	330	isolate_mode_t isolate_mode
b283666f PW	331	#else
b283666f PW	332	isolate_mode_t isolate_mode,
7c68b363	333	int file
b283666f	334	#endif
7c68b363	335	),
b283666f	336
7c68b363 AG	337	TP_ARGS(order, nr_requested, nr_scanned, nr_taken,
	338	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
	339	nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed,
	340	#endif
b283666f	341	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
7c68b363	342	isolate_mode
b283666f	343	#else
7c68b363	344	isolate_mode, file
b283666f	345	#endif
7c68b363 AG	346	),
7c68b363 AG	347
b283666f PW	348
	349	TP_STRUCT__entry(
	350	__field(int, order)
	351	__field(unsigned long, nr_requested)
	352	__field(unsigned long, nr_scanned)
	353	__field(unsigned long, nr_taken)
7c68b363	354	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
b283666f PW	355	__field(unsigned long, nr_lumpy_taken)
	356	__field(unsigned long, nr_lumpy_dirty)
	357	__field(unsigned long, nr_lumpy_failed)
7c68b363	358	#endif
b283666f PW	359	__field(isolate_mode_t, isolate_mode)
	360	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
	361	__field(int, file)
	362	#endif
	363	),
	364
	365	TP_fast_assign(
d3ac4d63 PW	366	tp_assign(order, order)
	367	tp_assign(nr_requested, nr_requested)
	368	tp_assign(nr_scanned, nr_scanned)
	369	tp_assign(nr_taken, nr_taken)
7c68b363	370	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
d3ac4d63 PW	371	tp_assign(nr_lumpy_taken, nr_lumpy_taken)
	372	tp_assign(nr_lumpy_dirty, nr_lumpy_dirty)
	373	tp_assign(nr_lumpy_failed, nr_lumpy_failed)
7c68b363	374	#endif
d3ac4d63	375	tp_assign(isolate_mode, isolate_mode)
b283666f	376	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
d3ac4d63	377	tp_assign(file, file)
b283666f PW	378	#endif
	379	),
	380
	381	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
	382	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	383	__entry->isolate_mode,
	384	__entry->order,
	385	__entry->nr_requested,
	386	__entry->nr_scanned,
	387	__entry->nr_taken,
	388	__entry->nr_lumpy_taken,
	389	__entry->nr_lumpy_dirty,
b283666f	390	__entry->nr_lumpy_failed)
7c68b363 AG	391	#elif (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
	392	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",
	393	__entry->isolate_mode,
	394	__entry->order,
	395	__entry->nr_requested,
	396	__entry->nr_scanned,
	397	__entry->nr_taken,
	398	__entry->nr_lumpy_taken,
	399	__entry->nr_lumpy_dirty,
b283666f PW	400	__entry->nr_lumpy_failed,
b283666f PW	401	__entry->file)
7c68b363 AG	402	#else
	403	TP_printk("isolate_mode=%d order=%d nr_requested=%lu nr_scanned=%lu nr_taken=%lu file=%d",
	404	__entry->isolate_mode,
	405	__entry->order,
	406	__entry->nr_requested,
	407	__entry->nr_scanned,
	408	__entry->nr_taken,
	409	__entry->file)
b283666f PW	410	#endif
	411	)
	412
3bc29f0a	413	LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_lru_isolate_template, mm_vmscan_lru_isolate,
b283666f PW	414
	415	TP_PROTO(int order,
	416	unsigned long nr_requested,
	417	unsigned long nr_scanned,
	418	unsigned long nr_taken,
	419	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
	420	unsigned long nr_lumpy_taken,
	421	unsigned long nr_lumpy_dirty,
	422	unsigned long nr_lumpy_failed,
	423	#endif
	424	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
7c68b363	425	isolate_mode_t isolate_mode
b283666f PW	426	#else
b283666f PW	427	isolate_mode_t isolate_mode,
7c68b363	428	int file
b283666f	429	#endif
7c68b363	430	),
b283666f	431
7c68b363 AG	432	TP_ARGS(order, nr_requested, nr_scanned, nr_taken,
	433	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
	434	nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed,
	435	#endif
b283666f	436	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
7c68b363	437	isolate_mode
b283666f	438	#else
7c68b363	439	isolate_mode, file
b283666f	440	#endif
7c68b363	441	)
b283666f PW	442
	443	)
	444
3bc29f0a	445	LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_lru_isolate_template, mm_vmscan_memcg_isolate,
b283666f PW	446
	447	TP_PROTO(int order,
	448	unsigned long nr_requested,
	449	unsigned long nr_scanned,
	450	unsigned long nr_taken,
	451	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
	452	unsigned long nr_lumpy_taken,
	453	unsigned long nr_lumpy_dirty,
	454	unsigned long nr_lumpy_failed,
	455	#endif
	456	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
7c68b363	457	isolate_mode_t isolate_mode
b283666f PW	458	#else
b283666f PW	459	isolate_mode_t isolate_mode,
7c68b363	460	int file
b283666f	461	#endif
7c68b363	462	),
b283666f	463
7c68b363 AG	464	TP_ARGS(order, nr_requested, nr_scanned, nr_taken,
	465	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
	466	nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed,
	467	#endif
b283666f	468	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
7c68b363	469	isolate_mode
b283666f	470	#else
7c68b363	471	isolate_mode, file
b283666f	472	#endif
7c68b363	473	)
b283666f PW	474	)
b283666f PW	475
3bc29f0a	476	LTTNG_TRACEPOINT_EVENT(mm_vmscan_writepage,
b283666f PW	477
	478	TP_PROTO(struct page *page,
	479	int reclaim_flags),
	480
	481	TP_ARGS(page, reclaim_flags),
	482
	483	TP_STRUCT__entry(
	484	__field(struct page *, page)
	485	__field(int, reclaim_flags)
	486	),
	487
	488	TP_fast_assign(
d3ac4d63 PW	489	tp_assign(page, page)
d3ac4d63 PW	490	tp_assign(reclaim_flags, reclaim_flags)
b283666f PW	491	),
	492
	493	TP_printk("page=%p pfn=%lu flags=%s",
	494	__entry->page,
	495	page_to_pfn(__entry->page),
	496	show_reclaim_flags(__entry->reclaim_flags))
	497	)
	498
7c68b363	499	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
3bc29f0a	500	LTTNG_TRACEPOINT_EVENT(mm_vmscan_lru_shrink_inactive,
b283666f PW	501
	502	TP_PROTO(int nid, int zid,
	503	unsigned long nr_scanned, unsigned long nr_reclaimed,
	504	int priority, int reclaim_flags),
	505
	506	TP_ARGS(nid, zid, nr_scanned, nr_reclaimed, priority, reclaim_flags),
	507
	508	TP_STRUCT__entry(
	509	__field(int, nid)
	510	__field(int, zid)
	511	__field(unsigned long, nr_scanned)
	512	__field(unsigned long, nr_reclaimed)
	513	__field(int, priority)
	514	__field(int, reclaim_flags)
	515	),
	516
	517	TP_fast_assign(
d3ac4d63 PW	518	tp_assign(nid, nid)
	519	tp_assign(zid, zid)
	520	tp_assign(nr_scanned, nr_scanned)
	521	tp_assign(nr_reclaimed, nr_reclaimed)
	522	tp_assign(priority, priority)
	523	tp_assign(reclaim_flags, reclaim_flags)
b283666f PW	524	),
	525
	526	TP_printk("nid=%d zid=%d nr_scanned=%ld nr_reclaimed=%ld priority=%d flags=%s",
	527	__entry->nid, __entry->zid,
	528	__entry->nr_scanned, __entry->nr_reclaimed,
	529	__entry->priority,
	530	show_reclaim_flags(__entry->reclaim_flags))
	531	)
7c68b363	532	#endif
b283666f PW	533
b283666f PW	534	#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
3bc29f0a	535	LTTNG_TRACEPOINT_EVENT_MAP(replace_swap_token,
9cf29d3e MD	536
	537	mm_vmscan_replace_swap_token,
	538
b283666f PW	539	TP_PROTO(struct mm_struct *old_mm,
	540	struct mm_struct *new_mm),
	541
	542	TP_ARGS(old_mm, new_mm),
	543
	544	TP_STRUCT__entry(
	545	__field(struct mm_struct*, old_mm)
	546	__field(unsigned int, old_prio)
	547	__field(struct mm_struct*, new_mm)
	548	__field(unsigned int, new_prio)
	549	),
	550
	551	TP_fast_assign(
d3ac4d63 PW	552	tp_assign(old_mm, old_mm)
	553	tp_assign(old_prio, old_mm ? old_mm->token_priority : 0)
	554	tp_assign(new_mm, new_mm)
	555	tp_assign(new_prio, new_mm->token_priority)
b283666f PW	556	),
	557
	558	TP_printk("old_token_mm=%p old_prio=%u new_token_mm=%p new_prio=%u",
	559	__entry->old_mm, __entry->old_prio,
	560	__entry->new_mm, __entry->new_prio)
	561	)
	562
3bc29f0a	563	LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_put_swap_token_template,
b283666f PW	564	TP_PROTO(struct mm_struct *swap_token_mm),
	565
	566	TP_ARGS(swap_token_mm),
	567
	568	TP_STRUCT__entry(
	569	__field(struct mm_struct*, swap_token_mm)
	570	),
	571
	572	TP_fast_assign(
d3ac4d63	573	tp_assign(swap_token_mm, swap_token_mm)
b283666f PW	574	),
	575
	576	TP_printk("token_mm=%p", __entry->swap_token_mm)
	577	)
	578
3bc29f0a	579	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(mm_vmscan_put_swap_token_template, put_swap_token,
9cf29d3e MD	580
	581	mm_vmscan_put_swap_token,
	582
b283666f PW	583	TP_PROTO(struct mm_struct *swap_token_mm),
	584	TP_ARGS(swap_token_mm)
	585	)
	586
3bc29f0a	587	LTTNG_TRACEPOINT_EVENT_INSTANCE_CONDITION_MAP(mm_vmscan_put_swap_token_template, disable_swap_token,
9cf29d3e MD	588
	589	mm_vmscan_disable_swap_token,
	590
b283666f PW	591	TP_PROTO(struct mm_struct *swap_token_mm),
	592	TP_ARGS(swap_token_mm),
	593	TP_CONDITION(swap_token_mm != NULL)
	594	)
	595
3bc29f0a	596	LTTNG_TRACEPOINT_EVENT_CONDITION_MAP(update_swap_token_priority,
9cf29d3e MD	597
	598	mm_vmscan_update_swap_token_priority,
	599
b283666f PW	600	TP_PROTO(struct mm_struct *mm,
	601	unsigned int old_prio,
	602	struct mm_struct *swap_token_mm),
	603
	604	TP_ARGS(mm, old_prio, swap_token_mm),
	605
	606	TP_CONDITION(mm->token_priority != old_prio),
	607
	608	TP_STRUCT__entry(
	609	__field(struct mm_struct*, mm)
	610	__field(unsigned int, old_prio)
	611	__field(unsigned int, new_prio)
	612	__field(struct mm_struct*, swap_token_mm)
	613	__field(unsigned int, swap_token_prio)
	614	),
	615
	616	TP_fast_assign(
d3ac4d63 PW	617	tp_assign(mm, mm)
	618	tp_assign(old_prio, old_prio)
	619	tp_assign(new_prio, mm->token_priority)
	620	tp_assign(swap_token_mm, swap_token_mm)
	621	tp_assign(swap_token_prio, swap_token_mm ? swap_token_mm->token_priority : 0)
b283666f PW	622	),
	623
	624	TP_printk("mm=%p old_prio=%u new_prio=%u swap_token_mm=%p token_prio=%u",
	625	__entry->mm, __entry->old_prio, __entry->new_prio,
	626	__entry->swap_token_mm, __entry->swap_token_prio)
	627	)
b283666f PW	628	#endif
b283666f PW	629
3bc29f0a	630	#endif /* LTTNG_TRACE_VMSCAN_H */
b283666f PW	631
	632	/* This part must be outside protection */
	633	#include "../../../probes/define_trace.h"