[linux-2.6-block.git] / include / trace / events / kmem.h

/* SPDX-License-Identifier: GPL-2.0 */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM kmem

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

#include <linux/types.h>
#include <linux/tracepoint.h>
#include <trace/events/mmflags.h>

TRACE_EVENT(kmem_cache_alloc,

	TP_PROTO(unsigned long call_site,
		 const void *ptr,
		 struct kmem_cache *s,
		 gfp_t gfp_flags,
		 int node),

	TP_ARGS(call_site, ptr, s, gfp_flags, node),

	TP_STRUCT__entry(
		__field(	unsigned long,	call_site	)
		__field(	const void *,	ptr		)
		__field(	size_t,		bytes_req	)
		__field(	size_t,		bytes_alloc	)
		__field(	unsigned long,	gfp_flags	)
		__field(	int,		node		)
		__field(	bool,		accounted	)
	),

	TP_fast_assign(
		__entry->call_site	= call_site;
		__entry->ptr		= ptr;
		__entry->bytes_req	= s->object_size;
		__entry->bytes_alloc	= s->size;
		__entry->gfp_flags	= (__force unsigned long)gfp_flags;
		__entry->node		= node;
		__entry->accounted	= IS_ENABLED(CONFIG_MEMCG_KMEM) ?
					  ((gfp_flags & __GFP_ACCOUNT) ||
					  (s->flags & SLAB_ACCOUNT)) : false;
	),

	TP_printk("call_site=%pS ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%s node=%d accounted=%s",
		(void *)__entry->call_site,
		__entry->ptr,
		__entry->bytes_req,
		__entry->bytes_alloc,
		show_gfp_flags(__entry->gfp_flags),
		__entry->node,
		__entry->accounted ? "true" : "false")
);

TRACE_EVENT(kmalloc,

	TP_PROTO(unsigned long call_site,
		 const void *ptr,
		 size_t bytes_req,
		 size_t bytes_alloc,
		 gfp_t gfp_flags,
		 int node),

	TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node),

	TP_STRUCT__entry(
		__field(	unsigned long,	call_site	)
		__field(	const void *,	ptr		)
		__field(	size_t,		bytes_req	)
		__field(	size_t,		bytes_alloc	)
		__field(	unsigned long,	gfp_flags	)
		__field(	int,		node		)
	),

	TP_fast_assign(
		__entry->call_site	= call_site;
		__entry->ptr		= ptr;
		__entry->bytes_req	= bytes_req;
		__entry->bytes_alloc	= bytes_alloc;
		__entry->gfp_flags	= (__force unsigned long)gfp_flags;
		__entry->node		= node;
	),

	TP_printk("call_site=%pS ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%s node=%d accounted=%s",
		(void *)__entry->call_site,
		__entry->ptr,
		__entry->bytes_req,
		__entry->bytes_alloc,
		show_gfp_flags(__entry->gfp_flags),
		__entry->node,
		(IS_ENABLED(CONFIG_MEMCG_KMEM) &&
		 (__entry->gfp_flags & (__force unsigned long)__GFP_ACCOUNT)) ? "true" : "false")
);

TRACE_EVENT(kfree,

	TP_PROTO(unsigned long call_site, const void *ptr),

	TP_ARGS(call_site, ptr),

	TP_STRUCT__entry(
		__field(	unsigned long,	call_site	)
		__field(	const void *,	ptr		)
	),

	TP_fast_assign(
		__entry->call_site	= call_site;
		__entry->ptr		= ptr;
	),

	TP_printk("call_site=%pS ptr=%p",
		  (void *)__entry->call_site, __entry->ptr)
);

TRACE_EVENT(kmem_cache_free,

	TP_PROTO(unsigned long call_site, const void *ptr, const struct kmem_cache *s),

	TP_ARGS(call_site, ptr, s),

	TP_STRUCT__entry(
		__field(	unsigned long,	call_site	)
		__field(	const void *,	ptr		)
		__string(	name,		s->name		)
	),

	TP_fast_assign(
		__entry->call_site	= call_site;
		__entry->ptr		= ptr;
		__assign_str(name);
	),

	TP_printk("call_site=%pS ptr=%p name=%s",
		  (void *)__entry->call_site, __entry->ptr, __get_str(name))
);

