1dnl #
2dnl # 3.1 API change
3dnl # The super_block structure now stores a per-filesystem shrinker.
4dnl # This interface is preferable because it can be used to specifically
5dnl # target only the zfs filesystem for pruning.
6dnl #
7AC_DEFUN([ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_SHRINK], [
8	ZFS_LINUX_TEST_SRC([super_block_s_shrink], [
9		#include <linux/fs.h>
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)) = {
16			.s_shrink.seeks = DEFAULT_SEEKS,
17			.s_shrink.batch = 0,
18		};
19	],[])
20])
21
22AC_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], [
25		AC_MSG_RESULT(yes)
26	],[
27		ZFS_LINUX_TEST_ERROR([sb->s_shrink()])
28	])
29])
30
31dnl #
32dnl # 3.12 API change
33dnl # The nid member was added to struct shrink_control to support
34dnl # NUMA-aware shrinkers.
35dnl #
36AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_HAS_NID], [
37	ZFS_LINUX_TEST_SRC([shrink_control_nid], [
38		#include <linux/fs.h>
39	],[
40		struct shrink_control sc __attribute__ ((unused));
41		unsigned long scnidsize __attribute__ ((unused)) =
42		    sizeof(sc.nid);
43	])
44])
45
46AC_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], [
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])
56
57AC_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
72AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINKER_CALLBACK], [
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; }
77	],[
78		struct shrinker cache_shrinker = {
79			.shrink = shrinker_cb,
80			.seeks = DEFAULT_SEEKS,
81		};
82		register_shrinker(&cache_shrinker);
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; }
89	],[
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
99AC_DEFUN([ZFS_AC_KERNEL_SHRINKER_CALLBACK],[
100	dnl #
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
104	dnl #
105	AC_MSG_CHECKING([whether new var-arg register_shrinker() exists])
106	ZFS_LINUX_TEST_RESULT([register_shrinker_vararg], [
107		AC_MSG_RESULT(yes)
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])
117	],[
118		AC_MSG_RESULT(no)
119		dnl #
120		dnl # 3.0 - 3.11 API change
121		dnl # cs->shrink(struct shrinker *, struct shrink_control *sc)
122		dnl #
123		AC_MSG_CHECKING([whether new 2-argument shrinker exists])
124		ZFS_LINUX_TEST_RESULT([shrinker_cb_shrink_control], [
125			AC_MSG_RESULT(yes)
126			AC_DEFINE(HAVE_SINGLE_SHRINKER_CALLBACK, 1,
127				[new shrinker callback wants 2 args])
128		],[
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			])
145		])
146	])
147])
148
149dnl #
150dnl # 2.6.39 API change,
151dnl # Shrinker adjust to use common shrink_control structure.
152dnl #
153AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_STRUCT], [
154	ZFS_LINUX_TEST_SRC([shrink_control_struct], [
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;
161	])
162])
163
164AC_DEFUN([ZFS_AC_KERNEL_SHRINK_CONTROL_STRUCT], [
165	AC_MSG_CHECKING([whether struct shrink_control exists])
166	ZFS_LINUX_TEST_RESULT([shrink_control_struct], [
167		AC_MSG_RESULT(yes)
168		AC_DEFINE(HAVE_SHRINK_CONTROL_STRUCT, 1,
169		    [struct shrink_control exists])
170	],[
171		ZFS_LINUX_TEST_ERROR([shrink_control])
172	])
173])
174
175AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINKER], [
176	ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_SHRINK
177	ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_HAS_NID
178	ZFS_AC_KERNEL_SRC_SHRINKER_CALLBACK
179	ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_STRUCT
180	ZFS_AC_KERNEL_SRC_REGISTER_SHRINKER_VARARG
181])
182
183AC_DEFUN([ZFS_AC_KERNEL_SHRINKER], [
184	ZFS_AC_KERNEL_SUPER_BLOCK_S_SHRINK
185	ZFS_AC_KERNEL_SHRINK_CONTROL_HAS_NID
186	ZFS_AC_KERNEL_SHRINKER_CALLBACK
187	ZFS_AC_KERNEL_SHRINK_CONTROL_STRUCT
188])
189