[mirror_ubuntu-focal-kernel.git] / include / trace / events / mmflags.h

#include <linux/node.h>
#include <linux/mmzone.h>
#include <linux/compaction.h>
/*
 * The order of these masks is important. Matching masks will be seen
 * first and the left over flags will end up showing by themselves.
 *
 * For example, if we have GFP_KERNEL before GFP_USER we wil get:
 *
 *  GFP_KERNEL|GFP_HARDWALL
 *
 * Thus most bits set go first.
 */

#define __def_gfpflag_names						\
	{(unsigned long)GFP_TRANSHUGE,		"GFP_TRANSHUGE"},	\
	{(unsigned long)GFP_TRANSHUGE_LIGHT,	"GFP_TRANSHUGE_LIGHT"}, \
	{(unsigned long)GFP_HIGHUSER_MOVABLE,	"GFP_HIGHUSER_MOVABLE"},\
	{(unsigned long)GFP_HIGHUSER,		"GFP_HIGHUSER"},	\
	{(unsigned long)GFP_USER,		"GFP_USER"},		\
	{(unsigned long)GFP_TEMPORARY,		"GFP_TEMPORARY"},	\
	{(unsigned long)GFP_KERNEL_ACCOUNT,	"GFP_KERNEL_ACCOUNT"},	\
	{(unsigned long)GFP_KERNEL,		"GFP_KERNEL"},		\
	{(unsigned long)GFP_NOFS,		"GFP_NOFS"},		\
	{(unsigned long)GFP_ATOMIC,		"GFP_ATOMIC"},		\
	{(unsigned long)GFP_NOIO,		"GFP_NOIO"},		\
	{(unsigned long)GFP_NOWAIT,		"GFP_NOWAIT"},		\
	{(unsigned long)GFP_DMA,		"GFP_DMA"},		\
	{(unsigned long)__GFP_HIGHMEM,		"__GFP_HIGHMEM"},	\
	{(unsigned long)GFP_DMA32,		"GFP_DMA32"},		\
	{(unsigned long)__GFP_HIGH,		"__GFP_HIGH"},		\
	{(unsigned long)__GFP_ATOMIC,		"__GFP_ATOMIC"},	\
	{(unsigned long)__GFP_IO,		"__GFP_IO"},		\
	{(unsigned long)__GFP_FS,		"__GFP_FS"},		\
	{(unsigned long)__GFP_COLD,		"__GFP_COLD"},		\
	{(unsigned long)__GFP_NOWARN,		"__GFP_NOWARN"},	\
	{(unsigned long)__GFP_RETRY_MAYFAIL,	"__GFP_RETRY_MAYFAIL"},	\
	{(unsigned long)__GFP_NOFAIL,		"__GFP_NOFAIL"},	\
	{(unsigned long)__GFP_NORETRY,		"__GFP_NORETRY"},	\
	{(unsigned long)__GFP_COMP,		"__GFP_COMP"},		\
	{(unsigned long)__GFP_ZERO,		"__GFP_ZERO"},		\
	{(unsigned long)__GFP_NOMEMALLOC,	"__GFP_NOMEMALLOC"},	\
	{(unsigned long)__GFP_MEMALLOC,		"__GFP_MEMALLOC"},	\
	{(unsigned long)__GFP_HARDWALL,		"__GFP_HARDWALL"},	\
	{(unsigned long)__GFP_THISNODE,		"__GFP_THISNODE"},	\
	{(unsigned long)__GFP_RECLAIMABLE,	"__GFP_RECLAIMABLE"},	\
	{(unsigned long)__GFP_MOVABLE,		"__GFP_MOVABLE"},	\
	{(unsigned long)__GFP_ACCOUNT,		"__GFP_ACCOUNT"},	\
	{(unsigned long)__GFP_NOTRACK,		"__GFP_NOTRACK"},	\
	{(unsigned long)__GFP_WRITE,		"__GFP_WRITE"},		\
	{(unsigned long)__GFP_RECLAIM,		"__GFP_RECLAIM"},	\
	{(unsigned long)__GFP_DIRECT_RECLAIM,	"__GFP_DIRECT_RECLAIM"},\
	{(unsigned long)__GFP_KSWAPD_RECLAIM,	"__GFP_KSWAPD_RECLAIM"}\