TRACE_EVENT(mm_page_free,

	TP_PROTO(struct page *page, unsigned int order),

	TP_ARGS(page, order),

	TP_STRUCT__entry(
		__field(	unsigned long,	pfn		)
		__field(	unsigned int,	order		)
	),

	TP_fast_assign(
		__entry->pfn		= page_to_pfn(page);
		__entry->order		= order;
	),

	TP_printk("page=%p pfn=0x%lx order=%d",
			pfn_to_page(__entry->pfn),
			__entry->pfn,
			__entry->order)
);

TRACE_EVENT(mm_page_free_batched,

	TP_PROTO(struct page *page),

	TP_ARGS(page),

	TP_STRUCT__entry(
		__field(	unsigned long,	pfn		)
	),

	TP_fast_assign(
		__entry->pfn		= page_to_pfn(page);
	),

	TP_printk("page=%p pfn=0x%lx order=0",
			pfn_to_page(__entry->pfn),
			__entry->pfn)
);

TRACE_EVENT(mm_page_alloc,

	TP_PROTO(struct page *page, unsigned int order,
			gfp_t gfp_flags, int migratetype),

	TP_ARGS(page, order, gfp_flags, migratetype),

	TP_STRUCT__entry(
		__field(	unsigned long,	pfn		)
		__field(	unsigned int,	order		)
		__field(	unsigned long,	gfp_flags	)
		__field(	int,		migratetype	)
	),

	TP_fast_assign(
		__entry->pfn		= page ? page_to_pfn(page) : -1UL;
		__entry->order		= order;
		__entry->gfp_flags	= (__force unsigned long)gfp_flags;
		__entry->migratetype	= migratetype;
	),

	TP_printk("page=%p pfn=0x%lx order=%d migratetype=%d gfp_flags=%s",
		__entry->pfn != -1UL ? pfn_to_page(__entry->pfn) : NULL,
		__entry->pfn != -1UL ? __entry->pfn : 0,
		__entry->order,
		__entry->migratetype,
		show_gfp_flags(__entry->gfp_flags))
);

DECLARE_EVENT_CLASS(mm_page,

	TP_PROTO(struct page *page, unsigned int order, int migratetype,
		 int percpu_refill),

	TP_ARGS(page, order, migratetype, percpu_refill),

	TP_STRUCT__entry(
		__field(	unsigned long,	pfn		)
		__field(	unsigned int,	order		)
		__field(	int,		migratetype	)
		__field(	int,		percpu_refill	)
	),

	TP_fast_assign(
		__entry->pfn		= page ? page_to_pfn(page) : -1UL;
		__entry->order		= order;
		__entry->migratetype	= migratetype;
		__entry->percpu_refill	= percpu_refill;
	),

	TP_printk("page=%p pfn=0x%lx order=%u migratetype=%d percpu_refill=%d",
		__entry->pfn != -1UL ? pfn_to_page(__entry->pfn) : NULL,
		__entry->pfn != -1UL ? __entry->pfn : 0,
		__entry->order,
		__entry->migratetype,
		__entry->percpu_refill)
);

DEFINE_EVENT(mm_page, mm_page_alloc_zone_locked,

	TP_PROTO(struct page *page, unsigned int order, int migratetype,
		 int percpu_refill),

	TP_ARGS(page, order, migratetype, percpu_refill)
);

TRACE_EVENT(mm_page_pcpu_drain,

	TP_PROTO(struct page *page, unsigned int order, int migratetype),

	TP_ARGS(page, order, migratetype),

	TP_STRUCT__entry(
		__field(	unsigned long,	pfn		)
		__field(	unsigned int,	order		)
		__field(	int,		migratetype	)
	),

	TP_fast_assign(
		__entry->pfn		= page ? page_to_pfn(page) : -1UL;
		__entry->order		= order;
		__entry->migratetype	= migratetype;
	),

	TP_printk("page=%p pfn=0x%lx order=%d migratetype=%d",
		pfn_to_page(__entry->pfn), __entry->pfn,
		__entry->order, __entry->migratetype)
);

