[mirror_zfs.git] / config / kernel-shrink.m4

dnl #
dnl # 3.1 API change
dnl # The super_block structure now stores a per-filesystem shrinker.
dnl # This interface is preferable because it can be used to specifically
dnl # target only the zfs filesystem for pruning.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_SHRINK], [
	ZFS_LINUX_TEST_SRC([super_block_s_shrink], [
		#include <linux/fs.h>

		int shrink(struct shrinker *s, struct shrink_control *sc)
		    { return 0; }

		static const struct super_block
		    sb __attribute__ ((unused)) = {
			.s_shrink.seeks = DEFAULT_SEEKS,
			.s_shrink.batch = 0,
		};
	],[])
])

AC_DEFUN([ZFS_AC_KERNEL_SUPER_BLOCK_S_SHRINK], [
	AC_MSG_CHECKING([whether super_block has s_shrink])
	ZFS_LINUX_TEST_RESULT([super_block_s_shrink], [
		AC_MSG_RESULT(yes)
	],[
		ZFS_LINUX_TEST_ERROR([sb->s_shrink()])
	])
])

dnl #
dnl # 3.12 API change
dnl # The nid member was added to struct shrink_control to support
dnl # NUMA-aware shrinkers.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_HAS_NID], [
	ZFS_LINUX_TEST_SRC([shrink_control_nid], [
		#include <linux/fs.h>
	],[
		struct shrink_control sc __attribute__ ((unused));
		unsigned long scnidsize __attribute__ ((unused)) =
		    sizeof(sc.nid);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_SHRINK_CONTROL_HAS_NID], [
	AC_MSG_CHECKING([whether shrink_control has nid])
	ZFS_LINUX_TEST_RESULT([shrink_control_nid], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(SHRINK_CONTROL_HAS_NID, 1,
		    [struct shrink_control has nid])
	],[
		AC_MSG_RESULT(no)
	])
])

AC_DEFUN([ZFS_AC_KERNEL_SRC_REGISTER_SHRINKER_VARARG], [
	ZFS_LINUX_TEST_SRC([register_shrinker_vararg], [
		#include <linux/mm.h>
		unsigned long shrinker_cb(struct shrinker *shrink,
		    struct shrink_control *sc) { return 0; }
	],[
		struct shrinker cache_shrinker = {
			.count_objects = shrinker_cb,
			.scan_objects = shrinker_cb,
			.seeks = DEFAULT_SEEKS,
		};
		register_shrinker(&cache_shrinker, "vararg-reg-shrink-test");
	])
])

AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINKER_CALLBACK], [
	ZFS_LINUX_TEST_SRC([shrinker_cb_shrink_control], [
		#include <linux/mm.h>
		int shrinker_cb(struct shrinker *shrink,
		    struct shrink_control *sc) { return 0; }
	],[
		struct shrinker cache_shrinker = {
			.shrink = shrinker_cb,
			.seeks = DEFAULT_SEEKS,
		};
		register_shrinker(&cache_shrinker);
	])

	ZFS_LINUX_TEST_SRC([shrinker_cb_shrink_control_split], [
		#include <linux/mm.h>
		unsigned long shrinker_cb(struct shrinker *shrink,
		    struct shrink_control *sc) { return 0; }
	],[
		struct shrinker cache_shrinker = {
			.count_objects = shrinker_cb,
			.scan_objects = shrinker_cb,
			.seeks = DEFAULT_SEEKS,
		};
		register_shrinker(&cache_shrinker);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_SHRINKER_CALLBACK],[
	dnl #
	dnl # 6.0 API change
	dnl # register_shrinker() becomes a var-arg function that takes
	dnl # a printf-style format string as args > 0
	dnl #
	AC_MSG_CHECKING([whether new var-arg register_shrinker() exists])
	ZFS_LINUX_TEST_RESULT([register_shrinker_vararg], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_REGISTER_SHRINKER_VARARG, 1,
		    [register_shrinker is vararg])

		dnl # We assume that the split shrinker callback exists if the
		dnl # vararg register_shrinker() exists, because the latter is
		dnl # a much more recent addition, and the macro test for the
		dnl # var-arg version only works if the callback is split
		AC_DEFINE(HAVE_SPLIT_SHRINKER_CALLBACK, 1,
			[cs->count_objects exists])
	],[
		AC_MSG_RESULT(no)
		dnl #
		dnl # 3.0 - 3.11 API change
		dnl # cs->shrink(struct shrinker *, struct shrink_control *sc)
		dnl #
		AC_MSG_CHECKING([whether new 2-argument shrinker exists])
		ZFS_LINUX_TEST_RESULT([shrinker_cb_shrink_control], [
			AC_MSG_RESULT(yes)
			AC_DEFINE(HAVE_SINGLE_SHRINKER_CALLBACK, 1,
				[new shrinker callback wants 2 args])
		],[
			AC_MSG_RESULT(no)

			dnl #
			dnl # 3.12 API change,
			dnl # cs->shrink() is logically split in to
			dnl # cs->count_objects() and cs->scan_objects()
			dnl #
			AC_MSG_CHECKING([if cs->count_objects callback exists])
			ZFS_LINUX_TEST_RESULT(
				[shrinker_cb_shrink_control_split],[
					AC_MSG_RESULT(yes)
					AC_DEFINE(HAVE_SPLIT_SHRINKER_CALLBACK, 1,
						[cs->count_objects exists])
			],[
					ZFS_LINUX_TEST_ERROR([shrinker])
			])
		])
	])
])