#define show_gfp_flags(flags)						\
	(flags) ? __print_flags(flags, "|",				\
	__def_gfpflag_names						\
	) : "none"

#ifdef CONFIG_MMU
#define IF_HAVE_PG_MLOCK(flag,string) ,{1UL << flag, string}
#else
#define IF_HAVE_PG_MLOCK(flag,string)
#endif

#ifdef CONFIG_ARCH_USES_PG_UNCACHED
#define IF_HAVE_PG_UNCACHED(flag,string) ,{1UL << flag, string}
#else
#define IF_HAVE_PG_UNCACHED(flag,string)
#endif

#ifdef CONFIG_MEMORY_FAILURE
#define IF_HAVE_PG_HWPOISON(flag,string) ,{1UL << flag, string}
#else
#define IF_HAVE_PG_HWPOISON(flag,string)
#endif

#if defined(CONFIG_IDLE_PAGE_TRACKING) && defined(CONFIG_64BIT)
#define IF_HAVE_PG_IDLE(flag,string) ,{1UL << flag, string}
#else
#define IF_HAVE_PG_IDLE(flag,string)
#endif

#define __def_pageflag_names						\
	{1UL << PG_locked,		"locked"	},		\
	{1UL << PG_waiters,		"waiters"	},		\
	{1UL << PG_error,		"error"		},		\
	{1UL << PG_referenced,		"referenced"	},		\
	{1UL << PG_uptodate,		"uptodate"	},		\
	{1UL << PG_dirty,		"dirty"		},		\
	{1UL << PG_lru,			"lru"		},		\
	{1UL << PG_active,		"active"	},		\
	{1UL << PG_slab,		"slab"		},		\
	{1UL << PG_owner_priv_1,	"owner_priv_1"	},		\
	{1UL << PG_arch_1,		"arch_1"	},		\
	{1UL << PG_reserved,		"reserved"	},		\
	{1UL << PG_private,		"private"	},		\
	{1UL << PG_private_2,		"private_2"	},		\
	{1UL << PG_writeback,		"writeback"	},		\
	{1UL << PG_head,		"head"		},		\
	{1UL << PG_mappedtodisk,	"mappedtodisk"	},		\
	{1UL << PG_reclaim,		"reclaim"	},		\
	{1UL << PG_swapbacked,		"swapbacked"	},		\
	{1UL << PG_unevictable,		"unevictable"	}		\
IF_HAVE_PG_MLOCK(PG_mlocked,		"mlocked"	)		\
IF_HAVE_PG_UNCACHED(PG_uncached,	"uncached"	)		\
IF_HAVE_PG_HWPOISON(PG_hwpoison,	"hwpoison"	)		\
IF_HAVE_PG_IDLE(PG_young,		"young"		)		\
IF_HAVE_PG_IDLE(PG_idle,		"idle"		)

#define show_page_flags(flags)						\
	(flags) ? __print_flags(flags, "|",				\
	__def_pageflag_names						\
	) : "none"

#if defined(CONFIG_X86)
#define __VM_ARCH_SPECIFIC_1 {VM_PAT,     "pat"           }
#elif defined(CONFIG_PPC)
#define __VM_ARCH_SPECIFIC_1 {VM_SAO,     "sao"           }
#elif defined(CONFIG_PARISC) || defined(CONFIG_METAG) || defined(CONFIG_IA64)
#define __VM_ARCH_SPECIFIC_1 {VM_GROWSUP,	"growsup"	}
#elif !defined(CONFIG_MMU)
#define __VM_ARCH_SPECIFIC_1 {VM_MAPPED_COPY,"mappedcopy"	}
#else
#define __VM_ARCH_SPECIFIC_1 {VM_ARCH_1,	"arch_1"	}
#endif