TRACE_EVENT(mm_page_alloc_extfrag,

	TP_PROTO(struct page *page,
		int alloc_order, int fallback_order,
		int alloc_migratetype, int fallback_migratetype),

	TP_ARGS(page,
		alloc_order, fallback_order,
		alloc_migratetype, fallback_migratetype),

	TP_STRUCT__entry(
		__field(	unsigned long,	pfn			)
		__field(	int,		alloc_order		)
		__field(	int,		fallback_order		)
		__field(	int,		alloc_migratetype	)
		__field(	int,		fallback_migratetype	)
		__field(	int,		change_ownership	)
	),

	TP_fast_assign(
		__entry->pfn			= page_to_pfn(page);
		__entry->alloc_order		= alloc_order;
		__entry->fallback_order		= fallback_order;
		__entry->alloc_migratetype	= alloc_migratetype;
		__entry->fallback_migratetype	= fallback_migratetype;
		__entry->change_ownership	= (alloc_migratetype ==
					get_pageblock_migratetype(page));
	),

	TP_printk("page=%p pfn=0x%lx alloc_order=%d fallback_order=%d pageblock_order=%d alloc_migratetype=%d fallback_migratetype=%d fragmenting=%d change_ownership=%d",
		pfn_to_page(__entry->pfn),
		__entry->pfn,
		__entry->alloc_order,
		__entry->fallback_order,
		pageblock_order,
		__entry->alloc_migratetype,
		__entry->fallback_migratetype,
		__entry->fallback_order < pageblock_order,
		__entry->change_ownership)
);

TRACE_EVENT(mm_alloc_contig_migrate_range_info,

	TP_PROTO(unsigned long start,
		 unsigned long end,
		 unsigned long nr_migrated,
		 unsigned long nr_reclaimed,
		 unsigned long nr_mapped,
		 int migratetype),

	TP_ARGS(start, end, nr_migrated, nr_reclaimed, nr_mapped, migratetype),

	TP_STRUCT__entry(
		__field(unsigned long, start)
		__field(unsigned long, end)
		__field(unsigned long, nr_migrated)
		__field(unsigned long, nr_reclaimed)
		__field(unsigned long, nr_mapped)
		__field(int, migratetype)
	),

	TP_fast_assign(
		__entry->start = start;
		__entry->end = end;
		__entry->nr_migrated = nr_migrated;
		__entry->nr_reclaimed = nr_reclaimed;
		__entry->nr_mapped = nr_mapped;
		__entry->migratetype = migratetype;
	),

	TP_printk("start=0x%lx end=0x%lx migratetype=%d nr_migrated=%lu nr_reclaimed=%lu nr_mapped=%lu",
		  __entry->start,
		  __entry->end,
		  __entry->migratetype,
		  __entry->nr_migrated,
		  __entry->nr_reclaimed,
		  __entry->nr_mapped)
);

/*
 * Required for uniquely and securely identifying mm in rss_stat tracepoint.
 */
#ifndef __PTR_TO_HASHVAL
static unsigned int __maybe_unused mm_ptr_to_hash(const void *ptr)
{
	int ret;
	unsigned long hashval;

	ret = ptr_to_hashval(ptr, &hashval);
	if (ret)
		return 0;

	/* The hashed value is only 32-bit */
	return (unsigned int)hashval;
}
#define __PTR_TO_HASHVAL
#endif

#define TRACE_MM_PAGES		\
	EM(MM_FILEPAGES)	\
	EM(MM_ANONPAGES)	\
	EM(MM_SWAPENTS)		\
	EMe(MM_SHMEMPAGES)

#undef EM
#undef EMe

#define EM(a)	TRACE_DEFINE_ENUM(a);
#define EMe(a)	TRACE_DEFINE_ENUM(a);