dnl #
dnl # 2.6.39 API change,
dnl # Shrinker adjust to use common shrink_control structure.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_STRUCT], [
	ZFS_LINUX_TEST_SRC([shrink_control_struct], [
		#include <linux/mm.h>
	],[
		struct shrink_control sc __attribute__ ((unused));

		sc.nr_to_scan = 0;
		sc.gfp_mask = GFP_KERNEL;
	])
])

AC_DEFUN([ZFS_AC_KERNEL_SHRINK_CONTROL_STRUCT], [
	AC_MSG_CHECKING([whether struct shrink_control exists])
	ZFS_LINUX_TEST_RESULT([shrink_control_struct], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_SHRINK_CONTROL_STRUCT, 1,
		    [struct shrink_control exists])
	],[
		ZFS_LINUX_TEST_ERROR([shrink_control])
	])
])

AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINKER], [
	ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_SHRINK
	ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_HAS_NID
	ZFS_AC_KERNEL_SRC_SHRINKER_CALLBACK
	ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_STRUCT
	ZFS_AC_KERNEL_SRC_REGISTER_SHRINKER_VARARG
])

AC_DEFUN([ZFS_AC_KERNEL_SHRINKER], [
	ZFS_AC_KERNEL_SUPER_BLOCK_S_SHRINK
	ZFS_AC_KERNEL_SHRINK_CONTROL_HAS_NID
	ZFS_AC_KERNEL_SHRINKER_CALLBACK
	ZFS_AC_KERNEL_SHRINK_CONTROL_STRUCT
])
Commit	Line	Data
ab26409d BB	1	dnl #
	2	dnl # 3.1 API change
	3	dnl # The super_block structure now stores a per-filesystem shrinker.
	4	dnl # This interface is preferable because it can be used to specifically
	5	dnl # target only the zfs filesystem for pruning.
	6	dnl #
608f8749 BB	7	AC_DEFUN([ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_SHRINK], [
608f8749 BB	8	ZFS_LINUX_TEST_SRC([super_block_s_shrink], [
ab26409d	9	#include <linux/fs.h>
c38367c7 RY	10
	11	int shrink(struct shrinker s, struct shrink_control sc)
	12	{ return 0; }
	13
	14	static const struct super_block
	15	sb __attribute__ ((unused)) = {
ab26409d BB	16	.s_shrink.seeks = DEFAULT_SEEKS,
	17	.s_shrink.batch = 0,
	18	};
608f8749 BB	19	],[])
	20	])
	21
	22	AC_DEFUN([ZFS_AC_KERNEL_SUPER_BLOCK_S_SHRINK], [
	23	AC_MSG_CHECKING([whether super_block has s_shrink])
	24	ZFS_LINUX_TEST_RESULT([super_block_s_shrink], [
ab26409d	25	AC_MSG_RESULT(yes)
ab26409d	26	],[
066e8252	27	ZFS_LINUX_TEST_ERROR([sb->s_shrink()])
ab26409d BB	28	])
ab26409d BB	29	])
90947b23 TC	30
	31	dnl #
	32	dnl # 3.12 API change
	33	dnl # The nid member was added to struct shrink_control to support
	34	dnl # NUMA-aware shrinkers.
	35	dnl #