#if defined(CONFIG_X86)
#define __VM_ARCH_SPECIFIC_2 {VM_MPX,		"mpx"		}
#else
#define __VM_ARCH_SPECIFIC_2 {VM_ARCH_2,	"arch_2"	}
#endif

#ifdef CONFIG_MEM_SOFT_DIRTY
#define IF_HAVE_VM_SOFTDIRTY(flag,name) {flag, name },
#else
#define IF_HAVE_VM_SOFTDIRTY(flag,name)
#endif

#define __def_vmaflag_names						\
	{VM_READ,			"read"		},		\
	{VM_WRITE,			"write"		},		\
	{VM_EXEC,			"exec"		},		\
	{VM_SHARED,			"shared"	},		\
	{VM_MAYREAD,			"mayread"	},		\
	{VM_MAYWRITE,			"maywrite"	},		\
	{VM_MAYEXEC,			"mayexec"	},		\
	{VM_MAYSHARE,			"mayshare"	},		\
	{VM_GROWSDOWN,			"growsdown"	},		\
	{VM_UFFD_MISSING,		"uffd_missing"	},		\
	{VM_PFNMAP,			"pfnmap"	},		\
	{VM_DENYWRITE,			"denywrite"	},		\
	{VM_UFFD_WP,			"uffd_wp"	},		\
	{VM_LOCKED,			"locked"	},		\
	{VM_IO,				"io"		},		\
	{VM_SEQ_READ,			"seqread"	},		\
	{VM_RAND_READ,			"randread"	},		\
	{VM_DONTCOPY,			"dontcopy"	},		\
	{VM_DONTEXPAND,			"dontexpand"	},		\
	{VM_LOCKONFAULT,		"lockonfault"	},		\
	{VM_ACCOUNT,			"account"	},		\
	{VM_NORESERVE,			"noreserve"	},		\
	{VM_HUGETLB,			"hugetlb"	},		\
	__VM_ARCH_SPECIFIC_1				,		\
	__VM_ARCH_SPECIFIC_2				,		\
	{VM_DONTDUMP,			"dontdump"	},		\
IF_HAVE_VM_SOFTDIRTY(VM_SOFTDIRTY,	"softdirty"	)		\
	{VM_MIXEDMAP,			"mixedmap"	},		\
	{VM_HUGEPAGE,			"hugepage"	},		\
	{VM_NOHUGEPAGE,			"nohugepage"	},		\
	{VM_MERGEABLE,			"mergeable"	}		\

#define show_vma_flags(flags)						\
	(flags) ? __print_flags(flags, "|",				\
	__def_vmaflag_names						\
	) : "none"

#ifdef CONFIG_COMPACTION
#define COMPACTION_STATUS					\
	EM( COMPACT_SKIPPED,		"skipped")		\
	EM( COMPACT_DEFERRED,		"deferred")		\
	EM( COMPACT_CONTINUE,		"continue")		\
	EM( COMPACT_SUCCESS,		"success")		\
	EM( COMPACT_PARTIAL_SKIPPED,	"partial_skipped")	\
	EM( COMPACT_COMPLETE,		"complete")		\
	EM( COMPACT_NO_SUITABLE_PAGE,	"no_suitable_page")	\
	EM( COMPACT_NOT_SUITABLE_ZONE,	"not_suitable_zone")	\
	EMe(COMPACT_CONTENDED,		"contended")

/* High-level compaction status feedback */
#define COMPACTION_FAILED	1
#define COMPACTION_WITHDRAWN	2
#define COMPACTION_PROGRESS	3

#define compact_result_to_feedback(result)	\
({						\
	enum compact_result __result = result;	\
	(compaction_failed(__result)) ? COMPACTION_FAILED : \
		(compaction_withdrawn(__result)) ? COMPACTION_WITHDRAWN : COMPACTION_PROGRESS; \
})