TRACE_MM_PAGES

#undef EM
#undef EMe

#define EM(a)	{ a, #a },
#define EMe(a)	{ a, #a }

TRACE_EVENT(rss_stat,

	TP_PROTO(struct mm_struct *mm,
		int member),

	TP_ARGS(mm, member),

	TP_STRUCT__entry(
		__field(unsigned int, mm_id)
		__field(unsigned int, curr)
		__field(int, member)
		__field(long, size)
	),

	TP_fast_assign(
		__entry->mm_id = mm_ptr_to_hash(mm);
		__entry->curr = !!(current->mm == mm);
		__entry->member = member;
		__entry->size = (percpu_counter_sum_positive(&mm->rss_stat[member])
							    << PAGE_SHIFT);
	),

	TP_printk("mm_id=%u curr=%d type=%s size=%ldB",
		__entry->mm_id,
		__entry->curr,
		__print_symbolic(__entry->member, TRACE_MM_PAGES),
		__entry->size)
	);
#endif /* _TRACE_KMEM_H */

/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
d0b6e04a LZ	2	#undef TRACE_SYSTEM
	3	#define TRACE_SYSTEM kmem
	4
ea20d929	5	#if !defined(_TRACE_KMEM_H) \|\| defined(TRACE_HEADER_MULTI_READ)
02af61bb	6	#define _TRACE_KMEM_H
b9ce08c0 EGM	7
b9ce08c0 EGM	8	#include <linux/types.h>
fc182a43	9	#include <linux/tracepoint.h>
420adbe9	10	#include <trace/events/mmflags.h>
62ba180e	11
2c1d697f	12	TRACE_EVENT(kmem_cache_alloc,
ea20d929	13
ea20d929 SR	14	TP_PROTO(unsigned long call_site,
ea20d929 SR	15	const void *ptr,
b347aa7b	16	struct kmem_cache *s,
ea20d929 SR	17	gfp_t gfp_flags,
	18	int node),
	19
2c1d697f	20	TP_ARGS(call_site, ptr, s, gfp_flags, node),
ea20d929 SR	21
	22	TP_STRUCT__entry(
	23	__field( unsigned long, call_site )
	24	__field( const void *, ptr )
	25	__field( size_t, bytes_req )
	26	__field( size_t, bytes_alloc )
fe573327	27	__field( unsigned long, gfp_flags )
ea20d929	28	__field( int, node )
b347aa7b	29	__field( bool, accounted )
ea20d929 SR	30	),
	31
	32	TP_fast_assign(
	33	__entry->call_site = call_site;
	34	__entry->ptr = ptr;
2c1d697f HY	35	__entry->bytes_req = s->object_size;
2c1d697f HY	36	__entry->bytes_alloc = s->size;
fe573327	37	__entry->gfp_flags = (__force unsigned long)gfp_flags;
ea20d929	38	__entry->node = node;
b347aa7b VA	39	__entry->accounted = IS_ENABLED(CONFIG_MEMCG_KMEM) ?
b347aa7b VA	40	((gfp_flags & __GFP_ACCOUNT) \|\|
2c1d697f	41	(s->flags & SLAB_ACCOUNT)) : false;
ea20d929 SR	42	),
ea20d929 SR	43
b347aa7b	44	TP_printk("call_site=%pS ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%s node=%d accounted=%s",
7e168b9b	45	(void *)__entry->call_site,
ea20d929 SR	46	__entry->ptr,
	47	__entry->bytes_req,
	48	__entry->bytes_alloc,
62ba180e	49	show_gfp_flags(__entry->gfp_flags),
b347aa7b VA	50	__entry->node,
b347aa7b VA	51	__entry->accounted ? "true" : "false")
ea20d929 SR	52	);
ea20d929 SR	53
2c1d697f	54	TRACE_EVENT(kmalloc,
ea20d929	55
2c1d697f HY	56	TP_PROTO(unsigned long call_site,
	57	const void *ptr,
	58	size_t bytes_req,
	59	size_t bytes_alloc,
	60	gfp_t gfp_flags,
	61	int node),
ea20d929	62
2c1d697f	63	TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node),
ea20d929	64
2c1d697f HY	65	TP_STRUCT__entry(
	66	__field( unsigned long, call_site )
	67	__field( const void *, ptr )
	68	__field( size_t, bytes_req )
	69	__field( size_t, bytes_alloc )
	70	__field( unsigned long, gfp_flags )
	71	__field( int, node )
	72	),
