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

#undef TRACE_SYSTEM
#define TRACE_SYSTEM mm_vmscan

#if !defined(LTTNG_TRACE_MM_VMSCAN_H) || defined(TRACE_HEADER_MULTI_READ)
#define LTTNG_TRACE_MM_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_MAP(mm_shrink_slab_start,

	mm_vmscan_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_MAP(mm_shrink_slab_end,

	mm_vmscan_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_MAP(mm_shrink_slab_end,

	mm_vmscan_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_MM_VMSCAN_H */

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