#define COMPACTION_FEEDBACK		\
	EM(COMPACTION_FAILED,		"failed")	\
	EM(COMPACTION_WITHDRAWN,	"withdrawn")	\
	EMe(COMPACTION_PROGRESS,	"progress")

#define COMPACTION_PRIORITY						\
	EM(COMPACT_PRIO_SYNC_FULL,	"COMPACT_PRIO_SYNC_FULL")	\
	EM(COMPACT_PRIO_SYNC_LIGHT,	"COMPACT_PRIO_SYNC_LIGHT")	\
	EMe(COMPACT_PRIO_ASYNC,		"COMPACT_PRIO_ASYNC")
#else
#define COMPACTION_STATUS
#define COMPACTION_PRIORITY
#define COMPACTION_FEEDBACK
#endif

#ifdef CONFIG_ZONE_DMA
#define IFDEF_ZONE_DMA(X) X
#else
#define IFDEF_ZONE_DMA(X)
#endif

#ifdef CONFIG_ZONE_DMA32
#define IFDEF_ZONE_DMA32(X) X
#else
#define IFDEF_ZONE_DMA32(X)
#endif

#ifdef CONFIG_HIGHMEM
#define IFDEF_ZONE_HIGHMEM(X) X
#else
#define IFDEF_ZONE_HIGHMEM(X)
#endif

#define ZONE_TYPE						\
	IFDEF_ZONE_DMA(		EM (ZONE_DMA,	 "DMA"))	\
	IFDEF_ZONE_DMA32(	EM (ZONE_DMA32,	 "DMA32"))	\
				EM (ZONE_NORMAL, "Normal")	\
	IFDEF_ZONE_HIGHMEM(	EM (ZONE_HIGHMEM,"HighMem"))	\
				EMe(ZONE_MOVABLE,"Movable")

#define LRU_NAMES		\
		EM (LRU_INACTIVE_ANON, "inactive_anon") \
		EM (LRU_ACTIVE_ANON, "active_anon") \
		EM (LRU_INACTIVE_FILE, "inactive_file") \
		EM (LRU_ACTIVE_FILE, "active_file") \
		EMe(LRU_UNEVICTABLE, "unevictable")

/*
 * First define the enums in the above macros to be exported to userspace
 * via TRACE_DEFINE_ENUM().
 */
#undef EM
#undef EMe
#define EM(a, b)	TRACE_DEFINE_ENUM(a);
#define EMe(a, b)	TRACE_DEFINE_ENUM(a);

COMPACTION_STATUS
COMPACTION_PRIORITY
/* COMPACTION_FEEDBACK are defines not enums. Not needed here. */
ZONE_TYPE
LRU_NAMES

/*
 * Now redefine the EM() and EMe() macros to map the enums to the strings
 * that will be printed in the output.
 */
#undef EM
#undef EMe
#define EM(a, b)	{a, b},
#define EMe(a, b)	{a, b}
Commit	Line	Data
aff28015 MH	1	#include <linux/node.h>
	2	#include <linux/mmzone.h>
	3	#include <linux/compaction.h>
420adbe9 VB	4	/*
	5	* The order of these masks is important. Matching masks will be seen
	6	* first and the left over flags will end up showing by themselves.
	7	*
	8	* For example, if we have GFP_KERNEL before GFP_USER we wil get:
	9	*
	10	* GFP_KERNEL\|GFP_HARDWALL
	11	*
	12	* Thus most bits set go first.
	13	*/
	14
	15	#define __def_gfpflag_names \
	16	{(unsigned long)GFP_TRANSHUGE, "GFP_TRANSHUGE"}, \