ea20d929	73
2c1d697f HY	74	TP_fast_assign(
	75	__entry->call_site = call_site;
	76	__entry->ptr = ptr;
	77	__entry->bytes_req = bytes_req;
	78	__entry->bytes_alloc = bytes_alloc;
	79	__entry->gfp_flags = (__force unsigned long)gfp_flags;
	80	__entry->node = node;
	81	),
ea20d929	82
2c1d697f HY	83	TP_printk("call_site=%pS ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%s node=%d accounted=%s",
	84	(void *)__entry->call_site,
	85	__entry->ptr,
	86	__entry->bytes_req,
	87	__entry->bytes_alloc,
	88	show_gfp_flags(__entry->gfp_flags),
	89	__entry->node,
	90	(IS_ENABLED(CONFIG_MEMCG_KMEM) &&
	91	(__entry->gfp_flags & (__force unsigned long)__GFP_ACCOUNT)) ? "true" : "false")
ea20d929 SR	92	);
ea20d929 SR	93
3544de8e	94	TRACE_EVENT(kfree,
ea20d929 SR	95
	96	TP_PROTO(unsigned long call_site, const void *ptr),
	97
	98	TP_ARGS(call_site, ptr),
	99
	100	TP_STRUCT__entry(
	101	__field( unsigned long, call_site )
	102	__field( const void *, ptr )
	103	),
	104
	105	TP_fast_assign(
	106	__entry->call_site = call_site;
	107	__entry->ptr = ptr;
	108	),
	109
f7d6316f CD	110	TP_printk("call_site=%pS ptr=%p",
f7d6316f CD	111	(void *)__entry->call_site, __entry->ptr)
ea20d929 SR	112	);
ea20d929 SR	113
3544de8e	114	TRACE_EVENT(kmem_cache_free,
ea20d929	115
2c1d697f	116	TP_PROTO(unsigned long call_site, const void ptr, const struct kmem_cache s),
ea20d929	117
2c1d697f	118	TP_ARGS(call_site, ptr, s),
ea20d929	119
3544de8e JW	120	TP_STRUCT__entry(
	121	__field( unsigned long, call_site )
	122	__field( const void *, ptr )
2c1d697f	123	__string( name, s->name )
3544de8e	124	),
ea20d929	125
3544de8e JW	126	TP_fast_assign(
	127	__entry->call_site = call_site;
	128	__entry->ptr = ptr;
2c92ca84	129	__assign_str(name);
3544de8e	130	),
ea20d929	131
3544de8e	132	TP_printk("call_site=%pS ptr=%p name=%s",
d8145679	133	(void *)__entry->call_site, __entry->ptr, __get_str(name))
ea20d929	134	);
4b4f278c	135
633f6f58	136	TRACE_EVENT(mm_page_free,
4b4f278c MG	137
	138	TP_PROTO(struct page *page, unsigned int order),
	139
	140	TP_ARGS(page, order),
	141
	142	TP_STRUCT__entry(
9fdd8a87	143	__field( unsigned long, pfn )
4b4f278c MG	144	__field( unsigned int, order )
	145	),
	146
	147	TP_fast_assign(
9fdd8a87	148	__entry->pfn = page_to_pfn(page);
4b4f278c MG	149	__entry->order = order;
	150	),
	151
53d884a6	152	TP_printk("page=%p pfn=0x%lx order=%d",
9fdd8a87 NK	153	pfn_to_page(__entry->pfn),
9fdd8a87 NK	154	__entry->pfn,
4b4f278c MG	155	__entry->order)
	156	);
	157
