[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>

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

dnl #
dnl # 6.7 API change
dnl # s_shrink is now a pointer.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_SHRINK_PTR], [
	ZFS_LINUX_TEST_SRC([super_block_s_shrink_ptr], [
		#include <linux/fs.h>
		static unsigned long shrinker_cb(struct shrinker *shrink,
		    struct shrink_control *sc) { return 0; }
		static struct shrinker shrinker = {
			.count_objects = shrinker_cb,
			.scan_objects = shrinker_cb,
			.seeks = DEFAULT_SEEKS,
		};
		static const struct super_block
		    sb __attribute__ ((unused)) = {
			.s_shrink = &shrinker,
		};
	],[])
])

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)
		AC_DEFINE(HAVE_SUPER_BLOCK_S_SHRINK, 1,
			[have super_block s_shrink])
	],[
		AC_MSG_RESULT(no)
		AC_MSG_CHECKING([whether super_block has s_shrink pointer])
		ZFS_LINUX_TEST_RESULT([super_block_s_shrink_ptr], [
			AC_MSG_RESULT(yes)
			AC_DEFINE(HAVE_SUPER_BLOCK_S_SHRINK_PTR, 1,
				[have super_block s_shrink pointer])
		],[
			AC_MSG_RESULT(no)
			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>
		static 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>
		static 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>
		static 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);
	])
])

dnl #
dnl # 6.7 API change
dnl # register_shrinker has been replaced by shrinker_register.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINKER_REGISTER], [
	ZFS_LINUX_TEST_SRC([shrinker_register], [
		#include <linux/shrinker.h>
		static 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,
		};
		shrinker_register(&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(
			    [whether 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])
			],[
				AC_MSG_RESULT(no)

				AC_MSG_CHECKING(
				    [whether shrinker_register exists])
				ZFS_LINUX_TEST_RESULT([shrinker_register], [
					AC_MSG_RESULT(yes)
					AC_DEFINE(HAVE_SHRINKER_REGISTER, 1,
					    [shrinker_register exists])

					dnl # We assume that the split shrinker
					dnl # callback exists if
					dnl # shrinker_register() exists,
					dnl # because the latter is a much more
					dnl # recent addition, and the macro
					dnl # test for shrinker_register() only
					dnl # works if the callback is split
					AC_DEFINE(HAVE_SPLIT_SHRINKER_CALLBACK,
					    1, [cs->count_objects exists])
				],[
					AC_MSG_RESULT(no)
					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_SUPER_BLOCK_S_SHRINK_PTR
	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
	ZFS_AC_KERNEL_SRC_SHRINKER_REGISTER
])

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	10
c38367c7 RY	11	static const struct super_block
c38367c7 RY	12	sb __attribute__ ((unused)) = {
ab26409d BB	13	.s_shrink.seeks = DEFAULT_SEEKS,
	14	.s_shrink.batch = 0,
	15	};
608f8749 BB	16	],[])
	17	])
	18
1d324ace RN	19	dnl #
	20	dnl # 6.7 API change
	21	dnl # s_shrink is now a pointer.
	22	dnl #
	23	AC_DEFUN([ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_SHRINK_PTR], [
	24	ZFS_LINUX_TEST_SRC([super_block_s_shrink_ptr], [
	25	#include <linux/fs.h>
a41d0b29	26	static unsigned long shrinker_cb(struct shrinker *shrink,
1d324ace RN	27	struct shrink_control *sc) { return 0; }
	28	static struct shrinker shrinker = {
	29	.count_objects = shrinker_cb,
	30	.scan_objects = shrinker_cb,
	31	.seeks = DEFAULT_SEEKS,
	32	};
	33	static const struct super_block
	34	sb __attribute__ ((unused)) = {
	35	.s_shrink = &shrinker,
	36	};
	37	],[])
	38	])
	39
608f8749 BB	40	AC_DEFUN([ZFS_AC_KERNEL_SUPER_BLOCK_S_SHRINK], [
	41	AC_MSG_CHECKING([whether super_block has s_shrink])
	42	ZFS_LINUX_TEST_RESULT([super_block_s_shrink], [
ab26409d	43	AC_MSG_RESULT(yes)
1d324ace RN	44	AC_DEFINE(HAVE_SUPER_BLOCK_S_SHRINK, 1,
1d324ace RN	45	[have super_block s_shrink])
ab26409d	46	],[
1d324ace RN	47	AC_MSG_RESULT(no)
	48	AC_MSG_CHECKING([whether super_block has s_shrink pointer])
	49	ZFS_LINUX_TEST_RESULT([super_block_s_shrink_ptr], [
	50	AC_MSG_RESULT(yes)
	51	AC_DEFINE(HAVE_SUPER_BLOCK_S_SHRINK_PTR, 1,
	52	[have super_block s_shrink pointer])
	53	],[
	54	AC_MSG_RESULT(no)
	55	ZFS_LINUX_TEST_ERROR([sb->s_shrink()])
	56	])
ab26409d BB	57	])
ab26409d BB	58	])
90947b23 TC	59
	60	dnl #
	61	dnl # 3.12 API change
	62	dnl # The nid member was added to struct shrink_control to support
	63	dnl # NUMA-aware shrinkers.
	64	dnl #