25160354	17	{(unsigned long)GFP_TRANSHUGE_LIGHT, "GFP_TRANSHUGE_LIGHT"}, \
420adbe9 VB	18	{(unsigned long)GFP_HIGHUSER_MOVABLE, "GFP_HIGHUSER_MOVABLE"},\
	19	{(unsigned long)GFP_HIGHUSER, "GFP_HIGHUSER"}, \
	20	{(unsigned long)GFP_USER, "GFP_USER"}, \
	21	{(unsigned long)GFP_TEMPORARY, "GFP_TEMPORARY"}, \
	22	{(unsigned long)GFP_KERNEL_ACCOUNT, "GFP_KERNEL_ACCOUNT"}, \
	23	{(unsigned long)GFP_KERNEL, "GFP_KERNEL"}, \
	24	{(unsigned long)GFP_NOFS, "GFP_NOFS"}, \
	25	{(unsigned long)GFP_ATOMIC, "GFP_ATOMIC"}, \
	26	{(unsigned long)GFP_NOIO, "GFP_NOIO"}, \
	27	{(unsigned long)GFP_NOWAIT, "GFP_NOWAIT"}, \
	28	{(unsigned long)GFP_DMA, "GFP_DMA"}, \
	29	{(unsigned long)__GFP_HIGHMEM, "__GFP_HIGHMEM"}, \
	30	{(unsigned long)GFP_DMA32, "GFP_DMA32"}, \
	31	{(unsigned long)__GFP_HIGH, "__GFP_HIGH"}, \
	32	{(unsigned long)__GFP_ATOMIC, "__GFP_ATOMIC"}, \
	33	{(unsigned long)__GFP_IO, "__GFP_IO"}, \
	34	{(unsigned long)__GFP_FS, "__GFP_FS"}, \
	35	{(unsigned long)__GFP_COLD, "__GFP_COLD"}, \
	36	{(unsigned long)__GFP_NOWARN, "__GFP_NOWARN"}, \
dcda9b04	37	{(unsigned long)__GFP_RETRY_MAYFAIL, "__GFP_RETRY_MAYFAIL"}, \
420adbe9 VB	38	{(unsigned long)__GFP_NOFAIL, "__GFP_NOFAIL"}, \
	39	{(unsigned long)__GFP_NORETRY, "__GFP_NORETRY"}, \
	40	{(unsigned long)__GFP_COMP, "__GFP_COMP"}, \
	41	{(unsigned long)__GFP_ZERO, "__GFP_ZERO"}, \
	42	{(unsigned long)__GFP_NOMEMALLOC, "__GFP_NOMEMALLOC"}, \
	43	{(unsigned long)__GFP_MEMALLOC, "__GFP_MEMALLOC"}, \
	44	{(unsigned long)__GFP_HARDWALL, "__GFP_HARDWALL"}, \
	45	{(unsigned long)__GFP_THISNODE, "__GFP_THISNODE"}, \
	46	{(unsigned long)__GFP_RECLAIMABLE, "__GFP_RECLAIMABLE"}, \
	47	{(unsigned long)__GFP_MOVABLE, "__GFP_MOVABLE"}, \
	48	{(unsigned long)__GFP_ACCOUNT, "__GFP_ACCOUNT"}, \
	49	{(unsigned long)__GFP_NOTRACK, "__GFP_NOTRACK"}, \
	50	{(unsigned long)__GFP_WRITE, "__GFP_WRITE"}, \
	51	{(unsigned long)__GFP_RECLAIM, "__GFP_RECLAIM"}, \
	52	{(unsigned long)__GFP_DIRECT_RECLAIM, "__GFP_DIRECT_RECLAIM"},\