b413d48a	158	TRACE_EVENT(mm_page_free_batched,
4b4f278c	159
2d4894b5	160	TP_PROTO(struct page *page),
4b4f278c	161
2d4894b5	162	TP_ARGS(page),
4b4f278c MG	163
4b4f278c MG	164	TP_STRUCT__entry(
9fdd8a87	165	__field( unsigned long, pfn )
4b4f278c MG	166	),
	167
	168	TP_fast_assign(
9fdd8a87	169	__entry->pfn = page_to_pfn(page);
4b4f278c MG	170	),
4b4f278c MG	171
53d884a6	172	TP_printk("page=%p pfn=0x%lx order=0",
9fdd8a87	173	pfn_to_page(__entry->pfn),
2d4894b5	174	__entry->pfn)
4b4f278c MG	175	);
	176
	177	TRACE_EVENT(mm_page_alloc,
	178
	179	TP_PROTO(struct page *page, unsigned int order,
	180	gfp_t gfp_flags, int migratetype),
	181
	182	TP_ARGS(page, order, gfp_flags, migratetype),
	183
	184	TP_STRUCT__entry(
9fdd8a87	185	__field( unsigned long, pfn )
4b4f278c	186	__field( unsigned int, order )
fe573327	187	__field( unsigned long, gfp_flags )
4b4f278c MG	188	__field( int, migratetype )
	189	),
	190
	191	TP_fast_assign(
9fdd8a87	192	__entry->pfn = page ? page_to_pfn(page) : -1UL;
4b4f278c	193	__entry->order = order;
fe573327	194	__entry->gfp_flags = (__force unsigned long)gfp_flags;
4b4f278c MG	195	__entry->migratetype = migratetype;
	196	),
	197
53d884a6	198	TP_printk("page=%p pfn=0x%lx order=%d migratetype=%d gfp_flags=%s",
9fdd8a87 NK	199	__entry->pfn != -1UL ? pfn_to_page(__entry->pfn) : NULL,
9fdd8a87 NK	200	__entry->pfn != -1UL ? __entry->pfn : 0,
4b4f278c MG	201	__entry->order,
	202	__entry->migratetype,
	203	show_gfp_flags(__entry->gfp_flags))
	204	);
	205