608f8749 BB	36	AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_HAS_NID], [
608f8749 BB	37	ZFS_LINUX_TEST_SRC([shrink_control_nid], [
90947b23 TC	38	#include <linux/fs.h>
	39	],[
	40	struct shrink_control sc __attribute__ ((unused));
	41	unsigned long scnidsize __attribute__ ((unused)) =
	42	sizeof(sc.nid);
608f8749 BB	43	])
	44	])
	45
	46	AC_DEFUN([ZFS_AC_KERNEL_SHRINK_CONTROL_HAS_NID], [
	47	AC_MSG_CHECKING([whether shrink_control has nid])
	48	ZFS_LINUX_TEST_RESULT([shrink_control_nid], [
90947b23 TC	49	AC_MSG_RESULT(yes)
	50	AC_DEFINE(SHRINK_CONTROL_HAS_NID, 1,
	51	[struct shrink_control has nid])
	52	],[
	53	AC_MSG_RESULT(no)
	54	])
	55	])
93ce2b4c	56
ad096763 CK	57	AC_DEFUN([ZFS_AC_KERNEL_SRC_REGISTER_SHRINKER_VARARG], [
	58	ZFS_LINUX_TEST_SRC([register_shrinker_vararg], [
	59	#include <linux/mm.h>
	60	unsigned long shrinker_cb(struct shrinker *shrink,
	61	struct shrink_control *sc) { return 0; }
	62	],[
	63	struct shrinker cache_shrinker = {
	64	.count_objects = shrinker_cb,
	65	.scan_objects = shrinker_cb,
	66	.seeks = DEFAULT_SEEKS,
	67	};
	68	register_shrinker(&cache_shrinker, "vararg-reg-shrink-test");
	69	])
	70	])
	71