41b6167e	53	{(unsigned long)__GFP_KSWAPD_RECLAIM, "__GFP_KSWAPD_RECLAIM"}\
420adbe9 VB	54
	55	#define show_gfp_flags(flags) \
	56	(flags) ? __print_flags(flags, "\|", \
	57	__def_gfpflag_names \
	58	) : "none"
	59
	60	#ifdef CONFIG_MMU
	61	#define IF_HAVE_PG_MLOCK(flag,string) ,{1UL << flag, string}
	62	#else
	63	#define IF_HAVE_PG_MLOCK(flag,string)
	64	#endif
	65
	66	#ifdef CONFIG_ARCH_USES_PG_UNCACHED
	67	#define IF_HAVE_PG_UNCACHED(flag,string) ,{1UL << flag, string}
	68	#else
	69	#define IF_HAVE_PG_UNCACHED(flag,string)
	70	#endif
	71
	72	#ifdef CONFIG_MEMORY_FAILURE
	73	#define IF_HAVE_PG_HWPOISON(flag,string) ,{1UL << flag, string}
	74	#else
	75	#define IF_HAVE_PG_HWPOISON(flag,string)
	76	#endif
	77
	78	#if defined(CONFIG_IDLE_PAGE_TRACKING) && defined(CONFIG_64BIT)
	79	#define IF_HAVE_PG_IDLE(flag,string) ,{1UL << flag, string}
	80	#else
	81	#define IF_HAVE_PG_IDLE(flag,string)
	82	#endif
	83
	84	#define __def_pageflag_names \
	85	{1UL << PG_locked, "locked" }, \
62906027	86	{1UL << PG_waiters, "waiters" }, \
420adbe9 VB	87	{1UL << PG_error, "error" }, \
	88	{1UL << PG_referenced, "referenced" }, \
	89	{1UL << PG_uptodate, "uptodate" }, \
	90	{1UL << PG_dirty, "dirty" }, \
	91	{1UL << PG_lru, "lru" }, \
	92	{1UL << PG_active, "active" }, \
	93	{1UL << PG_slab, "slab" }, \
	94	{1UL << PG_owner_priv_1, "owner_priv_1" }, \
	95	{1UL << PG_arch_1, "arch_1" }, \
	96	{1UL << PG_reserved, "reserved" }, \
	97	{1UL << PG_private, "private" }, \
	98	{1UL << PG_private_2, "private_2" }, \
	99	{1UL << PG_writeback, "writeback" }, \
	100	{1UL << PG_head, "head" }, \
420adbe9 VB	101	{1UL << PG_mappedtodisk, "mappedtodisk" }, \
	102	{1UL << PG_reclaim, "reclaim" }, \
	103	{1UL << PG_swapbacked, "swapbacked" }, \
	104	{1UL << PG_unevictable, "unevictable" } \
	105	IF_HAVE_PG_MLOCK(PG_mlocked, "mlocked" ) \
	106	IF_HAVE_PG_UNCACHED(PG_uncached, "uncached" ) \
	107	IF_HAVE_PG_HWPOISON(PG_hwpoison, "hwpoison" ) \
	108	IF_HAVE_PG_IDLE(PG_young, "young" ) \
	109	IF_HAVE_PG_IDLE(PG_idle, "idle" )
	110
	111	#define show_page_flags(flags) \
	112	(flags) ? __print_flags(flags, "\|", \
	113	__def_pageflag_names \
	114	) : "none"
	115
	116	#if defined(CONFIG_X86)
bcf66917	117	#define __VM_ARCH_SPECIFIC_1 {VM_PAT, "pat" }
420adbe9	118	#elif defined(CONFIG_PPC)
bcf66917	119	#define __VM_ARCH_SPECIFIC_1 {VM_SAO, "sao" }
420adbe9	120	#elif defined(CONFIG_PARISC) \|\| defined(CONFIG_METAG) \|\| defined(CONFIG_IA64)
bcf66917	121	#define __VM_ARCH_SPECIFIC_1 {VM_GROWSUP, "growsup" }
420adbe9	122	#elif !defined(CONFIG_MMU)
bcf66917	123	#define __VM_ARCH_SPECIFIC_1 {VM_MAPPED_COPY,"mappedcopy" }
420adbe9	124	#else
bcf66917 KS	125	#define __VM_ARCH_SPECIFIC_1 {VM_ARCH_1, "arch_1" }
	126	#endif
	127
	128	#if defined(CONFIG_X86)
	129	#define __VM_ARCH_SPECIFIC_2 {VM_MPX, "mpx" }
	130	#else
	131	#define __VM_ARCH_SPECIFIC_2 {VM_ARCH_2, "arch_2" }