53d0422c	206	DECLARE_EVENT_CLASS(mm_page,
0d3d062a	207
10e0f753 WY	208	TP_PROTO(struct page *page, unsigned int order, int migratetype,
10e0f753 WY	209	int percpu_refill),
0d3d062a	210
10e0f753	211	TP_ARGS(page, order, migratetype, percpu_refill),
0d3d062a MG	212
0d3d062a MG	213	TP_STRUCT__entry(
9fdd8a87	214	__field( unsigned long, pfn )
0d3d062a MG	215	__field( unsigned int, order )
0d3d062a MG	216	__field( int, migratetype )
10e0f753	217	__field( int, percpu_refill )
0d3d062a MG	218	),
	219
	220	TP_fast_assign(
9fdd8a87	221	__entry->pfn = page ? page_to_pfn(page) : -1UL;
0d3d062a MG	222	__entry->order = order;
0d3d062a MG	223	__entry->migratetype = migratetype;
10e0f753	224	__entry->percpu_refill = percpu_refill;
0d3d062a MG	225	),
0d3d062a MG	226
53d884a6	227	TP_printk("page=%p pfn=0x%lx order=%u migratetype=%d percpu_refill=%d",
9fdd8a87 NK	228	__entry->pfn != -1UL ? pfn_to_page(__entry->pfn) : NULL,
9fdd8a87 NK	229	__entry->pfn != -1UL ? __entry->pfn : 0,
0d3d062a MG	230	__entry->order,
0d3d062a MG	231	__entry->migratetype,
10e0f753	232	__entry->percpu_refill)
0d3d062a MG	233	);
0d3d062a MG	234
53d0422c	235	DEFINE_EVENT(mm_page, mm_page_alloc_zone_locked,
0d3d062a	236
10e0f753 WY	237	TP_PROTO(struct page *page, unsigned int order, int migratetype,
10e0f753 WY	238	int percpu_refill),
0d3d062a	239
10e0f753	240	TP_ARGS(page, order, migratetype, percpu_refill)
53d0422c	241	);
0d3d062a	242
633f6f58	243	TRACE_EVENT(mm_page_pcpu_drain,
0d3d062a	244
53d0422c LZ	245	TP_PROTO(struct page *page, unsigned int order, int migratetype),
	246
	247	TP_ARGS(page, order, migratetype),
0d3d062a	248
649b8de2 SP	249	TP_STRUCT__entry(
	250	__field( unsigned long, pfn )
	251	__field( unsigned int, order )
	252	__field( int, migratetype )
	253	),
	254
	255	TP_fast_assign(
	256	__entry->pfn = page ? page_to_pfn(page) : -1UL;
	257	__entry->order = order;
	258	__entry->migratetype = migratetype;
	259	),
	260
53d884a6	261	TP_printk("page=%p pfn=0x%lx order=%d migratetype=%d",
9fdd8a87	262	pfn_to_page(__entry->pfn), __entry->pfn,
53d0422c	263	__entry->order, __entry->migratetype)
0d3d062a MG	264	);
0d3d062a MG	265
e0fff1bd MG	266	TRACE_EVENT(mm_page_alloc_extfrag,
	267
	268	TP_PROTO(struct page *page,
52c8f6a5	269	int alloc_order, int fallback_order,
99592d59	270	int alloc_migratetype, int fallback_migratetype),
e0fff1bd MG	271
	272	TP_ARGS(page,
	273	alloc_order, fallback_order,
99592d59	274	alloc_migratetype, fallback_migratetype),
e0fff1bd MG	275
e0fff1bd MG	276	TP_STRUCT__entry(
9fdd8a87	277	__field( unsigned long, pfn )
e0fff1bd MG	278	__field( int, alloc_order )
	279	__field( int, fallback_order )
	280	__field( int, alloc_migratetype )
	281	__field( int, fallback_migratetype )
f92310c1	282	__field( int, change_ownership )
e0fff1bd MG	283	),
	284
	285	TP_fast_assign(
9fdd8a87	286	__entry->pfn = page_to_pfn(page);
e0fff1bd MG	287	__entry->alloc_order = alloc_order;
	288	__entry->fallback_order = fallback_order;
	289	__entry->alloc_migratetype = alloc_migratetype;
	290	__entry->fallback_migratetype = fallback_migratetype;
99592d59 VB	291	__entry->change_ownership = (alloc_migratetype ==
99592d59 VB	292	get_pageblock_migratetype(page));
e0fff1bd MG	293	),
e0fff1bd MG	294
53d884a6	295	TP_printk("page=%p pfn=0x%lx alloc_order=%d fallback_order=%d pageblock_order=%d alloc_migratetype=%d fallback_migratetype=%d fragmenting=%d change_ownership=%d",
9fdd8a87 NK	296	pfn_to_page(__entry->pfn),
9fdd8a87 NK	297	__entry->pfn,
e0fff1bd MG	298	__entry->alloc_order,
	299	__entry->fallback_order,
	300	pageblock_order,
	301	__entry->alloc_migratetype,
	302	__entry->fallback_migratetype,
	303	__entry->fallback_order < pageblock_order,
f92310c1	304	__entry->change_ownership)
e0fff1bd MG	305	);
e0fff1bd MG	306
c8b36003 RC	307	TRACE_EVENT(mm_alloc_contig_migrate_range_info,
	308
	309	TP_PROTO(unsigned long start,
	310	unsigned long end,
	311	unsigned long nr_migrated,
	312	unsigned long nr_reclaimed,
	313	unsigned long nr_mapped,
	314	int migratetype),
	315
	316	TP_ARGS(start, end, nr_migrated, nr_reclaimed, nr_mapped, migratetype),
	317
	318	TP_STRUCT__entry(
	319	__field(unsigned long, start)
	320	__field(unsigned long, end)
	321	__field(unsigned long, nr_migrated)
	322	__field(unsigned long, nr_reclaimed)
	323	__field(unsigned long, nr_mapped)
	324	__field(int, migratetype)
	325	),
	326
	327	TP_fast_assign(
	328	__entry->start = start;
	329	__entry->end = end;
	330	__entry->nr_migrated = nr_migrated;
	331	__entry->nr_reclaimed = nr_reclaimed;
	332	__entry->nr_mapped = nr_mapped;
	333	__entry->migratetype = migratetype;
	334	),
	335
	336	TP_printk("start=0x%lx end=0x%lx migratetype=%d nr_migrated=%lu nr_reclaimed=%lu nr_mapped=%lu",
	337	__entry->start,
	338	__entry->end,
	339	__entry->migratetype,
	340	__entry->nr_migrated,
	341	__entry->nr_reclaimed,
	342	__entry->nr_mapped)
	343	);
	344