608f8749 BB	65	AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_HAS_NID], [
608f8749 BB	66	ZFS_LINUX_TEST_SRC([shrink_control_nid], [
90947b23 TC	67	#include <linux/fs.h>
	68	],[
	69	struct shrink_control sc __attribute__ ((unused));
	70	unsigned long scnidsize __attribute__ ((unused)) =
	71	sizeof(sc.nid);
608f8749 BB	72	])
	73	])
	74
	75	AC_DEFUN([ZFS_AC_KERNEL_SHRINK_CONTROL_HAS_NID], [
	76	AC_MSG_CHECKING([whether shrink_control has nid])
	77	ZFS_LINUX_TEST_RESULT([shrink_control_nid], [
90947b23 TC	78	AC_MSG_RESULT(yes)
	79	AC_DEFINE(SHRINK_CONTROL_HAS_NID, 1,
	80	[struct shrink_control has nid])
	81	],[
	82	AC_MSG_RESULT(no)
	83	])
	84	])
93ce2b4c	85
ad096763 CK	86	AC_DEFUN([ZFS_AC_KERNEL_SRC_REGISTER_SHRINKER_VARARG], [
	87	ZFS_LINUX_TEST_SRC([register_shrinker_vararg], [
	88	#include <linux/mm.h>
a41d0b29	89	static unsigned long shrinker_cb(struct shrinker *shrink,
ad096763 CK	90	struct shrink_control *sc) { return 0; }
	91	],[
	92	struct shrinker cache_shrinker = {
	93	.count_objects = shrinker_cb,
	94	.scan_objects = shrinker_cb,
	95	.seeks = DEFAULT_SEEKS,
	96	};
	97	register_shrinker(&cache_shrinker, "vararg-reg-shrink-test");
	98	])
	99	])
	100
608f8749	101	AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINKER_CALLBACK], [
608f8749 BB	102	ZFS_LINUX_TEST_SRC([shrinker_cb_shrink_control], [
608f8749 BB	103	#include <linux/mm.h>
a41d0b29	104	static int shrinker_cb(struct shrinker *shrink,
608f8749	105	struct shrink_control *sc) { return 0; }
93ce2b4c BB	106	],[
	107	struct shrinker cache_shrinker = {
	108	.shrink = shrinker_cb,
	109	.seeks = DEFAULT_SEEKS,
	110	};
	111	register_shrinker(&cache_shrinker);
608f8749 BB	112	])
	113
	114	ZFS_LINUX_TEST_SRC([shrinker_cb_shrink_control_split], [
	115	#include <linux/mm.h>
a41d0b29	116	static unsigned long shrinker_cb(struct shrinker *shrink,
608f8749	117	struct shrink_control *sc) { return 0; }
93ce2b4c	118	],[
608f8749 BB	119	struct shrinker cache_shrinker = {
	120	.count_objects = shrinker_cb,
	121	.scan_objects = shrinker_cb,
	122	.seeks = DEFAULT_SEEKS,
	123	};
	124	register_shrinker(&cache_shrinker);
	125	])
	126	])
	127
957dc103 RN	128	dnl #
	129	dnl # 6.7 API change
	130	dnl # register_shrinker has been replaced by shrinker_register.
	131	dnl #
	132	AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINKER_REGISTER], [
	133	ZFS_LINUX_TEST_SRC([shrinker_register], [
	134	#include <linux/shrinker.h>
a41d0b29	135	static unsigned long shrinker_cb(struct shrinker *shrink,
957dc103 RN	136	struct shrink_control *sc) { return 0; }
	137	],[
	138	struct shrinker cache_shrinker = {
	139	.count_objects = shrinker_cb,
	140	.scan_objects = shrinker_cb,
	141	.seeks = DEFAULT_SEEKS,
	142	};
	143	shrinker_register(&cache_shrinker);
	144	])
	145	])
	146