420adbe9 VB	132	#endif
	133
	134	#ifdef CONFIG_MEM_SOFT_DIRTY
	135	#define IF_HAVE_VM_SOFTDIRTY(flag,name) {flag, name },
	136	#else
	137	#define IF_HAVE_VM_SOFTDIRTY(flag,name)
	138	#endif
	139
	140	#define __def_vmaflag_names \
	141	{VM_READ, "read" }, \
	142	{VM_WRITE, "write" }, \
	143	{VM_EXEC, "exec" }, \
	144	{VM_SHARED, "shared" }, \
	145	{VM_MAYREAD, "mayread" }, \
	146	{VM_MAYWRITE, "maywrite" }, \
	147	{VM_MAYEXEC, "mayexec" }, \
	148	{VM_MAYSHARE, "mayshare" }, \
	149	{VM_GROWSDOWN, "growsdown" }, \
bcf66917	150	{VM_UFFD_MISSING, "uffd_missing" }, \
420adbe9 VB	151	{VM_PFNMAP, "pfnmap" }, \
420adbe9 VB	152	{VM_DENYWRITE, "denywrite" }, \
bcf66917	153	{VM_UFFD_WP, "uffd_wp" }, \
420adbe9 VB	154	{VM_LOCKED, "locked" }, \
	155	{VM_IO, "io" }, \
	156	{VM_SEQ_READ, "seqread" }, \
	157	{VM_RAND_READ, "randread" }, \
	158	{VM_DONTCOPY, "dontcopy" }, \
	159	{VM_DONTEXPAND, "dontexpand" }, \
bcf66917	160	{VM_LOCKONFAULT, "lockonfault" }, \
420adbe9 VB	161	{VM_ACCOUNT, "account" }, \
	162	{VM_NORESERVE, "noreserve" }, \
	163	{VM_HUGETLB, "hugetlb" }, \
bcf66917 KS	164	__VM_ARCH_SPECIFIC_1 , \
bcf66917 KS	165	__VM_ARCH_SPECIFIC_2 , \
420adbe9 VB	166	{VM_DONTDUMP, "dontdump" }, \
	167	IF_HAVE_VM_SOFTDIRTY(VM_SOFTDIRTY, "softdirty" ) \
	168	{VM_MIXEDMAP, "mixedmap" }, \
	169	{VM_HUGEPAGE, "hugepage" }, \
	170	{VM_NOHUGEPAGE, "nohugepage" }, \
	171	{VM_MERGEABLE, "mergeable" } \
	172
	173	#define show_vma_flags(flags) \
	174	(flags) ? __print_flags(flags, "\|", \
	175	__def_vmaflag_names \
	176	) : "none"
aff28015 MH	177
	178	#ifdef CONFIG_COMPACTION
	179	#define COMPACTION_STATUS \
	180	EM( COMPACT_SKIPPED, "skipped") \
	181	EM( COMPACT_DEFERRED, "deferred") \
	182	EM( COMPACT_CONTINUE, "continue") \
	183	EM( COMPACT_SUCCESS, "success") \
	184	EM( COMPACT_PARTIAL_SKIPPED, "partial_skipped") \
	185	EM( COMPACT_COMPLETE, "complete") \
	186	EM( COMPACT_NO_SUITABLE_PAGE, "no_suitable_page") \
	187	EM( COMPACT_NOT_SUITABLE_ZONE, "not_suitable_zone") \
	188	EMe(COMPACT_CONTENDED, "contended")