e4dcad20 JFG	345	/*
	346	* Required for uniquely and securely identifying mm in rss_stat tracepoint.
	347	*/
	348	#ifndef __PTR_TO_HASHVAL
	349	static unsigned int __maybe_unused mm_ptr_to_hash(const void *ptr)
	350	{
	351	int ret;
	352	unsigned long hashval;
	353
	354	ret = ptr_to_hashval(ptr, &hashval);
	355	if (ret)
	356	return 0;
	357
	358	/* The hashed value is only 32-bit */
	359	return (unsigned int)hashval;
	360	}
	361	#define __PTR_TO_HASHVAL
	362	#endif
	363
f9001107 OP	364	#define TRACE_MM_PAGES \
	365	EM(MM_FILEPAGES) \
	366	EM(MM_ANONPAGES) \
	367	EM(MM_SWAPENTS) \
	368	EMe(MM_SHMEMPAGES)
	369
	370	#undef EM
	371	#undef EMe
	372
	373	#define EM(a) TRACE_DEFINE_ENUM(a);
	374	#define EMe(a) TRACE_DEFINE_ENUM(a);
	375
	376	TRACE_MM_PAGES
	377
	378	#undef EM
	379	#undef EMe
	380
	381	#define EM(a) { a, #a },
	382	#define EMe(a) { a, #a }
	383
b3d1411b JFG	384	TRACE_EVENT(rss_stat,
b3d1411b JFG	385
e4dcad20	386	TP_PROTO(struct mm_struct *mm,
f1a79412	387	int member),
b3d1411b	388
f1a79412	389	TP_ARGS(mm, member),
b3d1411b JFG	390
b3d1411b JFG	391	TP_STRUCT__entry(
e4dcad20 JFG	392	__field(unsigned int, mm_id)
e4dcad20 JFG	393	__field(unsigned int, curr)
b3d1411b JFG	394	__field(int, member)
	395	__field(long, size)
	396	),
	397
	398	TP_fast_assign(
e4dcad20 JFG	399	__entry->mm_id = mm_ptr_to_hash(mm);
e4dcad20 JFG	400	__entry->curr = !!(current->mm == mm);
b3d1411b	401	__entry->member = member;
f1a79412 SB	402	__entry->size = (percpu_counter_sum_positive(&mm->rss_stat[member])
f1a79412 SB	403	<< PAGE_SHIFT);
b3d1411b JFG	404	),
b3d1411b JFG	405
f9001107	406	TP_printk("mm_id=%u curr=%d type=%s size=%ldB",
e4dcad20 JFG	407	__entry->mm_id,
e4dcad20 JFG	408	__entry->curr,
f9001107	409	__print_symbolic(__entry->member, TRACE_MM_PAGES),
b3d1411b JFG	410	__entry->size)
b3d1411b JFG	411	);
a8d154b0	412	#endif /* _TRACE_KMEM_H */
ea20d929	413
a8d154b0 SR	414	/* This part must be outside protection */
a8d154b0 SR	415	#include <trace/define_trace.h>