608f8749 BB	147	AC_DEFUN([ZFS_AC_KERNEL_SHRINKER_CALLBACK],[
608f8749 BB	148	dnl #
ad096763 CK	149	dnl # 6.0 API change
	150	dnl # register_shrinker() becomes a var-arg function that takes
	151	dnl # a printf-style format string as args > 0
608f8749	152	dnl #
ad096763 CK	153	AC_MSG_CHECKING([whether new var-arg register_shrinker() exists])
ad096763 CK	154	ZFS_LINUX_TEST_RESULT([register_shrinker_vararg], [
93ce2b4c	155	AC_MSG_RESULT(yes)
ad096763 CK	156	AC_DEFINE(HAVE_REGISTER_SHRINKER_VARARG, 1,
	157	[register_shrinker is vararg])
	158
	159	dnl # We assume that the split shrinker callback exists if the
	160	dnl # vararg register_shrinker() exists, because the latter is
	161	dnl # a much more recent addition, and the macro test for the
	162	dnl # var-arg version only works if the callback is split
	163	AC_DEFINE(HAVE_SPLIT_SHRINKER_CALLBACK, 1,
	164	[cs->count_objects exists])
93ce2b4c BB	165	],[
	166	AC_MSG_RESULT(no)
	167	dnl #
ad096763 CK	168	dnl # 3.0 - 3.11 API change
ad096763 CK	169	dnl # cs->shrink(struct shrinker , struct shrink_control sc)
93ce2b4c	170	dnl #
ad096763 CK	171	AC_MSG_CHECKING([whether new 2-argument shrinker exists])
ad096763 CK	172	ZFS_LINUX_TEST_RESULT([shrinker_cb_shrink_control], [
93ce2b4c	173	AC_MSG_RESULT(yes)
ad096763 CK	174	AC_DEFINE(HAVE_SINGLE_SHRINKER_CALLBACK, 1,
ad096763 CK	175	[new shrinker callback wants 2 args])
93ce2b4c	176	],[
ad096763 CK	177	AC_MSG_RESULT(no)
	178
	179	dnl #
	180	dnl # 3.12 API change,
	181	dnl # cs->shrink() is logically split in to
	182	dnl # cs->count_objects() and cs->scan_objects()
	183	dnl #
957dc103 RN	184	AC_MSG_CHECKING(
957dc103 RN	185	[whether cs->count_objects callback exists])
ad096763	186	ZFS_LINUX_TEST_RESULT(
957dc103 RN	187	[shrinker_cb_shrink_control_split],[
	188	AC_MSG_RESULT(yes)
	189	AC_DEFINE(HAVE_SPLIT_SHRINKER_CALLBACK, 1,
	190	[cs->count_objects exists])
ad096763	191	],[
957dc103 RN	192	AC_MSG_RESULT(no)
	193
	194	AC_MSG_CHECKING(
	195	[whether shrinker_register exists])
	196	ZFS_LINUX_TEST_RESULT([shrinker_register], [
	197	AC_MSG_RESULT(yes)
	198	AC_DEFINE(HAVE_SHRINKER_REGISTER, 1,
	199	[shrinker_register exists])
	200
	201	dnl # We assume that the split shrinker
	202	dnl # callback exists if
	203	dnl # shrinker_register() exists,
	204	dnl # because the latter is a much more
	205	dnl # recent addition, and the macro
	206	dnl # test for shrinker_register() only
	207	dnl # works if the callback is split
	208	AC_DEFINE(HAVE_SPLIT_SHRINKER_CALLBACK,
	209	1, [cs->count_objects exists])
	210	],[
	211	AC_MSG_RESULT(no)
ad096763	212	ZFS_LINUX_TEST_ERROR([shrinker])
957dc103	213	])
ad096763	214	])
93ce2b4c BB	215	])
93ce2b4c BB	216	])
93ce2b4c BB	217	])
	218
	219	dnl #
	220	dnl # 2.6.39 API change,
	221	dnl # Shrinker adjust to use common shrink_control structure.
	222	dnl #
608f8749 BB	223	AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_STRUCT], [
608f8749 BB	224	ZFS_LINUX_TEST_SRC([shrink_control_struct], [
93ce2b4c BB	225	#include <linux/mm.h>
	226	],[
	227	struct shrink_control sc __attribute__ ((unused));
	228
	229	sc.nr_to_scan = 0;
	230	sc.gfp_mask = GFP_KERNEL;
608f8749 BB	231	])
	232	])
	233
	234	AC_DEFUN([ZFS_AC_KERNEL_SHRINK_CONTROL_STRUCT], [
	235	AC_MSG_CHECKING([whether struct shrink_control exists])
	236	ZFS_LINUX_TEST_RESULT([shrink_control_struct], [
93ce2b4c BB	237	AC_MSG_RESULT(yes)
93ce2b4c BB	238	AC_DEFINE(HAVE_SHRINK_CONTROL_STRUCT, 1,
608f8749	239	[struct shrink_control exists])
93ce2b4c	240	],[
066e8252	241	ZFS_LINUX_TEST_ERROR([shrink_control])
93ce2b4c BB	242	])
93ce2b4c BB	243	])
608f8749 BB	244
	245	AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINKER], [
	246	ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_SHRINK
1d324ace	247	ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_SHRINK_PTR
608f8749 BB	248	ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_HAS_NID
	249	ZFS_AC_KERNEL_SRC_SHRINKER_CALLBACK
	250	ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_STRUCT
ad096763	251	ZFS_AC_KERNEL_SRC_REGISTER_SHRINKER_VARARG
957dc103	252	ZFS_AC_KERNEL_SRC_SHRINKER_REGISTER
608f8749 BB	253	])
	254
	255	AC_DEFUN([ZFS_AC_KERNEL_SHRINKER], [
	256	ZFS_AC_KERNEL_SUPER_BLOCK_S_SHRINK
608f8749 BB	257	ZFS_AC_KERNEL_SHRINK_CONTROL_HAS_NID
	258	ZFS_AC_KERNEL_SHRINKER_CALLBACK
	259	ZFS_AC_KERNEL_SHRINK_CONTROL_STRUCT
	260	])