config/kernel-shrink.m4

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