608f8749	72	AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINKER_CALLBACK], [
608f8749 BB	73	ZFS_LINUX_TEST_SRC([shrinker_cb_shrink_control], [
	74	#include <linux/mm.h>
	75	int shrinker_cb(struct shrinker *shrink,
	76	struct shrink_control *sc) { return 0; }
93ce2b4c BB	77	],[
	78	struct shrinker cache_shrinker = {
	79	.shrink = shrinker_cb,
	80	.seeks = DEFAULT_SEEKS,
	81	};
	82	register_shrinker(&cache_shrinker);
608f8749 BB	83	])
	84
	85	ZFS_LINUX_TEST_SRC([shrinker_cb_shrink_control_split], [
	86	#include <linux/mm.h>
	87	unsigned long shrinker_cb(struct shrinker *shrink,
	88	struct shrink_control *sc) { return 0; }
93ce2b4c	89	],[
608f8749 BB	90	struct shrinker cache_shrinker = {
	91	.count_objects = shrinker_cb,
	92	.scan_objects = shrinker_cb,
	93	.seeks = DEFAULT_SEEKS,
	94	};
	95	register_shrinker(&cache_shrinker);
	96	])
	97	])
	98
	99	AC_DEFUN([ZFS_AC_KERNEL_SHRINKER_CALLBACK],[
	100	dnl #
ad096763 CK	101	dnl # 6.0 API change
	102	dnl # register_shrinker() becomes a var-arg function that takes
	103	dnl # a printf-style format string as args > 0
608f8749	104	dnl #
ad096763 CK	105	AC_MSG_CHECKING([whether new var-arg register_shrinker() exists])
ad096763 CK	106	ZFS_LINUX_TEST_RESULT([register_shrinker_vararg], [
93ce2b4c	107	AC_MSG_RESULT(yes)
ad096763 CK	108	AC_DEFINE(HAVE_REGISTER_SHRINKER_VARARG, 1,
	109	[register_shrinker is vararg])
	110
	111	dnl # We assume that the split shrinker callback exists if the
	112	dnl # vararg register_shrinker() exists, because the latter is
	113	dnl # a much more recent addition, and the macro test for the
	114	dnl # var-arg version only works if the callback is split
	115	AC_DEFINE(HAVE_SPLIT_SHRINKER_CALLBACK, 1,
	116	[cs->count_objects exists])
93ce2b4c BB	117	],[
	118	AC_MSG_RESULT(no)
	119	dnl #
ad096763 CK	120	dnl # 3.0 - 3.11 API change
ad096763 CK	121	dnl # cs->shrink(struct shrinker , struct shrink_control sc)
93ce2b4c	122	dnl #
ad096763 CK	123	AC_MSG_CHECKING([whether new 2-argument shrinker exists])
ad096763 CK	124	ZFS_LINUX_TEST_RESULT([shrinker_cb_shrink_control], [
93ce2b4c	125	AC_MSG_RESULT(yes)
ad096763 CK	126	AC_DEFINE(HAVE_SINGLE_SHRINKER_CALLBACK, 1,
ad096763 CK	127	[new shrinker callback wants 2 args])
93ce2b4c	128	],[
ad096763 CK	129	AC_MSG_RESULT(no)
	130
	131	dnl #
	132	dnl # 3.12 API change,
	133	dnl # cs->shrink() is logically split in to
	134	dnl # cs->count_objects() and cs->scan_objects()
	135	dnl #
	136	AC_MSG_CHECKING([if cs->count_objects callback exists])
	137	ZFS_LINUX_TEST_RESULT(
	138	[shrinker_cb_shrink_control_split],[
	139	AC_MSG_RESULT(yes)
	140	AC_DEFINE(HAVE_SPLIT_SHRINKER_CALLBACK, 1,
	141	[cs->count_objects exists])
	142	],[
	143	ZFS_LINUX_TEST_ERROR([shrinker])
	144	])
93ce2b4c BB	145	])
93ce2b4c BB	146	])
93ce2b4c BB	147	])
	148
	149	dnl #
	150	dnl # 2.6.39 API change,
	151	dnl # Shrinker adjust to use common shrink_control structure.
	152	dnl #
608f8749 BB	153	AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_STRUCT], [
608f8749 BB	154	ZFS_LINUX_TEST_SRC([shrink_control_struct], [
93ce2b4c BB	155	#include <linux/mm.h>
	156	],[
	157	struct shrink_control sc __attribute__ ((unused));
	158
	159	sc.nr_to_scan = 0;
	160	sc.gfp_mask = GFP_KERNEL;
608f8749 BB	161	])
	162	])
	163
	164	AC_DEFUN([ZFS_AC_KERNEL_SHRINK_CONTROL_STRUCT], [
	165	AC_MSG_CHECKING([whether struct shrink_control exists])
	166	ZFS_LINUX_TEST_RESULT([shrink_control_struct], [
93ce2b4c BB	167	AC_MSG_RESULT(yes)
93ce2b4c BB	168	AC_DEFINE(HAVE_SHRINK_CONTROL_STRUCT, 1,
608f8749	169	[struct shrink_control exists])
93ce2b4c	170	],[
066e8252	171	ZFS_LINUX_TEST_ERROR([shrink_control])
93ce2b4c BB	172	])
93ce2b4c BB	173	])
608f8749 BB	174
	175	AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINKER], [
	176	ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_SHRINK
608f8749 BB	177	ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_HAS_NID
	178	ZFS_AC_KERNEL_SRC_SHRINKER_CALLBACK
	179	ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_STRUCT
ad096763	180	ZFS_AC_KERNEL_SRC_REGISTER_SHRINKER_VARARG
608f8749 BB	181	])
	182
	183	AC_DEFUN([ZFS_AC_KERNEL_SHRINKER], [
	184	ZFS_AC_KERNEL_SUPER_BLOCK_S_SHRINK
608f8749 BB	185	ZFS_AC_KERNEL_SHRINK_CONTROL_HAS_NID
	186	ZFS_AC_KERNEL_SHRINKER_CALLBACK
	187	ZFS_AC_KERNEL_SHRINK_CONTROL_STRUCT
	188	])