65190cff MH	189
	190	/* High-level compaction status feedback */
	191	#define COMPACTION_FAILED 1
	192	#define COMPACTION_WITHDRAWN 2
	193	#define COMPACTION_PROGRESS 3
	194
	195	#define compact_result_to_feedback(result) \
	196	({ \
	197	enum compact_result __result = result; \
	198	(compaction_failed(__result)) ? COMPACTION_FAILED : \
	199	(compaction_withdrawn(__result)) ? COMPACTION_WITHDRAWN : COMPACTION_PROGRESS; \
	200	})
	201
	202	#define COMPACTION_FEEDBACK \
	203	EM(COMPACTION_FAILED, "failed") \
	204	EM(COMPACTION_WITHDRAWN, "withdrawn") \
	205	EMe(COMPACTION_PROGRESS, "progress")
	206
	207	#define COMPACTION_PRIORITY \
	208	EM(COMPACT_PRIO_SYNC_FULL, "COMPACT_PRIO_SYNC_FULL") \
	209	EM(COMPACT_PRIO_SYNC_LIGHT, "COMPACT_PRIO_SYNC_LIGHT") \
	210	EMe(COMPACT_PRIO_ASYNC, "COMPACT_PRIO_ASYNC")
aff28015 MH	211	#else
aff28015 MH	212	#define COMPACTION_STATUS
65190cff MH	213	#define COMPACTION_PRIORITY
65190cff MH	214	#define COMPACTION_FEEDBACK
aff28015 MH	215	#endif
	216
	217	#ifdef CONFIG_ZONE_DMA
	218	#define IFDEF_ZONE_DMA(X) X
	219	#else
	220	#define IFDEF_ZONE_DMA(X)
	221	#endif
	222
	223	#ifdef CONFIG_ZONE_DMA32
	224	#define IFDEF_ZONE_DMA32(X) X
	225	#else
	226	#define IFDEF_ZONE_DMA32(X)
	227	#endif
	228
	229	#ifdef CONFIG_HIGHMEM
	230	#define IFDEF_ZONE_HIGHMEM(X) X
	231	#else
	232	#define IFDEF_ZONE_HIGHMEM(X)
	233	#endif
	234
	235	#define ZONE_TYPE \
	236	IFDEF_ZONE_DMA( EM (ZONE_DMA, "DMA")) \
	237	IFDEF_ZONE_DMA32( EM (ZONE_DMA32, "DMA32")) \
	238	EM (ZONE_NORMAL, "Normal") \
	239	IFDEF_ZONE_HIGHMEM( EM (ZONE_HIGHMEM,"HighMem")) \
	240	EMe(ZONE_MOVABLE,"Movable")
	241
32b3f297 MH	242	#define LRU_NAMES \
	243	EM (LRU_INACTIVE_ANON, "inactive_anon") \
	244	EM (LRU_ACTIVE_ANON, "active_anon") \
	245	EM (LRU_INACTIVE_FILE, "inactive_file") \
	246	EM (LRU_ACTIVE_FILE, "active_file") \
	247	EMe(LRU_UNEVICTABLE, "unevictable")
	248
aff28015 MH	249	/*
	250	* First define the enums in the above macros to be exported to userspace
	251	* via TRACE_DEFINE_ENUM().
	252	*/
	253	#undef EM
	254	#undef EMe
	255	#define EM(a, b) TRACE_DEFINE_ENUM(a);
	256	#define EMe(a, b) TRACE_DEFINE_ENUM(a);
	257
	258	COMPACTION_STATUS
65190cff	259	COMPACTION_PRIORITY
7ab0e50a	260	/* COMPACTION_FEEDBACK are defines not enums. Not needed here. */
aff28015	261	ZONE_TYPE
32b3f297	262	LRU_NAMES
aff28015 MH	263
	264	/*
	265	* Now redefine the EM() and EMe() macros to map the enums to the strings
	266	* that will be printed in the output.
	267	*/
	268	#undef EM
	269	#undef EMe
	270	#define EM(a, b) {a, b},
	271	#define EMe(a, b) {a, b}